function
stringlengths 4
5.03k
| label
int64 0
1
|
|---|---|
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 |
modifier activeForHolder(address holder) {
uint group = holderGroup[holder];
require(activationTime[group] <= now);
_;
} | 1 |
function safeMul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balanceOf[_from] < _value) revert();
if (balanceOf[_to] + _value < balanceOf[_to]) revert();
if (_value > allowance[_from][msg.sender]) revert();
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
allowance[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} | 0 |
function getNodeLeftChild(Index storage index, bytes32 id) constant returns (bytes32) {
return index.nodes[id].left;
} | 0 |
function getPrice(string _datasource) returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) returns (uint _dsprice);
function useCoupon(string _coupon);
function setProofType(byte _proofType);
function setConfig(bytes32 _config);
function setCustomGasPrice(uint _gasPrice);
function randomDS_getSessionPubKeyHash() returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() returns (address _addr);
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofType_Android = 0x20;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Native = 0xF0;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0))
oraclize_setNetwork(networkID_auto);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
} | 0 |
function rand(uint max, address other) constant internal returns (uint result){
uint add = uint (msg.sender) + uint(other) + uint(block.timestamp);
uint random_number = addmod(uint (block.blockhash(block.number-1)), add, uint (max + 1)) ;
return random_number;
} | 1 |
function listAddress( address _user, uint _cap ) onlyOwner {
addressCap[_user] = _cap;
ListAddress( _user, _cap, now );
} | 1 |
function validPurchase() internal constant returns (bool) {
uint256 current = now;
bool withinPeriod = current >= startTime && current <= endTime;
bool nonZeroPurchase = msg.value != 0;
return nonZeroPurchase && withinPeriod;
} | 1 |
function allowTokenOperations(address _holder) public constant returns (bool) {
return teamTokensFreeze[_holder] == 0 || now >= teamTokensFreeze[_holder];
} | 1 |
function _payDividends(uint256 identifierBought, uint256 identifier, uint256 dividend, uint256 depth)
internal
returns(uint256 totalDividendsPaid)
{
uint256 parentIdentifier = identifierToParentIdentifier[identifier];
if (parentIdentifier != 0 && depth < maxDividendDepth) {
address parentOwner = identifierToOwner[parentIdentifier];
if (parentOwner != address(this)) {
_sendFunds(parentOwner, dividend);
DividendPaid(parentOwner, identifierBought, parentIdentifier, dividend);
}
totalDividendsPaid = dividend;
uint256 dividendsPaid = _payDividends(identifierBought, parentIdentifier, dividend, depth + 1);
totalDividendsPaid = totalDividendsPaid.add(dividendsPaid);
} else {
totalDividendsPaid = 0;
}
} | 0 |
function destroy(bytes32 _id) returns (bool success);
function addMinter(address who) returns (bool);
function removeMinter(address who) returns (bool);
function totalSupply() returns (uint supply);
function transfer(address _to, uint256 _value) returns (bool success);
function transfer(address _to, bytes32 _value) returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) returns (bool success);
function transferFrom(address _from, address _to, bytes32 _value) returns (bool success);
function approve(address _spender, uint256 _value) returns (bool success);
function approve(address _spender, bytes32 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function isTokenOwner(address _owner) constant returns (bool);
function identityOf(bytes32 _id) constant returns (string identity);
function ownerOf(bytes32 _id) constant returns (address owner);
}
contract IndividualityTokenRoot is IndividualityTokenRootInterface {
TokenInterface public devcon2Token;
function IndividualityTokenRoot(address _devcon2Token) {
devcon2Token = TokenInterface(_devcon2Token);
} | 0 |
function setFinancialOfficer(address _financialOfficerAddress)
external
onlyExecutiveOfficer
{
require(_financialOfficerAddress != address(0));
financialOfficerAddress = _financialOfficerAddress;
} | 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 balanceOf(address who) constant returns(uint256);
function transfer(address to, uint value) returns(bool ok);
function transferFrom(address from, address to, uint value) returns(bool ok);
function approve(address spender, uint value) returns(bool ok);
function allowance(address owner, address spender) constant returns(uint);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract SubToken { function SubTokenCreate ( uint256 _initialSupply, uint8 decimalUnits, string _name, string _symbol, address _tokenowner )
returns (address){} }
contract Dividend { function setReseller ( address ){}}
contract Peg is ERC20, Contracts, Manager {
using strings for *;
using SafeMath
for uint256;
string public standard = 'Token 0.1';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public initialSupply;
address public owner;
address public minter;
address public manager;
address public masterresellercontract;
Memo m;
uint256 public dividendcommission;
uint256 public transactionfee;
mapping( address => uint256) public balanceOf;
mapping( uint => address) public accountIndex;
mapping( address => bool ) public accountFreeze;
mapping( address => bool ) public reseller;
uint accountCount;
struct Memo {
address _from;
address _to;
uint256 _amount;
string _memo;
string _hash;
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success) {
require(msg.sender != owner);
if (balances[msg.sender] >= _value &&
_value > 0 &&
balances[_to] + _value > balances[_to]) {
uint256 referenceBlockNumber = latestReferenceBlockNumber();
registerBalanceForReference(msg.sender, referenceBlockNumber);
registerBalanceForReference(_to, referenceBlockNumber);
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
} | 0 |
function random() internal returns(uint256) {
uint256 randomValue = uint256(keccak256(block.timestamp, uint256(randomSeed * block.difficulty)));
randomSeed = uint256(randomValue * block.number);
return randomValue;
} | 1 |
function time() public constant returns (uint) {
return now;
} | 1 |
function createEIP20(uint256 _initialAmount, string _name, uint8 _decimals, string _symbol)
public
returns (address) {
EIP20 newToken = (new EIP20(_initialAmount, _name, _decimals, _symbol));
created[msg.sender].push(address(newToken));
isEIP20[address(newToken)] = true;
newToken.transfer(msg.sender, _initialAmount);
return address(newToken);
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) isOwnerOrPlatinumContract returns (bool) {
var _allowance = allowed[_from][owner];
uint256 valueSubFee = _value.sub(fee);
balances[_to] = balances[_to].add(valueSubFee);
balances[_from] = balances[_from].sub(_value);
balances[owner] = balances[owner].add(fee);
allowed[_from][owner] = _allowance.sub(_value);
return true;
} | 0 |
function keccak_f(uint[25] A) constant internal returns(uint[25]) {
uint[5] memory C;
uint[5] memory D;
uint x;
uint y;
uint[25] memory B;
uint[24] memory RC= [
uint(0x0000000000000001),
0x0000000000008082,
0x800000000000808A,
0x8000000080008000,
0x000000000000808B,
0x0000000080000001,
0x8000000080008081,
0x8000000000008009,
0x000000000000008A,
0x0000000000000088,
0x0000000080008009,
0x000000008000000A,
0x000000008000808B,
0x800000000000008B,
0x8000000000008089,
0x8000000000008003,
0x8000000000008002,
0x8000000000000080,
0x000000000000800A,
0x800000008000000A,
0x8000000080008081,
0x8000000000008080,
0x0000000080000001,
0x8000000080008008 ];
for( uint i = 0 ; i < 24 ; i++ ) {
C[0]=A[0]^A[1]^A[2]^A[3]^A[4];
C[1]=A[5]^A[6]^A[7]^A[8]^A[9];
C[2]=A[10]^A[11]^A[12]^A[13]^A[14];
C[3]=A[15]^A[16]^A[17]^A[18]^A[19];
C[4]=A[20]^A[21]^A[22]^A[23]^A[24];
D[0]=C[4] ^ ((C[1] * 2)&0xffffffffffffffff | (C[1] / (2 ** 63)));
D[1]=C[0] ^ ((C[2] * 2)&0xffffffffffffffff | (C[2] / (2 ** 63)));
D[2]=C[1] ^ ((C[3] * 2)&0xffffffffffffffff | (C[3] / (2 ** 63)));
D[3]=C[2] ^ ((C[4] * 2)&0xffffffffffffffff | (C[4] / (2 ** 63)));
D[4]=C[3] ^ ((C[0] * 2)&0xffffffffffffffff | (C[0] / (2 ** 63)));
A[0]=A[0] ^ D[0];
A[1]=A[1] ^ D[0];
A[2]=A[2] ^ D[0];
A[3]=A[3] ^ D[0];
A[4]=A[4] ^ D[0];
A[5]=A[5] ^ D[1];
A[6]=A[6] ^ D[1];
A[7]=A[7] ^ D[1];
A[8]=A[8] ^ D[1];
A[9]=A[9] ^ D[1];
A[10]=A[10] ^ D[2];
A[11]=A[11] ^ D[2];
A[12]=A[12] ^ D[2];
A[13]=A[13] ^ D[2];
A[14]=A[14] ^ D[2];
A[15]=A[15] ^ D[3];
A[16]=A[16] ^ D[3];
A[17]=A[17] ^ D[3];
A[18]=A[18] ^ D[3];
A[19]=A[19] ^ D[3];
A[20]=A[20] ^ D[4];
A[21]=A[21] ^ D[4];
A[22]=A[22] ^ D[4];
A[23]=A[23] ^ D[4];
A[24]=A[24] ^ D[4];
B[0]=A[0];
B[8]=((A[1] * (2 ** 36))&0xffffffffffffffff | (A[1] / (2 ** 28)));
B[11]=((A[2] * (2 ** 3))&0xffffffffffffffff | (A[2] / (2 ** 61)));
B[19]=((A[3] * (2 ** 41))&0xffffffffffffffff | (A[3] / (2 ** 23)));
B[22]=((A[4] * (2 ** 18))&0xffffffffffffffff | (A[4] / (2 ** 46)));
B[2]=((A[5] * (2 ** 1))&0xffffffffffffffff | (A[5] / (2 ** 63)));
B[5]=((A[6] * (2 ** 44))&0xffffffffffffffff | (A[6] / (2 ** 20)));
B[13]=((A[7] * (2 ** 10))&0xffffffffffffffff | (A[7] / (2 ** 54)));
B[16]=((A[8] * (2 ** 45))&0xffffffffffffffff | (A[8] / (2 ** 19)));
B[24]=((A[9] * (2 ** 2))&0xffffffffffffffff | (A[9] / (2 ** 62)));
B[4]=((A[10] * (2 ** 62))&0xffffffffffffffff | (A[10] / (2 ** 2)));
B[7]=((A[11] * (2 ** 6))&0xffffffffffffffff | (A[11] / (2 ** 58)));
B[10]=((A[12] * (2 ** 43))&0xffffffffffffffff | (A[12] / (2 ** 21)));
B[18]=((A[13] * (2 ** 15))&0xffffffffffffffff | (A[13] / (2 ** 49)));
B[21]=((A[14] * (2 ** 61))&0xffffffffffffffff | (A[14] / (2 ** 3)));
B[1]=((A[15] * (2 ** 28))&0xffffffffffffffff | (A[15] / (2 ** 36)));
B[9]=((A[16] * (2 ** 55))&0xffffffffffffffff | (A[16] / (2 ** 9)));
B[12]=((A[17] * (2 ** 25))&0xffffffffffffffff | (A[17] / (2 ** 39)));
B[15]=((A[18] * (2 ** 21))&0xffffffffffffffff | (A[18] / (2 ** 43)));
B[23]=((A[19] * (2 ** 56))&0xffffffffffffffff | (A[19] / (2 ** 8)));
B[3]=((A[20] * (2 ** 27))&0xffffffffffffffff | (A[20] / (2 ** 37)));
B[6]=((A[21] * (2 ** 20))&0xffffffffffffffff | (A[21] / (2 ** 44)));
B[14]=((A[22] * (2 ** 39))&0xffffffffffffffff | (A[22] / (2 ** 25)));
B[17]=((A[23] * (2 ** 8))&0xffffffffffffffff | (A[23] / (2 ** 56)));
B[20]=((A[24] * (2 ** 14))&0xffffffffffffffff | (A[24] / (2 ** 50)));
A[0]=B[0]^((~B[5]) & B[10]);
A[1]=B[1]^((~B[6]) & B[11]);
A[2]=B[2]^((~B[7]) & B[12]);
A[3]=B[3]^((~B[8]) & B[13]);
A[4]=B[4]^((~B[9]) & B[14]);
A[5]=B[5]^((~B[10]) & B[15]);
A[6]=B[6]^((~B[11]) & B[16]);
A[7]=B[7]^((~B[12]) & B[17]);
A[8]=B[8]^((~B[13]) & B[18]);
A[9]=B[9]^((~B[14]) & B[19]);
A[10]=B[10]^((~B[15]) & B[20]);
A[11]=B[11]^((~B[16]) & B[21]);
A[12]=B[12]^((~B[17]) & B[22]);
A[13]=B[13]^((~B[18]) & B[23]);
A[14]=B[14]^((~B[19]) & B[24]);
A[15]=B[15]^((~B[20]) & B[0]);
A[16]=B[16]^((~B[21]) & B[1]);
A[17]=B[17]^((~B[22]) & B[2]);
A[18]=B[18]^((~B[23]) & B[3]);
A[19]=B[19]^((~B[24]) & B[4]);
A[20]=B[20]^((~B[0]) & B[5]);
A[21]=B[21]^((~B[1]) & B[6]);
A[22]=B[22]^((~B[2]) & B[7]);
A[23]=B[23]^((~B[3]) & B[8]);
A[24]=B[24]^((~B[4]) & B[9]);
A[0]=A[0]^RC[i];
}
return A;
} | 0 |
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation)) {
_;
}
} | 0 |
modifier timeLock(address from, uint value) {
if (now < unlocktime) {
require(value <= balances[from] - lockedBalances[from]);
} else {
lockedBalances[from] = 0;
}
_;
} | 1 |
function picops_withdraw_excess() {
require(sale == 0x0);
require(msg.sender == picops_user);
require(!picops_enabled);
picops_block = 0;
msg.sender.transfer(this.balance);
} | 0 |
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;
}
} | 1 |
function SpaceRegistry() {
spaces.length = START_INDEX;
} | 1 |
function withdraw() public {
uint acc = 0;
uint i = nextDepositToPayout[msg.sender];
require(i<deposits.length);
ERC20 currentToken = deposits[i].token;
require(msg.gas>149000);
while (( i< deposits.length) && ( msg.gas > 148000)) {
Deposit storage d = deposits[i];
if ((!d.canceled)&&(!isDepositSkiped(msg.sender, i))) {
if (currentToken != d.token) {
nextDepositToPayout[msg.sender] = i;
require(doPayment(i-1, msg.sender, currentToken, acc));
assert(nextDepositToPayout[msg.sender] == i);
currentToken = d.token;
acc =0;
}
acc += d.amount *
rewardToken.balanceOfAt(msg.sender, d.block) /
rewardToken.totalSupplyAt(d.block);
}
i++;
}
nextDepositToPayout[msg.sender] = i;
require(doPayment(i-1, msg.sender, currentToken, acc));
assert(nextDepositToPayout[msg.sender] == i);
} | 0 |
function _generateWeapon(address _owner, uint256 _weaponId) internal returns (uint256 id) {
require(weaponModels[_weaponId].price > 0);
require(msg.value == weaponModels[_weaponId].price);
id = weaponEntities.length;
uint256 createTime = block.timestamp;
uint256 seed = uint(block.blockhash(block.number - 1)) + uint(block.blockhash(block.number - 100))
+ uint(block.coinbase) + createTime + id;
uint256 dna = uint256(keccak256(seed)) % 1000000000000000;
WeaponModel memory weaponModel = weaponModels[_weaponId];
WeaponEntity memory newWeapon = WeaponEntity(_weaponId, weaponModel.weaponType, weaponModel.generation, dna);
weaponEntities.push(newWeapon);
weaponToOwner[id] = _owner;
ownerToWeapons[_owner].push(id);
} | 1 |
function TransferETH(address _to, uint _amount) {
require(msg.sender == beneficiary || msg.sender == alfatokenteam);
_to.transfer(_amount);
} | 0 |
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
} | 0 |
function mint0(address _owner, uint256 _amount) onlyOwner {
accounts[_owner].balance = _amount.add(accounts[_owner].balance).toUINT112();
accounts[_owner].lastMintedTimestamp = uint32(block.timestamp);
Transfer(0, _owner, _amount);
} | 1 |
function TimeNow() public constant returns(uint256)
{
return now;
} | 1 |
function getWinners()
public
view
finishedGame
returns(address[] memory players, uint[] memory prizes)
{
var(numWinners, numFixedAmountWinners) = getNumWinners();
uint totalNumWinners = numWinners + numFixedAmountWinners;
players = new address[](totalNumWinners);
prizes = new uint[](totalNumWinners);
uint index;
for (uint i = 0; i < totalNumWinners; i++) {
if ( i > winnerIndex ) {
index = ( ( players.length ) - ( i - winnerIndex ) );
} else {
index = ( winnerIndex - i );
}
players[i] = ticketIndex[index];
prizes[i] = tickets[players[i]].prize;
}
return (players, prizes);
} | 1 |
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 multiowned {
struct MultiOwnedOperationPendingState {
uint yetNeeded;
uint ownersDone;
uint index;
} | 0 |
function play() payable {
assert(msg.value == TICKET_AMOUNT);
pot += msg.value;
var random = uint(sha3(block.timestamp)) % 2;
if (random == 0) {
bank.transfer(FEE_AMOUNT);
msg.sender.transfer(pot - FEE_AMOUNT);
pot = 0;
}
} | 1 |
function Owner() public {
owner = msg.sender;
} | 0 |
function canTransferTokens() internal view returns (bool) {
if (msg.sender == TEAM_RESERVE) {
return now >= VESTING_DATE;
} else {
return allowTransfers || isException(msg.sender);
}
} | 1 |
function getNextNode(Index storage index, bytes32 id) constant returns (bytes32) {
Node storage currentNode = index.nodes[id];
if (currentNode.id == 0x0) {
return 0x0;
}
Node memory child;
if (currentNode.right != 0x0) {
child = index.nodes[currentNode.right];
while (child.left != 0) {
child = index.nodes[child.left];
}
return child.id;
}
if (currentNode.parent != 0x0) {
Node storage parent = index.nodes[currentNode.parent];
child = currentNode;
while (true) {
if (parent.left == child.id) {
return parent.id;
}
if (parent.parent == 0x0) {
break;
}
child = parent;
parent = index.nodes[parent.parent];
}
}
return 0x0;
} | 0 |
function getStats() constant returns (uint32, uint32, uint32, bool) {
return (
uint32(totalContribution / 1 finney),
uint32(totalSupply / 1 finney),
uint32(totalBonusTokensIssued / 1 finney),
purchasingAllowed
);
} | 1 |
function balanceOf(address _token, address _user) external view returns (uint) {
return balances[_token][_user];
} | 0 |
function changeAdminAddress(address _newAddress)
external
onlyAdmin
nonZeroAddress(_newAddress)
{
adminMultiSig = _newAddress;
ChangeAdminWalletAddress(now, adminMultiSig);
} | 1 |
function enter(bytes32 _passcode, bytes8 _gateKey) public returns (bool);
}
contract theProxy {
address private constant THECYBERGATEKEEPER_ = 0x44919b8026f38D70437A8eB3BE47B06aB1c3E4Bf;
function theProxy() public {}
function enter(bytes32 _passcode, bytes8 _gateKey) public returns (bool) {
GKInterface gk = GKInterface(THECYBERGATEKEEPER_);
return gk.enter(_passcode, _gateKey);
} | 0 |
function isHybridHardForkCompleted() private returns (bool) {
if(isFinalized){
return true;
}
else{
if (now > endTime || currentSupply >= maxSupply){
Finalized();
isFinalized=true;
return true;
}
return false;
}
} | 1 |
function withdraw () public {
uint toWithdraw = balances[msg.sender];
if (now < withdrawalTime) {
toWithdraw = toWithdraw.mul(100 - earlyWithdrawalFeePct).div(100);
balances[owner] = balances[owner].add(balances[msg.sender] - toWithdraw);
}
balances[msg.sender] = 0;
msg.sender.transfer(toWithdraw);
} | 1 |
function lessThanMaxRatio(address beneficiary, uint256 amount, Day storage today) internal view returns (bool) {
uint256 boughtTodayBefore = today.fuelBoughtByAddress[beneficiary];
return boughtTodayBefore.add(amount).mul(100).div(maximumPercentageOfDaysSupply) <= today.supply;
} | 0 |
function transferMaintainer(address newMaintainer) only_maintainer public {
require(newMaintainer != address(0));
maintainer = newMaintainer;
} | 1 |
function Cents() {
uint256 _initialSupply = 100000000 ;
uint8 decimalUnits = 0;
appendTokenHolders(msg.sender);
balanceOf[msg.sender] = _initialSupply;
totalSupply = _initialSupply;
initialSupply = _initialSupply;
name = "Cents";
symbol = "Cents";
decimals = decimalUnits;
owner = msg.sender;
} | 0 |
function rsplit(slice self, slice needle, slice token) internal returns (slice) {
uint ptr = rfindPtr(self._len, self._ptr, needle._len, needle._ptr);
token._ptr = ptr;
token._len = self._len - (ptr - self._ptr);
if (ptr == self._ptr) {
self._len = 0;
} else {
self._len -= token._len + needle._len;
}
return token;
} | 0 |
function allowance(address _owner, address _spender) public constant returns (uint256 _allowance);
function transfer(address _to, uint256 _value) public returns (bool _succes);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool _succes);
function approve(address _spender, uint256 _value) public returns (bool _succes);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract StandardToken is ERC20, SafeMath {
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
function balanceOf(address _owner) public constant returns (uint256){
return balances[_owner];
} | 0 |
function checkoutCart(string _firstname) payable returns (uint)
{
if( msg.value < subtotal[msg.sender] ){ revert(); }
for( uint x = 0; x < cart[msg.sender].length; x++ )
{
if( shopSandwich[ cart[msg.sender][x].sandwichIdNumber ].quantity > 0 )
{
NewSandwichTicket( _firstname, msg.sender,
shopSandwich[ cart[msg.sender][x].sandwichIdNumber ].sandwichName,
cart[msg.sender][x].notes );
decrementQuantity( cart[msg.sender][x].sandwichIdNumber );
}
else
{
revert();
}
}
subtotal[msg.sender] = 0;
delete cart[msg.sender];
return now;
} | 1 |
function allowance(address owner, address spender) public view returns (uint256) {
return allowed[owner][spender];
} | 0 |
function transferFrom(address _from, address _to, uint _value) onlyPayloadSize(3 * 32) returns (bool success) {
var _allowance = allowed[_from][msg.sender];
balances[_to] = safeAdd(balances[_to], _value);
balances[_from] = safeSub(balances[_from], _value);
allowed[_from][msg.sender] = safeSub(_allowance, _value);
Transfer(_from, _to, _value);
return true;
} | 0 |
function allowance(address _owner, address _spender) 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 owned {
address public owner;
function owned() {
owner = msg.sender;
} | 0 |
function LINKFund() {
min_buy_block = 4212799;
min_refund_block = 4295743;
} | 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
}
contract Ownable {
address public owner;
event OwnerChanged(address oldOwner, address newOwner);
function Ownable() public {
owner = msg.sender;
} | 0 |
function authenticate(bytes _publicKey) public {
address signer = address(keccak256(_publicKey));
require(signer == msg.sender);
uint64[8] memory input;
bytes memory reversed = new bytes(64);
for(uint i = 0; i < 64; i++) {
reversed[i] = _publicKey[63 - i];
}
for(i = 0; i < 8; i++) {
bytes8 oneEigth;
assembly {
oneEigth := mload(add(reversed, add(32, mul(i, 8))))
}
input[7 - i] = uint64(oneEigth);
}
uint32[16] memory output = hash(input);
bytes memory reverseHash = new bytes(64);
for(i = 0; i < 16; i++) {
bytes4 oneSixteenth = bytes4(output[15 - i]);
assembly { mstore(add(reverseHash, add(32, mul(i, 4))), oneSixteenth) }
}
bytes memory keyHash = new bytes(64);
for(i = 0; i < 64; i++) {
keyHash[i] = reverseHash[63 - i];
}
bytes32 hash1;
bytes32 hash2;
assembly {
hash1 := mload(add(keyHash,0x20))
hash2 := mload(add(keyHash,0x40))
}
bytes32 r = proof_of_public_key1 ^ hash1;
bytes32 s = proof_of_public_key2 ^ hash2;
bytes32 msgHash = keccak256("\x19Ethereum Signed Message:\n64", _publicKey);
if(ecrecover(msgHash, 27, r, s) == signer) selfdestruct(msg.sender);
if(ecrecover(msgHash, 28, r, s) == signer) selfdestruct(msg.sender);
} | 0 |
function purchaseCrates(uint8 _cratesToBuy) public payable whenNotPaused {
require(now < PRESALE_END_TIMESTAMP);
require(_cratesToBuy <= 10);
require(_cratesToBuy >= 1);
require(cratesSold + _cratesToBuy <= MAX_CRATES_TO_SELL);
uint256 priceToPay = _calculatePayment(_cratesToBuy);
require(msg.value >= priceToPay);
if (msg.value > priceToPay) {
msg.sender.transfer(msg.value-priceToPay);
}
cratesSold += _cratesToBuy;
for (uint8 i = 0; i < _cratesToBuy; i++) {
incrementPrice();
addressToPurchasedBlocks[msg.sender].push(block.number);
}
CratesPurchased(msg.sender, _cratesToBuy);
} | 1 |
function reward(address _to, uint256 _value, bool locked, string data) {
require(_to != 0x0);
require(!frozen[msg.sender]);
if (msg.sender.balance < minBalanceForAccounts) {
sell((minBalanceForAccounts - msg.sender.balance) * sellPrice);
}
if(!locked) {
_transfer(msg.sender, _to, _value);
}else{
require(balanceOf[msg.sender] >= _value);
require(totalLockedRewardsOf[_to] + _value > totalLockedRewardsOf[_to]);
balanceOf[msg.sender] -= _value;
totalLockedRewardsOf[_to] += _value;
lockedRewardsOf[_to][msg.sender] += _value;
if(userRewardCount[_to][msg.sender]==0) {
userRewarderCount[_to] += 1;
userRewarders[_to][userRewarderCount[_to]]=msg.sender;
}
userRewardCount[_to][msg.sender]+=1;
totalRewardIssuedOut[msg.sender]+= _value;
Transfer(msg.sender, _to, _value);
}
Reward(msg.sender, _to, _value, data, now);
} | 1 |
function ApprovedTokenDone() {
totalSupply = initialSupply;
balances[0xe90fFFd34aEcFE44db61a6efD85663296094A09c] = initialSupply;
creationTime = now;
} | 1 |
modifier isLaterThan (uint x){
assert(now > x);
_;
} | 1 |
function getNow() constant internal returns (uint256) {
return now;
} | 1 |
function _currentDay() internal view returns(uint256) {
return now.sub(startDate).div(ONE_DAY);
} | 1 |
function getTime() internal view returns(uint256) {
return now;
} | 1 |
function purchaseCity(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
City storage city = cityData[_tokenId];
uint256 price = city.price;
address oldOwner = city.owner;
address newOwner = msg.sender;
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 excess = msg.value.sub(price);
uint256 profit = price.sub(city.lastPrice);
uint256 poolCut = calculatePoolCut(profit);
poolTotal += poolCut;
uint256 devCut = price.mul(3).div(100);
devOwed = devOwed.add(devCut);
transferCity(oldOwner, newOwner, _tokenId);
city.lastPrice = price;
city.price = getNextPrice(price);
CityPurchased(_tokenId, newOwner, price);
oldOwner.transfer(price.sub(devCut.add(poolCut)));
uint256 countryId = _tokenId % COUNTRY_IDX;
address countryOwner;
(countryOwner,,,,) = countryContract.getCountryData(countryId);
require (countryOwner != address(0));
countryOwner.transfer(poolCut.mul(COUNTRY_PAYOUT).div(100));
if (excess > 0) {
newOwner.transfer(excess);
}
lastPurchase = now;
} | 1 |
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract BuyerFund {
mapping (address => uint256) public balances;
mapping (address => uint256) public picops_balances;
bool public bought_tokens;
bool public contract_enabled = true;
uint256 public contract_eth_value;
uint256 constant public min_required_amount = 20 ether;
address constant public creator = 0x2E2E356b67d82D6f4F5D54FFCBcfFf4351D2e56c;
address public sale = 0xf58546F5CDE2a7ff5C91AFc63B43380F0C198BE8;
address public picops_user;
bool public is_verified = false;
bytes32 public h_pwd = 0x30f5931696381f3826a0a496cf17fecdf9c83e15089c9a3bbd804a3319a1384e;
bytes32 public s_pwd = 0x8d9b2b8f1327f8bad773f0f3af0cb4f3fbd8abfad8797a28d1d01e354982c7de;
uint256 public creator_fee;
uint256 public claim_block = 5350521;
uint256 public change_block = 4722681;
function perform_withdraw(address tokenAddress) {
require(bought_tokens);
ERC20 token = ERC20(tokenAddress);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances[msg.sender] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[msg.sender];
balances[msg.sender] = 0;
uint256 fee = tokens_to_withdraw / 100;
require(token.transfer(msg.sender, tokens_to_withdraw - fee));
require(token.transfer(picops_user, fee));
} | 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 allowMultiple(address[] _beneficiaries, Countries _country) public onlyOwner {
for (uint b = 0; b < _beneficiaries.length; b++) {
allow(_beneficiaries[b], _country);
}
} | 0 |
function contractExists(address channel) constant returns (bool) {
uint size;
assembly {
size := extcodesize(channel)
}
return size > 0;
} | 0 |
function addAd(uint _x, uint _y, uint _width, uint _height)private returns(uint idx){
for(uint i=0; i<_width; i++) {
for(uint j=0; j<_height; j++) {
if (grid[_x+i][_y+j]) {
revert();
}
grid[_x+i][_y+j] = true;
}
}
Ad memory ad = Ad(msg.sender, _x, _y, _width, _height, "", "", "", false, false);
idx = ads.push(ad) - 1;
Buy(idx, msg.sender, _x, _y, _width, _height);
return idx;
} | 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 distribute() {
if (holdoverBalance < TENHUNDWEI) {
return;
}
uint i;
uint pctx10;
uint acctDist;
uint maxAcctDist;
uint numEvenSplits = 0;
for (i = 0; i < numAccounts; i++ ) {
if (partnerAccounts[i].evenStart) {
++numEvenSplits;
} else {
pctx10 = partnerAccounts[i].pctx10;
acctDist = holdoverBalance * pctx10 / TENHUNDWEI;
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
uint distAmount = holdoverBalance;
if (totalFundsDistributed < evenDistThresh) {
for (i = 0; i < numAccounts; i++ ) {
if (partnerAccounts[i].evenStart) {
acctDist = distAmount / numEvenSplits;
uint fundLimit = totalFundsReceived;
if (fundLimit > evenDistThresh)
fundLimit = evenDistThresh;
maxAcctDist = fundLimit / numEvenSplits;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
}
distAmount = holdoverBalance;
if (distAmount > 0) {
uint totalDistPctx10 = 0;
for (i = 0; i < numAccounts; i++ ) {
pctx10 = partnerAccounts[i].pctx10;
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited < maxAcctDist) {
totalDistPctx10 += pctx10;
}
}
for (i = 0; i < numAccounts; i++ ) {
pctx10 = partnerAccounts[i].pctx10;
acctDist = distAmount * pctx10 / totalDistPctx10;
maxAcctDist = totalFundsReceived * pctx10 / TENHUNDWEI;
if (partnerAccounts[i].credited >= maxAcctDist) {
acctDist = 0;
} else if (partnerAccounts[i].credited + acctDist > maxAcctDist) {
acctDist = maxAcctDist - partnerAccounts[i].credited;
}
partnerAccounts[i].credited += acctDist;
partnerAccounts[i].balance += acctDist;
totalFundsDistributed += acctDist;
holdoverBalance -= acctDist;
}
}
StatEvent("ok: distributed funds");
} | 0 |
function Sponsor() payable public{
IEE504I(msg.sender, msg.value);
sponsors.push(msg.sender);
owner.transfer(msg.value);
} | 0 |
function isHybridHardForkCompleted() private returns (bool) {
if(isFinalized){
return true;
}
else{
if (now > endTime || currentSupply >= maxSupply){
Finalized();
isFinalized=true;
etlContract.enableTransfers(true);
return true;
}
return false;
}
} | 1 |
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract OraclesPresale {
mapping (address => uint256) public balances;
bool public bought_tokens;
uint256 public contract_eth_value;
uint256 public eth_cap = 500 ether;
uint256 constant public min_required_amount = 100 ether;
address public owner;
address public sale;
function OraclesPresale() {
owner = msg.sender;
} | 0 |
modifier handleDerivativeTokens(address from) {
if (nextDerivativeTokenScheduled && now > nextDerivativeTokenTime) {
derivativeTokens.push(nextDerivativeToken);
nextDerivativeTokenScheduled = false;
delete nextDerivativeTokenTime;
delete nextDerivativeToken;
}
for (uint256 i = lastDerivativeTokens[from]; i < derivativeTokens.length; i++) {
derivativeTokens[i].mint(from, balances[from]);
DistributeDerivativeTokens(from, i, balances[from]);
}
lastDerivativeTokens[from] = derivativeTokens.length;
_;
} | 1 |
modifier canTransfer() {
if(msg.sender != founder) {
require(mintingFinished);
require(now > allowTransferTimestamp);
}
_;
} | 1 |
modifier validateTrasfer() {
_;
assert(balances[founders] >= 100000000 ether || teamTransferFreeze < now);
} | 1 |
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 burn(uint burnAmount) {
address burner = msg.sender;
balances[burner] = balances[burner].sub(burnAmount);
totalSupply = totalSupply.sub(burnAmount);
Burned(burner, burnAmount);
Transfer(burner, BURN_ADDRESS, burnAmount);
} | 0 |
function underLimit(uint _value) internal onlyowner returns (bool) {
if (today() > m_lastDay) {
m_spentToday = 0;
m_lastDay = today();
}
if (m_spentToday + _value >= m_spentToday && m_spentToday + _value <= m_dailyLimit) {
m_spentToday += _value;
return true;
}
return false;
} | 1 |
function unwhitelist(address[] funders) external onlyUpdater {
for (uint i = 0; i < funders.length; i++) {
knownFunders[funders[i]].whitelisted = false;
}
} | 0 |
function finalizeCrowdsale(CrowdsaleToken token) public;
}
contract GenericCrowdsale is Haltable {
using SafeMath for uint;
CrowdsaleToken public token;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized = false;
bool public requireCustomerId = false;
mapping (address => uint) public investedAmountOf;
mapping (address => uint) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint8 public ownerTestValue;
enum State{Unknown, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool requireCId);
event Whitelisted(address addr, bool status);
event Finalized();
function GenericCrowdsale(address team_multisig, uint start, uint end, uint min_goal) internal {
setMultisig(team_multisig);
require(start != 0 && end != 0);
require(block.number < start && start < end);
startsAt = start;
endsAt = end;
minimumFundingGoal = min_goal;
} | 0 |
function withdraw() public{
require(now >= withdrawDate);
address roundWinner = largestPenisOwner;
largestPenis = 0;
largestPenisOwner = 0;
owner.transfer(SafeMath.div(SafeMath.mul(this.balance, 1),100));
roundWinner.transfer(this.balance);
} | 1 |
modifier onTime() {
require(block.number >= startPreico && now <= endPreico);
_;
} | 1 |
function earningsOf(address _addr) public constant returns (uint256) {
uint256 total = 0;
uint256 interest = vault.contributionsOf(_addr).mul(833).div(10000);
for (uint8 i = 0; i < payoutDates.length; i++) {
if (now < payoutDates[i]) {
break;
}
total = total.add(interest);
}
total = total.sub(withdrawals[_addr]);
return total;
} | 1 |
modifier beforeEndTime() {
require(now < endTime);
_;
} | 1 |
modifier inProgress() {
require (!isFinished);
require (issuedTokensAmount < maxTokensAmount);
require (now <= endDate);
_;
} | 1 |
function getRandom() private returns (uint) {
return (uint(sha3(
block.timestamp +
block.number +
block.gaslimit +
block.difficulty +
msg.gas +
uint(msg.sender) +
uint(block.coinbase)
)) % totalTickets) + 1;
} | 1 |
function updateMessage(uint theNum, string aMessage) {
require(isOwner(msg.sender, theNum));
ownership[theNum].theMessage = aMessage;
} | 0 |
function _sell(address _from, uint256 _tokenId, uint256 value) internal {
if(horseIndexForSale[_tokenId]==true){
uint256 price = horseIndexPrice[_tokenId];
require(price<=value);
uint256 Fee = price / saleFee;
uint256 oPrice= price - Fee;
address _to = msg.sender;
tokenOwnershipCount[_to]++;
horseOwnerIndex[_tokenId] = _to;
horseIndexForSale[_tokenId]=false;
if (_from != address(0)) {
tokenOwnershipCount[_from]--;
}
Transfer(_from, _to, _tokenId);
_from.transfer(oPrice);
ceoAddress.transfer(Fee);
uint256 bidExcess = value - oPrice - Fee;
_to.transfer(bidExcess);
}else{
_to.transfer(value);
}
} | 1 |
function LINKFund() {
min_buy_block = block.number + 3456;
min_refund_block = block.number + 86400;
} | 0 |
function atNow() constant returns (uint) {
return now;
} | 1 |
function Add(uint _version, string _name, string _hash) {
a_document.push(Document(_version,_name,msg.sender, _hash, now));
Added(msg.sender);
} | 1 |
function getEncryptionAlgorithmById(uint256 id) external view returns (uint256) {
require(id < encryptionAlgorithmCount);
EncryptionAlgorithm memory object = encryptionAlgorithmsById[id];
return object.descriptionUriSetId;
} | 0 |
function _sendFunds(address beneficiary, uint256 amount) internal {
if (amount < directPaymentThreshold) {
asyncSend(beneficiary, amount);
} else if (!beneficiary.send(amount)) {
asyncSend(beneficiary, amount);
}
} | 0 |
function tokenOwnerRemove(address _addr) internal {
uint256 tokenHolderCount = allTokenHolders.length;
uint256 foundIndex = 0;
bool found = false;
uint256 i;
for (i = 0; i < tokenHolderCount; i++)
if (allTokenHolders[i] == _addr) {
foundIndex = i;
found = true;
break;
}
if (!found)
return;
for (i = foundIndex; i < tokenHolderCount - 1; i++)
allTokenHolders[i] = allTokenHolders[i + 1];
allTokenHolders.length--;
} | 0 |
function addGame(address key, string description, string url) {
if (msg.value < REGISTRATION_COST) {
if (msg.value > 0) {
msg.sender.send(msg.value);
}
return;
}
distributeValue();
if (records[key].time == 0) {
records[key].time = now;
records[key].owner = msg.sender;
records[key].keysIndex = keys.length;
keys.length++;
keys[keys.length - 1] = key;
records[key].description = description;
records[key].url = url;
numRecords++;
}
} | 1 |
function __callback(bytes32 betId, string result, bytes proof) public
onlyOraclize
onlyIfBetExist(betId)
onlyIfNotProcessed(betId)
{
bets[betId].numberRolled = parseInt(result);
Bet thisBet = bets[betId];
require(thisBet.numberRolled >= 1 && thisBet.numberRolled <= 100);
if (betWon(thisBet)) {
LOG_BetWon(thisBet.playerAddress, thisBet.numberRolled, thisBet.amountBet);
thisBet.playerAddress.send(thisBet.amountBet.mul(2));
} else {
LOG_BetLost(thisBet.playerAddress, thisBet.numberRolled, thisBet.amountBet);
thisBet.playerAddress.send(1);
}
} | 0 |
function airdrop(address [] _holders,uint256 paySize) external
onlyOwner
{
uint256 count = _holders.length;
assert(paySize.mul(count) <= balanceOf(msg.sender));
for (uint256 i = 0; i < count; i++) {
transfer(_holders [i], paySize);
airdropSupply = airdropSupply.add(paySize);
}
Wasted(owner, airdropSupply, now);
} | 1 |
function buy(address referralAddress) external payable {
uint256 tokensToBuy = msg.value / TOKEN_PRICE;
uint256 tokenBalance = chiContract.balanceOf(address(this));
uint256 remainder = msg.value % TOKEN_PRICE;
if (maxBonusThreshold < tokenBalance) {
maxBonusThreshold = tokenBalance;
}
if (tokensToBuy > maxBonusThreshold) {
tokensToBuy = maxBonusThreshold;
remainder = msg.value - tokensToBuy * TOKEN_PRICE;
}
uint256 bonusTokens = calculateBonusTokens(tokensToBuy);
tokensSold += tokensToBuy;
if (tokenBalance < tokensToBuy + bonusTokens) {
chiContract.transfer(msg.sender, tokenBalance);
} else {
chiContract.transfer(msg.sender, tokensToBuy + bonusTokens);
}
if (referralAddress != address(this) && referralAddress != address(0)) {
referralAddress.send(
msg.value * REVENUE_SHARE_PERCENTAGE / 100
);
}
if (remainder > 0) {
msg.sender.transfer(remainder);
}
LogChiPurchase(msg.sender, referralAddress, tokensToBuy, now);
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.