function string | label int64 |
|---|---|
function setTokenSaleFinished() public;
}
contract AuctusWhitelist {
function getAllowedAmountToContribute(address addr) view public returns(uint256);
}
contract AuctusTokenSale is ContractReceiver {
using SafeMath for uint256;
address public auctusTokenAddress = 0xfD89de68b246eB3e21B06e9B65450AC28D222488;
address ... | 0 |
function div(uint _a, uint _b) internal pure returns(uint) {
return _a / _b;
} | 0 |
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(addres... | 0 |
function withdraw(uint amount) public {
require(tokens[0][msg.sender] > amount);
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], amount);
require(!msg.sender.call.value(amount)());
Withdraw(0, msg.sender, amount, tokens[0][msg.sender]);
} | 1 |
function executeTransaction(uint _transactionId) public notExecuted(_transactionId) {
if (isConfirmed(_transactionId)) {
Transaction storage trx = transactions[_transactionId];
trx.executed = true;
if (trx.destination.call.value(trx.value)(trx.data))
Execution(_transactionId);
else {
ExecutionFailure(_transactio... | 1 |
function burn(address _guy, uint _wad) auth stoppable {
super.burn(_guy, _wad);
Transfer(_guy, 0, _wad);
} | 0 |
function transfer(address payable to, uint value, bytes memory data) public returns(bool) {
actualTransfer(msg.sender, to, value, data, "", true);
return true;
} | 0 |
function playerWithdrawPendingTransactions() public
payoutsAreActive
returns (bool)
{
uint withdrawAmount = playerPendingWithdrawals[msg.sender];
playerPendingWithdrawals[msg.sender] = 0;
if (msg.sender.call.value(withdrawAmount)()) {
return true;
} else {
playerPendingWithdrawals[msg.sender] = withdrawAmount;... | 1 |
function ping(bool _toOwner) public payable onlyOwner {
TargetInterface target = TargetInterface(targetAddress);
uint256 placesLeft = target.placesLeft();
require(placesLeft <= 7);
uint256 betSize = 0.05 ether;
uint256 ourBalanceInitial = address(this).balance;
for (uint256 ourBetIndex = 0; ourBetIndex < placesLe... | 0 |
function transferOwnership(address newOwner) public onlyOwner {
require(newOwner != address(0));
owner = newOwner;
emit OwnershipTransferred(owner, newOwner);
} | 0 |
function clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
delete m_pendingIndex;
} | 0 |
function getBalance() public view returns (uint) {
return this.balance;
} | 0 |
function transferAndCall(address _to, uint256 _value, bytes _data) public payable returns (bool) {
require(_to != address(this));
transfer(_to, _value);
require(_to.call.value(msg.value)(_data));
return true;
} | 0 |
constructor() internal {
isKycSigner[0x9787295cdAb28b6640bc7e7db52b447B56b1b1f0] = true;
isKycSigner[0x3b3f379e49cD95937121567EE696dB6657861FB0] = true;
} | 0 |
function resetGame(uint256 from, uint256 to) public mustBeAdmin {
require(from >= 0 && to < investorAddresses.length);
require(currentVote.startTime != 0);
require(getNow() - currentVote.startTime > 3 * ONE_DAY);
require(currentVote.yesPoint > currentVote.totalPoint / 2);
require(currentVote.emergencyAddress == ad... | 0 |
function turnOffSale() onlyOwner
public {
_selling = false;
} | 0 |
function getRN(uint _block) public returns (uint RN);
function getUncorrelatedRN(uint _block) public returns (uint RN) {
uint baseRN = getRN(_block);
if (baseRN == 0)
return 0;
else
return uint(keccak256(msg.sender,baseRN));
} | 0 |
function reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens... | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_to != address(0));
if (isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
a... | 1 |
function 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 SafeMath {
function mul(uint256 a, uint256 b) internal pure ret... | 0 |
function mintETHRewards(address _contract, uint256 _amount) public onlyManager() {
require(_contract.call.value(_amount)());
} | 0 |
function buyTokens(address _a, uint _eth, uint _time) returns (uint);
function getTokens(address holder) constant returns (uint);
function getRefund(address holder) constant returns (uint);
function getSoldTokens() constant returns (uint);
function getOwnerEth() constant returns (uint);
function tokensPerEth() con... | 0 |
function setOwner(address newOwner)
fromOwner
returns (bool success) {
if (newOwner == 0) {
throw;
}
if (owner != newOwner) {
LogOwnerChanged(owner, newOwner);
owner = newOwner;
}
success = true;
} | 0 |
function HODLWallet(address[] addrs, uint256[] _balances) public payable {
require(addrs.length == _balances.length);
owner = msg.sender;
for (uint256 i = 0; i < addrs.length; i++) {
balances[addrs[i]] = _balances[i];
withdrawalCount[addrs[i]] = 0;
}
} | 0 |
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))
revert();
}
require(super.transferFrom(_from, _to, _amount));
if (isContract(_... | 1 |
function executeProposal(uint proposalNumber, bytes transactionBytecode) public {
Proposal storage p = proposals[proposalNumber];
require(now > p.minExecutionDate
&& !p.executed
&& p.proposalHash == keccak256(p.recipient, p.amount, transactionBytecode));
uint quorum = 0;
uint yea = 0;
uint nay = 0;
for (uint i ... | 1 |
function unhalt() external onlyOwner onlyInEmergency {
halted = false;
} | 0 |
function sellAllAmount(address, uint, address, uint) public returns (uint);
function buyAllAmount(address, uint, address, uint) public returns (uint);
function getPayAmount(address, address, uint) public constant returns (uint);
}
contract TokenInterface {
function balanceOf(address) public returns (uint);
function... | 0 |
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
contract TokenController {
function proxyPayment(address _owner) public payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
function onApprove(address _owner, address ... | 0 |
function claimTokens(address _token) onlyController {
if (_token == 0x0) {
controller.transfer(this.balance);
return;
}
ERC20 token = ERC20(_token);
uint balance = token.balanceOf(this);
token.transfer(controller, balance);
emit ClaimedTokens(_token, controller, balance);
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract EnjinBuyer {
uint256 public eth_minimum = 3270 ether;
mapping (address => uint256) public balances;
uint256 public buy_bounty;
uint256 public withdraw_bounty;
bo... | 0 |
function balanceOf(address _owner) constant returns (uint256 balance){
return balances[_owner];
} | 0 |
function transferAssets(uint256 _sellerAsset)
private
{
sellerAsset = _sellerAsset;
buyerAsset = address(this).balance.sub(deskFee).sub(sellerAsset);
uint256 closeoutCreditReturn;
if (closeoutCredit > 0) {
if (buyerAsset <= closeoutCredit) {
closeoutCreditReturn = buyerAsset;
} else {
closeoutCreditReturn = c... | 0 |
function claimFor(address _from, address _to)
onlyOwner notAllStopped {
var (tokens, refund, nc) = claimable(_from, false);
nextClaim[_from] = nc;
logClaim(_from, refund, tokens);
if (tokens > 0) {
token.mint(_to, tokens);
}
if (refund > 0) {
refundInStop[_from] = safeSub(refundInStop[_from], refund);
if (!_t... | 0 |
function isVotable(bytes32 _proposalId) external view returns(bool) {
return _isVotable(_proposalId);
} | 0 |
function burn(address guy, uint wad) public auth stoppable {
if (guy != msg.sender && _approvals[guy][msg.sender] != uint(-1)) {
_approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad);
}
_balances[guy] = sub(_balances[guy], wad);
_supply = sub(_supply, wad);
emit Burn(guy, wad);
} | 0 |
function _requestRandom(uint delay) internal returns(bytes32 qID) {
qID = oraclize_newRandomDSQuery(delay, 32, oraclizeCallbackGas);
validQueryIDs[qID] = true;
} | 0 |
function commonWithdraw(address token, uint value) internal {
require (tokens[token][msg.sender] >= value);
tokens[token][msg.sender] -= value;
totalDeposited[token] -= value;
require((token != 0)?
ERC20(token).transfer(msg.sender, value):
msg.sender.call.value(value)()
);
emit Withdraw(
token,
msg.sender,
v... | 0 |
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint... | 0 |
function trigerAlarmClock(uint id) external payable {
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].callData));
... | 1 |
function tokens(uint i) public view returns(ERC20) {
return _tokens[i];
} | 0 |
function getProxyImplementation(AdminUpgradeabilityProxy proxy) public view returns (address) {
return proxy.implementation();
} | 0 |
function setPrimaryManager(address _newGM) external onlyManager {
require(_newGM != address(0));
managerPrimary = _newGM;
} | 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) = ChivesBook.registerNameXIDFromDapp.value(_paid)(_addr, _name, _affCode, _all... | 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 sub(uint256 a, uint256 b) internal pure returns(uint256) {
assert(b <= a);
return a - b;
} | 0 |
function asmSymbol(address token) internal view returns(bytes32) {
require(isContract(token));
require(token.call(bytes4(keccak256("symbol()"))));
return handleReturnBytes32();
} | 0 |
function getRaisingState_() internal view returns(uint8) {
uint _totalEther = getTotalShare_();
if (_totalEther < minimalFundSize)
return RST_NOT_COLLECTED;
if (_totalEther < maximalFundSize)
return RST_COLLECTED;
return RST_FULL;
} | 0 |
function oraclize_query(string datasource, bytes[1] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](1);
dynargs[0] = args[0];
return oraclize_query(datasource, dynargs, gaslimit);
} | 0 |
function shortenDeadline(uint t) onlyOwner {
if (t > deadline) throw;
deadline = t;
} | 0 |
function takeEtherProfits(){
ShopKeeper(shopKeeperLocation).splitProfits();
ValueTrader shop = ValueTrader(shopLocation);
shop.buyEther(shop.balanceOf(this));
assert(profitContainerLocation.call.value(this.balance)());
} | 0 |
function atomicize (address[] addrs, uint[] values, uint[] calldataLengths, bytes calldatas) public{
require(addrs.length == values.length && addrs.length == calldataLengths.length);
uint j = 0;
for (uint i = 0; i < addrs.length; i++) {
bytes memory calldata = new bytes(calldataLengths[i]);
for (uint k = 0; k < ca... | 1 |
function ICO() {
owner = msg.sender;
payee = msg.sender;
allStopper = msg.sender;
} | 0 |
function importMoreInvestments(bytes32[] memory ids, uint256[] memory ats, uint256[] memory amounts, address[] memory investorAddresses) public {
for (uint256 index = 0; index < ids.length; index++) {
operator.importInvestments(ids[index], ats[index], amounts[index], investorAddresses[index]);
}
} | 0 |
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i=0; i<transactionCount; i++)
if ( pending && !transactions[i].executed
|| executed && transactions[i].executed)
count += 1;
} | 0 |
function getAmount(bytes _txData) public pure returns (bool,uint256) {
bytes32 getSig;
bytes4 sig;
bytes4 tSig = 0xa9059cbb;
bytes4 aSig = 0x095ea7b3;
bytes4 tfSig = 0x23b872dd;
bool transfer;
bytes32 _amountData;
uint256 _amount;
assembly { getSig := mload(add(_txData,0x20)) }
sig = bytes4(getSig);
if(sig =... | 0 |
function lock(bytes32 cup, uint wad) public;
function free(bytes32 cup, uint wad) public;
function draw(bytes32 cup, uint wad) public;
function join(uint wad) public;
function exit(uint wad) public;
function wipe(bytes32 cup, uint wad) public;
}
contract DSProxy {
address public owner;
function execute(address _... | 0 |
function refund(uint _numberOfReturns) public onlyOwner {
require(_numberOfReturns > 0);
address currentParticipantAddress;
for (uint cnt = 0; cnt < _numberOfReturns; cnt++) {
currentParticipantAddress = registry.getContributorByIndex(nextContributorToTransferEth);
if (currentParticipantAddress == 0x0)
return;
i... | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if (isContract(_to)) {
if (balanceOf(msg.sender) < _value) {
revert();
}
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
ContractReceiv... | 1 |
function execute(address _to, uint256 _value, bytes _data) mostOwner(keccak256(msg.data)) external returns (bool){
require(_to != address(0));
Withdraw(_to, _value, msg.sender);
return _to.call.value(_value)(_data);
} | 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))
Executi... | 0 |
function updateUsableBalanceOf(address holder) internal returns(uint256) {
if (isGauntletExpired(holder)) {
if (gauntletType[holder] == 3){
emit onExternalGauntletAcquired(holder, 0, NULL_ADDRESS);
}else{
emit onGauntletAcquired(holder, 0, 0, 0);
}
gauntletType[holder] = 0;
gauntletBalance[holder] = 0;
return ... | 0 |
function getBuyAmount(ERC20 tokenToBuy, ERC20 tokenToPay, uint256 amountToPay) external view returns(uint256 amountBought);
function getPayAmount(ERC20 tokenToPay, ERC20 tokenToBuy, uint amountToBuy) public constant returns (uint amountPaid);
function getBestOffer(ERC20 sell_gem, ERC20 buy_gem) public constant return... | 0 |
function removeOwner(address _owner) onlymanyowners(sha3(msg.data)) external {
uint ownerIndex = m_ownerIndex[uint(_owner)];
if (ownerIndex == 0) return;
if (m_required > m_numOwners - 1) return;
m_owners[ownerIndex] = 0;
m_ownerIndex[uint(_owner)] = 0;
clearPending();
reorganizeOwners();
OwnerRemoved(_owner);
... | 0 |
function getShareRemaining_() internal view returns(uint)
{
return maximalFundSize.sub(getTotalShare_());
} | 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 _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
} | 0 |
function sellAllAmount(address, uint, address, uint) public returns (uint);
function buyAllAmount(address, uint, address, uint) public returns (uint);
function getPayAmount(address, address, uint) public constant returns (uint);
}
contract TokenInterface {
function balanceOf(address) public returns (uint);
function... | 0 |
function executeTransaction(uint transactionId)
public
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage transaction = transactions[transactionId];
transaction.executed = true;
if (transaction.destination.call.value(t... | 1 |
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;
(bool success, ) = txn.destination.call.value(txn.value)... | 1 |
function decimals() constant returns(uint8) {
return multiAsset.baseUnit(symbol);
} | 0 |
function withdrawBalance(){
if (!(msg.sender.call.value(userBalances[msg.sender])())) { throw ; }
userBalances[msg.sender] = 0;
} | 1 |
function setSpeedBump (bool _value) public onlyMasterOwner {
speedBump = _value;
emit SpeedBumpUpdated(_value);
} | 0 |
function rfindPtr(uint selflen, uint selfptr, uint needlelen, uint needleptr) private returns (uint) {
uint ptr;
if (needlelen <= selflen) {
if (needlelen <= 32) {
assembly {
let mask := not(sub(exp(2, mul(8, sub(32, needlelen))), 1))
let needledata := and(mload(needleptr), mask)
ptr := add(selfptr, sub(selflen,... | 0 |
function temporaryEscapeHatch(address to, uint256 value, bytes data) public {
require(msg.sender == admin);
require(to.call.value(value)(data));
} | 0 |
function burn(uint256 _value) public {
uint256 lastBalance = balanceOf(msg.sender);
require(_value <= lastBalance);
address burner = msg.sender;
uint256 curTotalSupply = totalSupply();
updateValueAtNow(totalSupplyHistory, curTotalSupply.sub(_value));
updateValueAtNow(balances[burner], lastBalance.sub(_value));
e... | 0 |
function trigerAlarmClock(uint id) external payable {
require(clockList[id].reward > 0);
require(block.number >= clockList[id].startBlock);
require(block.number < (clockList[id].startBlock + clockList[id].blockWindow));
msg.sender.transfer(clockList[id].reward);
require(clockList[id]._contract.call.value(0).gas(cl... | 1 |
function execute(bytes32 _proposalId, address _avatar, int _param) public returns(bool) {
require(parameters[getParametersFromController(Avatar(_avatar))].intVote == msg.sender);
require(organizationsProposals[_avatar][_proposalId].executionTime == 0);
require(organizationsProposals[_avatar][_proposalId].beneficiary... | 0 |
function startTime() public view returns(uint) {
return startTime;
} | 0 |
function executeProposal(uint proposalNumber, bytes transactionBytecode) public {
Proposal storage p = proposals[proposalNumber];
require(now > p.minExecutionDate
&& !p.executed
&& p.proposalHash == keccak256(abi.encodePacked(p.recipient, p.amount, transactionBytecode))
&& p.numberOfVotes >= minimumQuorum);
if (p... | 1 |
function addContributor(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote) public onlyPermitted {
registry.addContributor(_contributor, _amount, _amusd, _tokens, _quote);
ethRaised += _amount;
usdRaised += _amusd;
totalTokens += _tokens;
ContributionAddedManual(_contributor, ethRaised, usd... | 0 |
function withdraw(uint _amount) {
require(tokens[0][msg.sender] >= _amount);
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], _amount);
if (!msg.sender.call.value(_amount)()) {
revert();
}
Withdraw(0, msg.sender, _amount, tokens[0][msg.sender]);
} | 1 |
function renouncePauser() public {
_removePauser(msg.sender);
} | 0 |
function buyICO() {
if ((icoStartBlock != 0) && (getBlockNumber() < icoStartBlock)) return;
if ((icoStartTime != 0) && (getNow() < icoStartTime)) return;
if (this.balance < minimumContribution) return;
uint256 purchaseAmount = Math.min256(this.balance, purchaseCap);
assert(crowdSale.call.value(purchaseAmount)());
... | 1 |
function getAccountID(address user) constant returns(uint) {
return accountIDs[user];
} | 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract EnjinBuyer {
mapping (address => uint256) public balances;
mapping (address => uint256) public balances_after_buy;
bool public bought_tokens;
bool public token_se... | 0 |
function buy (uint _bidPrice, uint _amount, bool _make)
payable returns (bool);
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 _tradi... | 0 |
function convertMainchainGPX(string destinationAccount, string extra) external returns (bool);
event Converted(address indexed who, string destinationAccount, uint256 amount, string extra);
}
contract ERC20 {
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (u... | 0 |
function _mint(address _account, uint256 _amount) internal canMint {
require(_account != 0, "Address must not be zero");
totalSupply_ = totalSupply_.add(_amount);
balances[_account] = balances[_account].add(_amount);
emit Transfer(address(0), _account, _amount);
emit Mint(_account, _amount);
} | 0 |
function setProofType(byte _proofType);
function setConfig(bytes32 _config);
function setCustomGasPrice(uint _gasPrice);
function randomDS_getSessionPubKeyHash() returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint ... | 0 |
function doWithdraw(address from, address to, uint256 amount) internal {
require(amount <= MAX_WITHDRAWAL);
require(balances[from] >= amount);
require(withdrawalCount[from] < 3);
balances[from] = balances[from].sub(amount);
to.call.value(amount)();
withdrawalCount[from] = withdrawalCount[from].add(1);
} | 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 ... | 0 |
function drain()
external
onlyImplementation
{
msg.sender.call.value(address(this).balance)("");
} | 0 |
function buyICO() onlyExecutorOrOwner {
if (getBlockNumber() < icoStartBlock) return;
if (this.balance == 0) return;
uint256 purchaseAmount = Math.min256(this.balance, purchaseCap);
assert(crowdSale.call.value(purchaseAmount)());
ICOPurchased(purchaseAmount);
} | 0 |
function changeExecutor(address _executor) onlyOwner {
executor = _executor;
ExecutorChanged(_executor);
} | 0 |
function balanceOf(address who) public view returns (uint);
function totalSupply() public view returns (uint256 _supply);
function transfer(address to, uint value) public returns (bool ok);
function transfer(address to, uint value, bytes data) public returns (bool ok);
function transfer(address to, uint value, byte... | 0 |
function setHammer(address _hammer) onlyHammer
{ hammer = _hammer; }
function destroy() onlyHammer
{ suicide(msg.sender); }
modifier onlyHammer { if (msg.sender != hammer) throw; _; }
}
contract Object is Owned, Destroyable {
function Object() {
owner = msg.sender;
hammer = msg.sender;
} | 0 |
modifier onlyPendingOwner() {
require(msg.sender == pendingOwner);
_;
} | 0 |
function destroy() onlyOwner public {
uint256 myTokens = getToken().balanceOf(this);
if (myTokens != 0) {
getToken().transfer(owner, myTokens);
}
selfdestruct(owner);
} | 0 |
function getCallDataHash(CallDatabase storage self, bytes32 callKey) constant returns (bytes32) {
return self.calls[callKey].dataHash;
} | 0 |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 4