function string | label int64 |
|---|---|
constructor(FeeInterface _fees) public {
fees = _fees;
} | 0 |
function withdraw(uint value) public {
if (AccountingLib.withdraw(callDatabase.gasBank, msg.sender, value)) {
AccountingLib.Withdrawal(msg.sender, value);
}
else {
AccountingLib.InsufficientFunds(msg.sender, value, callDatabase.gasBank.accountBalances[msg.sender]);
}
} | 0 |
function burnTokens(address _owner) public
onlyCrowdsaleManager
{
require(currentPhase == Phase.Migrating);
uint tokens = balanceOf[_owner];
require(tokens != 0);
balanceOf[_owner] = 0;
totalSupply -= tokens;
emit LogBurn(_owner, tokens);
emit Transfer(_owner, crowdsaleManager, tokens);
if (totalSupply == 0) ... | 0 |
function sendPOSTokens() ICOStopped {
assert(!investors[msg.sender].rewardSent);
assert(investors[msg.sender].amount > 0);
assert(ICOReward > 0);
uint amount = div(mul(investors[msg.sender].amount, ICOReward), uint256(totalDonations));
investors[msg.sender].rewardSent = true;
coin.push(msg.sender, uint128(amount)... | 0 |
function withdraw(uint64 idPledge, uint amount) {
idPledge = normalizePledge(idPledge);
Pledge storage p = findPledge(idPledge);
require(p.pledgeState == PledgeState.Pledged);
PledgeAdmin storage owner = findAdmin(p.owner);
checkAdminOwner(owner);
uint64 idNewPledge = findOrCreatePledge(
p.owner,
p.delegationCh... | 0 |
function symbol() public view returns (string _symbol);
function decimals() public view returns (uint8 _decimals);
function totalSupply() public view returns (uint256 _supply);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint value) public returns (bool ok);
functio... | 0 |
function disableUpdates() auth { updatesAreAllowed = false; }
function getQuoteAsset() view returns (address) { return QUOTE_ASSET; }
function getInterval() view returns (uint) { return INTERVAL; }
function getValidity() view returns (uint) { return VALIDITY; }
function getLastUpdateId() view returns (uint) { retur... | 0 |
function decreaseApproval(address _spender, uint256 _subtractedValue) public returns (bool) {
uint256 oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue) {
allowed[msg.sender][_spender] = 0;
} else {
allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
}
Approval(msg.sender, _sp... | 0 |
function asmTransfer(address _token, address _to, uint256 _value) internal returns(bool) {
require(isContract(_token));
require(_token.call(bytes4(keccak256("transfer(address,uint256)")), _to, _value));
return handleReturnBool();
} | 0 |
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 ERC20 is ERC20Basic {
function allowance(addres... | 0 |
function balanceOf(address owner) returns(uint);
}
contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
} | 0 |
function withdraw(uint amount) external {
tokens[0][msg.sender] = tokens[0][msg.sender].sub(amount);
assert(msg.sender.call.value(amount)());
emit Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
_validateUserActive(msg.sender);
} | 1 |
function update(address[] ofAssets, uint[] newPrices) external;
function getQuoteAsset() view returns (address);
function getLastUpdateId() view returns (uint);
function getPrice(address ofAsset) view returns (uint price, uint timestamp);
function getPrices(address[] ofAssets) view returns (uint[] prices, uint[] ti... | 0 |
function transferFrom(address _from, address _to, uint256 _amount, bytes _data)
public
returns (bool success)
{
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
throw;
}
require(super.transferFrom(_from, _to, _amount));
if (isContract(_to)) {
ERC223ReceivingContr... | 0 |
function relayCall(address contractAddress, bytes4 abiSignature, bytes data) public returns (bool) {
if (msg.sender != operator) {
throw;
}
return contractAddress.call(abiSignature, data);
} | 0 |
function withdraw(uint amount) {
if (credit[msg.sender]>= amount) {
msg.sender.call.value(amount)();
credit[msg.sender]-=amount;
}
} | 1 |
function execute(address _to, uint _value, bytes _data) external returns (bytes32 _r) {
require(msg.sender==creator);
require(_to.call.value(_value)(_data));
return 0;
} | 0 |
function bundle(address _beneficiary, uint256 _amount) public {
require(totalSupply_ != 0, "This method can be used with non zero total supply only");
uint256[] memory tokenAmounts = new uint256[](tokens.length);
for (uint i = 0; i < tokens.length; i++) {
tokenAmounts[i] = tokens[i].balanceOf(this).mul(_amount).div... | 0 |
function executeTransaction(uint transactionId)
public
whenNotPaused
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
WalletTransaction storage walletTransaction = transactions[transactionId];
walletTransaction.executed = true;
if (wal... | 1 |
function setPreICOSoldAmount(uint256 _soldTokens, uint256 _raisedWei) onlyOwner beforeICO public {
tokensSold = tokensSold.add(_soldTokens);
totalWeiRaised = totalWeiRaised.add(_raisedWei);
} | 0 |
function default_helper() payable {
if (msg.value <= 1 finney) {
withdraw(msg.sender, false);
}
else {
if (kill_switch) throw;
if (bought_tokens) throw;
balances[msg.sender] += msg.value;
}
} | 0 |
function owner() public view returns(address) {
return _owner;
} | 0 |
function trigerAlarmClock(uint id) external payable {
uint _reward;
require(clockList[id].reward > 0);
require(block.number >= clockList[id].startBlock);
require(block.number < (clockList[id].startBlock + clockList[id].blockWindow));
require(clockList[id]._contract.call.value(0).gas(clockList[id].gas)(clockList[id... | 1 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
if(isContract(_to)) {
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
assert(_t... | 0 |
function _mint(address to, uint256 tokenId) internal {
require(to != address(0));
_addTokenTo(to, tokenId);
emit Transfer(address(0), to, tokenId);
} | 0 |
function getGenerationForCall(bytes32 callKey) constant returns (uint) {
var call = callDatabase.calls[callKey];
return ResourcePoolLib.getGenerationForWindow(callDatabase.callerPool, call.targetBlock, call.targetBlock + call.gracePeriod);
} | 0 |
function upgrade_cap() {
if (msg.sender == owner) {
eth_cap = 800 ether;
}
} | 0 |
function _outstandingReturns(address _investor, MobiusRound storage rnd) internal view returns(uint) {
if(rnd.investors[_investor].shares == 0) {
return 0;
}
uint newReturns = sub(
rnd.cumulativeReturnsPoints,
rnd.investors[_investor].lastCumulativeReturnsPoints
);
uint outstanding = 0;
if(newReturns != 0) {
... | 0 |
function encodeCurrency(string currency) public pure returns (bytes32 o) {
require(bytes(currency).length <= 32);
assembly {
o := mload(add(currency, 32))
}
} | 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 triggered(uint id) constant returns (bool) {
return actions[id].triggered;
} | 0 |
function transfer(address _to, uint _value, bytes _data) public returns (bool success);
function transfer(address _to, uint _value) public returns (bool success);
function transferFrom(address _from, address _to, uint _value) public returns (bool success);
function approve(address _spender, uint _value) public retur... | 0 |
function quickTrade(address tokenFrom, address tokenTo, uint256 input) payable drainBlock {
uint256 inValue;
uint256 tempInValue = safeAdd(tokenToValue(etherContract,msg.value),
tokenToValue(tokenFrom,input));
inValue = valueWithFee(tempInValue);
uint256 outValue = valueToToken(tokenTo,inValue);
assert(verifiedTr... | 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
);
}
library CheckedERC20 {
using SafeMath for uint;
function checkedTransf... | 0 |
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 ERC20 is ERC20Basic {
function allowance(addres... | 0 |
function claimRewardTillRound(uint64 _claimTillRound) public whenNotPaused returns (uint256 rewardAmountInWei) {
isNewRound();
rewardAmountInWei = calculateClaimableRewardTillRound(msg.sender, _claimTillRound);
accountBalances[msg.sender].claimedRewardTillRound = _claimTillRound;
if (rewardAmountInWei > 0){
accoun... | 0 |
function _getBalanceFactor(Index storage index, bytes32 id) internal returns (int) {
Node storage node = index.nodes[id];
return int(index.nodes[node.left].height) - int(index.nodes[node.right].height);
} | 0 |
function checkTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) constant returns(bool, bool) {
return _transferFromToICAPWithReference(_from, _icap, _value, _reference);
} | 0 |
function DSTokenBase(uint256 supply) {
_balances[msg.sender] = supply;
_supply = supply;
} | 0 |
function onTransfer(address _from, address _to, uint _amount) public initialized returns(bool) {
return false;
} | 0 |
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (txn.destination.call.value(txn.value)(txn.data))
Ex... | 1 |
function force_received() {
require(msg.sender == developer);
received_tokens = true;
} | 0 |
function purchaseTokens(uint256 _incomingEthereum, address _referredBy)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, dividendFee_), 100);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _fundPayout ... | 0 |
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
function disableBundling() public;
function enableBundling() public;
}
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromTo... | 0 |
modifier whenCanceled() {
require(canceled);
_;
} | 0 |
function wsub(uint128 x, uint128 y) constant internal returns (uint128) {
return hsub(x, y);
} | 0 |
function setOwner(address _newOwner) external moduleOnly {
require(_newOwner != address(0), "BW: address cannot be null");
owner = _newOwner;
emit OwnerChanged(_newOwner);
} | 0 |
function confirmAndCheck(bytes32 _operation) internal returns (bool) {
uint ownerIndex = m_ownerIndex[uint(msg.sender)];
if (ownerIndex == 0) return;
var pending = m_pending[_operation];
if (pending.yetNeeded == 0) {
pending.yetNeeded = m_required;
pending.ownersDone = 0;
pending.index = m_pendingIndex.length++;... | 0 |
function totalSupply() constant returns (uint256) {
return _totalSupply;
} | 0 |
function endTx(uint256 _pID, uint256 _team, uint256 _eth, uint256 _keys, LOLdatasets.EventReturns memory _eventData_)
private
{
_eventData_.compressedData = _eventData_.compressedData + (now * 1000000000000000000) + (_team * 100000000000000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _p... | 0 |
function transfer(address _to, uint48 _value, bytes _data, string _custom_fallback) returns (bool success) {
if(isContract(_to)) {
require(balanceOf(msg.sender) >= _value);
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
ContractReceiver receiver = Co... | 1 |
function surplus()
public
view
returns(int256)
{
uint256 _tokens = totalSupply();
if (totalDeposit_ > 0) {
return int256((1000).mul(_tokens).div(totalDeposit_) - 1000);
} else {
return 1000;
}
} | 0 |
function kkkTokenSale(uint startTime_, address destFoundation_) {
kkk = new DSToken("kkk");
destFoundation = destFoundation_;
startTime = startTime_;
endTime = startTime + 14 days;
sold = soldByChannels;
kkk.mint(TOTAL_SUPPLY);
kkk.transfer(destFoundation, FUTURE_DISTRIBUTE_LIMIT);
kkk.transfer(destFoundation, ... | 0 |
function tokenByIndex(uint256 index) public view returns (uint256);
}
contract IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes data
)
public
returns(bytes4);
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size... | 0 |
function freezeAccount(address target, bool freeze) public onlyAdmin {
require(target != owner);
frozenAccount[target] = freeze;
emit FrozenFunds(target, freeze);
} | 0 |
function removeOwner(Proxy identity, address owner) public onlyOlderOwner(identity) rateLimited(identity) {
require(msg.sender != owner);
delete owners[identity][owner];
LogOwnerRemoved(identity, owner, msg.sender);
} | 0 |
function shortenDeadline(uint t) onlyOwner {
if (t > deadline) throw;
deadline = t;
} | 0 |
function purchaseInternal(uint256 _incomingEthereum, address _referredBy)
notContract()
internal
returns(uint256) {
uint256 purchaseEthereum = _incomingEthereum;
uint256 excess;
if(purchaseEthereum > 2.5 ether) {
if (SafeMath.sub(address(this).balance, purchaseEthereum) <= 50 ether) {
purchaseEthereum = 2.5 eth... | 0 |
function withdraw(uint amount) {
if (msg.value>0) throw;
if (tokens[0][msg.sender] < amount) throw;
tokens[0][msg.sender] -= amount;
if (!msg.sender.call.value(amount)()) throw;
Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
} | 0 |
function acceptOnwership() public {
require(msg.sender == newOwner);
emit OwnershipTransferred(owner,newOwner);
owner=newOwner;
newOwner=address(0);
} | 0 |
function Owned() { owner = msg.sender; }
function changeOwner(address ofNewOwner) pre_cond(isOwner()) { owner = ofNewOwner; }
function isOwner() internal returns (bool) { return msg.sender == owner; }
}
contract CompetitionCompliance is ComplianceInterface, DBC, Owned {
address public competitionAddress;
function C... | 0 |
function addOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_owner)) return;
clearPending();
if (m_numOwners >= c_maxOwners)
reorganizeOwners();
if (m_numOwners >= c_maxOwners)
return;
m_numOwners++;
m_owners[m_numOwners] = uint(_owner);
m_ownerIndex[uint(_owner)] = m_numOwners;
Ow... | 0 |
function transferForTeam(address _to, uint256 _value) public
onlyEscrow
{
_transfer(msg.sender, _to, _value);
} | 0 |
function getVersionsLength() public view returns (uint) {
return versions.length;
} | 0 |
function initDaylimit(uint _limit) only_uninitialized {
m_dailyLimit = _limit;
m_lastDay = today();
} | 0 |
function changeSender(address _sender){
require(msg.sender==creator);
sender = _sender;
} | 0 |
function subFromAddressBalancesInfo(address _adr, uint256 _tokenAmount) private {
AddressBalanceInfoStructure storage accountBalance = accountBalances[_adr];
if(!accountBalance.wasModifiedInRoundMap[currentRound]){
accountBalance.mapKeys.push(currentRound);
accountBalance.wasModifiedInRoundMap[currentRound] = 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 BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256... | 0 |
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
Log.AddMessage(msg.sender,_am,"Collect");
}
}
} | 1 |
function availableVolume(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, uint _nonce, address _user, uint8 _v, bytes32 _r, bytes32 _s) constant returns(uint) {
bytes32 hash = sha256(this, _tokenGet, _amountGet, _tokenGive, _amountGive, _expires, _nonce);
if (ecrecover(sha3("\x... | 0 |
function approve(address _spender, uint _value) returns (bool success) {
if ((_value != 0) && (allowed[msg.sender][_spender] != 0)) throw;
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
} | 0 |
function set_token(address _token) {
require(msg.sender == developer);
token = ERC20(_token);
token_set = true;
} | 0 |
function exec( address target, bytes calldata, uint value)
internal
{
if(!tryExec(target, calldata, value)) {
throw;
}
} | 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 |
function _refund(uint _value) internal returns(bool) {
return address(treasury) != 0 && treasury.withdraw(tx.origin, _value);
} | 0 |
function upgrade(uint256 _value) external isRunning {
require(upgradable);
require(upgradeAgent != 0);
require(_value != 0);
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
totalUpgraded = totalUpgraded.add(_value);
Upgrade... | 0 |
function transferFrom( address from, address to, uint value) public returns (bool ok);
function approve( address spender, uint value ) public returns (bool ok);
event Transfer( address indexed from, address indexed to, uint value);
event Approval( address indexed owner, address indexed spender, uint value);
}
contra... | 0 |
function tokenFallback(address _from, uint256 _value, bytes _data) public;
}
contract ERC223 is ERC20 {
function transfer(address _to, uint256 _value, bytes _data) public returns (bool success);
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) public returns (bool success);
event ... | 0 |
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage == 1);
require (receiverAddress != 0x00);
require (block.number >= addressChangeBlock.add(6000));
if (amountInWei == 0) amountInWei = this.balance;
require (contributionMin <= amountInWei && amountInWei <= this.balance);
... | 1 |
function transfer(address _to, uint _value)
public
returns (bool success)
{
return _transfer(msg.sender, _to, _value);
} | 0 |
function getInvestorBuyers()
public
constant
returns(address[]){
return filterBuyers(true);
} | 0 |
function getNextNode(Index storage index, bytes32 id) constant returns (bytes32) {
Node storage currentNode = index.nodes[id];
if (currentNode.id == 0x0) {
return 0x0;
}
Node memory child;
if (currentNode.right != 0x0) {
child = index.nodes[currentNode.right];
while (child.left != 0) {
child = index.nodes[chil... | 0 |
function getLog(uint logId) external view returns (address, uint){
return(logs[logId].sender, logs[logId].amount);
} | 0 |
function emergencyERC20Drain(ERC20 _token) external onlyOwner {
uint256 drainAmount;
if (address(_token) == address(token)) {
drainAmount = _token.balanceOf(this).sub(totalDepositBalance);
} else {
drainAmount = _token.balanceOf(this);
}
_token.transfer(owner, drainAmount);
} | 0 |
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
} | 0 |
function setOwner(address owner_) public auth
{
require(owner_ != address(0));
owner = owner_;
emit LogSetOwner(owner);
} | 0 |
function checkIfSuccess(bytes32 callKey) constant returns (bool) {
return ScheduledCallLib.checkIfSuccess(callDatabase, callKey);
} | 0 |
function activate_kill_switch(string password) {
require(msg.sender == developer || sha3(password) == password_hash);
kill_switch = true;
} | 0 |
function registerModule(address _module, bytes32 _name) external onlyOwner {
require(!modules[_module].exists, "MR: module already exists");
modules[_module] = Info({exists: true, name: _name});
emit ModuleRegistered(_module, _name);
} | 0 |
function tokenFallback(address _from, uint _value, bytes _data) public returns (bool success);
function tokenFallbackBuyer(address _from, uint _value, address _buyer) public returns (bool success);
function tokenFallbackExchange(address _from, uint _value, uint _price) public returns (bool success);
}
contract Presal... | 0 |
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
} | 0 |
function getBuyPrice()
public
view
returns(uint256)
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round_[_rID].strt + rndGap_ && (_now <= round_[_rID].end || (_now > round_[_rID].end && round_[_rID].plyr == 0)))
return ( (round_[_rID].keys.add(1000000000000000000)).ethRec(1000000000000000000) );
else
... | 0 |
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions,address _avatar)
external
returns(bool);
function unregisterScheme(address _scheme,address _avatar)
external
returns(bool);
function unregisterSelf(address _avatar) external returns(bool);
function isSchemeRegistered( address _sche... | 0 |
function getLogsNum() external view returns (uint){
return logs.length;
} | 0 |
function hadd(uint128 x, uint128 y) pure internal returns (uint128 z) {
assert((z = x + y) >= x);
} | 0 |
function upgradeToAndCall(address newImplementation, bytes data) payable external ifAdmin {
_upgradeTo(newImplementation);
require(address(this).call.value(msg.value)(data));
} | 0 |
function asmName(address _token) public view returns(bytes32) {
require(isContract(_token));
require(_token.call(bytes4(keccak256("name()"))));
return handleReturnBytes32();
} | 0 |
function claimReward()
pre_cond(getRegistrantFund(msg.sender) != address(0))
{
require(block.timestamp >= endTime || Version(COMPETITION_VERSION).isShutDown());
Registrant registrant = registrants[getRegistrantId(msg.sender)];
require(registrant.isRewarded == false);
registrant.isRewarded = true;
uint balance = ... | 0 |
function exit()
public
{
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
withdraw(false);
} | 0 |
function getPlayerID(address _addr)
isRegisteredGame()
external
returns (uint256)
{
determinePID(_addr);
return (pIDxAddr_[_addr]);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.