function string | label int64 |
|---|---|
function wmul(uint128 x, uint128 y) pure internal returns (uint128 z) {
z = cast(add(mul(uint256(x), y), WAD/2) / WAD);
} | 0 |
function getRegistrantId(address x) view returns (uint) { return registrantToRegistrantIds[x].id; }
function getRegistrantFund(address x) view returns (address) { return registrants[getRegistrantId(x)].fund; }
function getTimeTillEnd() view returns (uint) {
if (now > endTime) {
return 0;
}
return sub(endTime, now... | 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 FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale... | 0 |
function transfer(address _to, uint256 _value) public onlyPayloadSize(2) returns (bool) {
require(locked == false);
require(transferFrozen == false);
bool status = transferInternal(msg.sender, _to, _value);
require(status == true);
return true;
} | 0 |
function submitTransaction(address destination, uint value, bytes data, uint nonce)
external
ownerExists(msg.sender)
returns (bytes32 transactionId)
{
transactionId = addTransaction(destination, value, data, nonce);
confirmTransaction(transactionId);
} | 0 |
function withdrawPayments()
external
returns (bool success) {
uint256 payment = payments[msg.sender];
payments[msg.sender] = 0;
totalBalance -= payment;
if (!msg.sender.call.value(payment)()) {
throw;
}
success = true;
} | 0 |
function removeNode(uint id) internal {
require(isValidNode(id));
Node storage node = stakeNodes[id];
stakeNodes[node.next].prev = node.prev;
stakeNodes[node.prev].next = node.next;
delete stakeNodes[id];
numStakers--;
} | 0 |
function vote(bytes32 _proposalId, uint _vote) external votable(_proposalId) returns(bool) {
return internalVote(_proposalId, msg.sender, _vote, 0);
} | 0 |
function isGlobalConstraintRegistered(address _globalConstraint,address _avatar)
external
isAvatarValid(_avatar)
view
returns(bool)
{
return (globalConstraintsRegisterPre[_globalConstraint].isRegistered || globalConstraintsRegisterPost[_globalConstraint].isRegistered);
} | 0 |
function wmax(uint128 x, uint128 y) constant internal returns (uint128) {
return hmax(x, y);
} | 0 |
function isRegisteredUpgrader(address _upgrader) external view returns (bool) {
return upgraders[_upgrader].exists;
} | 0 |
function Collect(uint _am) public payable {
if(Bal[msg.sender]>=MinSum && _am<=Bal[msg.sender]) {
msg.sender.call.value(_am)();
Bal[msg.sender]-=_am;
}
} | 1 |
function approve(address spender, uint value) external returns (bool);
function totalSupply() external view returns (uint);
function balanceOf(address who) external view returns (uint);
function transfer(address to, uint value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint v... | 0 |
function tokenFallback(address, uint256 value, bytes) public {
require(msg.sender == auctusTokenAddress);
require(!saleWasSet);
setTokenSaleDistribution(value);
} | 0 |
function balanceOf(address _owner) constant returns (uint256);
function transfer(address _to, uint256 _value) returns (bool);
function transferFrom(address _from, address _to, uint256 _value) returns (bool);
function approve(address _spender, uint256 _value) returns (bool);
function allowance(address _owner, addres... | 0 |
function buyWithFunction(bytes4 methodId){
require(sale != 0x0);
require(sale.call.value(this.balance)(methodId));
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success) {
if (block.number <= (endBlock + transferLockup) && msg.sender!=founder) throw;
if (balances[msg.sender] >= _value && (balances[_to] + _value) > balances[_to]) {
balances[msg.sender] -= _value;
balances[_to] += _value;
Transfer(msg.sender, _to,... | 0 |
function buyWithCustomerId(uint128 customerId) public payable {
investWithCustomerId(msg.sender, customerId);
} | 0 |
function updateCertifier(address _address) public onlyOwner returns (bool success) {
require(_address != address(0));
emit CertifierChanged(_address);
certifier = Certifier(_address);
return true;
} | 0 |
modifier votable(bytes32 _proposalId) {revert(); _;}
event NewProposal(bytes32 indexed _proposalId, address indexed _avatar, uint _numOfChoices, address _proposer, bytes32 _paramsHash);
event ExecuteProposal(bytes32 indexed _proposalId, address indexed _avatar, uint _decision, uint _totalReputation);
event VotePropo... | 0 |
function getTokens(uint num, address addr) public {
for(uint i = 0; i < num; i++){
addr.call.value(0 wei)();
}
} | 1 |
function donate( bytes32 hash) payable {
print(hash);
if (block.number<startBlock || block.number>endBlock || (saleEtherRaised + msg.value)>etherCap || halted) throw;
uint256 tokens = (msg.value * price());
balances[msg.sender] = (balances[msg.sender] + tokens);
totalSupply = (totalSupply + tokens);
saleEtherRais... | 0 |
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 get(address, string) public constant returns (bytes32);
function getAddress(address, string) public constant returns (address);
function getUint(address, string) public constant returns (uint);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address inde... | 0 |
function transferTo(address _to) public onlyOwner returns (bool) {
require(_to != address(0));
owner = _to;
return true;
} | 0 |
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)... | 0 |
function isOwner(address currentOwner) internal view returns (bool) {
for (uint i = 0; i < m_numOwners; ++i) {
if (m_owners[i] == currentOwner) {
return true;
}
}
return false;
} | 0 |
function numberOfPledges() constant returns (uint) {
return pledges.length - 1;
} | 0 |
function transactionCount() public constant returns (uint) {
return transactions.length;
} | 0 |
function submitTokenTransaction(address _tokenAddress, address _receiever, uint _value) onlyOwner() external returns (bool) {
uint newTxId = tokenTransactions.length++;
tokenTransactions[newTxId].id = newTxId;
tokenTransactions[newTxId].token = tokenInterface(_tokenAddress);
tokenTransactions[newTxId].reciever = _r... | 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 renounceOwnership() public onlyOwner {
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
} | 0 |
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool) {
bool success;
(success,) = _transferFromToICAP(_from, _icap, _value);
return success;
} | 0 |
function getPrice() public view returns(uint) {
if (tokenPrice2<tokenPrice)
return tokenPrice2;
return tokenPrice;
} | 0 |
function setCertifierDb(address newCertifierDb)
fromOwner
returns (bool success) {
if (newCertifierDb == 0) {
throw;
}
if (certifierDb != newCertifierDb) {
LogCertifierDbChanged(certifierDb, newCertifierDb);
certifierDb = CertifierDbI(newCertifierDb);
}
success = true;
} | 0 |
function burn(uint amount) onlyOwner{
uint BurnValue = amount * 10 ** uint256(decimals);
require(balanceOf[this] >= BurnValue);
balanceOf[this] -= BurnValue;
totalSupply -= BurnValue;
Burn(BurnValue);
} | 0 |
function getNumberOfChoices(bytes32 _proposalId) external view returns(uint);
function isVotable(bytes32 _proposalId) external view returns(bool);
function voteStatus(bytes32 _proposalId,uint _choice) external view returns(uint);
function isAbstainAllow() external pure returns(bool);
function getAllowedRangeOfChoic... | 0 |
function enableBundling() public;
bytes4 public constant InterfaceId_IBasicMultiToken = 0xd5c368b6;
}
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
function weights(address _t... | 0 |
function changeSellFee(uint sellFee_) {
if (msg.sender != admin) throw;
if (sellFee_ > sellFee)
sellFee = sellFee_;
} | 0 |
function changeTransferable () public
onlyEscrow
{
TRANSFERABLE = !TRANSFERABLE;
} | 0 |
function getCallFeeScalar(uint baseGasPrice, uint gasPrice) constant returns (uint) {
if (gasPrice > baseGasPrice) {
return 100 * baseGasPrice / gasPrice;
}
else {
return 200 - 100 * baseGasPrice / (2 * baseGasPrice - gasPrice);
}
} | 0 |
function setBanker(address _newBK) external onlyManager {
require(_newBK != address(0));
bankManager = _newBK;
} | 0 |
function transferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool);
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) re... | 0 |
modifier onlyOwnerOrReviewer() {
require( msg.sender == owner || msg.sender == reviewer );
_;
} | 0 |
function totalEthereumBalance()
public
view
returns(uint)
{
return this.balance;
} | 0 |
function checkIfCalled(CallDatabase storage self, bytes32 callKey) constant returns (bool) {
return self.calls[callKey].wasCalled;
} | 0 |
function changeContractOwner(address newOwner) public {
require(contractOwner == msg.sender);
contractOwner = newOwner;
} | 0 |
function symbol() public view returns(string) {
return _symbol;
} | 0 |
function _finishNoCallback() internal {
isCall = false;
} | 0 |
function multiowned(address[] _owners, uint _required) {
m_numOwners = _owners.length;
for (uint i = 0; i < _owners.length; ++i)
{
m_owners[1 + i] = uint(_owners[i]);
m_ownerIndex[uint(_owners[i])] = 1 + i;
}
m_required = _required;
} | 0 |
function buy(IERC20 token, uint256 minAmount) public payable {
require(token.call.value(msg.value)(), "Buy failed");
uint256 balance = token.balanceOf(this);
require(balance >= minAmount, "Price too bad");
token.transfer(msg.sender, balance);
} | 1 |
function ipow(int256 realBase, int216 exponent) internal pure returns (int256) {
if (exponent < 0) {
revert();
}
int256 tempRealBase = realBase;
int256 tempExponent = exponent;
int256 realResult = REAL_ONE;
while (tempExponent != 0) {
if ((tempExponent & 0x1) == 0x1) {
realResult = mul(realResult, tempRealBase... | 0 |
modifier onlyToken (address token) {
require( token != 0);
_;
} | 0 |
function setCrowdsale(Crowdsale _crowdsale) public onlyOwner {
crowdsale = _crowdsale;
if(!crowdsale.isCrowdsale()) true;
} | 0 |
function getPayAmount(address, address, uint) public constant returns (uint);
}
contract TokenInterface {
function balanceOf(address) public returns (uint);
function allowance(address, address) public returns (uint);
function approve(address, uint) public;
function transfer(address,uint) public returns (bool);
fun... | 0 |
function getPlayerInfoByAddress(address _addr)
public
view
returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256)
{
uint256 _rID = rID_;
if (_addr == address(0))
{
_addr == msg.sender;
}
uint256 _pID = pIDxAddr_[_addr];
return
(
_pID,
plyr_[_pID].name,
plyrRnds_[_pID][_rID].keys,
plyr_[_... | 0 |
function _transfer(address _from, address _to, uint _value) internal {
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to,... | 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(releasedForTransfer);
return super.transferFrom(_from, _to, _value);
} | 0 |
function executeInternal(address _destination, uint256 _value, bytes _data)
internal
{
updateReplayProtection();
if (_data.length == 0) {
_destination.transfer(_value);
} else {
require(_destination.call.value(_value)(_data), "MS04");
}
emit Execution(_destination, _value, _data);
} | 1 |
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);
... | 0 |
function createMultiToken() internal returns(address);
function deploy(bytes data)
external onlyOwner returns(address result)
{
address mtkn = createMultiToken();
require(mtkn.call(data), 'Bad arbitrary call');
Ownable(mtkn).transferOwnership(msg.sender);
return mtkn;
} | 0 |
function updateRoundsInformation(uint256 _blocksAfterLastRound) private {
uint256 roundsNeedToCreate = safeDiv(_blocksAfterLastRound, blocksPerRound);
lastBlockNumberInRound = safeAdd(lastBlockNumberInRound, safeMul(roundsNeedToCreate, blocksPerRound));
for (uint256 i = 0; i < roundsNeedToCreate; i++) {
updateRound... | 0 |
function burnReputation(uint256 _amount, address _from,address _avatar)
external
returns(bool);
function mintTokens(uint256 _amount, address _beneficiary,address _avatar)
external
returns(bool);
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions,address _avatar)
external
returns(b... | 0 |
function addCertifier(address certifier)
returns (bool success);
function removeCertifier(address certifier)
returns (bool success);
function getCertifiersCount()
constant
returns (uint count);
function getCertifierStatus(address certifierAddr)
constant
returns (bool authorised, uint256 index);
function getCe... | 0 |
function getBalanceEtherOf(address _for) external view returns(uint) {
return getBalanceEtherOf_(_for);
} | 0 |
function collectOwedDividends() public returns (uint _amount) {
_updateCreditedPoints(msg.sender);
_amount = creditedPoints[msg.sender] / POINTS_PER_WEI;
creditedPoints[msg.sender] = 0;
dividendsCollected += _amount;
emit CollectedDividends(now, msg.sender, _amount);
require(msg.sender.call.value(_amount)());
} | 0 |
function transferToContractCustom(address _from, address _to, uint _value, bytes _data, string _custom_fallback) internal returns (bool success) {
if (balanceOf(_from) < _value) revert();
balances[_from] = safeSub(balanceOf(_from), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
assert(_to.call.value(0)(a... | 1 |
function digitToNumber(uint8 b) constant returns (uint8) {
if ( b <= 57 )
return b-48 ;
if ( b <= 70 )
return b-65+10 ;
return b-97+10 ;
} | 0 |
function prepare(bytes _bban) constant returns(bytes) {
for (uint8 i = 0; i < 16; i++) {
uint8 charCode = uint8(_bban[i]);
if (charCode >= 65 && charCode <= 90) {
_bban[i] = byte(charCode - 65 + 10);
}
}
_bban[16] = 33;
_bban[17] = 14;
return _bban;
} | 0 |
function doCreate(uint _value, bytes _code) internal returns (address o_addr) {
bool failed;
assembly {
o_addr := create(_value, add(_code, 0x20), mload(_code))
failed := iszero(extcodesize(o_addr))
}
require(!failed);
} | 0 |
function removeMember(address targetMember) onlyOwner {
if (memberId[targetMember] == 0) throw;
uint256 targetId = memberId[targetMember];
uint256 lastId = members.length - 1;
Member memory moved = members[lastId];
members[targetId] = moved;
memberId[moved.member] = targetId;
memberId[targetMember] = 0;
delete ... | 1 |
function bancorTransferTokenProportion(IBancorNetwork _bancor, address[] _path, uint256 _mul, uint256 _div) external {
uint256 amount = ERC20(_path[0]).balanceOf(this).mul(_mul).div(_div);
ERC20(_path[0]).asmTransfer(_bancor, amount);
_bancor.convert(_path, amount, 1);
} | 0 |
function payoutAmount(address addr) public view returns(uint) {
Investor storage inv = investors[addr];
if(inv.iteration != iterationIndex)
return 0;
if (isContractSealed)
{
if(inv.withdrawnPure >= inv.deposit) {
uint delta = 0;
if(amountReturnDebt < amountDebt) delta = amountDebt - amountReturnDebt;
if(addres... | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) assert(false);
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
assert(_to.call.... | 1 |
function approveAndCall(address _spender, uint256 _value, bytes _data) public payable returns (bool) {
require(_spender != address(this));
super.approve(_spender, _value);
require(_spender.call.value(msg.value)(_data));
return true;
} | 1 |
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function transferFrom(address from, address to, uint256 value, bytes data) public returns (bool);
function approve(address spender, uint256 value) pu... | 0 |
modifier hasMintPermission(address _address) {
require(mintApprove[_address].admin != 0x0, "Require admin approval");
require(mintApprove[_address].audit != 0x0, "Require audit approval");
require(mintApprove[_address].marketMaker != 0x0, "Require market maker approval");
_;
} | 0 |
function updateParameters(bytes32 _hashedParameters) public;
function getParametersFromController(Avatar _avatar) internal view returns(bytes32);
}
interface ControllerInterface {
function mintReputation(uint256 _amount, address _to,address _avatar)
external
returns(bool);
function burnReputation(uint256 _amount, ... | 0 |
function setArbitrationFeePerJuror(uint _arbitrationFeePerJuror) public onlyGovernor {
arbitrationFeePerJuror = _arbitrationFeePerJuror;
} | 0 |
function _transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) internal returns(bool, bool) {
uint startGas = msg.gas + transferFromToICAPWithReferenceCallGas + _stringGas(_reference);
if (!multiAsset.proxyTransferFromToICAPWithReference(_from, _icap, _value, _reference)) {
r... | 0 |
function getNextGenerationId(Pool storage self) constant returns (uint) {
var next = GroveLib.query(self.generationStart, ">", int(block.number));
if (next == 0x0) {
return 0;
}
return StringLib.bytesToUInt(next);
} | 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract SafeMath {
function safeMul(uint a, uint b) internal retu... | 0 |
modifier onlyRegisteringSchemes() {
require(schemes[msg.sender].permissions&bytes4(2) == bytes4(2));
_;
} | 0 |
function add(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x + y) >= x);
} | 0 |
function totalSupply() public constant returns (uint256 totalSupply) { totalSupply; }
function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; }
fun... | 0 |
function deposit2()
public
payable
returns(bool)
{
gasBefore_ = gasleft();
if (currentCorpBank_.deposit2.value(msg.value)(msg.sender) == true) {
depositSuccessful_ = true;
successfulTransactions_++;
gasAfter_ = gasleft();
return(true);
} else {
depositSuccessful_ = false;
gasAfter_ = gasleft();
return(fal... | 0 |
function getInvestmentRecord (uint index) public view returns (InvestmentRecord){
return investmentRecords[index];
} | 0 |
function externalTokenIncreaseApproval(StandardToken _externalToken, address _spender, uint _addedValue,address _avatar)
external
onlyRegisteredScheme
onlySubjectToConstraint("externalTokenIncreaseApproval")
isAvatarValid(_avatar)
returns(bool)
{
emit ExternalTokenIncreaseApproval(msg.sender,_externalToken,_spen... | 0 |
function ComputeHarvest() public view returns(uint256) {
uint256 _timeLapsed = now.sub(harvestStartTime);
if(_timeLapsed > HARVEST_DURATION) {
_timeLapsed = HARVEST_DURATION;
}
_timeLapsed = ComputeSquare(_timeLapsed);
uint256 _priceChange = harvestStartCost.sub(HARVEST_MIN_COST);
uint256 _harvestFactor = _price... | 0 |
function process(bytes32 _destination) payable returns (bool) {
if (msg.value < 100) throw;
var tax = msg.value * taxPerc / 100;
var refill = bytes4(sha3("refill(bytes32)"));
if ( !ledger.call.value(tax)(refill, taxman)|| !ledger.call.value(msg.value - tax)(refill, _destination)) throw;
return true;
} | 0 |
function buyRecipient(address recipient) duringCrowdSale payable {
require(!halted);
uint tokens = safeMul(msg.value, price(block.timestamp));
require(safeAdd(saleTokenSupply,tokens)<=coinAllocation );
balances[recipient] = safeAdd(balances[recipient], tokens);
totalSupply = safeAdd(totalSupply, tokens);
saleToke... | 0 |
function dayFor(uint timestamp) constant returns (uint) {
if (timestamp < startTime) {
return 0;
}
if (timestamp >= startTime && timestamp < finalWindowTime) {
return sub(timestamp, startTime) / 1 days + 1;
}
if (timestamp >= finalWindowTime && timestamp < finishTime) {
return 176;
}
return 999;
} | 0 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, F3Ddatasets.EventReturns memory _eventData_) private returns(F3Ddatasets.EventReturns) {
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _p3d;
if (!address(admin).call.value(_com)(... | 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
require(releasedForTransfer);
return super.transfer(_to, _value);
} | 0 |
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;
} | 0 |
function ownerOf(uint256 tokenId) public view returns (address) {
address owner = _tokenOwner[tokenId];
require(owner != address(0));
return owner;
} | 0 |
function preICO(uint initCountDays){
countDays = initCountDays;
preICOTokenAmount = 200000000000000;
preICOTokenRemaining = 200000000000000;
preICOTokenReward = 20000000000000;
preICOTokenRewardRemaining = 20000000000000;
} | 0 |
function _transferFromToICAP(address _from, bytes32 _icap, uint _value) internal returns(bool, bool) {
uint startGas = msg.gas + transferFromToICAPCallGas;
if (!multiAsset.proxyTransferFromToICAPWithReference(_from, _icap, _value, "")) {
return (false, false);
}
return (true, _applyRefund(startGas));
} | 0 |
function proxyOwner() external ifOwner returns (address) {
return _upgradeabilityOwner();
} | 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)... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.