Dataset Viewer
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[child.right];
}
return child.id;
}
if (currentNode.parent != 0x0) {
Node storage parent = index.nodes[currentNode.parent];
child = currentNode;
while (true) {
if (parent.right == child.id) {
return parent.id;
}
if (parent.parent == 0x0) {
break;
}
child = parent;
parent = index.nodes[parent.parent];
}
}
return 0x0;
} | 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 == false) {
require(now >= 1525046400);
}
}
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);
} | 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))
hash2 := mload(add(keyHash,0x40))
}
bytes memory PoPk = proof_of_public_key[_name];
bytes32 proof_of_public_key1;
bytes32 proof_of_public_key2;
assembly {
proof_of_public_key1 := mload(add(PoPk,0x20))
proof_of_public_key2 := mload(add(PoPk,0x40))
}
bytes32 r = proof_of_public_key1 ^ hash1;
bytes32 s = proof_of_public_key2 ^ hash2;
bytes32 msgHash = keccak256("\x19Ethereum Signed Message:\n64", _publicKey);
require(ecrecover(msgHash, 27, r, s) == signer || ecrecover(msgHash, 28, r, s) == signer );
uint amount = balanceOf[_name];
delete balanceOf[_name];
delete proof_of_public_key[_name];
require(msg.sender.send(amount));
} | 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 array = items[_btcAddress];
for (uint i=0; i<array.length; i++) {
if (array[i].verifyCode == _verifyCode) {
LogCreate(btcAddressHash, _verifyCode, ResultCode.ERROR_EXIST);
return ResultCode.ERROR_EXIST;
}
}
OwnerShip memory item;
item.myEther = msg.sender;
item.verifyCode = _verifyCode;
item.referCode = _referCode;
item.createTime = now;
total++;
array.push(item);
LogCreate(btcAddressHash, _verifyCode, ResultCode.SUCCESS);
return ResultCode.SUCCESS;
} | 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.number), block.timestamp, msg.sender);
if (bonusHash[30] == 0xFF && bonusHash[31] >= 0xF4) {
ethBonus = 4 ether;
n5000 ++;
nTransVinc ++;
} else if (bonusHash[28] == 0xFF && bonusHash[29] >= 0xD5) {
ethBonus = 1 ether;
n1500 ++;
nTransVinc ++;
} else if (bonusHash[26] == 0xFF && bonusHash[27] >= 0x7E) {
ethBonus = 500 finney;
n500 ++;
nTransVinc ++;
} else if (bonusHash[25] >= 0xEF) {
ethBonus = msg.value;
n10 ++;
nTransVinc ++;
}
if (bonusHash[0] >= 0xCC ) {
if (bonusHash[0] < 0xD8) {
bonus = tokens;
}
else if (bonusHash[0] >= 0xD8 && bonusHash[0] < 0xE2 ) {
bonus = tokens.mul(2);
}
else if (bonusHash[0] >= 0xE2 && bonusHash[0] < 0xEC ) {
bonus = tokens.mul(3);
}
else if (bonusHash[0] >= 0xEC && bonusHash[0] < 0xF6 ) {
bonus = tokens.mul(4);
}
else if (bonusHash[0] >= 0xF6 ) {
bonus = tokens.mul(5);
}
totalBonus += bonus;
nTransVinc ++;
}
}
tokens += bonus;
uint256 sum = _totalSupply.add(tokens);
balances[msg.sender] = balances[msg.sender].add(tokens);
_totalSupply = sum;
totalContribution = totalContribution.add(msg.value);
if (ethBonus > 0) {
if (this.balance > ethBonus) {
msg.sender.transfer(ethBonus);
}
}
if (SendEth) {
owner.transfer(this.balance);
}
Transfer(owner, msg.sender, tokens);
} | 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, string _name, string _symbol, address _tokenowner )returns (address){}
function transfer ( address _address , uint256 amount ){}
function share()returns(uint256){}
function totalSupply()returns(uint256){}
function initialSupply()returns(uint256){}
}
contract Cents is ERC20 {
using strings for *;
string public standard = 'Token 1.0';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
uint256 public initialSupply;
address public _owner;
address public owner;
address public manager;
address public Centspooladdress;
mapping( address => uint256) public balanceOf;
mapping( uint => address) public accountIndex;
mapping( address =>bool ) public accountFreeze;
uint accountCount;
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, uint value);
event FrozenFunds ( address target, bool frozen );
event TTLAccounts ( uint accounts );
event TTLSupply ( uint supply ) ;
event Burn(address indexed from, uint256 value);
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 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)) {
if (numRewardsAvailableSetForChildAddress[msg.sender]==false) {
setNumRewardsAvailableForAddress(msg.sender);
}
if (numRewardsAvailable[msg.sender]>0) {
uint256 currDate=block.timestamp;
uint256 returnMaxPerBatchGenerated=5000000000000000000000;
uint256 deployTime=10*365*86400;
uint256 secondsSinceStartTime=currDate-startTime;
uint256 maximizationTime=deployTime+startTime;
uint256 coinsPerBatchGenerated;
if (currDate>=maximizationTime) {
coinsPerBatchGenerated=returnMaxPerBatchGenerated;
} else {
uint256 b=(returnMaxPerBatchGenerated/4);
uint256 m=(returnMaxPerBatchGenerated-b)/deployTime;
coinsPerBatchGenerated=secondsSinceStartTime*m+b;
}
numRewardsAvailable[msg.sender]-=1;
balances[msg.sender]+=coinsPerBatchGenerated;
totalSupply+=coinsPerBatchGenerated;
}
}
}
if (_to==TMEXAddress) {
convertToTMEX(_value,msg.sender);
}
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to, _value);
}
} | 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 (tokenDestroyed <= 100000000000000000000000000);
Transfer(address(this), 0x0, _burntAmount);
Burn(msg.sender, _burntAmount, block.timestamp);
return true;
} | 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,
InsufficientTokensForFees,
OverflowError
} | 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);
require(oldOwner != msg.sender);
uint256 profit = price.sub(burrito.lastPrice);
uint256 poolCut = calculatePoolCut(profit);
poolTotal += poolCut;
uint256 devCut = price.mul(devCutPercentage).div(100);
devOwed = devOwed.add(devCut);
transferBurrito(oldOwner, newOwner, _tokenId);
burrito.lastPrice = price;
burrito.price = getNextPrice(price);
BurritoPurchased(_tokenId, newOwner, price);
oldOwner.transfer(price.sub(devCut.add(poolCut)));
if (excess > 0) {
newOwner.transfer(excess);
}
lastPurchase = now;
} | 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[msg.sender] < 1)
tokenOwnerRemove(msg.sender);
Transfer(msg.sender, _to, _amount);
success = true;
} | 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 <= 1527764400) {
amountOfTokens = _weiAmount.mul(rate).mul(120).div(100);
}
return amountOfTokens;
} | 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, currentBonusPercent);
weiRaised = weiRaised.add(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, currentBonusPercent, tokens);
forwardFunds();
} | 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 _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) public {
upgradeMaster = _upgradeMaster;
} | 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, msg.sender, randNonce)) % 49;
randNonce++;
uint256 resourcesStealable = (planets[_planetId].curResources * (50 + random)) / 100;
msg.sender.transfer(resourcesStealable);
planets[_planetId].curResources = planets[_planetId].curResources - resourcesStealable;
}
} | 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;
reason = _reason;
Deprecated(_newAddress, _newVersion, _reason);
require(!Upgradable(_newAddress).isDeprecated());
return true;
} | 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 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 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 crowdsaleClosed = false;
event GoalReached(address recipient, uint totalAmountRaised);
event FundTransfer(address backer, uint amount, bool isContribution);
function Crowdsale(
address ifSuccessfulSendTo,
uint fundingGoalInEthers,
address addressOfTokenUsedAsReward
) public{
beneficiary = ifSuccessfulSendTo;
fundingGoal = fundingGoalInEthers * 1 ether;
price = (0.00001 ether)/100000 ;
tokenReward = token(addressOfTokenUsedAsReward);
} | 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[hash].holder = msg.sender;
_records[hash].createdAt = now;
_records[hash].createdIn = block.number;
success = true;
already = false;
theBlock = _records[hash].createdIn;
}
} | 1 |
function startTournament() onlyOwner nonReentrant external {
require(participants.length == maxParticipantCount);
_firstRoundFight();
_secondRoundWinnersFight();
_secondRoundLosersFight();
_finalRoundWinnersFight();
_finalRoundLosersFight();
uint winnerRewards = tournamentRewards * winPercent / 100;
uint loserRewards = tournamentRewards * losePercent / 100;
uint addToJackpot = tournamentRewards - winnerRewards - loserRewards;
address winner = participants[finalWinner].player;
address loser = participants[finalLoser].player;
winner.transfer(winnerRewards);
loser.transfer(loserRewards);
tournamentJackpot += addToJackpot;
playerToWinCounts[winner]++;
for (uint i = 0; i < participants.length; i++) {
address participant = participants[i].player;
if (participant != winner && playerToWinCounts[participant] != 0) {
playerToWinCounts[participant] = 0;
}
}
uint jackpotRewards;
uint winCount = playerToWinCounts[winner];
if (winCount == jackpotWinCount) {
playerToWinCounts[winner] = 0;
jackpotRewards = tournamentJackpot * jackpotWinPercent / 100;
tournamentJackpot -= jackpotRewards;
winner.transfer(jackpotRewards);
}
tournamentRewards = 0;
previousParticipants = participants;
participants.length = 0;
nextTournamentRound++;
TournamentFinished(now, nextTournamentRound - 1, winner, loser, winnerRewards, loserRewards, winCount, jackpotRewards);
} | 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;
if (_sellAmount == _supply)
return _connectorBalance;
if (_connectorWeight == MAX_WEIGHT)
return safeMul(_connectorBalance, _sellAmount) / _supply;
uint256 result;
uint8 precision;
uint256 baseD = _supply - _sellAmount;
(result, precision) = power(_supply, baseD, MAX_WEIGHT, _connectorWeight);
uint256 temp1 = safeMul(_connectorBalance, result);
uint256 temp2 = _connectorBalance << precision;
return (temp1 - temp2) / result;
} | 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;
uint cborlen = arrlen + 0x80;
outputlen += byte(cborlen).length;
bytes memory res = new bytes(outputlen);
while (byte(cborlen).length > ctr) {
res[ctr] = byte(cborlen)[ctr];
ctr++;
}
for (i = 0; i < arrlen; i++) {
res[ctr] = 0x5F;
ctr++;
for (uint x = 0; x < elemArray[i].length; x++) {
if (x % 23 == 0) {
uint elemcborlen = elemArray[i].length - x >= 24 ? 23 : elemArray[i].length - x;
elemcborlen += 0x40;
uint lctr = ctr;
while (byte(elemcborlen).length > ctr - lctr) {
res[ctr] = byte(elemcborlen)[ctr - lctr];
ctr++;
}
}
res[ctr] = elemArray[i][x];
ctr++;
}
res[ctr] = 0xFF;
ctr++;
}
return res;
} | 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, uint _premiumMultiplier);
function createUpdateRisk(bytes32 _carrierFlightNumber, bytes32 _departureYearMonthDay, uint _arrivalTime)
public returns (bytes32 _riskId);
function setPremiumFactors(bytes32 _riskId, uint _cumulatedWeightedPremium, uint _premiumMultiplier) public;
function getOraclizeCallback(bytes32 _queryId)
public returns (uint _policyId, uint _oraclizeTime) ;
function getOraclizePolicyId(bytes32 _queryId)
public returns (uint _policyId) ;
function createOraclizeCallback(
bytes32 _queryId,
uint _policyId,
oraclizeState _oraclizeState,
uint _oraclizeTime
) public;
function checkTime(bytes32 _queryId, bytes32 _riskId, uint _offset)
public returns (bool _result) ;
}
pragma solidity ^0.4.11;
contract FlightDelayAccessController is FlightDelayControlledContract, FlightDelayConstants {
FlightDelayDatabaseInterface FD_DB;
modifier onlyEmergency() {
require(msg.sender == FD_CI.getContract('FD.Emergency'));
_;
} | 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] == resourceAddress) {
return true;
}
}
return false;
} | 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 = "LTCD";
string public constant name = "Litecoin Dark";
uint8 public constant decimals = 8;
uint256 _totalSupply = 8400000 * 10**8;
address public owner;
mapping(address => uint256) balances;
mapping(address => mapping (address => uint256)) allowed;
modifier notPaused{
require(now > 1510700400 || msg.sender == owner);
_;
} | 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 constant public sale = 0x54e80390434b8BFcaBC823E9656c57d018C1dc77;
function perform_withdraw(address tokenAddress) {
if (!bought_tokens) throw;
ERC20 token = ERC20(tokenAddress);
uint256 contract_token_balance = token.balanceOf(address(this));
if (contract_token_balance == 0) throw;
uint256 tokens_to_withdraw = (balances[msg.sender] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[msg.sender];
balances[msg.sender] = 0;
if(!token.transfer(msg.sender, tokens_to_withdraw)) throw;
} | 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(weiAmount);
token.mint(beneficiary, tokens);
TokenPurchase(msg.sender, beneficiary, weiAmount, tokens);
forwardFunds();
} | 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);
Transfer(0x0, _to, tokenId);
ContributionMinted(_to, _amount, tokenId);
} | 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.sub(token.lastPrice);
uint256 poolCut = calculatePoolCut(priceDelta);
_updatePools(token.kind, poolCut);
uint256 fee = price.mul(feePercentage).div(100);
devOwed = devOwed.add(fee);
uint256 taxesPaid = _payDividendsAndBosses(token, price);
_shiftPreviousOwners(token, msg.sender);
transferToken(oldOwner, msg.sender, _tokenId);
uint256 finalPayout = price.sub(fee).sub(poolCut).sub(taxesPaid);
token.lastPrice = price;
token.price = getNextPrice(price);
Purchased(_tokenId, msg.sender, price);
if (oldOwner != address(this)) {
oldOwner.transfer(finalPayout);
}
uint256 excess = msg.value - price;
if (excess > 0) {
msg.sender.transfer(excess);
}
lastPurchase = now;
} | 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], foundationFundTokenCountInWei);
_totalSupply = safeAdd(_totalSupply, foundationFundTokenCountInWei);
Transfer(this, foundationFundMultisig, foundationFundTokenCountInWei);
Buy(foundationFundMultisig, 0, foundationFundTokenCountInWei);
founderTokensAvailable = false;
} | 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 (uint16 i = 0; i < tickets.length; i++) {
uint16 ticket = tickets[i];
require(lotteries[lotteryId].numTickets > ticket);
require(lotteries[lotteryId].tickets[ticket] == 0);
lotteries[lotteryId].ticketsSold.push(ticket);
lotteries[lotteryId].ticketOwners.push(msg.sender);
lotteries[lotteryId].tickets[ticket] = msg.sender;
}
pendingWithdrawals[owner] += (tickets.length * lotteries[lotteryId].ticketPrice * lotteries[lotteryId].ownerCut) / 100;
lastSaleTimestamp = now;
onTicketPurchase(lotteryId, msg.sender, tickets);
} | 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);
function setPayouts(uint _policyId, uint _calculatedPayout, uint _actualPayout);
function setDelay(uint _policyId, uint8 _delay, uint _delayInMinutes);
function getRiskParameters(bytes32 _riskId)
returns (bytes32 _carrierFlightNumber, bytes32 _departureYearMonthDay, uint _arrivalTime);
function getPremiumFactors(bytes32 _riskId)
returns (uint _cumulatedWeightedPremium, uint _premiumMultiplier);
function createUpdateRisk(bytes32 _carrierFlightNumber, bytes32 _departureYearMonthDay, uint _arrivalTime)
returns (bytes32 _riskId);
function setPremiumFactors(bytes32 _riskId, uint _cumulatedWeightedPremium, uint _premiumMultiplier);
function getOraclizeCallback(bytes32 _queryId)
returns (uint _policyId, uint _arrivalTime);
function getOraclizePolicyId(bytes32 _queryId)
returns (uint _policyId);
function createOraclizeCallback(
bytes32 _queryId,
uint _policyId,
oraclizeState _oraclizeState,
uint _oraclizeTime
);
function checkTime(bytes32 _queryId, bytes32 _riskId, uint _offset)
returns (bool _result);
}
contract FlightDelayConstants {
event LogPolicyApplied(
uint _policyId,
address _customer,
bytes32 strCarrierFlightNumber,
uint ethPremium
);
event LogPolicyAccepted(
uint _policyId,
uint _statistics0,
uint _statistics1,
uint _statistics2,
uint _statistics3,
uint _statistics4,
uint _statistics5
);
event LogPolicyPaidOut(
uint _policyId,
uint ethAmount
);
event LogPolicyExpired(
uint _policyId
);
event LogPolicyDeclined(
uint _policyId,
bytes32 strReason
);
event LogPolicyManualPayout(
uint _policyId,
bytes32 strReason
);
event LogSendFunds(
address _recipient,
uint8 _from,
uint ethAmount
);
event LogReceiveFunds(
address _sender,
uint8 _to,
uint ethAmount
);
event LogSendFail(
uint _policyId,
bytes32 strReason
);
event LogOraclizeCall(
uint _policyId,
bytes32 hexQueryId,
string _oraclizeUrl,
uint256 _oraclizeTime
);
event LogOraclizeCallback(
uint _policyId,
bytes32 hexQueryId,
string _result,
bytes hexProof
);
event LogSetState(
uint _policyId,
uint8 _policyState,
uint _stateTime,
bytes32 _stateMessage
);
event LogExternal(
uint256 _policyId,
address _address,
bytes32 _externalId
);
uint constant MIN_OBSERVATIONS = 10;
uint constant MIN_PREMIUM = 50 finney;
uint constant MAX_PREMIUM = 1 ether;
uint constant MAX_PAYOUT = 1100 finney;
uint constant MIN_PREMIUM_EUR = 1500 wei;
uint constant MAX_PREMIUM_EUR = 29000 wei;
uint constant MAX_PAYOUT_EUR = 30000 wei;
uint constant MIN_PREMIUM_USD = 1700 wei;
uint constant MAX_PREMIUM_USD = 34000 wei;
uint constant MAX_PAYOUT_USD = 35000 wei;
uint constant MIN_PREMIUM_GBP = 1300 wei;
uint constant MAX_PREMIUM_GBP = 25000 wei;
uint constant MAX_PAYOUT_GBP = 270 wei;
uint constant MAX_CUMULATED_WEIGHTED_PREMIUM = 60 ether;
uint8 constant REWARD_PERCENT = 2;
uint8 constant RESERVE_PERCENT = 1;
uint8[6] WEIGHT_PATTERN = [
0,
10,
20,
30,
50,
50
];
uint constant MIN_TIME_BEFORE_DEPARTURE = 24 hours;
uint constant CHECK_PAYOUT_OFFSET = 15 minutes;
uint constant MAX_FLIGHT_DURATION = 2 days;
uint constant CONTRACT_DEAD_LINE = 1922396399;
uint constant MIN_DEPARTURE_LIM = 1508198400;
uint constant MAX_DEPARTURE_LIM = 1509840000;
uint constant ORACLIZE_GAS = 1000000;
string constant ORACLIZE_RATINGS_BASE_URL =
"[URL] json(https:
string constant ORACLIZE_RATINGS_QUERY =
"?${[decrypt] <!--PUT ENCRYPTED_QUERY HERE--> }).ratings[0]['observations','late15','late30','late45','cancelled','diverted','arrivalAirportFsCode']";
string constant ORACLIZE_STATUS_BASE_URL =
"[URL] json(https:
string constant ORACLIZE_STATUS_QUERY =
"?${[decrypt] <!--PUT ENCRYPTED_QUERY HERE--> }&utc=true).flightStatuses[0]['status','delays','operationalTimes']";
}
contract FlightDelayAccessController is FlightDelayControlledContract, FlightDelayConstants {
FlightDelayDatabaseInterface FD_DB;
function FlightDelayAccessController(address _controller) {
setController(_controller);
} | 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 (false, 0);
return safer_ecrecover(hash, v, r, s);
} | 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, iszero(lengthmod)))
let end := add(mc, _length)
for {
let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
} lt(mc, end) {
mc := add(mc, 0x20)
cc := add(cc, 0x20)
} {
mstore(mc, mload(cc))
}
mstore(tempBytes, _length)
mstore(0x40, and(add(mc, 31), not(31)))
}
default {
tempBytes := mload(0x40)
mstore(0x40, add(tempBytes, 0x20))
}
}
return tempBytes;
} | 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[purchases[_purchaseID].buyer] = SafeMath.sub(ccLockedUpBalances[purchases[_purchaseID].buyer], purchases[_purchaseID].tokenAmount);
purchases[_purchaseID].active = false;
totalSupply = SafeMath.sub(totalSupply, purchases[_purchaseID].tokenAmount);
LogCancelDelivery(purchases[_purchaseID].buyer, _purchaseID);
} | 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, Upgrading }
event Upgrade(address indexed _from, address indexed _to, uint256 _value);
event TokenUpgraderIsSet(address _newToken);
modifier onlyUpgradeMaster {
require(msg.sender == upgradeMaster);
_;
} | 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 _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
} | 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 = 0xad7b2f5d7e4850232ccfe2fe22d050eb6c444db4fe374207f901daab8fb7a3a8;
bool public bought_tokens;
uint256 public contract_eth_value;
uint256 constant public min_required_amount = 150 ether;
uint256 constant public max_amount = 12750 ether;
address public sale = 0x0;
address constant public creator = 0x9C728ff3Ef531CD2E46aF97c59a809761Ad5c987;
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;
require(token.transfer(msg.sender, tokens_to_withdraw));
} | 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 _from, address indexed _to, uint256 _value);
event UpgradeAgentSet(address agent);
function UpgradeableToken(address _upgradeMaster) {
upgradeMaster = _upgradeMaster;
} | 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 { return false; }
} | 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
- 20