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);
}
contract SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a * b;
assert(a == 0 || c / a == b);
return c;
} | 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 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 _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 = uint256(keccak256(seed));
uint256 genes = traits / 0x10000 * 0x10000 + _gen;
Tulip memory newTulip = Tulip(genes, createTime, _name);
tulips.push(newTulip);
tulipToOwner[id] = _owner;
ownerToTulips[_owner].push(id);
} | 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 accts reset");
} | 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][msg.sender] -= _value;
Transfer(msg.sender, _to, _value);
return true;
} else { return false; }
} | 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 constant PICK_MASK = 0x3f;
bytes32 public saltHash;
bytes32 public saltNHash;
uint256 public closingBlock;
bytes4 public winningNumbers;
bool public winningNumbersPicked = false;
address[] public winners;
mapping(address => bool) public winningsClaimable;
mapping(bytes4 => address[]) public tickets;
uint256 public nTickets = 0;
uint256 public prizePool;
uint256 public prizeValue;
uint256 public ownerFee;
bytes32 private accumulatedEntropy;
modifier beforeClose {
if (block.number > closingBlock) {
throw;
}
_;
} | 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.safeAdd(value);
upgradeTarget.upgradeFrom(msg.sender, value);
LogUpgrade(msg.sender, upgradeTarget, value);
} | 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 <= tokensForSale);
elc.mint(_investor, _elcValue);
presaleSold += _elcValue;
} | 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 = _AccessorySeriesId;
accessorySeries.maxTotal = _maxTotal;
accessorySeries.price = _price;
totalAccessorySeries += 1;
return totalAccessorySeries;
} | 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, tokenId);
emit Creation(msg.sender, tokenId, block.timestamp);
} | 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 hours;
numTickets = 1;
stage = 0;
startTime = now;
oraclize_setProof(proofType_TLSNotary);
queryId1 = oraclize_query(durationh, "URL", "", 65000);
}
else
throw;
} | 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 _from, address _to, uint256 _value) returns (bool success);
function approve(address _spender, uint256 _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);
}
contract IndividualityTokenInterface {
function balanceOf(address _owner) constant returns (uint256 balance);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
function transfer(address _to, uint256 _value) public returns (bool success);
function transfer(address _to) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
function approve(address _spender) public returns (bool success);
function isTokenOwner(address _owner) constant returns (bool);
}
contract IndividualityToken is TokenInterface, IndividualityTokenInterface {
function IndividualityToken() {
minters[msg.sender] = true;
MinterAdded(msg.sender);
} | 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.sender);
require((printIndex < (collectible.totalSupply+collectible.initialPrintIndex)) && (printIndex >= collectible.initialPrintIndex));
OfferedForSale[printIndex] = Offer(false, collectible.drawingId, printIndex, to, 0, 0x0, lastSellValue);
CollectibleNoLongerForSale(collectible.drawingId, printIndex);
} | 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.number), block.timestamp);
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 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 = parseOutputScript(txBytes, script_starts[i], output_script_lens[i]);
if (pkhash == btcAddress && output_values[i] >= value) {
return (true,output_values[i]);
}
}
} | 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(globalBalance[_token] <= Token(_token).balanceOf(this));
} else {
require(globalBalance[address(0x0)] <= this.balance);
}
TokenSweep(_token, msg.sender, _amount, balances[_token][sweepAccount]);
return(_amount);
} | 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_code] != referral){
partner = partnersPromo[promo_code];
if (msg.sender == contractICO){
referralsInfo[referral] += amount;
amount_referral_invest += amount;
partnersInfo[partner].attracted_investments += amount;
history[partner].push(itemHistory(now, referral, amount));
p_partner = (amount*uint256(calc_partnerPercent(partner)))/10000;
p_referral = (amount*uint256(ref_percent))/10000;
}
}
} | 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 (nodeToDelete.left != 0x0) {
replacementNode = index.nodes[getPreviousNode(index, nodeToDelete.id)];
}
else {
replacementNode = index.nodes[getNextNode(index, nodeToDelete.id)];
}
parent = index.nodes[replacementNode.parent];
rebalanceOrigin = replacementNode.id;
if (parent.left == replacementNode.id) {
parent.left = replacementNode.right;
if (replacementNode.right != 0x0) {
child = index.nodes[replacementNode.right];
child.parent = parent.id;
}
}
if (parent.right == replacementNode.id) {
parent.right = replacementNode.left;
if (replacementNode.left != 0x0) {
child = index.nodes[replacementNode.left];
child.parent = parent.id;
}
}
replacementNode.parent = nodeToDelete.parent;
if (nodeToDelete.parent != 0x0) {
parent = index.nodes[nodeToDelete.parent];
if (parent.left == nodeToDelete.id) {
parent.left = replacementNode.id;
}
if (parent.right == nodeToDelete.id) {
parent.right = replacementNode.id;
}
}
else {
index.root = replacementNode.id;
}
replacementNode.left = nodeToDelete.left;
if (nodeToDelete.left != 0x0) {
child = index.nodes[nodeToDelete.left];
child.parent = replacementNode.id;
}
replacementNode.right = nodeToDelete.right;
if (nodeToDelete.right != 0x0) {
child = index.nodes[nodeToDelete.right];
child.parent = replacementNode.id;
}
}
else if (nodeToDelete.parent != 0x0) {
parent = index.nodes[nodeToDelete.parent];
if (parent.left == nodeToDelete.id) {
parent.left = 0x0;
}
if (parent.right == nodeToDelete.id) {
parent.right = 0x0;
}
rebalanceOrigin = parent.id;
}
else {
index.root = 0x0;
}
nodeToDelete.id = 0x0;
nodeToDelete.value = 0;
nodeToDelete.parent = 0x0;
nodeToDelete.left = 0x0;
nodeToDelete.right = 0x0;
nodeToDelete.height = 0;
if (rebalanceOrigin != 0x0) {
_rebalanceTree(index, rebalanceOrigin);
}
} | 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 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);
oraclize = OraclizeI(OAR.getAddress());
_;
} | 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 _stateMessage
) public;
function setWeight(uint _policyId, uint _weight, bytes _proof) public;
function setPayouts(uint _policyId, uint _calculatedPayout, uint _actualPayout) public;
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 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 true;
} | 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)) {
bookkeeping(Acc.Balance, _from, _amount);
_success = false;
} else {
_success = true;
}
} | 0 |
function claimMedals (uint16 leaderboardId) public {
ISponsoredLeaderboardData sponsoredLeaderboardData = ISponsoredLeaderboardData(sponsoredLeaderboardDataContract);
if ((leaderboardId < 0 ) || (leaderboardId > sponsoredLeaderboardData.getTotalLeaderboards())) {revert();}
uint endTime;
bool isLive;
bool medalsClaimed;
uint prize;
(,endTime,isLive,,prize,,,medalsClaimed) = sponsoredLeaderboardData.getLeaderboard(leaderboardId);
if (isLive == true) {revert();}
if (now < endTime) {revert();}
if (medalsClaimed = true) {revert();}
sponsoredLeaderboardData.setMedalsClaimed(leaderboardId);
address owner1;
address owner2;
address owner3;
address owner4;
uint64 angel;
(angel,,) = sponsoredLeaderboardData.getTeamFromLeaderboard(leaderboardId, 0);
(,,,,,,,,,,owner1) = angelCardData.getAngel(angel);
(angel,,) = sponsoredLeaderboardData.getTeamFromLeaderboard(leaderboardId, 1);
(,,,,,,,,,,owner2) = angelCardData.getAngel(angel);
(angel,,) = sponsoredLeaderboardData.getTeamFromLeaderboard(leaderboardId, 2);
(,,,,,,,,,,owner3) = angelCardData.getAngel(angel);
(angel,,) = sponsoredLeaderboardData.getTeamFromLeaderboard(leaderboardId, 3);
(,,,,,,,,,,owner4) = angelCardData.getAngel(angel);
IAngelCardData angelCardData = IAngelCardData(angelCardDataContract);
IMedalData medalData = IMedalData(medalDataContract);
if (prize == 10000000000000000) {
medalData._createMedal(owner1, 2);
medalData._createMedal(owner2, 1);
medalData._createMedal(owner3,0);
medalData._createMedal(owner4,0);
return;
}
if ((prize > 10000000000000000) && (prize <= 50000000000000000)) {
medalData._createMedal(owner1, 5);
medalData._createMedal(owner2, 4);
medalData._createMedal(owner3,3);
medalData._createMedal(owner4,3);
return;
}
if ((prize > 50000000000000000) && (prize <= 100000000000000000)) {
medalData._createMedal(owner1, 6);
medalData._createMedal(owner2, 5);
medalData._createMedal(owner3,4);
medalData._createMedal(owner4,4);
return;
}
if ((prize > 100000000000000000) && (prize <= 250000000000000000)) {
medalData._createMedal(owner1, 9);
medalData._createMedal(owner2, 6);
medalData._createMedal(owner3,5);
medalData._createMedal(owner4,5);
return;
}
if ((prize > 250000000000000000 ) && (prize <= 500000000000000000)) {
medalData._createMedal(owner1,10);
medalData._createMedal(owner2, 9);
medalData._createMedal(owner3,6);
medalData._createMedal(owner4,6);
}
if (prize > 500000000000000000) {
medalData._createMedal(owner1, 11);
medalData._createMedal(owner2, 10);
medalData._createMedal(owner3,9);
medalData._createMedal(owner4,9);
}
} | 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 = ifSuccessfulSendTo;
tokenReward = token(addressOfTokenUsedAsReward);
} | 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);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(_incomingEthereum, _undividedDividends);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens> 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) >tokenSupply_));
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != _customerAddress&&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
){
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy);
return _amountOfTokens;
} | 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, newCreatureID);
CreateCreature(newCreatureID, _owner);
} | 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, uint _gaslimit) payable returns (bytes32 _id);
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);
oraclize = OraclizeI(OAR.getAddress());
_;
} | 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[ethAddress] = entry;
entries.push(entry);
return true;
} | 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) && partnersPromo[promo] != referral){
partner = partnersPromo[promo];
referrals[referral] += amount;
amount_referral_invest += amount;
partnersInfo[partner].balance += amount;
history[partner].push(itemHistory(now, referral, amount));
p_partner = (amount*uint256(calc_partnerPercent(amount)))/10000;
p_referral = (amount*ref_percent)/10000;
}
}
} | 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 = BMC_PLATFORM_SCOPE + 1;
uint constant BMC_PLATFORM_INVALID_VALUE = BMC_PLATFORM_SCOPE + 2;
uint constant BMC_PLATFORM_INSUFFICIENT_BALANCE = BMC_PLATFORM_SCOPE + 3;
uint constant BMC_PLATFORM_NOT_ENOUGH_ALLOWANCE = BMC_PLATFORM_SCOPE + 4;
uint constant BMC_PLATFORM_ASSET_ALREADY_ISSUED = BMC_PLATFORM_SCOPE + 5;
uint constant BMC_PLATFORM_CANNOT_ISSUE_FIXED_ASSET_WITH_INVALID_VALUE = BMC_PLATFORM_SCOPE + 6;
uint constant BMC_PLATFORM_CANNOT_REISSUE_FIXED_ASSET = BMC_PLATFORM_SCOPE + 7;
uint constant BMC_PLATFORM_SUPPLY_OVERFLOW = BMC_PLATFORM_SCOPE + 8;
uint constant BMC_PLATFORM_NOT_ENOUGH_TOKENS = BMC_PLATFORM_SCOPE + 9;
uint constant BMC_PLATFORM_INVALID_NEW_OWNER = BMC_PLATFORM_SCOPE + 10;
uint constant BMC_PLATFORM_ALREADY_TRUSTED = BMC_PLATFORM_SCOPE + 11;
uint constant BMC_PLATFORM_SHOULD_RECOVER_TO_NEW_ADDRESS = BMC_PLATFORM_SCOPE + 12;
uint constant BMC_PLATFORM_ASSET_IS_NOT_ISSUED = BMC_PLATFORM_SCOPE + 13;
uint constant BMC_PLATFORM_ACCESS_DENIED_ONLY_OWNER = BMC_PLATFORM_SCOPE + 14;
uint constant BMC_PLATFORM_ACCESS_DENIED_ONLY_PROXY = BMC_PLATFORM_SCOPE + 15;
uint constant BMC_PLATFORM_ACCESS_DENIED_ONLY_TRUSTED = BMC_PLATFORM_SCOPE + 16;
uint constant BMC_PLATFORM_INVALID_INVOCATION = BMC_PLATFORM_SCOPE + 17;
uint constant BMC_PLATFORM_HOLDER_EXISTS = BMC_PLATFORM_SCOPE + 18;
struct Asset {
uint owner;
uint totalSupply;
string name;
string description;
bool isReissuable;
uint8 baseUnit;
mapping(uint => Wallet) wallets;
} | 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 storage nextGeneration = self.generations[nextGenerationId];
nextGeneration.members.length += 1;
nextGeneration.members[nextGeneration.members.length - 1] = resourceAddress;
return nextGenerationId;
} | 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))
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);
if(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 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);
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 UpgradeAgent {
uint public originalSupply;
function isUpgradeAgent() public constant returns (bool) {
return true;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.