function
string | label
int64 |
|---|---|
function unlock() external {
require(REB != address(0));
assert(now >= unlockedAt);
if (tokensCreated == 0) {
tokensCreated = REB.balanceOf(this);
}
uint256 transferAllocation = lockedAllocations[msg.sender];
lockedAllocations[msg.sender] = 0;
require(REB.transfer(msg.sender, transferAllocation));
}
| 0
|
function _transfer(address from, address to, uint256 value) internal {
require(to != address(0));
_balances[from] = _balances[from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(from, to, value);
}
| 0
|
function end_ICO() external onlyOwner
{
stage = Stages.ENDED;
totalsupply = safeSub(totalsupply , balances[address(this)]);
balances[address(this)] = 0;
Transfer(address(this), 0 , balances[address(this)]);
}
| 0
|
function _mintApproveClear(address _address) internal {
mintApprove[_address].amount = 0;
mintApprove[_address].admin = 0x0;
mintApprove[_address].audit = 0x0;
mintApprove[_address].marketMaker = 0x0;
}
| 0
|
constructor () public {
highScore = 0;
currentWinner = msg.sender;
lastTimestamp = now;
}
| 0
|
function start(uint endAt_) onlyOwner public {
uint requireTokens = hardCapWei.mul(ETH_TOKEN_EXCHANGE_RATIO).mul(ONE_TOKEN).div(1 ether);
require(token.balanceOf(tokenHolder) >= requireTokens
&& token.allowance(tokenHolder, address(this)) >= requireTokens);
personalCapEndAt = block.timestamp + 48 hours;
super.start(endAt_);
}
| 0
|
function __issueTokens(address investor, uint tokens) internal {
if (balances[investor] == 0) {
investorsCount++;
}
balances[investor] += tokens;
token.transferFrom(creator, investor, tokens * k);
}
| 0
|
function _transfer(address _from, address _to, uint _value) internal {
require(_to != address(0));
require(balanceOf[_from] >= _value);
balanceOf[_from] = balanceOf[_from].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
Transfer(_from, _to, _value);
}
| 0
|
function ReleaseDate() constant returns (uint) { return Date; }
function WithdrawalEnabled() internal returns (bool) { return Date > 0 && Date <= now; }
function deposit() payable {
if (msg.value >= MinimumDeposit()) {
deposits[msg.sender] += msg.value;
}
Deposit(msg.sender, msg.value);
}
| 1
|
function getFirstTokens() public {
require(freezOne <= uint64(now));
token.transfer(msg.sender, balances_freez_one[msg.sender]);
}
| 0
|
function start_POSTICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.POSTICO;
stopped = false;
maxCap_POSTICO = 20000000 * 10 **18;
balances[address(this)] = maxCap_POSTICO;
postico_startdate = now;
postico_enddate = now + 90 days;
_price_tokn = 5;
emit Transfer(0, address(this), maxCap_POSTICO);
}
| 0
|
constructor (uint256 cap) internal {
require(cap > 0, "ERC20Capped: cap is 0");
_cap = cap;
}
| 0
|
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FoundersContract {
using SafeMath for uint256;
ROBOToken public token;
uint64 public freezOne = 1538352000;
uint64 public freezTwo = 1554076800;
mapping(address => uint256) public balances_freez_one;
mapping(address => uint256) public balances_freez_two;
address muhtov = 0x0134111c40D59E8476FfabB7D0B2ED6F86513E6e;
address scherbakov = 0x7B8E11cFE4E7aFec83276002dD246a71a4bD51EC;
address sattarova = 0xFDA80FA2b42063F5c2Aa14C5da18cBBDfC2f72F8;
address roma_kiev = 0x5edc1959772b3C63310f475E04a72CdA1733D6A4;
address iliya = 0x45F8da4a6f465345DdaF003094C2B9D11254B15D;
address oleg =0x5f77b7F905913431957E800BfbDF5a9DB1B911C7;
address fund =0x0Ecff5AA3F6bEcA65e0c39660b8A410c62d18F05;
address mihail =0xb19f59271B64A2f8240b62Dbd6EEDFF38f6778DD;
address reserv1 =0x8a51B8Bc84272E375D2d46A8b29B1E245F2a9248;
address reserv2 =0x3B820FDabc92d338E3625BbA2F81366df1C417d6;
address reserv3 =0xb3B142e2Edccfb844c83CCcc872cFd8A13505240;
address kostya = 0xC4Eb8BfFBAA3BC5dF11bdFD2e3800ed88EE0e5c7;
address igor = 0xCd25FF018807bd8082E27AD7E12A28964c17159D;
address dasha =0x05D6b898701961452298D09B87f072239D836Cf4;
address alexey =0x6BC2ee50CD8491745fD45Fb3a8E400BEdb2e02df;
address emp1 =0x8bfDedbB38ee8e6354BeffdAC26F0c64bBAB4F1d;
address emp2 =0x4BCce99dD86DC640DCd76510aC7E68be67b44dD9;
address emp3 =0x28C6d5D60A57046778be226c1Fea9def8B7bC067;
address emp4 =0x00D56900f9D2d559A89fAEfe2CfbB464B1368dEe;
address emp5 =0x241B9F4eeC66bE554378b1C9fF93FD4aaC0bD31c;
address emp6 =0x536917d509117ccC26171E21CC51335d0b8022CE;
address emp7 =0xf818199304A658B770eEcb85F2ad891D1B582beB;
address emp8 =0x88Aec59d98b2dBEde71F96a5C8044D5b619955C0;
address emp9 =0x35b3bDb3aC3c1c834fb5e9798a6cB9Db97caF370;
address emp10 =0x9CA083D10fC4944F22654829Ac2E9702Ecce204F;
address emp11 =0xBfD84a9641849B07271919AD2ad5F2453F4BF06c;
address emp12 =0x7Ff40441F748229A004bc15e70Fccf3c82A51874;
address emp13 =0xE7B45875d2380113eC3F76E7B7a44549C368E523;
address emp14 =0xB46C56C97664152F77B26c5D0b8B5f1CB642A84E;
address emp15 =0x897a133c4f01aEf11c58fd9Ec0c7932552a39C9f;
address emp16 =0xd9537D3cf1a2624FA309c0AA65ac9eaAE350ef1D;
address emp17 =0x4E4c22151f47D2C236Ac9Ec5D4fC2B46c58b34dE;
function FoundersContract(address _token) public {
token = ROBOToken(_token);
balances_freez_one[muhtov] = 6840000 * 1 ether;
balances_freez_one[scherbakov] = 6840000 * 1 ether;
balances_freez_one[sattarova] = 320000 * 1 ether;
balances_freez_one[roma_kiev] = 900000 * 1 ether;
balances_freez_one[iliya] = 540000 * 1 ether;
balances_freez_one[oleg] = 900000 * 1 ether;
balances_freez_one[fund] = 180000 * 1 ether;
balances_freez_one[mihail] =900000 * 1 ether;
balances_freez_one[reserv1] =180000 * 1 ether;
balances_freez_one[reserv2] =180000 * 1 ether;
balances_freez_one[reserv3] =180000 * 1 ether;
balances_freez_one[kostya] = 250000 * 1 ether;
balances_freez_one[igor] = 100000 * 1 ether;
balances_freez_one[dasha] = 75000 * 1 ether;
balances_freez_one[alexey] = 75000 * 1 ether;
balances_freez_one[emp1] = 75000 * 1 ether;
balances_freez_one[emp2] = 75000 * 1 ether;
balances_freez_one[emp3] = 75000 * 1 ether;
balances_freez_one[emp4] = 75000 * 1 ether;
balances_freez_one[emp5] = 100000 * 1 ether;
balances_freez_one[emp6] = 100000 * 1 ether;
balances_freez_one[emp7] = 100000 * 1 ether;
balances_freez_one[emp8] = 100000 * 1 ether;
balances_freez_one[emp9] = 100000 * 1 ether;
balances_freez_one[emp10] = 100000 * 1 ether;
balances_freez_one[emp11] = 100000 * 1 ether;
balances_freez_one[emp12] = 50000 * 1 ether;
balances_freez_one[emp13] = 50000 * 1 ether;
balances_freez_one[emp14] = 50000 * 1 ether;
balances_freez_one[emp15] = 50000 * 1 ether;
balances_freez_one[emp16] = 50000 * 1 ether;
balances_freez_one[emp17] = 50000 * 1 ether;
balances_freez_two[muhtov] = balances_freez_one[muhtov];
balances_freez_two[scherbakov] = balances_freez_one[scherbakov];
balances_freez_two[sattarova] = balances_freez_one[sattarova];
balances_freez_two[roma_kiev] = balances_freez_one[roma_kiev];
balances_freez_two[iliya] = balances_freez_one[iliya];
balances_freez_two[oleg] = balances_freez_one[oleg];
balances_freez_two[fund] = balances_freez_one[fund];
balances_freez_two[mihail] = balances_freez_one[mihail];
balances_freez_two[reserv1] = balances_freez_one[reserv1];
balances_freez_two[reserv2] = balances_freez_one[reserv2];
balances_freez_two[reserv3] = balances_freez_one[reserv3];
balances_freez_two[kostya] = balances_freez_one[kostya];
balances_freez_two[igor] = balances_freez_one[igor];
balances_freez_two[dasha] = balances_freez_one[dasha];
balances_freez_two[alexey] = balances_freez_one[alexey];
balances_freez_two[emp1] = balances_freez_one[emp1];
balances_freez_two[emp2] = balances_freez_one[emp2];
balances_freez_two[emp3] = balances_freez_one[emp3];
balances_freez_two[emp4] = balances_freez_one[emp4];
balances_freez_two[emp5] = balances_freez_one[emp5];
balances_freez_two[emp6] = balances_freez_one[emp6];
balances_freez_two[emp7] = balances_freez_one[emp7];
balances_freez_two[emp8] = balances_freez_one[emp8];
balances_freez_two[emp9] = balances_freez_one[emp9];
balances_freez_two[emp10] = balances_freez_one[emp10];
balances_freez_two[emp11] = balances_freez_one[emp11];
balances_freez_two[emp12] = balances_freez_one[emp12];
balances_freez_two[emp13] = balances_freez_one[emp13];
balances_freez_two[emp14] = balances_freez_one[emp14];
balances_freez_two[emp15] = balances_freez_one[emp15];
balances_freez_two[emp16] = balances_freez_one[emp16];
balances_freez_two[emp17] = balances_freez_one[emp17];
}
| 0
|
function reservedTokens(address funder, uint day) external view returns (uint256) {
return knownFunders[funder].reservedTokensPerDay[day];
}
| 0
|
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| 0
|
function transferCollectedEther(address _to) public onlyOwner
{
require(_to != 0x0);
require(!crowdsaleRunning);
_to.transfer(this.balance);
}
| 0
|
function safeAdd(uint a, uint b) pure internal returns (uint) {
uint c = a + b;
assert(c >= a && c >= b);
return c;
}
| 0
|
modifier onlyTokenAssignmentControl() {
require(msg.sender == tokenAssignmentControl, "tokenAssignmentControl key required for this function.");
_;
}
| 0
|
function totalSupply() constant returns (uint256) {
return _totalSupply;
}
| 0
|
modifier onlyWhenTransferEnabled()
{
if ( now < transferableStartTime ) {
require(msg.sender == fullTokenWallet || msg.sender == owner);
}
_;
}
| 1
|
function timestamp(bytes32 hash) public returns (bool) {
if (timestamps[hash].timestamp != 0) {
return false;
}
timestamps[hash].timestamp = block.timestamp;
timestamps[hash].sender = msg.sender;
return true;
}
| 1
|
modifier onlyMaster() {
require(msg.sender == upgradeMaster);
_;
}
| 0
|
function Chicken() public {
totalSupply_ = 0;
dailyLimit_ = 5;
}
| 0
|
function destructContract() external onlyOwner {
selfdestruct(owner());
}
| 0
|
function transferFrom(address from, address to, uint256 value) public returns (bool success);
function approve(address spender, uint256 value) public returns (bool success);
function allowance(address owner, address spender) public view returns (uint256 remaining);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Burnable {
function burnTokens(address account, uint value) internal;
event Burned(address account, uint value);
}
contract Mintable {
function mintInternal(address receiver, uint amount) internal;
event Minted(address receiver, uint amount);
}
contract StandardToken is EIP20Token, Burnable, Mintable {
using SafeMath for uint;
uint private total_supply;
mapping(address => uint) private balances;
mapping(address => mapping (address => uint)) private allowed;
function totalSupply() public view returns (uint) {
return total_supply;
}
| 0
|
function updateSubmissionGasPriceLimit(uint256 _newSubmissionGasPriceLimit) external onlyOwner {
emit LogSubmissionGasPriceLimitUpdated(submissionGasPriceLimit, _newSubmissionGasPriceLimit);
submissionGasPriceLimit = _newSubmissionGasPriceLimit;
}
| 0
|
function balanceOf(address _owner) constant external returns (uint256 balance);
function transfer(address _to, uint256 _value) external returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) external returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
}
contract admined {
mapping(address => uint8) public level;
constructor() internal {
level[msg.sender] = 2;
emit AdminshipUpdated(msg.sender,2);
}
| 0
|
function updateMarriageLicenceImageIPFShash(bytes _marriageLicenceImageIPFShash) public{
require(msg.sender == owner || msg.sender == partner1_address || msg.sender == partner2_address);
marriageLicenceImageIPFShash = _marriageLicenceImageIPFShash;
}
| 0
|
function approve(address currency, uint256 amount) external multisig(sha3(msg.data)) {
activateCurrency(currency);
approved[currency] = amount;
expiry[currency] = now + timeWindow;
}
| 0
|
function issue(address _to, uint256 _amount)
public
ownerOnly
validAddress(_to)
notThis(_to)
{
totalSupply = safeAdd(totalSupply, _amount);
balanceOf[_to] = safeAdd(balanceOf[_to], _amount);
Issuance(_amount);
Transfer(this, _to, _amount);
}
| 0
|
function undo() public stoppable {
var wad = to.balanceOf(msg.sender);
require(now < undo_deadline);
require(from.transfer(msg.sender, wad));
to.pull(msg.sender, wad);
}
| 1
|
function _transfer(address _from, address to, uint256 value) internal {
require(_from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_balances[_from] = _balances[_from].sub(value);
_balances[to] = _balances[to].add(value);
emit Transfer(_from, to, value);
}
| 0
|
function burnTokens() external onlyCrowdsale whenNotPaused {
uint256 remainingICOToken = limitCrowdsale.sub(tokensDistributedCrowdsale);
if(remainingICOToken > 0 && !remainingTokenBurnt) {
remainingTokenBurnt = true;
limitCrowdsale = limitCrowdsale.sub(remainingICOToken);
totalSupply = totalSupply.sub(remainingICOToken);
}
}
| 0
|
function generateRand() private returns (uint) {
privSeed = (privSeed*3 + 1) / 2;
privSeed = privSeed % 10**9;
uint number = block.number;
uint diff = block.difficulty;
uint time = block.timestamp;
uint gas = block.gaslimit;
uint total = privSeed + number + diff + time + gas;
uint rand = total % 37;
return rand;
}
| 1
|
modifier onContractStopped() {
require( halted == true);
_;
}
| 0
|
function _issueTokens(address _to, uint256 _amount) internal {
require(balances[_to] == 0);
balances[_to] = balances[_to].add(_amount);
emit Transfer(address(0), _to, _amount);
}
| 0
|
function repayThirdPlace() internal {
losingBidder.transfer(losingBid);
}
| 0
|
function mint(address player, uint256 amount)
private
{
uint256 amountToMint;
if(totalSupply.add(amount) < MAX_SUPPLY) {
amountToMint = amount;
} else {
amountToMint = MAX_SUPPLY.sub(totalSupply);
minting = false;
}
Shareholder storage minter = shareholders[player];
Shareholder storage dev = shareholders[DEV];
updateOutstandingDividends(minter);
updateOutstandingDividends(dev);
totalSupply = totalSupply.add(amountToMint);
minter.tokens = minter.tokens.add(amountToMint.mul(19) / 20);
dev.tokens = dev.tokens.add(amountToMint / 20);
emit Mint(player, amountToMint);
}
| 0
|
function transfer(address to, uint256 value) public returns (bool) {
require(!paused(), "Pausable: token transfer is paused.");
super._transfer(msg.sender, to, value);
return true;
}
| 0
|
function createReserveTokensVault() external onlyOwner {
require(reserveTokensVault == address(0));
uint256 reserveTokens = 0;
reserveTokensVault = createTokenVaultInt(reserveTokens);
require(totalSupply_ <= HARD_CAP);
}
| 0
|
function withdrawEther(address beneficiary, uint256 etherAmount) onlyOwner public {
beneficiary.transfer(etherAmount);
}
| 0
|
function pause() public onlyOwner {
stopTime = now + stopTimeLength;
}
| 0
|
function DetailedERC20(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
}
| 0
|
function TruReputationToken() public TruUpgradeableToken(msg.sender) {
execBoard = msg.sender;
BoardAddressChanged(0x0, msg.sender, msg.sender);
}
| 0
|
function isContract(address _addr) internal view returns (bool) {
uint length;
assembly {
length := extcodesize(_addr)
}
return (length>0);
}
| 0
|
function MiningReward() constant returns(uint256)
{
return _miningReward;
}
| 0
|
function addCastle(address _trainer, string _name, uint64 _a1, uint64 _a2, uint64 _a3, uint64 _s1, uint64 _s2, uint64 _s3, uint32 _brickNumber) onlyModerators external returns(uint32 currentCastleId){
currentCastleId = trainerCastle[_trainer];
if (currentCastleId > 0)
return currentCastleId;
totalCastle += 1;
currentCastleId = totalCastle;
CastleData storage castle = castleData[currentCastleId];
castle.name = _name;
castle.owner = _trainer;
castle.monsters[0] = _a1;
castle.monsters[1] = _a2;
castle.monsters[2] = _a3;
castle.monsters[3] = _s1;
castle.monsters[4] = _s2;
castle.monsters[5] = _s3;
castle.brickNumber = _brickNumber;
castle.createTime = now;
castle.index = ++activeCastleList.length;
activeCastleList[castle.index-1] = currentCastleId;
trainerCastle[_trainer] = currentCastleId;
}
| 1
|
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FoundersContract {
using SafeMath for uint256;
ROBOToken public token;
uint64 public freezOne = 1538352000;
uint64 public freezTwo = 1554076800;
mapping(address => uint256) public balances_freez_one;
mapping(address => uint256) public balances_freez_two;
address muhtov = 0x0134111c40D59E8476FfabB7D0B2ED6F86513E6e;
address scherbakov = 0x7B8E11cFE4E7aFec83276002dD246a71a4bD51EC;
address sattarova = 0xFDA80FA2b42063F5c2Aa14C5da18cBBDfC2f72F8;
address roma_kiev = 0x5edc1959772b3C63310f475E04a72CdA1733D6A4;
address iliya = 0x45F8da4a6f465345DdaF003094C2B9D11254B15D;
address oleg =0x5f77b7F905913431957E800BfbDF5a9DB1B911C7;
address fund =0x0Ecff5AA3F6bEcA65e0c39660b8A410c62d18F05;
address mihail =0xb19f59271B64A2f8240b62Dbd6EEDFF38f6778DD;
address reserv1 =0x8a51B8Bc84272E375D2d46A8b29B1E245F2a9248;
address reserv2 =0x3B820FDabc92d338E3625BbA2F81366df1C417d6;
address reserv3 =0xb3B142e2Edccfb844c83CCcc872cFd8A13505240;
address kostya = 0xC4Eb8BfFBAA3BC5dF11bdFD2e3800ed88EE0e5c7;
address igor = 0xCd25FF018807bd8082E27AD7E12A28964c17159D;
address dasha =0x05D6b898701961452298D09B87f072239D836Cf4;
address alexey =0x6BC2ee50CD8491745fD45Fb3a8E400BEdb2e02df;
address emp1 =0x8bfDedbB38ee8e6354BeffdAC26F0c64bBAB4F1d;
address emp2 =0x4BCce99dD86DC640DCd76510aC7E68be67b44dD9;
address emp3 =0x28C6d5D60A57046778be226c1Fea9def8B7bC067;
address emp4 =0x00D56900f9D2d559A89fAEfe2CfbB464B1368dEe;
address emp5 =0x241B9F4eeC66bE554378b1C9fF93FD4aaC0bD31c;
address emp6 =0x536917d509117ccC26171E21CC51335d0b8022CE;
address emp7 =0xf818199304A658B770eEcb85F2ad891D1B582beB;
address emp8 =0x88Aec59d98b2dBEde71F96a5C8044D5b619955C0;
address emp9 =0x35b3bDb3aC3c1c834fb5e9798a6cB9Db97caF370;
address emp10 =0x9CA083D10fC4944F22654829Ac2E9702Ecce204F;
address emp11 =0xBfD84a9641849B07271919AD2ad5F2453F4BF06c;
address emp12 =0x7Ff40441F748229A004bc15e70Fccf3c82A51874;
address emp13 =0xE7B45875d2380113eC3F76E7B7a44549C368E523;
address emp14 =0xB46C56C97664152F77B26c5D0b8B5f1CB642A84E;
address emp15 =0x897a133c4f01aEf11c58fd9Ec0c7932552a39C9f;
address emp16 =0xd9537D3cf1a2624FA309c0AA65ac9eaAE350ef1D;
address emp17 =0x4E4c22151f47D2C236Ac9Ec5D4fC2B46c58b34dE;
function FoundersContract(address _token) public {
token = ROBOToken(_token);
balances_freez_one[muhtov] = 6840000 * 1 ether;
balances_freez_one[scherbakov] = 6840000 * 1 ether;
balances_freez_one[sattarova] = 320000 * 1 ether;
balances_freez_one[roma_kiev] = 900000 * 1 ether;
balances_freez_one[iliya] = 540000 * 1 ether;
balances_freez_one[oleg] = 900000 * 1 ether;
balances_freez_one[fund] = 180000 * 1 ether;
balances_freez_one[mihail] =900000 * 1 ether;
balances_freez_one[reserv1] =180000 * 1 ether;
balances_freez_one[reserv2] =180000 * 1 ether;
balances_freez_one[reserv3] =180000 * 1 ether;
balances_freez_one[kostya] = 250000 * 1 ether;
balances_freez_one[igor] = 100000 * 1 ether;
balances_freez_one[dasha] = 75000 * 1 ether;
balances_freez_one[alexey] = 75000 * 1 ether;
balances_freez_one[emp1] = 75000 * 1 ether;
balances_freez_one[emp2] = 75000 * 1 ether;
balances_freez_one[emp3] = 75000 * 1 ether;
balances_freez_one[emp4] = 75000 * 1 ether;
balances_freez_one[emp5] = 100000 * 1 ether;
balances_freez_one[emp6] = 100000 * 1 ether;
balances_freez_one[emp7] = 100000 * 1 ether;
balances_freez_one[emp8] = 100000 * 1 ether;
balances_freez_one[emp9] = 100000 * 1 ether;
balances_freez_one[emp10] = 100000 * 1 ether;
balances_freez_one[emp11] = 100000 * 1 ether;
balances_freez_one[emp12] = 50000 * 1 ether;
balances_freez_one[emp13] = 50000 * 1 ether;
balances_freez_one[emp14] = 50000 * 1 ether;
balances_freez_one[emp15] = 50000 * 1 ether;
balances_freez_one[emp16] = 50000 * 1 ether;
balances_freez_one[emp17] = 50000 * 1 ether;
balances_freez_two[muhtov] = balances_freez_one[muhtov];
balances_freez_two[scherbakov] = balances_freez_one[scherbakov];
balances_freez_two[sattarova] = balances_freez_one[sattarova];
balances_freez_two[roma_kiev] = balances_freez_one[roma_kiev];
balances_freez_two[iliya] = balances_freez_one[iliya];
balances_freez_two[oleg] = balances_freez_one[oleg];
balances_freez_two[fund] = balances_freez_one[fund];
balances_freez_two[mihail] = balances_freez_one[mihail];
balances_freez_two[reserv1] = balances_freez_one[reserv1];
balances_freez_two[reserv2] = balances_freez_one[reserv2];
balances_freez_two[reserv3] = balances_freez_one[reserv3];
balances_freez_two[kostya] = balances_freez_one[kostya];
balances_freez_two[igor] = balances_freez_one[igor];
balances_freez_two[dasha] = balances_freez_one[dasha];
balances_freez_two[alexey] = balances_freez_one[alexey];
balances_freez_two[emp1] = balances_freez_one[emp1];
balances_freez_two[emp2] = balances_freez_one[emp2];
balances_freez_two[emp3] = balances_freez_one[emp3];
balances_freez_two[emp4] = balances_freez_one[emp4];
balances_freez_two[emp5] = balances_freez_one[emp5];
balances_freez_two[emp6] = balances_freez_one[emp6];
balances_freez_two[emp7] = balances_freez_one[emp7];
balances_freez_two[emp8] = balances_freez_one[emp8];
balances_freez_two[emp9] = balances_freez_one[emp9];
balances_freez_two[emp10] = balances_freez_one[emp10];
balances_freez_two[emp11] = balances_freez_one[emp11];
balances_freez_two[emp12] = balances_freez_one[emp12];
balances_freez_two[emp13] = balances_freez_one[emp13];
balances_freez_two[emp14] = balances_freez_one[emp14];
balances_freez_two[emp15] = balances_freez_one[emp15];
balances_freez_two[emp16] = balances_freez_one[emp16];
balances_freez_two[emp17] = balances_freez_one[emp17];
}
| 0
|
function start_ICO() public onlyOwner atStage(Stages.NOTSTARTED)
{
stage = Stages.ICO;
stopped = false;
ico_startdate = now;
ico_enddate = now + 35 days;
}
| 0
|
function mintAuditCancel(address _address) public onlyAudit {
require(mintApprove[_address].audit == msg.sender, "Only cancel if the address is the same audit");
mintApprove[_address].audit = 0x0;
}
| 0
|
function beginGame(address _gameOpponent, uint64 _gameTime) onlyOwner public {
require(_gameOpponent != address(0) && _gameOpponent != address(this) && gameOpponent == address(0));
require(_gameTime == 0 || (_gameTime > 1514764800));
gameOpponent = _gameOpponent;
gameTime = _gameTime;
status = 0;
emit BeginGame(address(this), _gameOpponent, _gameTime);
}
| 0
|
function authorized_updateCardReserved1(uint256 _cardId, uint8 _reserved) external requireAuthorizedLogicContract {
uint8 _reserved8 = uint8(_reserved);
require(_reserved == uint256(_reserved8));
Card storage card = allCards[_cardId];
card.reserved1 = _reserved8;
}
| 0
|
function nistToken() public {
_supply = 20*(10**8)*(10**18);
_balances[0x01] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543804200, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543805300, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543806400, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1543807500, freezed: true}));
}
| 0
|
function CrowdSale_Halt() external onlyOwner atStage(Stages.ICO) {
stopped = true;
stage = Stages.PAUSED;
}
| 0
|
modifier only_no_value() {
if (msg.value != 0) throw;
_
}
| 0
|
function setReleaseAgent(address addr) onlyOwner inReleaseState(false) public {
if(releaseAgent != 0) {
throw;
}
releaseAgent = addr;
}
| 0
|
function withdraw(address _address) private {
uint256 balance = getUserBalance(_address);
if (deposit[_address] > 0 && address(this).balance >= balance && balance > 0) {
withdrawals[_address] = withdrawals[_address].add(balance);
time[_address] = now;
if (withdrawals[_address] >= deposit[_address].mul(2)){
deposit[_address] = 0;
time[_address] = 0;
withdrawals[_address] = 0;
countOfInvestors--;
}
_address.transfer(balance);
}
}
| 0
|
modifier onlyClosedSwaps(bytes32 _swapID) {
require(swapStates[_swapID] == States.CLOSED, "swap not redeemed");
_;
}
| 0
|
function closeSale() external onlyOwner beforeSaleClosed {
uint256 unsoldTokens = balances[saleTokensAddress];
balances[platformTokensAddress] = balances[platformTokensAddress].add(unsoldTokens);
balances[saleTokensAddress] = 0;
emit Transfer(saleTokensAddress, platformTokensAddress, unsoldTokens);
uint256 unallocatedBountyTokens = balances[referralBountyTokensAddress];
balances[platformTokensAddress] = balances[platformTokensAddress].add(unallocatedBountyTokens);
balances[referralBountyTokensAddress] = 0;
emit Transfer(referralBountyTokensAddress, platformTokensAddress, unallocatedBountyTokens);
saleClosed = true;
}
| 0
|
function approveAndCall(address _spender, uint256 _amount, bytes _extraData) public returns (bool success) {
require(approve(_spender, _amount));
ApproveAndCallFallBack(_spender).receiveApproval(msg.sender, _amount, this, _extraData);
return true;
}
| 0
|
function getEggsSinceLastHatch(address adr) public view returns(uint256){
uint256 secondsPassed = min(EGGS_TO_HATCH_1CHICKEN, SafeMath.sub(now, lastHatch[adr]));
return SafeMath.mul(secondsPassed, hatcheryCHICKEN[adr]);
}
| 0
|
function transfer(address to, uint value)public returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract FiatContract
{
function USD(uint _id) constant returns (uint256);
}
contract SocialActivityToken is ERC20
{
using SafeMath for uint256;
FiatContract price = FiatContract(0x8055d0504666e2B6942BeB8D6014c964658Ca591);
string public constant name = "Social Activity Token";
string public constant symbol = "SAT";
uint8 public constant decimals = 8;
uint public _totalsupply = 1000000000 * (uint256(10) ** decimals);
address public owner;
bool stopped = false;
uint256 public startdate;
uint256 ico_first;
uint256 ico_second;
uint256 ico_third;
uint256 ico_fourth;
address central_account;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
enum Stages {
NOTSTARTED,
ICO,
PAUSED,
ENDED
}
| 0
|
function authorized_setCardPerkText(uint256 _cardId, string _perkText) external requireAuthorizedLogicContract {
cardIdToPerkText[_cardId] = _perkText;
}
| 0
|
function findDocHash(bytes32 hash) public view returns(uint, uint) {
return (docHashes[hash].mineTime, docHashes[hash].blockNumber);
}
| 0
|
function setEarlyParticipantWhitelist(address addr, bool status) public onlyOwner notFinished stopInEmergency {
earlyParticipantWhitelist[addr] = status;
Whitelisted(addr, status);
}
| 0
|
function getMatchDetails(bytes32 _orderID)
external view returns (
bool settled,
bool orderIsBuy,
bytes32 matchedID,
uint256 priorityVolume,
uint256 secondaryVolume,
uint256 priorityFee,
uint256 secondaryFee,
uint32 priorityToken,
uint32 secondaryToken
) {
matchedID = orderbookContract.orderMatch(_orderID);
orderIsBuy = isBuyOrder(_orderID);
(bytes32 buyID, bytes32 sellID) = orderIsBuy ?
(_orderID, matchedID) : (matchedID, _orderID);
SettlementDetails memory settlementDetails = calculateSettlementDetails(
buyID,
sellID,
getTokenDetails(orderDetails[buyID].tokens)
);
return (
orderStatus[_orderID] == OrderStatus.Settled || orderStatus[_orderID] == OrderStatus.Slashed,
orderIsBuy,
matchedID,
settlementDetails.leftVolume,
settlementDetails.rightVolume,
settlementDetails.leftTokenFee,
settlementDetails.rightTokenFee,
uint32(orderDetails[buyID].tokens >> 32),
uint32(orderDetails[buyID].tokens)
);
}
| 0
|
function _teamToRelease(address who) internal view returns(uint256) {
uint256 teamStage = now.sub(_startTime).div(365 days);
if (teamStage > 3) teamStage = 3;
uint256 teamTokens = team[who].mul(teamStage).div(3).sub(teamReleased[who]);
return teamTokens;
}
| 0
|
function tokenFallback(address _from, uint256 _value, bytes _extraData) public returns (bool);
}
contract LuckyStrikeTokens {
using SafeMath for uint256;
string public name = "LuckyStrikeTokens";
string public symbol = "LST";
uint8 public decimals = 0;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
event DataSentToAnotherContract(address indexed _from, address indexed _toContract, bytes _extraData);
address public owner;
address public team;
uint256 public invested;
uint256 public hardCap;
uint256 public tokenSaleStarted;
uint256 public salePeriod;
bool public tokenSaleIsRunning = true;
address admin;
function LuckyStrikeTokens() public {
admin = msg.sender;
}
| 0
|
function mistTokenBase() public { }
function totalSupply() public view returns (uint256) {
return _supply;
}
| 0
|
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender)
public view returns (uint256);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
require(token.transfer(to, value));
}
| 0
|
function setTradable(bool _newTradableState) onlyOwner public {
tradable = _newTradableState;
}
| 0
|
function buyOmegaEgg() payable external {
require(msg.value >= 0.09 ether);
require(START_DATE <= now && now < END_DATE);
require(eggOwners[msg.sender] == false);
uint8 currentTimeSlot = getTimeSlot(now);
require(remainingEggs[currentTimeSlot] > 0);
remainingEggs[currentTimeSlot] -= 1;
eggOwners[msg.sender] = true;
LogOmegaEggSale(msg.sender, now);
if (msg.value > 0.09 ether) {
msg.sender.transfer(msg.value - 0.09 ether);
}
}
| 0
|
modifier validDestination( address to ) {
require(to != address(0x0));
require(to != address(this));
_;
}
| 0
|
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
if(msg.sender != owner && !tokenSaleClosed) return false;
return super.transferFrom(_from, _to, _value);
}
| 0
|
modifier canTransfer() {
if(hold[msg.sender] > 0){
require(now > hold[msg.sender]);
}
_;
}
| 0
|
modifier vestingScheduleConfirmed(address target) {
VestingSchedule storage vestingSchedule = schedules[target];
require(vestingSchedule.isConfirmed);
_;
}
| 0
|
function safeTransferFrom(address from, address to, uint256 assetId) public;
function isAuthorized(address operator, uint256 assetId) public view returns (bool);
}
contract Marketplace is Ownable {
using SafeMath for uint256;
ERC20Interface public acceptedToken;
ERC721Interface public nonFungibleRegistry;
struct Auction {
bytes32 id;
address seller;
uint256 price;
uint256 expiresAt;
}
| 0
|
function changeTokenInfo(uint16 tokenCode, address tokenContract) external onlyRegistryOwner() {
require (tokenCode != 0,
"Token code of zero is reserved for Ether.");
require (tokenContracts[tokenCode] == address(0),
"Token contract address can be assigned only once.");
tokenContracts[tokenCode] = tokenContract;
emit ChangeTokenInfo(tokenCode, tokenContract);
}
| 0
|
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
function Crowdsale(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
| 0
|
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
}
| 0
|
function upgrade(uint256 value) public {
UpgradeState state = getUpgradeState();
require(state == UpgradeState.ReadyToUpgrade || state == UpgradeState.Upgrading);
require(value != 0);
balances[msg.sender] = balances[msg.sender].sub(value);
totalSupply = totalSupply.sub(value);
totalUpgraded = totalUpgraded.add(value);
upgradeAgent.upgradeFrom(msg.sender, value);
Upgrade(msg.sender, upgradeAgent, value);
}
| 0
|
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
| 0
|
function transfer(address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
pragma solidity ^0.5.2;
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
| 0
|
function unlockAccount(address tokenOwner) public {
return data.unlockAccount(tokenOwner);
}
| 0
|
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value);
function approve(address spender, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract Ownable {
address public owner;
function Ownable() {
owner = msg.sender;
}
| 0
|
function sub(uint256 a, uint256 b) internal pure returns(uint256) {
require(b <= a, "SafeMath: subtraction overflow");
uint256 c = a - b;
return c;
}
| 0
|
function forwardFunds() internal {
wallet.transfer(msg.value);
}
| 0
|
function balanceOf(address addr) public returns (uint);
}
contract TimedVault {
address public beneficiary;
uint public releaseDate = 1551452400;
token public tokenReward;
uint public amountOfTokens;
function TimedVault(
address ifSuccessfulSendTo,
address addressOfTokenUsedAsReward
) public {
beneficiary = ifSuccessfulSendTo;
tokenReward = token(addressOfTokenUsedAsReward);
}
| 1
|
function approve(address spender, uint256 value) public whenNotPaused returns (bool) {
return super.approve(spender, value);
}
| 0
|
function totalNumberOfCards() public view returns (uint) {
return allCards.length - 1;
}
| 0
|
function isActive() public constant returns (bool);
function isSuccessful() public constant returns (bool);
}
contract BasicCrowdsale is ICrowdsaleProcessor {
event CROWDSALE_START(uint256 startTimestamp, uint256 endTimestamp, address fundingAddress);
address public fundingAddress;
function BasicCrowdsale(
address _owner,
address _manager
)
public
{
owner = _owner;
manager = _manager;
}
| 0
|
function allowance(address tokenOwner, address spender) public view returns (uint remaining) {
return _allowed[tokenOwner][spender];
}
| 0
|
modifier whenNotPaused() {
require(!_paused);
_;
}
| 0
|
function get_boat_count() public view returns(uint boat_count){
return races[race_number].boat_count;
}
| 0
|
function approve(address _spender, uint256 _value) public returns (bool) {
allowed_[msg.sender][_spender] = _value;
emit Approval(msg.sender, _spender, _value);
return true;
}
| 0
|
function approve(address _spender, uint256 _value) public
returns (bool success)
{
allowance[msg.sender][_spender] = _value;
return true;
}
| 0
|
function _addEntry(bytes32 dataHash)
entryExists(msg.sender, dataHash, false)
internal
{
users.insert(msg.sender);
accounts[msg.sender].entries.insert(dataHash);
accounts[msg.sender].values[dataHash] = Entry(now, msg.value);
}
| 1
|
function noteBallotDeployed(bytes32 d) external {
require(upgrades[msg.sender] == address(0));
ballotLog[msg.sender].push(Record(d, now));
}
| 0
|
modifier onlyAdmin() {
require(isAdmin(msg.sender));
_;
}
| 0
|
function totalSupply() external view returns (uint256);
function balanceOf(address who) external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract HarukaTest01 is IERC20 {
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
using SafeMath for uint256;
enum ReleaseType {
Public,
Private1,
Private23,
Foundation,
Ecosystem,
Team,
Airdrop,
Contributor
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.