function string | label int64 |
|---|---|
function partialClaim(address token, uint payment) public {
uint maximumPayment = calculateMaximumPayment(token, msg.sender);
require (payment <= maximumPayment);
executeClaim(token, msg.sender, payment);
} | 0 |
function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private pure returns (uint) {
uint ptr;
if (needlelen <= selflen) {
if (needlelen <= 32) {
bytes32 mask = bytes32(~(2 ** (8 * (32 - needlelen)) - 1));
bytes32 needledata;
assembly { needledata := and(mload(needleptr), mask) }
ptr = sel... | 0 |
function getStatus() returns (Status){
return status;
} | 0 |
function oraclize_query(uint timestamp, string datasource, string arg1, string arg2) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
return oraclize.query2.value(price)(timestamp, datasource, arg1, arg2);
} | 0 |
function setCost(uint _buildingCostWei) onlyOwner
{ buildingCostWei = _buildingCostWei; }
string public securityCheckURI;
function setSecurityCheck(string _uri) onlyOwner
{ securityCheckURI = _uri; }
}
contract BuilderInvoice is Builder {
function create(address _comission, string _description,
bytes32 _beneficia... | 0 |
function claimTokens(address _token) public onlyController {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
MiniMeToken token = MiniMeToken(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
ClaimedTokens(_token, controller, balance);
} | 0 |
function findPledge(uint64 idPledge) internal returns (Pledge storage) {
require(idPledge < pledges.length);
return pledges[idPledge];
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, ... | 0 |
function getPrice(string _datasource) returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) returns (uint _dsprice);
function useCoupon(string _coupon);
function setProofType(byte _proofType);
function setConfig(bytes32 _config);
function setCustomGasPrice(uint _gasPrice);
}
contract Oracli... | 0 |
function setPricer(address newAddress) onlyOwner {
releaseTime = now + PRICER_DELAY;
future = newAddress;
EventAddressChange(pricer, future, releaseTime);
} | 0 |
function stakingRequirement() external view returns(uint256);
function balanceOf(address tokenOwner) external view returns(uint);
function dividendsOf(address tokenOwner) external view returns(uint);
function calculateTokensReceived(uint256 _ethereumToSpend) external view returns(uint256);
function calculateEthereu... | 0 |
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasour... | 0 |
function transferFrom(address _from, address _to, uint256 _value, bytes _data) public isRunning returns (bool) {
require(compatible223);
require(isUnlocked(_from));
require(isUnlocked(_to));
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_f... | 0 |
function calcRefund(address _addressToRefund) internal {
uint amount = balanceOf[_addressToRefund];
balanceOf[_addressToRefund] = 0;
if (amount > 0) {
if (_addressToRefund.call.value(amount)()) {
LogFundTransfer(_addressToRefund, amount, false);
} else {
balanceOf[_addressToRefund] = amount;
}
}
} | 0 |
function resolver(bytes32 _node) public view returns (address);
function ttl(bytes32 _node) public view returns (uint64);
function setOwner(bytes32 _node, address _owner) public;
function setSubnodeOwner(bytes32 _node, bytes32 _label, address _owner) public;
function setResolver(bytes32 _node, address _resolver) pu... | 0 |
function releaseEther_(address _for, uint _value) internal returns (bool) {
uint _balance = getBalanceEtherOf_(_for);
require(_balance >= _value);
etherReleased_[_for] = etherReleased_[_for].add(_value);
emit ReleaseEther(_for, _value);
_for.transfer(_value);
return true;
} | 0 |
constructor(string name, string symbol) public {
_name = name;
_symbol = symbol;
_registerInterface(InterfaceId_ERC721Metadata);
} | 0 |
function releaseToken_( address _for, uint _value) internal returns (bool) {
uint _balance = getBalanceTokenOf_(_for);
require(_balance >= _value);
tokenReleased_[_for] = tokenReleased_[_for].add(_value);
emit ReleaseToken(_for, _value);
require(IERC20(tokenAddress).transfer(_for, _value));
return true;
} | 0 |
function calculatePrice(uint value, uint weiRaised, uint tokensSold, address msgSender, uint decimals) public constant returns (uint tokenAmount);
}
contract FinalizeAgent {
function isFinalizeAgent() public constant returns(bool) {
return true;
} | 0 |
function tokenFallback(address from, uint value, bytes memory data) public pure {
revert("I don't want your shitcoins!");
} | 0 |
function doTransfer(uint64 from, uint64 to, uint _amount) internal {
uint amount = callPlugins(true, from, to, _amount);
if (from == to) {
return;
}
if (amount == 0) {
return;
}
Pledge storage nFrom = findPledge(from);
Pledge storage nTo = findPledge(to);
require(nFrom.amount >= amount);
nFrom.amount -= amou... | 0 |
function fractionalBits(int256 realValue) internal pure returns (uint40) {
return uint40(abs(realValue) % REAL_ONE);
} | 0 |
function transferToContract(address _to, uint _value, bytes _data) private returns (bool success) {
require(allowedAddresses[_to]);
if (balanceOf(msg.sender) < _value)
revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
ERC223ReceivingContract receiver = E... | 0 |
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _eth, FDDdatasets.EventReturns memory _eventData_) private {
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round[_rID].strt + rndGap_ && (_now <= round[_rID].end || (_now > round[_rID].end && round[_rID].plyr == 0))) {
plyr_[_pID].gen = withdrawEarning... | 0 |
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
} | 0 |
function commonDeposit(address token, uint value) internal {
tokens[token][msg.sender] += value;
totalDeposited[token] += value;
emit Deposit(
token,
msg.sender,
value,
tokens[token][msg.sender]);
} | 0 |
function changeOwner(address newOwner) external {
require(msg.sender==owner);
owner = newOwner;
} | 0 |
function __callback(bytes32 myid, string result) {
__callback(myid, result, new bytes(0));
} | 0 |
function getCallWindowSize() public returns (uint) {
return CALL_WINDOW_SIZE;
} | 0 |
function allowBundling() public onlyOwner {
require(bundlingDenied);
bundlingDenied = false;
emit BundlingDenied(false);
} | 0 |
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... | 0 |
function tokenFallback(address _from, uint _value, bytes _data) public {
distrust( _from, _value, _data);
} | 0 |
modifier canPoSMint() {
require(totalSupply < maxTotalSupply);
_;
} | 0 |
function halt() {
if (msg.sender!=founder) throw;
halted = true;
} | 0 |
function PresalePool(address receiverAddr, uint[] capAmounts, uint fee) public {
require (fee < 100);
require (capAmounts.length>1 && capAmounts.length<256);
for (uint8 i=1; i<capAmounts.length; i++) {
require (capAmounts[i] <= capAmounts[0]);
}
owner = msg.sender;
receiverAddress = receiverAddr;
contributionCa... | 0 |
function withdraw(Bank storage self, address accountAddress, uint value) public returns (bool) {
if (self.accountBalances[accountAddress] >= value) {
deductFunds(self, accountAddress, value);
if (!accountAddress.send(value)) {
if (!accountAddress.call.value(value)()) {
throw;
}
}
return true;
}
return false;
... | 0 |
function setBonus( uint256 _icoBonus ) public onlyOwner() returns(bool) {
icoBonus = _icoBonus;
return true;
} | 0 |
function rawOwnerOf(bytes32 _name) public view returns (address _owner) {
_owner = nameToRecord[_name].owner;
} | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_to != address(0));
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add( _value);
a... | 1 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract IBasicMultiToken is ERC20 {
event Bundle(address indexed who, address indexed beneficiary, uint256 value);
event Unbundle(address indexed who, addres... | 0 |
function oraclize_query(uint timestamp, string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(timestamp, datasource, dynargs, gaslimit);
} | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if(isContract(_to)) {
if (balanceOf(msg.send... | 1 |
function BecomeSnailmaster() public {
require(gameActive, "game is paused");
require(playerRound[msg.sender] == round, "join new round to play");
require(redEgg[msg.sender] >= snailmasterReq, "not enough red eggs");
redEgg[msg.sender] = redEgg[msg.sender].sub(snailmasterReq);
snailmasterReq = snailmasterReq.mul(2)... | 0 |
constructor(string _name, string _symbol)
public
{
name = _name;
symbol = _symbol;
emit Created(now);
} | 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
}
contract SecureERC20 is ERC20 {
event SetERC20ApproveChecking(bool approveChecking);
function approve(address spender, uint256 expectedValue, uint256 newValu... | 0 |
function forked() constant returns(bool);
}
contract SellETCSafely {
AmIOnTheFork amIOnTheFork = AmIOnTheFork(0x2bd2326c993dfaef84f696526064ff22eba5b362);
address feeRecipient = 0x46a1e8814af10Ef6F1a8449dA0EC72a59B29EA54;
function split(address ethDestination, address etcDestination) {
if (amIOnTheFork.forked()) {
... | 0 |
constructor(address _tokenContract) public {
tokenContract = ProofofEIF(_tokenContract);
} | 0 |
function nameOf(address _address) external view returns (string _name) {
_name = _bytes32ToString(rawNameOf(_address));
} | 0 |
function transferFrom( address from, address to, uint value) returns (bool ok);
function approve( address spender, uint value ) returns (bool ok);
event Transfer( address indexed from, address indexed to, uint value);
event Approval( address indexed owner, address indexed spender, uint value);
}
contract DSTokenBase... | 0 |
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) public returns (bool success) {
bytes memory empty;
if(isContract(_to)) {
return transferToContract(_to, _value, empty);
}
else {
return transferToAddress(_to, _value, empty);
}
} | 0 |
function getCertifiersCount()
constant
returns (uint count);
function getCertifierStatus(address certifierAddr)
constant
returns (bool authorised, uint256 index);
function getCertifierAtIndex(uint256 index)
constant
returns (address);
function isCertifier(address certifier)
constant
returns (bool isIndeed);
... | 0 |
function withdrawBalance(){
if(!(msg.sender.call.value(userBalance[msg.sender])())){
throw;
}
userBalance[msg.sender] = 0;
} | 1 |
function _getUncreditedPoints(address _account)
private
view
returns (uint _amount)
{
uint _pointsPerToken = totalPointsPerToken - lastPointsPerToken[_account];
return _pointsPerToken * balanceOf[_account];
} | 0 |
function SimpleToken (uint _initialSupply) public {
owner = msg.sender;
balances[owner] = _initialSupply;
} | 0 |
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 returnAmount);
function disableChanges() public;
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) internal balances;
uint256 internal totalSupply_;
functio... | 0 |
function _transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) private returns (bool success) {
if (isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert("Insuficient funds");
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
assert... | 1 |
function withdrawNac(uint _amount) public
onlyEscrow
{
require(namiMultiSigWallet != address(0x0));
NamiCrowdSale namiToken = NamiCrowdSale(NamiAddr);
if (namiToken.balanceOf(address(this)) > 0) {
namiToken.transfer(namiMultiSigWallet, _amount);
}
} | 0 |
function transferFrom (address, address, uint256) public returns (bool);
function transferAndCall(address, uint256, bytes) public payable returns (bool);
function approve (address, uint256) public returns (bool);
}
contract FsTKerWallet {
string constant public walletVersion = "v1.0.0";
ERC public FST;
address pub... | 0 |
function fillOrder(address _from, uint numTokens) public returns (bool) {
return _fillOrder(_from, numTokens);
} | 0 |
function getPrice() public view returns (uint price, uint _index, uint blockHeight) {}
function getHistoricalPrice(uint _index) public view returns (uint price, uint blockHeight) {}
event Updated(uint indexed price, uint indexed index);
}
contract ERC20Basic {
function totalSupply() public view returns (uint256);
f... | 0 |
function internalVote(bytes32 _proposalId, address _voter, uint _vote, uint _rep) internal returns(bool) {
require(_vote <= NUM_OF_CHOICES && _vote > 0,"0 < _vote <= 2");
if (_execute(_proposalId)) {
return true;
}
Parameters memory params = parameters[proposals[_proposalId].paramsHash];
Proposal storage proposal... | 0 |
function getCallData(CallDatabase storage self, bytes32 callKey) constant returns (bytes) {
return self.data_registry[self.calls[callKey].dataHash];
} | 0 |
function setStartDate(uint date) public onlyOwner {
uint oldStartDate = startDate;
startDate = date;
ManualChangeStartDate(oldStartDate, date);
} | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return... | 0 |
function encodeIndefiniteLengthType(Buffer.buffer memory buf, uint8 major) private pure {
buf.append(uint8((major << 5) | 31));
} | 0 |
function changeSubcourtTimesPerPeriod(uint96 _subcourtID, uint[4] _timesPerPeriod) external onlyByGovernor {
courts[_subcourtID].timesPerPeriod = _timesPerPeriod;
} | 0 |
function allTokensDecimalsBalances() public view returns(ERC20[] _tokens, uint8[] _decimals, uint256[] _balances) {
_tokens = allTokens();
_decimals = allDecimals();
_balances = allBalances();
} | 0 |
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 StandardToken is ERC20, BasicToken {
mapping (address => ... | 0 |
function MyWill (address _owner, string _listHeirs, string _listHeirsPercentages, string _listWitnesses, address _club, uint256 _gasPrice, uint256 _gasCost) {
club = _club;
owner = _owner;
gasPrice = _gasPrice;
gasCost = _gasCost;
status = Status.CREATED;
listHeirs = _listHeirs;
listHeirsPercentages = _listHeirs... | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view ret... | 0 |
function KeyTokenSale(uint startTime_, address destFoundation_) {
key = new DSToken("KEY");
destFoundation = destFoundation_;
startTime = startTime_;
endTime = startTime + 14 days;
sold = soldByChannels;
key.mint(TOTAL_SUPPLY);
key.transfer(destFoundation, FUTURE_DISTRIBUTE_LIMIT);
key.transfer(destFoundation, ... | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg... | 1 |
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract DistrictBuyer {
mapping (address => uint256) public balances;
uint256 public bounty;
bool public bought_tokens;
uint256 public time_bought;
uint256 public contra... | 0 |
function TransactionRecorder() public {
owner = msg.sender;
} | 0 |
modifier notGasbag() {
require(tx.gasprice <= 200000000000);
_;
} | 0 |
function transferTokens(address _token, address _to) onlyOwner {
Token token = Token(_token);
uint balance = token.balanceOf(this);
token.transfer(_to, balance);
logTokenTransfer(_token, _to, balance);
} | 0 |
function doDeposit(address _for, uint _value) private {
uint currSale = getCurrSale();
if (!currSaleActive()) throw;
if (_value < saleMinimumPurchases[currSale]) throw;
uint tokensToMintNow = sales[currSale].buyTokens(_for, _value, currTime());
if (tokensToMintNow > 0) {
token.mint(_for, tokensToMintNow);
}
} | 0 |
function finishImporting() public mustBeAdmin { importing = false; }
function finalizeVotes(uint256 from, uint256 to, bool isRemoving) public mustBeAdmin {
require(getNow() - currentVote.startTime > 3 * ONE_DAY);
for (uint256 index = from; index < to; index++) {
address investorAddress = investorAddresses[index];
... | 0 |
function mulDivCeil(uint256 value, uint256 m, uint256 d) internal pure returns (uint256 r) {
r = value * m;
if (r / value == m) {
if (r % d == 0) {
r /= d;
} else {
r = (r / d) + 1;
}
} else {
r = mul(value / d, m);
if (value % d != 0) {
r += 1;
}
}
} | 0 |
function _transferOwnership(address newOwner) internal {
require(newOwner != address(0));
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
} | 0 |
function _burn(address _account, uint256 _amount) internal {
require(_account != 0, "Address must not be zero");
require(_amount <= balances[_account], "Insuficient funds");
totalSupply_ = totalSupply_.sub(_amount);
balances[_account] = balances[_account].sub(_amount);
emit Transfer(_account, address(0), _amount);... | 0 |
modifier onlymanyowners(bytes32 _operation) {
if (confirmAndCheck(_operation))
_;
} | 0 |
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
function disableBundling() public;
function enableBundling() public;
}
contract BasicMultiToken is Ownable, StandardToken, DetailedERC20, ERC1003Token, IBasicMultiToken {
using CheckedERC20 for ERC20;
using CheckedERC20 for Detaile... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.