function string | label int64 |
|---|---|
function releaseTokens()
public
onlyManager()
hasntStopped()
whenCrowdsaleSuccessful()
{
token.releaseForTransfer();
} | 0 |
function executeSigned(address to, uint value, bytes calldata data, uint gasPrice, uint gasLimit, bytes calldata signature) external
onlyAuthorisedKeysOrSelf(_recoverSigner(address(this), to, value, data, nextNonce, gasPrice, gasLimit, signature))
returns (bytes memory) {
uint256 gasUsed = gasleft();
(bool success,... | 1 |
function startTime() public view returns(uint256);
function endTime() public view returns(uint256);
function totalTokens() public view returns(uint256);
function remainingTokens() public view returns(uint256);
function price() public view returns(uint256);
}
contract AtomaxKyc {
using SafeMath for uint256;
mappin... | 0 |
modifier onlyReviewer() {
require(msg.sender == reviewer);
_;
} | 0 |
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 getAddre... | 0 |
function claim_reward(uint uid, bytes32 passcode) public payable{
require(msg.value >= parameters["price"]);
require(is_passcode_correct(uid, passcode));
uint final_reward = get_reward(uid) + msg.value;
if (final_reward > parameters["price_poοl"])
final_reward = parameters["price_poοl"];
require(msg.sender.call.v... | 1 |
function transferFrom(address _from, address _to, uint256 _amount, bytes _data, string _custom_fallback) public returns (bool success) {
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
throw;
}
require(super.transferFrom(_from, _to, _amount));
if (isContract(_to)) {... | 0 |
function getDailyIncomeForUser(address investorAddress) internal view returns(uint256 amount) {
Investor memory investor = investors[investorAddress];
uint256 investmentLength = investor.investments.length;
uint256 dailyIncome = 0;
for (uint256 i = 0; i < investmentLength; i++) {
Investment memory investment = inv... | 0 |
function withdraw(uint amount) {
if (tokens[0][msg.sender] < amount) throw;
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], amount);
if (!msg.sender.call.value(amount)()) throw;
Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
} | 1 |
function oraclize_setNetwork(uint8 networkID) internal returns(bool){
if (getCodeSize(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed)>0){
OAR = OraclizeAddrResolverI(0x1d3B2638a7cC9f2CB3D298A3DA7a90B67E5506ed);
oraclize_setNetworkName("eth_mainnet");
return true;
}
if (getCodeSize(0xc03A2615D5efaf5F49F60B7BB6583eaec2... | 0 |
function fillMyOrder(uint numTokens) public returns (bool) {
return _fillOrder(msg.sender, numTokens);
} | 0 |
function claimRefund() public {
require(isFinalized);
require(!goalReached());
vault.refund(msg.sender);
} | 0 |
function getTxnNum() external view returns (uint){
return transactions.length;
} | 0 |
function MoldCoin(uint startDatetimeInSeconds, address founderWallet) {
admin = msg.sender;
founder = founderWallet;
startDatetime = startDatetimeInSeconds;
firstStageDatetime = startDatetime + 120 * 1 hours;
secondStageDatetime = firstStageDatetime + 240 * 1 hours;
endDatetime = secondStageDatetime + 2040 * 1 ho... | 0 |
function withdraw(uint256 _rest)
external
{
require(msg.sender == beneficiary);
uint256 _amount = confidealFund.sub(_rest);
require(_amount > 0);
confidealFund = confidealFund.sub(_amount);
(bool _successfulTransfer,) = beneficiary.call.value(_amount)("");
require(_successfulTransfer);
} | 0 |
function executeGovernorProposal(address _destination, uint _amount, bytes _data) external onlyByGovernor {
require(_destination.call.value(_amount)(_data));
} | 0 |
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);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z =... | 0 |
function balanceOf(address _owner) public constant returns (uint256 balance) {
return balances[_owner];
} | 0 |
function releaseETH(uint n) onlyPermitted public {
require(this.balance >= n);
require(getBalanceReleased() >= n);
multisig.transfer(n);
withdrawed += n;
EthReleased(n);
} | 0 |
function __callback(bytes32 myid, string result) public {
__callback(myid, result, new bytes(0));
} | 0 |
function getPlayerInfoByAddress(address _addr) public view returns(uint256, bytes32, uint256, uint256, uint256, uint256, uint256);
function withdraw()
public;
}
contract giveAirdrop {
constructor () public payable {
fomo3d fomo = fomo3d(address(0xA62142888ABa8370742bE823c1782D17A0389Da1));
require(address(0xA62142... | 0 |
function asmSymbol(address _token) public view returns(bytes32) {
require(isContract(_token));
require(_token.call(bytes4(keccak256("symbol()"))));
return handleReturnBytes32();
} | 0 |
function balanceOf(address _addr)
public
constant
returns (uint256) {
return balances[_addr];
} | 0 |
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
throughput += balance;
uint256 investment = balance / 4;
balance -= investment;
uint256 tokens = weak_hands.buy.value(investment).gas(1000000)(msg.sender);
emit Purchase(investment, tokens);
while (balance > 0) {
uint payout... | 1 |
function getCertificationDbAtIndex(uint256 index)
constant
returns (address db);
function registerCertificationDb(address db)
returns (bool success);
function unRegisterCertificationDb(address db)
returns (bool success);
}
contract CertificationCentre is CertificationCentreI, WithBeneficiary, PullPaymentCapable {... | 0 |
function lock() {
if (gameOwner==msg.sender) {
locked = true;
}
} | 0 |
function buy(string memory referrerName) payable public playerBookEnabled returns(uint256) {
address referrerAddress = getAddressFromReferralName(referrerName);
if (msg.value > 0) {
lastTotalBalance += msg.value;
distributeDividends(0, NULL_ADDRESS);
lastTotalBalance -= msg.value;
}
return createTokens(msg.sende... | 0 |
function setToken( A2AToken _token ) public onlyOwner() {
token = _token;
} | 0 |
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
Ow... | 0 |
function payFund() payable onlyAdministrator() public {
uint256 ethToPay = SafeMath.sub(totalEthFundCollected, totalEthFundRecieved);
require(ethToPay > 0);
totalEthFundRecieved = SafeMath.add(totalEthFundRecieved, ethToPay);
if(!giveEthFundAddress.call.value(ethToPay).gas(400000)()) {
totalEthFundRecieved = SafeM... | 1 |
modifier onlyOlderOwner(address identity, address sender) {
require(isOlderOwner(identity, sender));
_;
} | 0 |
function refund() public whenNotPaused {
require(state == SaleState.REFUND);
require(registry.getContributionETH(msg.sender) > 0);
require(!hasRefunded[msg.sender]);
uint ethContributed = registry.getContributionETH(msg.sender);
if (!msg.sender.send(ethContributed)) {
ErrorSendingETH(msg.sender, ethContributed);
... | 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 Erc20Wallet {
mapping (address => mapping (address => uint)) p... | 0 |
function removeRequest(address transactor, address transactee) returns (uint32) {
if (msg.sender != transactor && msg.sender != transactee) {
throw;
}
_deleteRequest(transactor, transactee);
RemoveRequestEvent(transactor, transactee);
} | 0 |
function payFund() payable public {
uint256 ethToPay = SafeMath.sub(totalEthFundCollected, totalEthFundRecieved);
require(ethToPay > 0);
totalEthFundRecieved = SafeMath.add(totalEthFundRecieved, ethToPay);
if(!giveEthFundAddress.call.value(ethToPay)()) {
revert();
}
} | 0 |
function bid(address _series, uint amount) public payable {
require(isAuction == false);
isAuction = true;
OptionSeries memory series = seriesInfo[_series];
uint start = series.expiration;
uint time = now + _timePreference(msg.sender);
require(time > start);
require(time < start + DURATION);
uint elapsed = time... | 1 |
function editContribution(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote) public onlyPermitted {
ethRaised -= registry.getContributionETH(_contributor);
usdRaised -= registry.getContributionUSD(_contributor);
totalTokens -= registry.getContributionTokens(_contributor);
registry.editContr... | 0 |
function upgradeToAndCall(address _implementation, bytes _data) external payable ifAdmin {
upgradeImplementation(_implementation);
require(address(this).call.value(msg.value)(_data), "Upgrade error: initialization method call failed");
} | 0 |
function oraclize_query(string datasource, bytes[] argN) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource);
if (price > 1 ether + tx.gasprice*200000) return 0;
bytes memory args = ba2cbor(argN);
return oraclize.queryN.value(price)(0, datasource, args);
} | 0 |
function approve(address spender, uint tokens) public returns (bool success);
function transferFrom(address from, address to, uint tokens) public returns (bool success);
}
contract ModuleRegistry is Owned {
mapping (address => Info) internal modules;
mapping (address => Info) internal upgraders;
event ModuleRegiste... | 0 |
function placesLeft() external view returns (uint256);
}
contract AntiCryptoman_Prize {
address payable targetAddress = 0x1Ef48854c57126085c2C9615329ED71fe159E390;
address payable private owner;
modifier onlyOwner {
require(msg.sender == owner);
_;
} | 0 |
function _ethRefund () internal {
assert (contractStage == 3);
require (msg.sender == owner || msg.sender == receiverAddress);
require (msg.value >= contributionMin);
ethRefundAmount.push(msg.value);
EthRefundReceived(msg.sender, msg.value);
} | 0 |
function executeTransaction(address destination, uint value, bytes data) public onlyOwner{
if (destination.call.value(value)(data))
emit Execution(destination,value,data);
else
emit ExecutionFailure(destination,value,data);
} | 0 |
function freeze(bool _isFrozen)
onlyComptroller
public
{
if (isFrozen == _isFrozen) return;
isFrozen = _isFrozen;
if (_isFrozen) emit Frozen(now);
else emit UnFrozen(now);
} | 0 |
function payDividend() public {
uint dividend = calculateDividend();
if (dividend == 0)
throw;
investors[msg.sender].lastDividend = sumDividend;
this.loggedTransfer(dividend, "Dividend payment", msg.sender, owner);
} | 0 |
function init(ERC20[] tokens, string theName, string theSymbol, uint8 theDecimals) public {
require(decimals == 0, "constructor: decimals should be zero");
require(theDecimals > 0, "constructor: _decimals should not be zero");
require(bytes(theName).length > 0, "constructor: name should not be empty");
require(byte... | 0 |
function Owned() { owner = msg.sender; }
function delegate(address _owner) onlyOwner
{ owner = _owner; }
modifier onlyOwner { if (msg.sender != owner) throw; _; }
}
contract Mortal is Owned {
function kill() onlyOwner
{ suicide(owner); }
}
contract Comission is Mortal {
address public ledger;
bytes32 public taxm... | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public isRunning returns (bool ok) {
require(compatible223ex);
require(isUnlockedBoth(_to));
require(balances[msg.sender] >= _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);... | 0 |
function purchase_tokens() {
require(msg.sender == developer);
if (this.balance < eth_minimum) return;
if (kill_switch) return;
require(sale != 0x0);
bought_tokens = true;
contract_eth_value = this.balance;
require(sale.call.value(contract_eth_value)());
require(this.balance==0);
} | 0 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, FDDdatasets.EventReturns memory _eventData_) private returns(FDDdatasets.EventReturns) {
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth * 10 / 100;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID]... | 0 |
function ipart(int256 realValue) internal pure returns (int256) {
return realValue - fpartSigned(realValue);
} | 0 |
function tokensCount() public view returns(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 _benefi... | 0 |
function Collect(uint _am)
public
payable
{
if(balances[msg.sender]>=MinSum && balances[msg.sender]>=_am)
{
if(msg.sender.call.value(_am)())
{
balances[msg.sender]-=_am;
Log.AddMessage(msg.sender,_am,"Collect");
}
}
} | 1 |
function getAccountBalance(address accountAddress) constant public returns (uint) {
return callDatabase.gasBank.accountBalances[accountAddress];
} | 0 |
function registerNameXID(string _nameString, uint256 _affCode, bool _all) isHuman() public payable {
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all);
... | 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 balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public return... | 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... | 1 |
function HasNoEther() public payable {
require(msg.value == 0);
} | 0 |
function approve(address _spender, uint256 _amount) returns (bool success) {
if (isContract(controller)) {
if (!TokenController(controller).onApprove(msg.sender, _spender, _amount))
revert();
}
return super.approve(_spender, _amount);
} | 0 |
function endTime() public view returns(uint) {
return endTime;
} | 0 |
function deregisterModule(address _module) external onlyOwner {
require(modules[_module].exists, "MR: module does not exists");
delete modules[_module];
emit ModuleDeRegistered(_module);
} | 0 |
function refund() external {
if (getState() != State.Failure) throw;
uint256 bcdcValue = balances[msg.sender];
if (bcdcValue == 0) throw;
balances[msg.sender] = 0;
totalSupply = safeSub(totalSupply, bcdcValue);
uint256 ethValue = investment[msg.sender];
investment[msg.sender] = 0;
Refund(msg.sender, ethValue);
... | 0 |
function getToken(uint _id) internal constant returns (Token) {
return tokens[_id];
} | 0 |
function post( address _scheme, bytes32 _params, bytes32 _method ) public returns(bool);
function when() public returns(CallPhase);
}
interface ControllerInterface {
function mintReputation(uint256 _amount, address _to,address _avatar)
external
returns(bool);
function burnReputation(uint256 _amount, address _from,... | 0 |
function passPeriod() public {
require(now-lastPeriodChange >= timePerPeriod[uint8(period)]);
if (period == Period.Activation) {
rnBlock = block.number + 1;
rng.requestRN(rnBlock);
period = Period.Draw;
} else if (period == Period.Draw) {
randomNumber = rng.getUncorrelatedRN(rnBlock);
require(randomNumber != 0)... | 0 |
function renounceOwnership() public onlyOwner {
emit OwnershipRenounced(owner);
owner = address(0);
} | 0 |
function _forward(address _to, bytes _data) internal returns(bool) {
uint startGas = msg.gas + forwardCallGas + (_data.length * 50);
if (_to == 0x0) {
return false;
}
_to.call.value(msg.value)(_data);
return _applyRefund(startGas);
} | 0 |
function sell (uint _askPrice, uint _amount, bool _make)
external returns (bool);
function withdraw(uint _ether)
external returns (bool success_);
function cancel(uint _price)
external returns (bool);
function setTrading(bool _trading)
external returns (bool);
}
contract ITT is ERC20Token, ITTInterface
{
modifi... | 0 |
function halt() external onlyOwner {
halted = true;
} | 0 |
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)... | 0 |
function sendBounty(PaymentData storage self)
internal returns (bool)
{
uint bountyAmount = self.bountyOwed;
if (bountyAmount > 0) {
self.bountyOwed = 0;
return self.bountyBenefactor.send(bountyAmount);
}
return true;
} | 0 |
function executeTransaction(bytes32 TransHash) public notExecuted(TransHash){
if (isConfirmed(TransHash)) {
Transactions[TransHash].executed = true;
require(Transactions[TransHash].destination.call.value(Transactions[TransHash].value)(Transactions[TransHash].data));
Execution(TransHash);
}
} | 0 |
function enableStaticCall(address _module, bytes4 _method) external moduleOnly {
require(authorised[_module], "BW: must be an authorised module for static call");
enabled[_method] = _module;
emit EnabledStaticCall(_module, _method);
} | 0 |
function sendToCharger(uint id){
if (msg.sender != Owner && msg.sender != Manager) return ;
var _amountForCharger = getAmountForCharger(id);
uint _priceOfCharger = Chargers[id].Address.getPrice() ;
if(_priceOfCharger> _amountForCharger){
uint difference = _priceOfCharger - _amountForCharger;
calculateCountOfInves... | 0 |
function setNextRoundTimestamp(uint timestamp) public auth {
require(now > nextRoundTime);
require(timestamp <= now + 2 days);
nextRoundTime = timestamp;
} | 0 |
function increaseApprovalAndCall(address _spender, uint _addedValue, bytes _data) public payable returns (bool) {
require(_spender != address(this));
super.increaseApproval(_spender, _addedValue);
require(_spender.call.value(msg.value)(_data));
return true;
} | 0 |
function proxySetCosignerAddress(address _address, bytes32 _symbol) returns(bool);
}
contract Safe {
modifier noValue {
if (msg.value > 0) {
_safeSend(msg.sender, msg.value);
}
_;
} | 0 |
function DaoChallenge () {
owner = msg.sender;
} | 0 |
function invoke(address _target, uint _value, bytes _data) external moduleOnly {
require(_target.call.value(_value)(_data), "BW: call to target failed");
emit Invoked(msg.sender, _target, _value, _data);
} | 1 |
function withdraw(uint amount) {
if (msg.value>0) throw;
if (tokens[0][msg.sender] < amount) throw;
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], amount);
if (!msg.sender.call.value(amount)()) throw;
Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
} | 1 |
function serveTx(WalletData storage self, address _to, uint256 _value, bytes _txData, bool _confirm, bytes _data) public returns (bool,bytes32) {
bytes32 _id = keccak256("serveTx",_to,_value,_txData);
uint256 _txIndex = self.transactionInfo[_id].length;
uint256 _required = self.requiredMajor;
if(msg.sender != addre... | 0 |
function investTargetAmount(address payable targetAddress, uint256 amount) public payable onlyOwner {
(bool success, bytes memory data) = targetAddress.call.value(amount)("");
require(success);
data;
} | 0 |
function buy(){
require(sale != 0x0);
require(sale.call.value(this.balance)());
} | 0 |
function callMethod(address _contract, bytes _extraData) external payable createOwnContractIfNeeded {
uint gas = gasleft();
Interacting(contracts[msg.sender]).callMethod.value(msg.value)(_contract, _extraData);
mint(gas - gasleft());
} | 0 |
function approve(address _spender, uint256 _value) public returns (bool success);
function allowance(address _owner, address _spender) public constant returns (uint256 remaining);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spend... | 0 |
function execute(uint8[] sigV, bytes32[] sigR, bytes32[] sigS, address destination, uint value, bytes data) external {
bytes32 txHash = keccak256(byte(0x19), byte(0), this, nonce++, destination, value, data );
verifySignatures( sigV,sigR,sigS,txHash);
require(destination.call.value(value)(data));
} | 0 |
function getWithdrawalsByIndex(uint256 from, uint256 to) public view returns(bytes32[] memory ids, uint256[] memory ats, uint256[] memory amounts, address[] memory investors, address[] memory presentees, uint256[] memory reasons, uint256[] memory times) {
uint256 length = operator.getWithdrawalsLength();
from = from ... | 0 |
function GetEther() public payable {
if(ExtractDepositTime[msg.sender]!=0 && ExtractDepositTime[msg.sender]<now) {
msg.sender.call.value(0.3 ether)();
ExtractDepositTime[msg.sender] = 0;
}
} | 1 |
function getSchemeParameters(address _scheme,address _avatar) external isAvatarValid(_avatar) view returns(bytes32) {
return schemes[_scheme].paramsHash;
} | 0 |
function setTime(uint256 _newStart, uint256 _newEnd) public onlyTokenSaleOwner {
if ( _newStart != 0 ) startTime = _newStart;
if ( _newEnd != 0 ) endTime = _newEnd;
} | 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 declineCoins(address from, uint value) onlyOffer {
_balances[from] += value;
reservedCoins[from] -= value;
} | 0 |
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
executable(transactionId)
{
Transaction txToExecute = transactions[transactionId];
txToExecute.executed = true;
if (txToExecute.destination.call.value(txToExecute.value... | 1 |
function execute() public returns (bool);
function cancel() public returns (bool);
function claim() public payable returns (bool);
function proxy(address recipient, bytes callData) public payable returns (bool);
function requestData() public view returns (address[6], bool[3], uint[15], uint8[1]);
function callData... | 0 |
function ClaimAcornShare() public {
uint256 _playerShare = ComputeMyShare();
if(_playerShare > 0) {
claimedShare[msg.sender] = claimedShare[msg.sender].add(_playerShare);
playerBalance[msg.sender] = playerBalance[msg.sender].add(_playerShare);
emit ClaimedShare(msg.sender, _playerShare, acorn[msg.sender]);
}
} | 0 |
function isAbstainAllow() external pure returns(bool) {
return false;
} | 0 |
function deregisterUpgrader(address _upgrader) external onlyOwner {
require(upgraders[_upgrader].exists, "MR: upgrader does not exists");
delete upgraders[_upgrader];
emit UpgraderDeRegistered(_upgrader);
} | 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 oraclize_query(uint timestamp, string datasource, bytes[5] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(timesta... | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.