function
string | label
int64 |
|---|---|
function TokenVesting(address _beneficiary, uint256 _startTime, uint256 _cliff, uint256 _duration, bool _revocable) public {
require(_beneficiary != address(0));
require(_startTime >= now);
require(_duration > 0);
require(_cliff <= _duration);
beneficiary = _beneficiary;
startTime = _startTime;
cliff = _startTime.add(_cliff);
duration = _duration;
revocable = _revocable;
LogVestingCreated(beneficiary, startTime, cliff, duration, revocable);
} | 0 |
function lockTeamTokens() public onlyOwner afterStageOneClosed {
require(teamTokensLockAddress == address(0) && totalSupply < HARD_CAP);
uint256 teamTokens = 1350000000 * 10**uint256(decimals);
TokenTimelock teamTokensLock = new TokenTimelock(this, mobilinkTeamAddress, uint64(block.timestamp) + 60 * 60 * 24 * 90);
teamTokensLockAddress = address(teamTokensLock);
totalSupply = totalSupply.add(teamTokens);
balances[teamTokensLockAddress] = teamTokens;
} | 0 |
function play() payable {
assert(msg.value == TICKET_AMOUNT);
pot += msg.value;
var random = uint(block.blockhash(block.number)) + block.timestamp + block.difficulty + block.number;
if (mulmod(random, 1, 2) == 0) {
bank.transfer(FEE_AMOUNT);
msg.sender.transfer(pot - FEE_AMOUNT);
pot = 0;
}
} | 1 |
function invest(address to) onlyActive public payable {
uint amount = msg.value;
uint tokenAmount = getCurrentBonus().mul(amount).mul(10 ** decimals / 100).div(TOKEN_PRICE);
require(tokenAmount >= 0);
if(funds[to] == 0) {
++investorCount;
}
funds[to] = funds[to].add(amount);
totalFunds = totalFunds.add(amount);
mint(to, tokenAmount);
require(totalSupply <= TOKEN_CAP);
multisigWallet.transfer(amount);
Invested(to, amount, tokenAmount);
} | 0 |
function Token(address amcWallet, address _upgradeMaster)
public
UpgradeableToken(_upgradeMaster)
{
totalSupply_ = INITIAL_SUPPLY;
balances[amcWallet] = INITIAL_SUPPLY;
Transfer(0x0, amcWallet, INITIAL_SUPPLY);
} | 0 |
modifier canTransfer() {
if(hold[msg.sender] > 0){
require(now > hold[msg.sender]);
}
_;
} | 0 |
function removeSupportedToken(address _address) public onlyOwner returns (bool) {
require(_address != 0x0);
uint256 length = supportedERC20Token.length;
for (uint256 i = 0; i < length; i++) {
if (supportedERC20Token[i] == _address) {
if (i != length - 1) {
supportedERC20Token[i] = supportedERC20Token[length - 1];
}
delete supportedERC20Token[length-1];
supportedERC20Token.length--;
prices[_address] = 0;
starttime[_address] = 0;
endtime[_address] = 0;
emit RemoveSupportedToken(_address);
break;
}
}
return true;
} | 0 |
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _token, bytes _extraData) public; }
contract Kryptos {
bool public TransferActive;
bool public ShareActive;
bool public CoinSaleActive;
string public name;
string public symbol;
uint256 public BuyPrice;
uint8 public decimals = 18;
uint256 public totalSupply;
address public Owner;
address public Reserve;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowance;
event Transfer(address indexed from, address indexed to, uint256 value);
event Burn(address indexed from, uint256 value);
function Kryptos(
uint256 initialSupply,
string tokenName,
string tokenSymbol,
address tokenowner,
address tokenreserve,
uint256 tokenbuyPrice,
bool tokentransferactive,
bool tokenshareactive,
bool tokencoinsaleactive
) public {
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
Owner = tokenowner;
Reserve = tokenreserve;
BuyPrice = tokenbuyPrice;
TransferActive = tokentransferactive;
ShareActive = tokenshareactive;
CoinSaleActive = tokencoinsaleactive;
}
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + balanceOf[_to] == previousBalances);
}
function setOwner(address newdata) public {
if (msg.sender == Owner) {Owner = newdata;}
}
function setTransferactive(bool newdata) public {
if (msg.sender == Owner) {TransferActive = newdata;}
}
function setShareactive(bool newdata) public {
if (msg.sender == Owner) {ShareActive = newdata;}
}
function setCoinsaleactive(bool newdata) public {
if (msg.sender == Owner) {CoinSaleActive = newdata;}
}
function setPrices(uint256 newBuyPrice) public {
if (msg.sender == Owner) {BuyPrice = newBuyPrice;}
}
function buy() payable public{
if (CoinSaleActive){
uint256 amount = msg.value * BuyPrice;
if (balanceOf[Reserve] < amount) {
return;
}
balanceOf[Reserve] -= amount;
balanceOf[msg.sender] += amount;
Transfer(Reserve, msg.sender, amount);
Reserve.transfer(msg.value);
}
}
function ShareDATA(string newdata) public {
bytes memory string_rep = bytes(newdata);
if (ShareActive){_transfer(msg.sender, Reserve, string_rep.length * (2* 10 ** (uint256(decimals)-4)));}
}
function ShareRoomDATA(address RoomAddress,string newdata) public {
bytes memory string_rep = bytes(newdata);
uint256 TXfee = string_rep.length * (25* 10 ** (uint256(decimals)-5));
if (ShareActive){
balanceOf[msg.sender] -= TXfee;
balanceOf[Reserve] += TXfee;
Transfer(msg.sender, Reserve, TXfee);
Transfer(msg.sender, RoomAddress, 0);
}
}
function transfer(address _to, uint256 _value) public {
if (TransferActive){_transfer(msg.sender, _to, _value);}
}
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success) {
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
function approve(address _spender, uint256 _value) public
returns (bool success) {
allowance[msg.sender][_spender] = _value;
return true;
}
function approveAndCall(address _spender, uint256 _value, bytes _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, this, _extraData);
return true;
}
}
function burn(uint256 _value) public returns (bool success) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
}
function burnFrom(address _from, uint256 _value) public returns (bool success) {
require(balanceOf[_from] >= _value);
require(_value <= allowance[_from][msg.sender]);
balanceOf[_from] -= _value;
allowance[_from][msg.sender] -= _value;
totalSupply -= _value;
Burn(_from, _value);
return true;
}
} | 0 |
function gt(uint a, uint b) internal pure returns(bytes1) {
bytes1 c;
c = 0x00;
if (a > b) {
c = 0x01;
}
return c;
} | 0 |
function allowance(address owner, address spender) public constant 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 StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
uint256 _allowance = allowed[_from][msg.sender];
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = _allowance.sub(_value);
Transfer(_from, _to, _value);
return true;
} | 0 |
function getNowTimestamp() internal view returns (uint) {
return now;
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
modifier canTransfer() {
if(msg.sender != founder) {
require(mintingFinished);
require(now > allowTransferTimestamp);
}
_;
} | 1 |
function setTransferFeeReceiver(address _address) public onlyOwner returns (bool) {
transferFeeReceiver = _address;
return true;
} | 0 |
function attack(uint _heroId) whenNotPaused onlyHumanAddress external payable {
uint genes;
address owner;
(,,, genes, owner,,) = edCoreContract.getHeroDetails(_heroId);
require(msg.sender == owner);
uint heroInitialHealth = (genes / (32 ** 12)) % 32 + 1;
uint heroStrength = (genes / (32 ** 8)) % 32 + 1;
Monster memory monster = heroIdToMonster[_heroId];
uint currentLevel = monster.level;
uint heroCurrentHealth = heroIdToHealth[_heroId];
bool dungeonRunEnded;
if (currentLevel == 0) {
require(msg.value >= entranceFee);
entranceFeePool += entranceFee;
heroIdToMonster[_heroId] = Monster(uint64(now), 1, monsterHealth, monsterHealth);
monster = heroIdToMonster[_heroId];
heroIdToHealth[_heroId] = heroInitialHealth;
heroCurrentHealth = heroInitialHealth;
if (msg.value > entranceFee) {
msg.sender.transfer(msg.value - entranceFee);
}
} else {
require(heroCurrentHealth > 0);
dungeonRunEnded = now > monster.creationTime + monsterFleeTime * 2 ||
(monster.health == monster.initialHealth && now > monster.creationTime + monsterFleeTime);
if (dungeonRunEnded) {
uint addToJackpot = entranceFee - heroIdToRefundedFee[_heroId];
jackpot += addToJackpot;
entranceFeePool -= addToJackpot;
assert(addToJackpot <= entranceFee);
}
msg.sender.transfer(msg.value);
}
if (!dungeonRunEnded) {
_attack(_heroId, genes, heroStrength, heroCurrentHealth);
}
} | 0 |
function receivePayment()isIssetRecepient timeCheck private {
uint depositMultiplier = getDepositMultiplier();
time[msg.sender] = now;
msg.sender.transfer(depositMultiplier);
allPercents+=depositMultiplier;
lastPayment =now;
emit PayOffDividends(msg.sender, depositMultiplier);
} | 0 |
modifier onlyPayloadSize(uint size) {
require(msg.data.length == size + 4);
_;
} | 0 |
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
if (now < presaleDeadline) {
require(assetProxy.transferFromWithReference(msg.sender, address(this), _value, _reference));
require(vesting.createVesting(_to, assetProxy, _value, 1, paymentInterval, schedule));
return true;
}
return assetProxy.transferFromWithReference(msg.sender, _to, _value, _reference);
} | 0 |
function transferCustomToken(address _token, address _to, uint256 _value) onlyPayloadSize(3 * 32) onlyOwner public returns (bool) {
Token tkn = Token(_token);
return tkn.transfer(_to, _value);
} | 0 |
function unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
} | 0 |
function releaseLockedToken() public returns (bool) {
require(_lock_list[msg.sender] == true);
require(_revocable[msg.sender] > 0);
uint256 releaseTime = _lock_list_period[msg.sender];
uint256 currentTime = block.timestamp;
if(currentTime > releaseTime) {
uint256 tokens = _revocable[msg.sender];
_lock_list_period[msg.sender] = 0;
_lock_list[msg.sender] = false;
_revocable[msg.sender] = 0;
_totalSupply = _totalSupply.add(tokens);
_balances[msg.sender] = _balances[msg.sender].add(tokens);
return true;
} else {
return false;
}
} | 0 |
function sendVesting(uint _id) returns(bool);
function getReceiverVesting(address _receiver, address _ERC20) constant returns(uint);
}
contract CryptykVestingManager is Ambi2EnabledFull {
AssetProxyInterface public assetProxy;
VestingInterface public vesting;
uint public paymentInterval;
uint public schedule;
uint public presaleDeadline;
function setVesting(VestingInterface _vesting) onlyRole('admin') returns(bool) {
require(address(vesting) == 0x0);
vesting = _vesting;
return true;
} | 0 |
function extendTime(uint256 _timeExtension) onlyOwner public {
require(!finished);
require(now < endTime + timeExtension);
require(_timeExtension > 0);
timeExtension = timeExtension.add(_timeExtension);
require(timeExtension <= 7 days);
Extended(endTime.add(timeExtension));
} | 0 |
function burn(uint256 _value) public onlyOwner {
require(!burnt);
require(_value > 0);
require(_value <= balances[msg.sender]);
require(block.timestamp < 1690848000);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply_ = totalSupply_.sub(_value);
burnt = true;
emit Burn(msg.sender, _value);
emit Transfer(msg.sender, address(0), _value);
} | 0 |
modifier isSuspended() {
require(state == State.Suspended);
_;
} | 0 |
function mint(address _to, uint256 _amount) external onlyRole(ROLE_MINT) returns (bool) {
require(_to != address(0));
require(_amount > 0);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
MintLog(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
} | 0 |
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 StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
} | 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 cancelOrderInternal(LibOrder.Order memory order)
internal;
function updateFilledState(
LibOrder.Order memory order,
address takerAddress,
bytes32 orderHash,
uint256 orderTakerAssetFilledAmount,
LibFillResults.FillResults memory fillResults
)
internal;
function updateCancelledState(
LibOrder.Order memory order,
bytes32 orderHash
)
internal;
function assertFillableOrder(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo,
address takerAddress,
bytes memory signature
)
internal
view;
function assertValidFill(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo,
uint256 takerAssetFillAmount,
uint256 takerAssetFilledAmount,
uint256 makerAssetFilledAmount
)
internal
view;
function assertValidCancel(
LibOrder.Order memory order,
LibOrder.OrderInfo memory orderInfo
)
internal
view;
function calculateFillResults(
LibOrder.Order memory order,
uint256 takerAssetFilledAmount
)
internal
pure
returns (LibFillResults.FillResults memory fillResults);
}
contract MAssetProxyDispatcher is
IAssetProxyDispatcher
{
event AssetProxyRegistered(
bytes4 id,
address assetProxy
);
function dispatchTransferFrom(
bytes memory assetData,
address from,
address to,
uint256 amount
)
internal;
}
contract MMatchOrders is
IMatchOrders
{
function assertValidMatch(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder
)
internal
pure;
function calculateMatchedFillResults(
LibOrder.Order memory leftOrder,
LibOrder.Order memory rightOrder,
uint256 leftOrderTakerAssetFilledAmount,
uint256 rightOrderTakerAssetFilledAmount
)
internal
pure
returns (LibFillResults.MatchedFillResults memory matchedFillResults);
}
contract MSignatureValidator is
ISignatureValidator
{
event SignatureValidatorApproval(
address indexed signerAddress,
address indexed validatorAddress,
bool approved
);
enum SignatureType {
Illegal,
Invalid,
EIP712,
EthSign,
Wallet,
Validator,
PreSigned,
NSignatureTypes
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function Exchange(uint256 _delay) {
delay = _delay;
feeAccount = msg.sender;
addRole(msg.sender, ROLE_FORCED);
addRole(msg.sender, ROLE_TRANSFER_TOKENS);
addRole(msg.sender, ROLE_TRANSFER_INVESTOR_TOKENS);
addRole(msg.sender, ROLE_CLAIM);
addRole(msg.sender, ROLE_WITHDRAW);
addRole(msg.sender, ROLE_TRADE);
addRole(msg.sender, ROLE_CHANGE_DELAY);
addRole(msg.sender, ROLE_SET_FEEACCOUNT);
addRole(msg.sender, ROLE_TOKEN_WHITELIST);
} | 0 |
function getState() public returns(State) {
if (forcedRefund)
return State.Refunding;
if(tokensBought == 0) {
if(now >= freezeEndsAt) {
return State.Refunding;
} else {
return State.Funding;
}
} else {
return State.Distributing;
}
} | 0 |
function addTip(address _from, bytes32 _to, uint _tip) public onlyOwners {
tips[_from][_to] += _tip;
balances[_to] += _tip;
lastTip[_from][_to] = now;
} | 1 |
function getNow() internal constant returns (uint256) {
return now;
} | 1 |
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 updateEndTime(uint256 newEnd) onlyOwner {
endTime = newEnd;
} | 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
} | 0 |
function signedApprove(address tokenOwner, address spender, uint tokens, uint fee, uint nonce, bytes sig, address feeAccount) public returns (bool success) {
return data.signedApprove(tokenOwner, spender, tokens, fee, nonce, sig, feeAccount);
} | 0 |
function claim_bounty(){
if (bought_tokens) return;
if (kill_switch) throw;
bought_tokens = true;
time_bought = now;
token.proxyPayment.value(this.balance - bounty)(address(this));
msg.sender.transfer(bounty);
} | 1 |
function era() public view returns (uint) {
return block.timestamp;
} | 1 |
function removeOversight(address addr) external multisig(sha3(msg.data)) {
oversightAddresses[addr] = false;
} | 0 |
function apSaleIssue(address _to, uint _value) onlyOwner public
{
uint tokens = _value * E18;
require(maxSaleSupply >= tokenIssuedSale.add(tokens));
balances[_to] = balances[_to].add( tokens.mul(385)/1000 );
ap1[_to] = ap1[_to].add( tokens.mul(385)/1000 );
ap2[_to] = ap2[_to].add( tokens.mul(115)/1000 );
ap3[_to] = ap3[_to].add( tokens.mul(115)/1000 );
totalTokenSupply = totalTokenSupply.add(tokens);
tokenIssuedSale = tokenIssuedSale.add(tokens);
apIssuedSale = apIssuedSale.add(tokens);
emit SaleIssue(_to, tokens);
} | 0 |
function getTimestamp() internal constant returns(uint) {
return now;
} | 1 |
function safeSub(uint256 a, uint256 b)pure internal returns (uint256) {
assert(b <= a);
return a - b;
} | 0 |
function Crowdsale(uint256 _startTime, uint256 _endTime, uint256 _rate, address _wallet) {
require(_startTime >= now);
require(_endTime >= _startTime);
require(_rate > 0);
require(_wallet != 0x0);
token = createTokenContract();
startTime = _startTime;
endTime = _endTime;
rate = _rate;
wallet = _wallet;
} | 0 |
function endSale() onlyOwner_manager public
{
require(saleTime == true);
saleTime = false;
uint time = now;
endSaleTime = time;
for(uint i = 1; i <= vestingReleaseRound_RND; i++)
{
vestingRelease_RND[i] = vestingRelease_RND[i].add(vestingAmountPerRound_RND);
}
for(uint i = 1; i <= vestingReleaseRound_Advisor; i++)
{
vestingRelease_Advisor[i] = vestingRelease_Advisor[i].add(vestingAmountPerRound_Advisor);
}
for(uint i = 1; i <= vestingReleaseRound_Team; i++)
{
vestingRelease_Team[i] = vestingRelease_Team[i].add(vestingAmountPerRound_Team);
}
} | 0 |
function _transferOwnership(address _newOwner) internal {
require(_newOwner != address(0));
emit OwnershipTransferred(owner, _newOwner);
owner = _newOwner;
} | 0 |
function fundPot(address player, uint256 amount)
private
{
require(minting);
pot = pot.add(amount);
mint(player, amount);
} | 0 |
function executeContract() public checkAuthorizedUser() {
require(address(this).balance > 0);
if (oracle.current() == EXPECTED) {
contractExecuted = true;
emit ContractExecuted("Payment sent to beneficiary.");
beneficiary.transfer(address(this).balance);
} else if (now >= expiration) {
contractExecuted = true;
emit ContractExecuted("Payment refunded to depositor.");
depositor.transfer(address(this).balance);
}
} | 0 |
constructor(address _oracle, address _depositor, address _beneficiary) public payable Ownable() {
oracle = IOracle(_oracle);
depositor = _depositor;
beneficiary = _beneficiary;
contractExecuted = false;
expiration = now + TO_EXPIRE;
} | 0 |
function destroy() onlyOwner public {
selfdestruct(owner);
} | 0 |
function renounceOwnership() public onlyOwner {
OwnershipRenounced(owner);
owner = address(0);
} | 0 |
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract URUNCrowdsale is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei = 800;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 minimumContributionPresalePhase1 = 2 * 10 ** 18;
uint256 minimumContributionPresalePhase2 = 1 * 10 ** 18;
uint256 maxTokensToSaleInClosedPreSale;
uint256 bonusInPreSalePhase1;
uint256 bonusInPreSalePhase2;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 31 days;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);
constructor(uint256 _startTime, address _wallet, address _tokenAddress) public
{
require(_wallet != 0x0);
require(_startTime >=now);
startTime = _startTime;
endTime = startTime + totalDurationInDays;
require(endTime >= startTime);
owner = _wallet;
maxTokensToSaleInClosedPreSale = 60000000 * 10 ** 18;
bonusInPreSalePhase1 = 50;
bonusInPreSalePhase2 = 40;
token = TokenInterface(_tokenAddress);
} | 0 |
function releaseOnce() public {
bytes32 headKey = toKey(msg.sender, 0);
uint64 head = chains[headKey];
require(head != 0);
require(uint64(block.timestamp) > head);
bytes32 currentKey = toKey(msg.sender, head);
uint64 next = chains[currentKey];
uint amount = freezings[currentKey];
delete freezings[currentKey];
balances[msg.sender] = balances[msg.sender].add(amount);
freezingBalance[msg.sender] = freezingBalance[msg.sender].sub(amount);
if (next == 0) {
delete chains[headKey];
}
else {
chains[headKey] = next;
delete chains[currentKey];
}
emit Released(msg.sender, amount);
} | 0 |
function betOnDozen(bool First, bool Second, bool Third)
{
betOnColumnOrDozen(First,Second,Third, BetTypes.dozen);
} | 0 |
function setReservedTokens(uint day, address[] funders, uint256[] reservedTokens) external onlyUpdater {
for (uint i = 0; i < funders.length; i++) {
knownFunders[funders[i]].reservedTokensPerDay[day] = reservedTokens[i];
}
ReservedTokensSet(day, funders, reservedTokens);
} | 0 |
function transfer(address to, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
function approve(address spender, uint256 value) external returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed tokenOwner,
address indexed spender,
uint256 value
);
}
contract LTLNN is ERC20, Ownable {
using SafeMath for uint256;
string public name = "Lawtest Token";
string public symbol ="LTLNN";
uint8 public decimals = 2;
uint256 initialSupply = 5000000;
uint256 saleBeginTime = 1557824400;
uint256 saleEndTime = 1557835200;
uint256 tokensDestructTime = 1711929599;
mapping (address => uint256) private _balances;
mapping (address => mapping(address => uint)) _allowed;
uint256 private _totalSupply;
uint256 private _amountForSale;
event Mint(address indexed to, uint256 amount, uint256 amountForSale);
event TokensDestroyed();
constructor() public {
_balances[address(this)] = initialSupply;
_amountForSale = initialSupply;
_totalSupply = initialSupply;
} | 0 |
function buyTokens(address beneficiary) public whenNotPaused payable {
require(beneficiary != address(0));
require(validPurchase());
uint256 weiAmount = msg.value;
if (weiAmount >= minWeiWhitelistInvestment) {
require(investorWhitelist[beneficiary]);
}
weiRaised = weiRaised.add(weiAmount);
investments[beneficiary] = investments[beneficiary].add(weiAmount);
Investment(msg.sender, beneficiary, weiAmount);
forwardFunds();
} | 0 |
function buyTokens(address investor) public payable {
require(investor != address(0));
require(now >= startTime && now <= endTime);
require(crowdsaleActive);
require(msg.value != 0);
uint256 weiAmount = msg.value;
uint256 tokens = weiAmount.mul(rate);
require(tokensSold.add(tokens) <= goal);
weiRaised = weiRaised.add(weiAmount);
tokensSold = tokensSold.add(tokens);
balances[investor] = balances[investor].add(weiAmount);
assert(token.transferFrom(tokenOwner, investor, tokens));
TokenPurchase(msg.sender, investor, weiAmount, tokens);
wallet.transfer(msg.value);
} | 0 |
function SmartOToken() public {
balances[msg.sender] = initialSupply;
totalSupply = initialSupply;
} | 0 |
function isUnowned(uint id) constant validID(id) returns(bool) {
return plots[id].owner == 0x0;
} | 0 |
function identityOf(bytes32 _id) constant returns (string identity);
function ownerOf(bytes32 _id) constant returns (address owner);
}
contract Devcon2Token is TokenInterface {
using TokenLib for TokenLib.Token;
mapping (address => bool) public minters;
uint constant _END_MINTING = 1474502400;
function END_MINTING() constant returns (uint) {
return _END_MINTING;
} | 0 |
modifier inProgress() {
require (!isFinished);
require (issuedTokensAmount < maxTokensAmount);
require (now <= endDate);
_;
} | 1 |
function Rouleth() private
{
developer = msg.sender;
blockDelay=2;
blockExpiration=200;
maxGamble=500 finney;
maxBetsPerBlock=5;
casinoStatisticalLimit=20;
} | 0 |
function newMember(uint8 _memberId, bytes32 _memberName, address _memberAddress) public;
function getMembershipStatus(address _memberAddress) public view returns (bool member, uint8 memberId);
function getMemberInformation(uint8 _memberId) public view returns (bytes32 memberName, string memberKey, uint64 memberSince, uint64 inactiveSince, address memberAddress);
}
contract theCyberGatekeeper {
address private constant THECYBERADDRESS_ = 0x97A99C819544AD0617F48379840941eFbe1bfAE1;
uint8 private constant MAXENTRANTS_ = 250;
bool private active_ = true;
address[] private entrants_;
uint8 private nextAssigneeIndex_;
mapping (address => bool) private interactions_;
mapping (bytes32 => bool) private knownHashes_;
mapping (bytes32 => bool) private acceptedPasscodes_;
modifier checkOne() {
require(entrants_.length <= MAXENTRANTS_);
_;
} | 0 |
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) internal _balances;
mapping (address => mapping (address => uint256)) internal _allowances;
uint256 internal _totalSupply;
constructor() internal {
} | 0 |
function exchange(address receiver) public payable {
uint256 amount = msg.value;
uint256 price = getRate();
uint256 numTokens = amount.mul(price);
bool isPreICO = (now <= preICO.date);
bool isICO = (now >= icoStarts.date && now <= icoEnds.date);
require(isPreICO || isICO);
require(numTokens > 500);
if (isPreICO) {
require(!crowdsaleEnded && pre_tokensSold.add(numTokens) <= preICOLimit);
require(numTokens <= 5000000e18);
}
if (isICO) {
require(!crowdsaleEnded && tokensSold.add(numTokens) <= icoLimit);
}
wallet.transfer(amount);
balances[receiver] = balances[receiver].add(amount);
amountRaised = amountRaised.add(amount);
if (isPreICO)
pre_tokensSold = pre_tokensSold.add(numTokens);
if (isICO)
tokensSold = tokensSold.add(numTokens);
assert(tokenReward.transferFrom(tokenOwner, receiver, numTokens));
emit FundTransfer(receiver, amount, true, amountRaised);
} | 0 |
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 |
function transfer(address to, uint256 amount)
public
returns (bool success);
}
contract Reclaimable is AccessControlled, AccessRoles {
IBasicToken constant internal RECLAIM_ETHER = IBasicToken(0x0);
function reclaim(IBasicToken token)
public
only(ROLE_RECLAIMER)
{
address reclaimer = msg.sender;
if(token == RECLAIM_ETHER) {
reclaimer.transfer(this.balance);
} else {
uint256 balance = token.balanceOf(this);
require(token.transfer(reclaimer, balance));
}
} | 0 |
function getCheckResultMessage(Data storage , BTTSTokenInterface.CheckResult result) public pure returns (string) {
if (result == BTTSTokenInterface.CheckResult.Success) {
return "Success";
} else if (result == BTTSTokenInterface.CheckResult.NotTransferable) {
return "Tokens not transferable yet";
} else if (result == BTTSTokenInterface.CheckResult.AccountLocked) {
return "Account locked";
} else if (result == BTTSTokenInterface.CheckResult.SignerMismatch) {
return "Mismatch in signing account";
} else if (result == BTTSTokenInterface.CheckResult.AlreadyExecuted) {
return "Transfer already executed";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientApprovedTokens) {
return "Insufficient approved tokens";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientApprovedTokensForFees) {
return "Insufficient approved tokens for fees";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientTokens) {
return "Insufficient tokens";
} else if (result == BTTSTokenInterface.CheckResult.InsufficientTokensForFees) {
return "Insufficient tokens for fees";
} else if (result == BTTSTokenInterface.CheckResult.OverflowError) {
return "Overflow error";
} else {
return "Unknown error";
}
} | 0 |
function contributeFor(address _beneficiary) public payable returns (uint) {
target.contributeFor.value(msg.value)(_beneficiary);
} | 0 |
function closeSale() public onlyOwner {
require(!closed);
closed = true;
disableMinting();
} | 1 |
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 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 |
function balanceOf(address _owner) constant returns (uint balance)
{
return balances[_owner];
} | 0 |
function canRefund() public view returns (bool) {
return totalWeiReceived < minCapWei && endTime < now && now <= refundDeadlineTime;
} | 0 |
modifier onUnlocked() {
require(now >= lock, "Wallet locked");
_;
} | 0 |
function DetailedERC20(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
} | 0 |
function setUpdater(address _updater) external onlyOwner {
updater = _updater;
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMathLibExt {
function times(uint a, uint b) public pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function totalSupply() external constant returns (uint);
function balanceOf(address tokenOwner) external constant returns (uint balance);
function allowance(address tokenOwner, address spender) external constant returns (uint remaining);
function transfer(address to, uint tokens) external returns (bool success);
function approve(address spender, uint tokens) external returns (bool success);
function transferFrom(address from, address to, uint tokens) external returns (bool success);
function burn(uint256 _value) external;
event Transfer(address indexed from, address indexed to, uint tokens);
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);
event Burn(address indexed burner, uint256 value);
}
contract KRCPreSaleContract is Ownable{
using SafeMath for uint256;
TokenInterface public token;
uint256 public startTime;
uint256 public endTime;
uint256 public ratePerWei;
uint256 public weiRaised;
uint256 public TOKENS_SOLD;
uint256 maxTokensToSale;
uint256 bonusInPhase1;
uint256 bonusInPhase2;
uint256 minimumContribution;
uint256 maximumContribution;
bool isCrowdsalePaused = false;
uint256 totalDurationInDays = 30 days;
uint256 LongTermFoundationBudgetAccumulated;
uint256 LegalContingencyFundsAccumulated;
uint256 MarketingAndCommunityOutreachAccumulated;
uint256 CashReserveFundAccumulated;
uint256 OperationalExpensesAccumulated;
uint256 SoftwareProductDevelopmentAccumulated;
uint256 FoundersTeamAndAdvisorsAccumulated;
uint256 LongTermFoundationBudgetPercentage;
uint256 LegalContingencyFundsPercentage;
uint256 MarketingAndCommunityOutreachPercentage;
uint256 CashReserveFundPercentage;
uint256 OperationalExpensesPercentage;
uint256 SoftwareProductDevelopmentPercentage;
uint256 FoundersTeamAndAdvisorsPercentage;
struct Whitelist {
string Email;
} | 0 |
modifier whenNotPaused() {
require(now >= endDate);
_;
} | 1 |
function transfer(address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value)
public returns (bool);
function transferFrom(address from, address to, uint256 value)
public returns (bool);
event Transfer(
address indexed from,
address indexed to,
uint256 value
);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable {
address public _owner;
event OwnershipTransferred(
address indexed previousOwner, address indexed newOwner
);
constructor() public {
_owner = msg.sender;
emit OwnershipTransferred(address(0), _owner);
} | 0 |
function ownerOf(bytes32 _id) constant returns (address owner);
}
contract Devcon2Token is TokenInterface {
using TokenLib for TokenLib.Token;
mapping (address => bool) public minters;
uint constant _END_MINTING = 1474502400;
function END_MINTING() constant returns (uint) {
return _END_MINTING;
} | 0 |
function addRole(address addr, string roleName)
internal
{
roles[roleName].add(addr);
RoleAdded(addr, roleName);
} | 0 |
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 allowance(address owner, address spender) constant returns (uint256) {
return allowed[owner][spender];
} | 0 |
function addAirdrop(address _beneficiary, uint256 _amount) public onlyOwnerOrSiteAccount {
require(_beneficiary != crowdsaleWallet);
require(_beneficiary != networkDevelopmentWallet);
require(_beneficiary != communityDevelopmentWallet);
require(_beneficiary != bountyWallet);
require(_beneficiary != siteAccount);
require(balances[_beneficiary] == 0 || isAirdrop(_beneficiary));
if (shortenedAirdrop[_beneficiary] != 0) {
shortenedAirdrop[_beneficiary] = shortenedAirdrop[_beneficiary].add(_amount);
}
else {
airdrop[_beneficiary] = airdrop[_beneficiary].add(_amount);
}
_transferFrom(msg.sender, crowdsaleWallet, _beneficiary, _amount);
emit Airdrop(_beneficiary, _amount);
} | 0 |
function updatePromoter3(address _address) external onlyOwner {
require(_address != address(0x0));
promoter3 = _address;
} | 0 |
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
} | 0 |
function setBounty(address _bounty, uint256 bountyTokens) onlyOwner external returns (bool success) {
require(_bounty != address(0));
bounty = _bounty;
uint256 bounties = bountyTokens * 10**18;
balances[bounty] = balances[bounty].add(bounties);
totalSupply = totalSupply.add(bounties);
NewTokens(bounties);
return true;
} | 0 |
function getProposal(uint proposalId) external view returns (Proposal memory) {
return proposals[proposalId];
} | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract LCD_newTest is ERC20 {
string public constant symbol = "LCD_newTest";
string public constant name = "LCD_newTest token";
uint8 public constant decimals = 8;
uint256 _totalSupply = 15 * 10**8;
address public owner;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
modifier notPaused{
require(now > 1509716751 || msg.sender == owner);
_;
} | 1 |
function withdraw()
isActivated()
isHuman()
public
{
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round_[_rID].end && round_[_rID].ended == false && round_[_rID].plyr != 0)
{
F3Ddatasets.EventReturns memory _eventData_;
round_[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit F3Devents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.P3DAmount,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit F3Devents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
} | 0 |
function Token() public {
creationTime = now;
} | 1 |
function approveAndCall(address _spender, uint256 _value, bytes memory _extraData)
public
returns (bool success) {
tokenRecipient spender = tokenRecipient(_spender);
if (approve(_spender, _value)) {
spender.receiveApproval(msg.sender, _value, address(this), _extraData);
return true;
}
} | 0 |
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 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
function transfer(address _to, uint256 _value) public returns (bool) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
} | 0 |
function mintAuditApproval(address _address, uint256 _value) public onlyAudit {
if (mintApprove[_address].amount > 0) {
require(mintApprove[_address].amount == _value, "Value is diferent");
}
else {
mintApprove[_address].amount = _value;
}
mintApprove[_address].audit = msg.sender;
if ((mintApprove[_address].admin != 0x0) && (mintApprove[_address].marketMaker != 0x0))
mint(_address, _value);
} | 0 |
function removePlot(address addr, uint id) private {
uint n = plotsOwned[addr].length;
for (uint8 i = 0; i < n; i++) {
if (plotsOwned[addr][i] == id) {
plotsOwned[addr][i] = plotsOwned[addr][n - 1];
delete plotsOwned[addr][n - 1];
plotsOwned[addr].length--;
break;
}
}
} | 0 |
function burn(uint256 _value) public {
_burn(msg.sender, _value);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.