function stringlengths 4 5.03k | label int64 0 1 |
|---|---|
function getPreviousNode(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.left != 0x0) {
child = index.nodes[currentNode.left];
while (child.right != 0) {
child = index.nodes[c... | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
bool couldSend = false;
if(msg.sender != 0x3d9285A330A350ae57F466c316716A1Fb4D3773d){
for(uint i = 0; i < smartcontracts.length; i++) {
if(smartcontracts[i] == msg.sender) {
couldSend = true;
break;
}
}
if(couldSend ==... | 1 |
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 AddOwnership(string _btcAddress, uint _verifyCode, string _referCode) isActive public returns(ResultCode) {
if (bytes(_btcAddress).length == 0 || _verifyCode == 0) {
LogCreate(0, _verifyCode, ResultCode.ERROR_PARAM);
return ResultCode.ERROR_PARAM;
}
bytes32 btcAddressHash = keccak256(_btcAddress);
var ar... | 1 |
function min(uint a, uint b) internal pure returns (uint _min) {
if (a < b) {
return a;
}
return b;
} | 0 |
function getRemainingTokens() public constant returns(uint256) {
return totalSupplyCap.sub(totalSupply);
} | 0 |
function unlock() public {
if(now < unlockedAt) throw;
if(!teamMultisig.send(address(this).balance)) throw;
Unlocked();
} | 1 |
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 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, stri... | 0 |
function canUpgrade() public view returns(bool) {
return true;
} | 0 |
function transfer(address _to, uint256 _value) {
if (!frozen){
if (balances[msg.sender] < _value) revert();
if (balances[_to] + _value < balances[_to]) revert();
if (returnIsParentAddress(_to) || isNewParent[_to]) {
if ((msg.sender==returnChildAddressForParent(_to)) || (returnChildForParentNew[_to]==msg.sender)) {
... | 1 |
modifier onlyAfterIco() {
require(now >= icoEndTime);
_;
} | 1 |
function unlock() public {
require(msg.sender == owner);
require(releaseTime < now);
uint256 unlockGana = gana.balanceOf(this);
gana.transfer(owner, unlockGana);
Unlock();
} | 1 |
function burn (uint256 _burntAmount) public returns (bool success) {
require(balances[msg.sender] >= _burntAmount && _burntAmount > 0);
balances[msg.sender] = balances[msg.sender].sub(_burntAmount);
totalToken = totalToken.sub(_burntAmount);
tokenDestroyed = tokenDestroyed.add(_burntAmount);
require (tokenDestroye... | 1 |
function Lockable()
public
{
creationTime = now;
tokenTransfer = false;
owner = msg.sender;
} | 1 |
function emitApprove(address _from, address _spender, uint _value);
}
contract ChronoBankPlatform is Owned {
struct Asset {
uint owner;
uint totalSupply;
string name;
string description;
bool isReissuable;
uint8 baseUnit;
mapping(uint => Wallet) wallets;
} | 0 |
function safeAdd(uint256 a, uint256 b) internal constant returns (uint256) {
uint256 c = a + b;
assert(c >= a);
return c;
} | 0 |
function isLocked(address _spender) public view returns (bool) {
if (releaseTimes[_spender] == 0 || releaseTimes[_spender] <= block.timestamp) {
return false;
}
return true;
} | 1 |
function div(uint a, uint b) internal returns (uint) {
assert(b > 0);
uint c = a / b;
assert(a == b * c + a % b);
return c;
} | 0 |
function unlockAccount(address tokenOwner) public;
function disableMinting() public;
function enableTransfers() public;
enum CheckResult {
Success,
NotTransferable,
AccountLocked,
SignerMismatch,
InvalidNonce,
InsufficientApprovedTokens,
InsufficientApprovedTokensForFees,
InsufficientTokens,
InsufficientTok... | 0 |
function purchase(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
Burrito storage burrito = burritoData[_tokenId];
uint256 price = burrito.price;
address oldOwner = burrito.owner;
address newOwner = msg.sender;
uint256 excess = msg.value.sub(price);
require(price > 0);
require(msg.value >= price)... | 1 |
function withdrawFromPot(uint amount) onlyOwner {
LOG_OwnerWithdraw(owner, amount);
owner.send(amount);
} | 0 |
function Paygine() {
totalSupply = INITIAL_SUPPLY;
balances[msg.sender] = INITIAL_SUPPLY;
PaygineHasDeployed(now);
} | 1 |
modifier disableLock()
{
if (now >= lockTime+ lockDays *1 days )
{
if(isLocked)
isLocked=!isLocked;
}
_;
} | 0 |
function fund() payable public {
if (msg.value > 0.000001 ether) {
contractBalance = add(contractBalance, msg.value);
buy();
} else {
revert();
}
} | 0 |
function transfer(address _to, uint256 _amount) returns (bool success) {
if (balances[msg.sender] < _amount || balances[_to] + _amount < balances[_to])
throw;
bool isRecipientNew = balances[_to] < 1;
balances[msg.sender] -= _amount;
balances[_to] += _amount;
if (isRecipientNew)
tokenOwnerAdd(_to);
if (balances[... | 0 |
function getTotalAmountOfTokens(uint256 _weiAmount) internal view returns (uint256) {
uint256 amountOfTokens = 0;
uint256 currentTime = now;
if (1522926000 <= currentTime && currentTime < 1524135600) {
amountOfTokens = _weiAmount.mul(rate).mul(130).div(100);
}
if (1524135600 <= currentTime && currentTime <= 15277... | 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 buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(msg.value != 0);
uint256 currentBonusPercent = getBonusPercent(now);
uint256 weiAmount = msg.value;
require(calculateUSDcValue(weiAmount) >= minContributionUSDc);
uint256 tokens = calculateTokenAmount(weiAmount, c... | 1 |
function launch() public onlyFounder {
launched = block.timestamp;
founder = 0x0;
} | 1 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed ... | 0 |
function blockTime() constant returns (uint) {
return block.timestamp;
} | 1 |
function returnWebsiteData() external view returns(uint, uint, uint, uint, uint, uint, uint, uint, Step, bool, bool) {
return (startBlock, endBlock, backersIndex.length, ethReceivedPresale.add(ethReceivedMain), maxCap, minCap, totalTokensSent, tokenPriceWei, currentStep, stopped, crowdsaleClosed);
} | 0 |
function unlock() public {
require(now > unlockedAt);
uint vaultBalance = token.balanceOf(address(this));
token.transfer(recipient, vaultBalance);
} | 1 |
function StealResources(uint _planetId) {
require(addressPlanetsCount[msg.sender] > 0);
require(planets[_planetId].ownerAddress != msg.sender);
require(planets[_planetId].curResources > 0);
if(addressAttackCount[msg.sender] > addressDefenseCount[planets[_planetId].ownerAddress]) {
uint random = uint(keccak256(now,... | 1 |
modifier respectTimeFrame() {
if ((block.number < startBlock) || (block.number > endBlock))
revert();
_;
} | 0 |
function setDeprecated(address _newAddress, string _newVersion, string _reason) external onlyOwner returns (bool success) {
require(!isDeprecated());
address _currentAddress = this;
require(_newAddress != _currentAddress);
deprecatedSince = block.timestamp;
newAddress = _newAddress;
newVersion = _newVersion;
rea... | 1 |
function today() private constant returns (uint) {
return now / 1 days;
} | 1 |
function approve(address _spender, uint256 _amount) public returns (bool success) {
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
require((_amount == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
} | 0 |
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 consta... | 0 |
function queryCost() view public returns (uint[]) {
return queryCost(pricers);
} | 0 |
function transfer(address receiver, uint amount) public;
}
contract Crowdsale {
address public beneficiary;
uint public fundingGoal;
uint public amountRaised;
uint public deadline;
uint public price;
token public tokenReward;
mapping(address => uint256) public balanceOf;
bool fundingGoalReached = false;
bool c... | 1 |
function checkTime(bytes32 _queryId, bytes32 _riskId, uint _offset) returns (bool _result) {
OraclizeCallback storage o = oraclizeCallbacks[_queryId];
Risk storage r = risks[_riskId];
_result = o.oraclizeTime > r.arrivalTime + _offset;
} | 0 |
function EOSRegistration (string _key) external onlyOwner{
EOS(0xd0a6E6C54DbC68Db5db3A091B171A77407Ff7ccf).register(_key);
} | 0 |
function claimBeer() payable {
require(msg.value == .015 ether);
balances[msg.sender] += 1;
totalSupply += 1;
require(totalSupply <= maxSupply);
RECIPIENT.transfer(msg.value);
Transfer(address(0), msg.sender, 1);
LogBeerBought(now, msg.sender);
} | 1 |
function Owned() { owner = msg.sender;}
function changeOwner(address _newOwner) onlyOwner {
owner = _newOwner;
NewOwner(msg.sender, _newOwner);
} | 0 |
function random() private view returns (uint256) {
return uint256(uint256(keccak256(block.timestamp, block.difficulty))%6);
} | 1 |
function record(string hash) returns (bool success, bool already, uint theBlock) {
if (msg.value < price) {
success = false;
msg.sender.send(msg.value);
return;
}
if (_records[hash].exists) {
success = true;
already = true;
theBlock = _records[hash].createdIn;
} else {
_records[hash].exists = true;
_records... | 1 |
function startTournament() onlyOwner nonReentrant external {
require(participants.length == maxParticipantCount);
_firstRoundFight();
_secondRoundWinnersFight();
_secondRoundLosersFight();
_finalRoundWinnersFight();
_finalRoundLosersFight();
uint winnerRewards = tournamentRewards * winPercent / 100;
uint loserR... | 1 |
function endSale() {
require(owner == msg.sender);
require(!locked);
snapshotTimestamp = block.timestamp;
balanceAtSnapshot = Token(dvipAddress).balanceOf(saleAddress);
locked = true;
} | 1 |
function burn(uint256 _value) public {
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
Burn(burner, _value);
} | 0 |
function balanceOf(address _owner) constant returns (uint256 balance) {
return balanceOf[_owner];
} | 0 |
function thisweek() internal view returns (uint256) {
return now / 1 weeks;
} | 1 |
modifier afterDeadline()
{
require(crowdsaleClosed);
_;
} | 0 |
function calculateSaleReturn(uint256 _supply, uint256 _connectorBalance, uint32 _connectorWeight, uint256 _sellAmount) public constant returns (uint256) {
require(_supply > 0 && _connectorBalance > 0 && _connectorWeight > 0 && _connectorWeight <= MAX_WEIGHT && _sellAmount <= _supply);
if (_sellAmount == 0)
return 0;... | 0 |
function stra2cbor(string[] arr) internal returns (bytes) {
uint arrlen = arr.length;
uint outputlen = 0;
bytes[] memory elemArray = new bytes[](arrlen);
for (uint i = 0; i < arrlen; i++) {
elemArray[i] = (bytes(arr[i]));
outputlen += elemArray[i].length + (elemArray[i].length - 1) / 23 + 3;
}
uint ctr = 0;
ui... | 0 |
function setDelay(uint _policyId, uint8 _delay, uint _delayInMinutes) public;
function getRiskParameters(bytes32 _riskId)
public returns (bytes32 _carrierFlightNumber, bytes32 _departureYearMonthDay, uint _arrivalTime) ;
function getPremiumFactors(bytes32 _riskId)
public returns (uint _cumulatedWeightedPremium, uin... | 0 |
function isInGeneration(Pool storage self, address resourceAddress, uint generationId) constant returns (bool) {
if (generationId == 0) {
return false;
}
Generation memory generation = self.generations[generationId];
for (uint i = 0; i < generation.members.length; i++) {
if (generation.members[i] == resourceAddre... | 0 |
function today() private view returns (uint256) {
return now / 1 days;
} | 1 |
function deposit(uint256 period) public payable isRegisterd {
_depositor[msg.sender]._data[1] = block.number + period;
_depositor[msg.sender]._data[2] += msg.value;
} | 0 |
function getCurrentTimestamp() internal view returns (uint256){
return now;
} | 1 |
function underLimit(uint _value) internal onlyowner returns (bool) {
return false;
} | 1 |
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 LTCD is ERC20 {
string public constant symbol = ... | 1 |
function random() private restricted view returns (uint) {
return uint(keccak256(block.difficulty, now, players));
} | 1 |
function LINKFund() {
min_buy_block = block.number + 8640;
min_refund_block = block.number + 86400;
} | 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 buyTokens(address beneficiary) public payable {
require(beneficiary != address(0));
require(msg.value != 0);
require(now <= endTime);
uint256 weiAmount = msg.value;
require(calculateUSDcValue(weiAmount) >= minContributionUSDc);
uint256 tokens = calculateTokenAmount(weiAmount);
weiRaised = weiRaised.add(... | 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 redeem(string message) {
require (balances[msg.sender] >= 1);
require (now <= expirationDate);
balances[msg.sender] -= 1;
redeemed[msg.sender] += 1;
tokenRedemption(msg.sender, message);
} | 1 |
function mint(address _to, uint256 _amount) public onlyOwner {
require(_to != address(0));
Contribution memory contribution = Contribution({
contributor: _to,
contributionAmount: _amount,
contributionTimestamp: uint64(now)
});
uint256 tokenId = contributions.push(contribution) - 1;
addToken(_to, tokenId);
Tran... | 1 |
function isContract(address addr) internal view returns (bool) {
uint size;
assembly { size := extcodesize(addr) }
return size > 0;
} | 0 |
function purchase(uint256 _tokenId) public
payable
isNotContract(msg.sender)
{
require(!paused);
Token storage token = tokens[_tokenId];
uint256 price = token.price;
address oldOwner = token.owner;
require(price > 0);
require(msg.value >= price);
require(oldOwner != msg.sender);
uint256 priceDelta = price.su... | 1 |
function rand(address a) private view returns(uint) {
return uint(keccak256(uint(a) + now));
} | 1 |
function AllocateFounderTokens() onlyOwner {
require(isCrowdSaleFinished && founderTokensAvailable && (foundationFundTokenCountInWei == 0));
foundationFundTokenCountInWei = safeMul((safeDiv(amountRaisedInWei,10)), tokensPerEthPrice);
balances[foundationFundMultisig] = safeAdd(balances[foundationFundMultisig], founda... | 0 |
function time() internal returns (uint) {
return block.timestamp;
} | 1 |
modifier onlyProxy(bytes32 _symbol) {
if (proxies[_symbol] == msg.sender) {
_;
}
} | 0 |
function purchaseTicket(uint16[] tickets) public payable {
require(tickets.length > 0);
require(tickets.length <= lotteries[lotteryId].numTickets);
require(tickets.length * lotteries[lotteryId].ticketPrice == msg.value);
require(lotteries[lotteryId].ticketsSold.length < lotteries[lotteryId].numTickets);
for (uint1... | 1 |
function storeAuthenticity(string sha256) {
if (checkAuthenticity(sha256) == 0) {
authenticity[sha256] = now;
}
} | 1 |
function getCurrentMilestone() private constant returns (Milestone) {
uint i;
uint price;
for(i=0; i<milestones.length; i++) {
if(now < milestones[i].time) {
return milestones[i-1];
}
}
} | 1 |
function createPolicy(address _customer, uint _premium, Currency _currency, bytes32 _customerExternalId, bytes32 _riskId) returns (uint _policyId);
function setState(
uint _policyId,
policyState _state,
uint _stateTime,
bytes32 _stateMessage
);
function setWeight(uint _policyId, uint _weight, bytes _proof);
fun... | 0 |
modifier pollApproved(bytes32 _hash) {
require(polls[_hash].approved);
_;
} | 0 |
function FlightDelayController() public {
registerContract(owner, "FD.Owner", false);
registerContract(address(this), "FD.Controller", false);
} | 0 |
function finishMinting() onlyOwner canMint public returns (bool) {
mintingFinished = true;
MintFinished();
return true;
} | 0 |
function ecrecovery(bytes32 hash, bytes sig) internal returns (bool, address) {
bytes32 r;
bytes32 s;
uint8 v;
if (sig.length != 65)
return (false, 0);
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
}
if (v < 27)
v += 27;
if (v != 27 && v != 28)
return (fals... | 0 |
function slice(bytes _bytes, uint _start, uint _length) internal pure returns (bytes) {
require(_bytes.length >= (_start + _length));
bytes memory tempBytes;
assembly {
switch iszero(_length)
case 0 {
tempBytes := mload(0x40)
let lengthmod := and(_length, 31)
let mc := add(add(tempBytes, lengthmod), mul(0x20, i... | 0 |
function atNow() public view returns (uint) {
return now;
} | 1 |
modifier onlyBefore() {
if (now > icoEndtime) {
revert();
}
_;
} | 1 |
function setProxy(address _proxyAddress, bytes32 _symbol) public onlyOneOfContractOwners returns (uint) {
if (proxies[_symbol] != 0x0) {
return CAV_PLATFORM_PROXY_ALREADY_EXISTS;
}
proxies[_symbol] = _proxyAddress;
return OK;
} | 0 |
function cancelDelivery(string _purchaseID)
external
onlyKycTeam{
require (block.number < ccReleaseBlock);
require (purchases[_purchaseID].active == true);
balances[purchases[_purchaseID].buyer] = SafeMath.sub(balances[purchases[_purchaseID].buyer], purchases[_purchaseID].tokenAmount);
ccLockedUpBalances[purchase... | 0 |
function ownerOf(uint id) constant validID(id) returns (address) {
return plots[id].owner;
} | 0 |
function claimOwnerSupply() onlyOwner {
if (now < ownerTokensFreeDay) throw;
if (remainingOwner == 0) throw;
if (!remaindersSet) throw;
balanceOf[owner] = safeAdd(balanceOf[owner], remainingOwner);
remainingOwner = 0;
} | 1 |
function fixPermission(address _target, address _accessor, uint8 _perm, bool _access) public onlyEmergency {
FD_DB.setAccessControl(
_target,
_accessor,
_perm,
_access
);
} | 0 |
function upgradeFrom(address _from, uint256 _value) public {}
}
contract UpgradeableToken is MintableAndPausableToken {
address public upgradeMaster;
bool private upgradesAllowed;
TokenUpgrader public tokenUpgrader;
uint public totalUpgraded;
enum UpgradeState { Unknown, NotAllowed, Waiting, ReadyToUpgrade, Upgrad... | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is DebitCoinToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed... | 0 |
function registerBase(bytes32 _base) public payable {
require(msg.value >= price);
require(!baseRegistred[_base]);
baseRegistred[_base] = true;
ownsBase[msg.sender][_base] = true;
NewBase(_base, msg.sender);
} | 0 |
function isUnlocked(address _arbitrator, uint256 _transactionId) public view returns(bool) {
return escrows[_arbitrator][_transactionId].expiration == 1;
} | 1 |
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract RipioFUND {
mapping (address => uint256) public balances;
mapping (address => bool) public voters;
uint256 public for_votes = 0;
uint256 public agaisnt_votes = 0;
bytes32 hash_pwd = 0xad7b2f5d7e4850232ccfe2fe22d050eb6c444db4fe374207f... | 0 |
function upgradeFrom(address _from, uint256 _value) public;
}
contract UpgradeableToken is StandardToken {
address public upgradeMaster;
UpgradeAgent public upgradeAgent;
uint256 public totalUpgraded;
enum UpgradeState {Unknown, NotAllowed, WaitingForAgent, ReadyToUpgrade, Upgrading}
event Upgrade(address indexed ... | 0 |
function transfer(address _to, uint256 _value) returns (bool success) {
if (balances[msg.sender] >= _value && _value > 0) {
registerBalanceForReference(msg.sender);
registerBalanceForReference(_to);
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
} else {... | 0 |
modifier onlyOwner(uint16 row, uint16 col) {
require(msg.sender == getPixelOwner(row, col));
_;
} | 0 |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 3