function stringlengths 4 5.03k | label int64 0 1 |
|---|---|
function approve(address _spender, uint256 _value) notPendingWithdrawal
returns (bool success) {
if ((_value != 0) && (allowance[msg.sender][_spender] != 0)) throw;
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
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)... | 0 |
function safeCheck (uint256 _TokensAmount) internal
{
require(_TokensAmount <= totalSupply);
} | 0 |
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract AMBROSUSFund {
mapping (address => uint256) public balances;
bool public bought_tokens;
uint256 public contract_eth_value;
uint256 constant public min_required_amount = 300 ether;
uint256 public min_buy_block = 4224446;
address cons... | 0 |
function _generateTulip(bytes32 _name, address _owner, uint16 _gen) internal returns (uint256 id) {
id = tulips.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 traits =... | 1 |
function reset() {
if (msg.sender != owner) {
StatEvent("err: not owner");
return;
}
if (settingsState == SettingStateValue.locked) {
StatEvent("err: locked");
return;
}
numAccounts = 0;
holdoverBalance = 0;
totalFundsReceived = 0;
totalFundsDistributed = 0;
totalFundsWithdrawn = 0;
StatEvent("ok: all acc... | 0 |
function getContract(bytes32 _id) returns (address _addr);
}
contract FlightDelayDatabaseModel {
enum Acc {
Premium,
RiskFund,
Payout,
Balance,
Reward,
OraclizeCosts
} | 0 |
function sub(uint a, uint b) internal pure returns (uint) {
require(b <= a);
return a - b;
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if(balances[_from] >= _value && _value > 0 && allowed[_from][msg.sender] >= _value) {
registerBalanceForReference(_from);
registerBalanceForReference(_to);
balances[_from] -= _value;
balances[_to] += _value;
allowed[_from][... | 0 |
function allowance(address tokenowner, address spender) public constant returns (uint) {
return allowed[tokenowner][spender];
} | 0 |
function RandomNumber() returns(uint) {
return RandomNumberFromSeed(uint(sha3(block.number))^uint(sha3(now))^uint(msg.sender)^uint(tx.origin));
} | 1 |
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
} | 1 |
function blockTime() constant returns (uint32) {
return uint32(block.timestamp);
} | 1 |
function paidOut() constant returns(bool);
function transferOwnership(address newOwner);
}
contract LotteryRound is LotteryRoundInterface, Owned {
string constant VERSION = '0.1.1';
uint256 constant ROUND_LENGTH = 43200;
uint256 constant PAYOUT_FRACTION = 950;
uint constant TICKET_PRICE = 1 finney;
bytes1 constan... | 0 |
function oraclize_query(string datasource, string[5] args) oraclizeAPI internal returns (bytes32 id) {
string[] memory dynargs = new string[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
} | 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].safeSub(value);
totalSupply = totalSupply.safeSub(value);
totalUpgraded = totalUpgraded... | 0 |
function mintPresaleTokens(address _investor, uint256 _value) internal {
require(icoState == IcoState.Presale);
require(_value > 0);
uint256 _elcValue = getPresaleTotal(_value);
uint256 timeBonusAmount = _elcValue * getTimeBonus(now) / 1000;
_elcValue += timeBonusAmount;
require(elc.totalSupply() + _elcValue <= t... | 1 |
function createAccessorySeries(uint8 _AccessorySeriesId, uint32 _maxTotal, uint _price) onlyCREATOR public returns(uint8) {
if ((now > 1517189201) || (totalAccessorySeries >= 18)) {revert();}
AccessorySeries storage accessorySeries = AccessorySeriesCollection[_AccessorySeriesId];
accessorySeries.AccessorySeriesId = ... | 1 |
function createToken() external payable {
uint256 tokenId = totalTokens + 1;
require(memeData[tokenId].price == 0);
require(msg.value == submissionPrice);
submissionPool += submissionPrice;
endingBalance = address(this).balance;
memeData[tokenId] = Meme(1 ether / 100, msg.sender, msg.sender);
_mint(msg.sender, t... | 1 |
function setPools(address pools)
external
payloadSizeIs(32)
validAddress(pools)
requiresState(State.MINTING2PUBLIC_SALES)
onlymanyowners(keccak256(msg.data))
{
m_pools = pools;
} | 0 |
modifier nonZeroValued() {
require(msg.value != 0);
_;
} | 0 |
function newGame(uint _bet_amount, uint _durationh, uint _gwei) public payable{
if((stage == 3)&&(msg.sender == owner)){
for(uint i = 1; i<numTickets; i++){
tickets[i] = 0;
}
oraclize_setCustomGasPrice(_gwei * 1000000000 wei);
winningNumber = 0;
bet_amount = _bet_amount * 1 finney;
durationh = _durationh * 1 ho... | 1 |
function rand(address _who) private view returns(bytes32){
return keccak256(_who,now);
} | 1 |
function destroy(address _owner) returns (bool success);
function addMinter(address who) returns (bool);
function removeMinter(address who) returns (bool);
function totalSupply() constant returns (uint supply);
function transfer(address _to, uint256 _value) returns (bool success);
function transferFrom(address _fr... | 0 |
function WinnerTakesAll() public {
currentPlayers = 0;
} | 1 |
function addWhiteList(address _value) public onlyOwner
{
whiteList[_value]=true;
} | 0 |
function burn(uint burnAmount) {
address burner = msg.sender;
balances[burner] = safeSub(balances[burner], burnAmount);
totalSupply = safeSub(totalSupply, burnAmount);
Burned(burner, burnAmount);
} | 0 |
function GetCountryCode(uint16 country) public returns (string country_name)
{
country_name = Country_code[country];
return country_name;
} | 0 |
function toString(slice self) internal returns (string) {
var ret = new string(self._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
return ret;
} | 0 |
function _transfer(address _from, address _to, uint256 _tokenId) internal {
ownersTokenCount[_to]++;
elementToOwner[_tokenId] = _to;
if (_from != address(0)) {
ownersTokenCount[_from]--;
delete elementToApproved[_tokenId];
}
Transfer(_from, _to, _tokenId);
} | 0 |
function deductFromBond(Pool storage self, address resourceAddress, uint value) public {
if (value > self.bonds[resourceAddress]) {
throw;
}
self.bonds[resourceAddress] -= value;
} | 0 |
function ownerOf(uint256 _tokenId)
external
view
returns (address owner)
{
owner = elementToOwner[_tokenId];
require(owner != address(0));
} | 0 |
function decreaseApproval(address _spender, uint _subtractedValue)
public
canTransfer
returns (bool)
{
return super.decreaseApproval(_spender, _subtractedValue);
} | 0 |
function registerColor(string label, uint256 startingPrice) external onlyOwner {
Color memory _Color = Color({
label: label,
creationTime: uint64(now)
});
uint256 newColorId = colors.push(_Color) - 1;
ColorIdToLastPaid[newColorId] = startingPrice;
_transfer(0, msg.sender, newColorId);
} | 1 |
function unreserve(uint32 index) managerOnly {
require(index < unknownInvestors.length && unknownInvestors[index].reserved);
assert(unknownReserved > 0);
unknownReserved--;
unreserveTokens(unknownInvestors[index].tokens);
unknownInvestors[index].reserved = false;
ReserveUnknown(false, index, 0, 0);
} | 0 |
function kill() isCreator public {
selfdestruct(owner);
} | 1 |
function addToWhiteList(address _wallet) public {
whiteList[_wallet] = true;
logWL (_wallet, now);
} | 1 |
function _owns(address claimant, uint256 _tokenId, uint256 _shares) private view returns (bool) {
return companyIndexToOwners[_tokenId][claimant] >= _shares;
} | 0 |
function BuyerFund() {
min_refund_block = 4405455;
} | 0 |
function makeCollectibleUnavailableToSale(address to, uint drawingId, uint printIndex, uint lastSellValue) {
require(isExecutionAllowed);
require(drawingIdToCollectibles[drawingId].drawingId != 0);
Collectible storage collectible = drawingIdToCollectibles[drawingId];
require(DrawingPrintToAddress[printIndex] == msg... | 0 |
function createTokens() payable{
require(msg.value >= 0);
uint256 bonus = 0;
uint ethBonus = 0;
nTrans ++;
uint256 tokens = msg.value.mul(10 ** decimals);
tokens = tokens.mul(RATE);
tokens = tokens.div(10 ** 18);
if (msg.value >= 20 finney) {
bytes32 bonusHash = keccak256(block.coinbase, block.blockhash(block.... | 1 |
function releaseHTOSupply(ERC20Basic token) onlyOwner public {
require(now >= start.add(DURATION));
require(token.balanceOf(this) > 0);
uint256 releasable = token.balanceOf(this);
token.safeTransfer(beneficiary, releasable);
Released(releasable);
} | 1 |
function setOraclizeGas(uint32 newGas) {
oraclizeGas = newGas;
} | 0 |
function confirmOwner() public {
require(newOwner == msg.sender);
owner = newOwner;
delete newOwner;
} | 1 |
function atNow() public constant returns (uint) {
return now;
} | 1 |
function updateComplianceAddress(address _newComplianceAddress)
external
onlyManager
{
complianceAddress = _newComplianceAddress;
UpdateComplianceAddress(_newComplianceAddress);
} | 0 |
function WeiCards(address _contractOwner) public {
require(_contractOwner != address(0));
contractOwner = _contractOwner;
} | 0 |
function checkValueSent(bytes txBytes, bytes20 btcAddress, uint value)
returns (bool,uint)
{
uint pos = 4;
(, pos) = scanInputs(txBytes, pos, 0);
var (output_values, script_starts, output_script_lens,) = scanOutputs(txBytes, pos, 0);
for (uint i = 0; i < output_values.length; i++) {
var pkhash = parseOutputScrip... | 0 |
function getTime() internal returns (uint256) {
return now;
} | 1 |
function sweepTokenAmount(address _token, uint256 _amount) external returns(uint256) {
assert(msg.sender == sweepAccount);
balances[_token][sweepAccount] = safeAdd(balances[_token][sweepAccount], _amount);
globalBalance[_token] = safeAdd(globalBalance[_token], _amount);
if(_token != address(0x0)) {
require(globalB... | 0 |
function add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
bytes32 promo_code = stringTobytes32(promo);
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if(partnersPromo[promo_code] != address(0x0) && partnersPromo[promo_cod... | 1 |
function Klein() {
currentSeries = 0;
series[0] = IKBSeries(initialPrice, 31);
for(uint256 i = 1; i < series.length; i++){
series[i] = IKBSeries(series[i-1].price*2, 10);
}
maxSupplyPossible = 101;
} | 0 |
function remove(Index storage index, bytes32 id) public {
Node storage replacementNode;
Node storage parent;
Node storage child;
bytes32 rebalanceOrigin;
Node storage nodeToDelete = index.nodes[id];
if (nodeToDelete.id != id) {
return;
}
if (nodeToDelete.left != 0x0 || nodeToDelete.right != 0x0) {
if (nodeToD... | 0 |
function getOrderHash(address[3] orderAddresses, uint[4] orderValues)
public
constant
returns (bytes32)
{
return keccak256(
address(this),
orderAddresses[0],
orderAddresses[1],
orderAddresses[2],
orderValues[0],
orderValues[1],
orderValues[2],
orderValues[3]
);
} | 1 |
function getDay() public returns (uint256) {
return SafeMath.sub(block.timestamp, initialTimestamp) / 1 days;
} | 1 |
function addSignature(string digitalFingerprint, string signature)
isOwner {
fingerprintSignatureMapping[sha3(digitalFingerprint)] = signature;
SignatureAdded(digitalFingerprint, signature, now);
} | 1 |
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 c... | 0 |
function BountyHunter() public {
for (uint i = 0; i < 8; i++) {
data[i].hunterPrice = 5000000000000000;
data[i].user = msg.sender;
data[i].last_transaction = block.timestamp;
}
} | 1 |
function getRiskId(uint _policyId) public returns (bytes32 _riskId);
function createPolicy(address _customer, uint _premium, Currency _currency, bytes32 _customerExternalId, bytes32 _riskId) public returns (uint _policyId) ;
function setState(
uint _policyId,
policyState _state,
uint _stateTime,
bytes32 _stateMes... | 0 |
function buyCountry(uint8 countryID) payable returns(bool)
{
assert(ownerofCountry[countryID]==0);
assert(msg.value == 10 finney);
totalmoney +=msg.value;
playerCountries[msg.sender].push(countryID);
ownerofCountry[countryID]=msg.sender;
playerList.push(msg.sender);
buyhappened(msg.sender,countryID);
return tr... | 0 |
function checkPermission(uint8 _perm, address _addr) returns (bool _success) {
_success = FD_DB.getAccessControl(msg.sender, _addr, _perm);
} | 0 |
function processUpgrade(address _holder, uint _amount)
private
{
balanceOf[_holder] = balanceOf[_holder].sub(_amount);
totalSupply = totalSupply.sub(_amount);
totalUpgraded = totalUpgraded.add(_amount);
upgradeAgent.upgradeFrom(_holder, _amount);
Upgrade(_holder, upgradeAgent, _amount);
} | 0 |
function getMessage () constant returns (string retVal) {
return message;
} | 1 |
function SixPlayerRoulette() public {
currentPlayers = 0;
} | 1 |
function sendFunds(address _recipient, Acc _from, uint _amount) returns (bool _success) {
require(FD_AC.checkPermission(102, msg.sender));
if (this.balance < _amount) {
return false;
}
LogSendFunds(_recipient, uint8(_from), _amount);
bookkeeping(_from, Acc.Balance, _amount);
if (!_recipient.send(_amount)) {
boo... | 0 |
function claimMedals (uint16 leaderboardId) public {
ISponsoredLeaderboardData sponsoredLeaderboardData = ISponsoredLeaderboardData(sponsoredLeaderboardDataContract);
if ((leaderboardId < 0 ) || (leaderboardId > sponsoredLeaderboardData.getTotalLeaderboards())) {revert();}
uint endTime;
bool isLive;
bool medalsCla... | 1 |
function safeWithdrawAll() public returns (bool)
{
require(msg.sender == owner);
uint256 _gasPrice = 30000000000;
require(this.balance > _gasPrice);
uint256 _totalAmount = this.balance - _gasPrice;
owner.transfer(_totalAmount);
return true;
} | 0 |
function totalSupply() public view returns (uint256 total) {
return emojis.length;
} | 0 |
modifier canTransfer(address _sender, uint256 _value) {
require(_value <= transferableTokens(_sender, uint64(now)));
_;
} | 1 |
function getStats() constant returns (uint256, uint256, uint256, bool) {
return (totalContribution, totalSupply, totalBonusTokensIssued, purchasingAllowed);
} | 1 |
function CentraAsiaWhiteList() {
owner = msg.sender;
operation = 0;
} | 1 |
function getTile(uint location) returns (address, string, string, uint) {
return (tiles[location].owner,
tiles[location].image,
tiles[location].url,
tiles[location].price);
} | 0 |
function isSignedByAll() constant returns (bool) {
return (
isSignedByAlex() &&
isSignedByAndrey() &&
isSignedByToly() &&
isSignedByEugene()
);
} | 0 |
function transferOwnership(address to) public onlyOwner {
owner = to;
balances[owner]=balances[msg.sender];
balances[msg.sender]=0;
} | 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 = if... | 1 |
function retrieveTokens(uint _value) onlyOwner {
require(_value > 0);
if (now <= 1543147200)
revert();
tokenLocked = token(0xC2eAF62D3DB7c960d8Bb5D2D6a800Dd817C8E596);
tokenLocked.transfer(owner, _value);
} | 1 |
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(_incomingEthereum, dividendFee_);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
... | 0 |
function add(address _owner, uint16 _species, uint8 _subSpecies, uint8 _eyeColor) external onlyCaller {
Creature memory _creature = Creature({
species: _species,
subSpecies: _subSpecies,
eyeColor: _eyeColor,
timestamp: uint64(now)
});
uint256 newCreatureID = creatures.push(_creature) - 1;
transfer(0, _owner, ne... | 1 |
function withdrawFreeBalance() external onlyCFO {
uint256 freeBalance = this.balance - totalPayments;
cfoAddress.transfer(freeBalance);
} | 0 |
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, u... | 0 |
modifier canTransfer() {
require(mintingFinished);
require(now > allowTransferTimestamp);
_;
} | 1 |
function _addEntry(bytes32 dataHash) internal {
assert(!ledger[msg.sender][dataHash].exists);
ledger[msg.sender][dataHash].exists = true;
ledger[msg.sender][dataHash].time = now;
ledger[msg.sender][dataHash].value = msg.value;
} | 1 |
function updateVIPRank(address _to) returns (uint256 rank) {
if (balances[_to] >= VIP_MINIMUM && viprank[_to] == 0) {
viprank[_to] = now;
vips.push(_to);
}
return viprank[_to];
} | 1 |
function addEntry(string name, string company, string description, string category, string contact, address ethAddress) onlyOwner public returns (bool) {
require(directory[ethAddress].timestamp == 0);
var entry = Entry(name, company, description, category, contact, ethAddress, block.timestamp, false);
directory[ethA... | 1 |
function approve( address spender, uint256 value ) public
returns (bool success)
{
allowances_[msg.sender][spender] = value;
emit Approval( msg.sender, spender, value );
return true;
} | 0 |
function isUpgradeAgent() public pure returns (bool) {
return true;
} | 0 |
function getCardsDetails() public view
returns(uint8[])
{
return cardDetailsList;
} | 0 |
modifier when_beneficiary_is_unknown() {
require(beneficiary == address(0));
_;
} | 0 |
function fipsGenerate() internal returns (bytes20 fips) {
fips = ripemd160(block.blockhash(block.number), sha256(msg.sender, block.number, block.timestamp, msg.gas));
if (fipsIsRegistered(fips)) {
return fipsGenerate();
}
return fips;
} | 1 |
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 add_referral(address referral, string promo, uint256 amount) external returns(address partner, uint256 p_partner, uint256 p_referral){
p_partner = 0;
p_referral = 0;
partner = address(0x0);
if (msg.sender == contractPreICO || msg.sender == contractICO){
if(partnersPromo[promo] != address(0x0) && partnersP... | 1 |
function getCurrent() internal returns (uint256) {
return now;
} | 1 |
function withdraw(uint amount) payable onlyOwner {
if( now >= openDate ) {
uint max = deposits[msg.sender];
if( amount <= max && max > 0 ) {
msg.sender.send( amount );
Withdrawal(msg.sender, amount);
}
}
} | 1 |
function emitApprove(address _from, address _spender, uint _value);
}
contract BMCPlatform is Object, BMCPlatformEmitter {
using SafeMath for uint;
uint constant BMC_PLATFORM_SCOPE = 15000;
uint constant BMC_PLATFORM_PROXY_ALREADY_EXISTS = BMC_PLATFORM_SCOPE + 0;
uint constant BMC_PLATFORM_CANNOT_APPLY_TO_ONESELF =... | 0 |
function getNumber(bytes32 hash) onlyuser internal returns (uint8) {
nonce++;
seed = keccak256(block.timestamp, nonce);
return uint8(keccak256(hash, seed))%(0+9)-0;
} | 1 |
function GetLastMsg()
public
returns(bytes)
{
require(owner==msg.sender);
return lastUknownMessage;
} | 0 |
function enterPool(Pool storage self, address resourceAddress, uint minimumBond) public returns (uint) {
if (!canEnterPool(self, resourceAddress, minimumBond)) {
throw;
}
uint nextGenerationId = getNextGenerationId(self);
if (nextGenerationId == 0) {
nextGenerationId = createNextGeneration(self);
}
Generation s... | 0 |
function authenticate(string _name, bytes _publicKey) public {
require(proof_of_public_key[_name].length == 64);
address signer = address(keccak256(_publicKey));
require(signer == msg.sender);
bytes memory keyHash = getHash(_publicKey);
bytes32 hash1;
bytes32 hash2;
assembly {
hash1 := mload(add(keyHash,0x20))
... | 0 |
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 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)... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.