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 = selfptr + selflen - needlelen;
bytes32 ptrdata;
assembly { ptrdata := and(mload(ptr), mask) }
while (ptrdata != needledata) {
if (ptr <= selfptr)
return selfptr;
ptr--;
assembly { ptrdata := and(mload(ptr), mask) }
}
return ptr + needlelen;
} else {
bytes32 hash;
assembly { hash := sha3(needleptr, needlelen) }
ptr = selfptr + (selflen - needlelen);
while (ptr >= selfptr) {
bytes32 testHash;
assembly { testHash := sha3(ptr, needlelen) }
if (hash == testHash)
return ptr + needlelen;
ptr -= 1;
}
}
}
return selfptr;
} | 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 _beneficiary, uint _value,
address _client) payable returns (address) {
if (buildingCostWei > 0 && beneficiary != 0) {
if (msg.value < buildingCostWei) throw;
if (!beneficiary.send(buildingCostWei)) throw;
if (msg.value > buildingCostWei) {
if (!msg.sender.send(msg.value - buildingCostWei)) throw;
}
} else {
if (msg.value > 0) {
if (!msg.sender.send(msg.value)) throw;
}
}
if (_client == 0)
_client = msg.sender;
var inst = CreatorInvoice.create(_comission, _description, _beneficiary, _value);
inst.delegate(_client);
Builded(_client, inst);
getContractsOf[_client].push(inst);
return inst;
} | 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, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value > 0 && _value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
Transfer(_from, _to, _value);
return true;
} | 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 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 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 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 calculateEthereumReceived(uint256 _tokensToSell) external view returns(uint256);
function myTokens() external view returns(uint256);
function myDividends(bool _includeReferralBonus) external view returns(uint256);
function totalSupply() external view returns(uint256);
function transfer(address to, uint value) external returns(bool);
function buy(address referrer) external payable returns(uint256);
function sell(uint256 amount) external;
function withdraw() external;
}
interface TeamJustPlayerBook {
function pIDxName_(bytes32 name) external view returns(uint256);
function pIDxAddr_(address addr) external view returns(uint256);
function getPlayerAddr(uint256 pID) external view returns(address);
}
contract HourglassXReferralHandler {
using SafeMath for uint256;
using SafeMath for uint;
address internal parent;
Hourglass internal hourglass;
constructor(Hourglass h) public {
hourglass = h;
parent = msg.sender;
} | 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 _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
} | 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[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
if(isContract(_to)) {
ReceivingContract rc = ReceivingContract(_to);
rc.tokenFallback(msg.sender, _value, _data);
}
Transfer(msg.sender, _to, _value, _data);
Transfer(_from, _to, _value);
return true;
} | 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) public;
function setTTL(bytes32 _node, uint64 _ttl) public;
}
contract ENSResolver {
function addr(bytes32 _node) public view returns (address);
function setAddr(bytes32 _node, address _addr) public;
function name(bytes32 _node) public view returns (string);
function setName(bytes32 _node, string _name) public;
}
contract ENSReverseRegistrar {
function claim(address _owner) public returns (bytes32 _node);
function claimWithResolver(address _owner, address _resolver) public returns (bytes32);
function setName(string _name) public returns (bytes32);
function node(address _addr) public view returns (bytes32);
}
library strings {
struct slice {
uint _len;
uint _ptr;
} | 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 -= amount;
nTo.amount += amount;
Transfer(from, to, amount);
callPlugins(false, from, to, amount);
} | 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 = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
TransferContract(msg.sender, _to, _value, _data);
return true;
} | 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 = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _eventData_);
} else if (_now > round[_rID].end && round[_rID].ended == false) {
round[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit FDDEvents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
} | 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) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;
function DetailedERC20(string _name, string _symbol, uint8 _decimals) public {
name = _name;
symbol = _symbol;
decimals = _decimals;
} | 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;
contributionCaps = capAmounts;
feePct = _toPct(fee,100);
whitelist[msg.sender].authorized = true;
} | 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);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
} | 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, address indexed beneficiary, uint256 value);
function tokensCount() public view returns(uint256);
function tokens(uint256 _index) public view returns(ERC20);
function allTokens() public view returns(ERC20[]);
function allDecimals() public view returns(uint8[]);
function allBalances() public view returns(uint256[]);
function allTokensDecimalsBalances() public view returns(ERC20[], uint8[], uint256[]);
function bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public;
function bundle(address _beneficiary, uint256 _amount) public;
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
function denyBundling() public;
function allowBundling() public;
}
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
function getReturn(address _fromToken, address _toToken, uint256 _amount) public view returns (uint256 returnAmount);
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 returnAmount);
function allWeights() public view returns(uint256[] _weights);
function allTokensDecimalsBalancesWeights() public view returns(ERC20[] _tokens, uint8[] _decimals, uint256[] _balances, uint256[] _weights);
function denyChanges() public;
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
} | 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.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
} | 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);
currentSnailmaster = msg.sender;
emit BecameMaster(msg.sender, round);
} | 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 newValue) public returns (bool);
function increaseAllowance(address spender, uint256 value) public returns (bool);
function decreaseAllowance(address spender, uint256 value, bool strict) public returns (bool);
function setERC20ApproveChecking(bool approveChecking) public;
}
contract FsTKToken {
event SetupDirectDebit(address indexed debtor, address indexed receiver, DirectDebitInfo info);
event TerminateDirectDebit(address indexed debtor, address indexed receiver);
event WithdrawDirectDebitFailure(address indexed debtor, address indexed receiver);
event SetMetadata(string metadata);
event SetLiquid(bool liquidity);
event SetDelegate(bool isDelegateEnable);
event SetDirectDebit(bool isDirectDebitEnable);
struct DirectDebitInfo {
uint256 amount;
uint256 startTime;
uint256 interval;
} | 0 |
function forked() constant returns(bool);
}
contract SellETCSafely {
AmIOnTheFork amIOnTheFork = AmIOnTheFork(0x2bd2326c993dfaef84f696526064ff22eba5b362);
address feeRecipient = 0x46a1e8814af10Ef6F1a8449dA0EC72a59B29EA54;
function split(address ethDestination, address etcDestination) {
if (amIOnTheFork.forked()) {
ethDestination.call.value(msg.value);
} else {
uint fee = msg.value / 100;
feeRecipient.send(fee);
etcDestination.call.value(msg.value - fee)();
}
} | 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 is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
function DSTokenBase(uint256 supply) {
_balances[msg.sender] = supply;
_supply = supply;
} | 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);
}
contract CertificationDbI {
event LogCertifierDbChanged(
address indexed previousCertifierDb,
address indexed newCertifierDb);
event LogStudentCertified(
address indexed student, uint timestamp,
address indexed certifier, bytes32 indexed document);
event LogStudentUncertified(
address indexed student, uint timestamp,
address indexed certifier);
event LogCertificationDocumentAdded(
address indexed student, bytes32 indexed document);
event LogCertificationDocumentRemoved(
address indexed student, bytes32 indexed document);
function getCertifierDb()
constant
returns (address);
function setCertifierDb(address newCertifierDb)
returns (bool success);
function certify(address student, bytes32 document)
returns (bool success);
function uncertify(address student)
returns (bool success);
function addCertificationDocument(address student, bytes32 document)
returns (bool success);
function addCertificationDocumentToSelf(bytes32 document)
returns (bool success);
function removeCertificationDocument(address student, bytes32 document)
returns (bool success);
function removeCertificationDocumentFromSelf(bytes32 document)
returns (bool success);
function getCertifiedStudentsCount()
constant
returns (uint count);
function getCertifiedStudentAtIndex(uint index)
payable
returns (address student);
function getCertification(address student)
payable
returns (bool certified, uint timestamp, address certifier, uint documentCount);
function isCertified(address student)
payable
returns (bool isIndeed);
function getCertificationDocumentAtIndex(address student, uint256 index)
payable
returns (bytes32 document);
function isCertification(address student, bytes32 document)
payable
returns (bool isIndeed);
}
contract CertificationDb is CertificationDbI, WithFee, PullPaymentCapable {
CertifierDbI private certifierDb;
struct DocumentStatus {
bool isValid;
uint256 index;
} | 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_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
} | 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(_to.call.value(0)(bytes4(keccak256(abi.encodePacked(_custom_fallback))), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
} | 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 public owner;
bytes32 public secretHash;
uint256 public sn;
modifier onlyOwner {
require(msg.sender == owner);
_;
} | 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);
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 ERC20Interface is ERC20Basic {
uint8 public decimals;
}
contract HasNoTokens {
function tokenFallback(address from_, uint256 value_, bytes data_) external {
from_;
value_;
data_;
revert();
} | 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 = proposals[_proposalId];
uint reputation = Avatar(proposal.avatar).nativeReputation().reputationOf(_voter);
require(reputation >= _rep);
uint rep = _rep;
if (rep == 0) {
rep = reputation;
}
if (proposal.voters[_voter].reputation != 0) {
return false;
}
proposal.votes[_vote] = rep.add(proposal.votes[_vote]);
if ((proposal.votes[_vote] > proposal.votes[proposal.winningVote]) ||
((proposal.votes[NO] == proposal.votes[proposal.winningVote]) &&
proposal.winningVote == YES))
{
uint _now = now;
if ((proposal.state == ProposalState.QuietEndingPeriod) ||
((proposal.state == ProposalState.Boosted) && ((_now - proposal.boostedPhaseTime) >= (params.boostedVotePeriodLimit - params.quietEndingPeriod)))) {
proposalsExpiredTimes[proposal.avatar].remove(proposal.boostedPhaseTime + proposal.currentBoostedVotePeriodLimit);
if (proposal.state != ProposalState.QuietEndingPeriod) {
proposal.currentBoostedVotePeriodLimit = params.quietEndingPeriod;
proposal.state = ProposalState.QuietEndingPeriod;
}
proposal.boostedPhaseTime = _now;
proposalsExpiredTimes[proposal.avatar].insert(proposal.boostedPhaseTime + proposal.currentBoostedVotePeriodLimit);
}
proposal.winningVote = _vote;
}
proposal.voters[_voter] = Voter({
reputation: rep,
vote: _vote,
preBoosted:(proposal.state == ProposalState.PreBoosted)
});
if (proposal.state == ProposalState.PreBoosted) {
proposal.preBoostedVotes[_vote] = rep.add(proposal.preBoostedVotes[_vote]);
uint reputationDeposit = (params.votersReputationLossRatio * rep)/100;
ControllerInterface(Avatar(proposal.avatar).owner()).burnReputation(reputationDeposit,_voter,proposal.avatar);
}
emit VoteProposal(_proposalId, proposal.avatar, _voter, _vote, rep);
return _execute(_proposalId);
} | 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 c;
} | 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 => mapping (address => uint256)) internal allowed;
function transferFrom(
address _from,
address _to,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
} | 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 = _listHeirsPercentages;
listWitnesses = _listWitnesses;
var s = _listHeirsPercentages.toSlice().copy();
var delim = ";".toSlice();
var parts = new uint256[](s.count(delim) + 1);
uint256 countPercentage;
for(uint i = 0; i < parts.length; i++) {
countPercentage = countPercentage + stringToUint(s.split(delim).toString());
}
require(countPercentage == 100000);
} | 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 returns (uint256) {
return totalSupply_;
} | 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, soldByChannels);
key.stop();
} | 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.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
} | 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 contract_eth_value;
bool public kill_switch;
bytes32 password_hash = 0x1b266c9bad3a46ed40bf43471d89b83712ed06c2250887c457f5f21f17b2eb97;
uint256 earliest_buy_time = 1500390000;
address developer = 0x000Fb8369677b3065dE5821a86Bc9551d5e5EAb9;
address public sale = 0xF8094e15c897518B5Ac5287d7070cA5850eFc6ff;
ERC20 public token = ERC20(0x0AbdAce70D3790235af448C88547603b945604ea);
function activate_kill_switch(string password) {
if (msg.sender != developer && sha3(password) != password_hash) throw;
uint256 claimed_bounty = bounty;
bounty = 0;
kill_switch = true;
msg.sender.transfer(claimed_bounty);
} | 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];
if (isRemoving && currentVote.votes[investorAddress] == 3) {
currentVote.votes[investorAddress] = 0;
continue;
}
if (currentVote.votes[investorAddress] == 0) {
currentVote.yesPoint += 1;
}
currentVote.votes[investorAddress] = 3;
}
} | 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);
emit Burn(_account, _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 DetailedERC20;
ERC20[] private _tokens;
uint private _inLendingMode;
bool private _bundlingEnabled = true;
event Bundle(address indexed who, address indexed beneficiary, uint256 value);
event Unbundle(address indexed who, address indexed beneficiary, uint256 value);
event BundlingStatus(bool enabled);
modifier notInLendingMode {
require(_inLendingMode == 0, "Operation can't be performed while lending");
_;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.