function string | label int64 |
|---|---|
function submitPool(uint256 weiAmount) public onlyAdmin noReentrancy {
require(contractStage < CONTRACT_SUBMIT_FUNDS, "Cannot resubmit pool.");
require(receiverAddress != 0x00, "receiver address cannot be empty");
uint256 contractBalance = address(this).balance;
if(weiAmount == 0){
weiAmount = contractBalance;
}
... | 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 executeTransaction(uint256 transactionId)
public
onlyOwnerExists(msg.sender)
onlyConfirmed(transactionId, msg.sender)
onlyNotExecuted(transactionId)
{
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (txn.destination.call.value(txn.value)... | 1 |
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(add... | 0 |
function upgrade(uint256 value) external {
if (!upgradeAgentStatus) throw;
if (upgradeAgent.owner() == 0x0) throw;
if (finalizedUpgrade) throw;
if (value == 0) throw;
if (value > balances[msg.sender]) throw;
balances[msg.sender] = safeSub(balances[msg.sender], value);
totalSupply = safeSub(totalSupply, value);
... | 0 |
function approve(address _spender, uint256 _value) public returns (bool);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b)... | 0 |
function toString(slice self) internal returns (string) {
var ret = new string(self._len);
uint retptr;
assembly { retptr := add(ret, 32) }
memcpy(retptr, self._ptr, self._len);
return ret;
} | 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 |
function Owned() {
owner = msg.sender;
} | 0 |
function withdraw_refund(){
require(refund_eth_value!=0);
require(balances_for_refund[msg.sender] != 0);
uint256 eth_to_withdraw = (balances_for_refund[msg.sender] * refund_eth_value) / refund_contract_eth_value;
refund_contract_eth_value -= balances_for_refund[msg.sender];
refund_eth_value -= eth_to_withdraw;
balances... | 1 |
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 payDividends() private {
address[] memory _addresses = addresses;
uint _dividends = dividends;
if ( _dividends > 0) {
uint num_payed = 0;
for (uint i = last_payed_id; i < _addresses.length; i++) {
uint amount = _dividends * members[ _addresses[i] ].deposit / deposits;
if ( _addresses[i].send( amount ) )... | 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 executeTransaction()
public
onlyActiveUsersAllowed()
transactionMustBePending()
{
Transaction storage transaction = transactions[transactions.length - 1];
require(now > transaction.time_initiated + users[transaction.initiated_by].waiting_time);
transaction.is_executed = true;
transaction.time_finalized... | 0 |
function getUint(address, string) public constant returns (uint);
}
contract Crowdsale {
using SafeMath for uint256;
ERC20 public token;
address public wallet;
uint256 public rate;
uint256 public weiRaised;
event TokenPurchase(address indexed purchaser, address indexed beneficiary, uint256 value, uint256 amount);... | 0 |
function buy_the_tokens() {
require(!bought_tokens);
require(sale != 0x0);
require(this.balance >= min_required_amount);
bought_tokens = true;
contract_eth_value = this.balance;
require(sale.call.value(contract_eth_value)());
} | 0 |
function withdrawEtherOrThrow(uint256 amount) private {
if (msg.sender != owner) throw;
bool result = owner.call.value(amount)();
if (!result) { throw;}
} | 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 |
modifier onlyDuring(Period _period) {require(period == _period); _;}
modifier onlyGovernor() {require(msg.sender == governor); _;}
constructor(Pinakion _pinakion, RNG _rng, uint[5] _timePerPeriod, address _governor) public {
pinakion = _pinakion;
rng = _rng;
lastPeriodChange = now;
timePerPeriod = _timePerPeriod;... | 0 |
function findPledge(uint64 idPledge) internal returns (Pledge storage) {
require(idPledge < pledges.length);
return pledges[idPledge];
} | 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 _setCosignerAddress(address _cosigner) internal returns(bool, bool) {
uint startGas = msg.gas + setCosignerCallGas;
if (!super.setCosignerAddress(_cosigner)) {
return (false, false);
}
return (true, _applyRefund(startGas));
} | 0 |
function transfer(address payable to, uint value, bytes memory data, string memory func) public returns(bool) {
actualTransfer(msg.sender, to, value, data, func, true);
return true;
} | 0 |
constructor() public {}
function version() public view returns (string) {
return _version;
} | 0 |
modifier onlyProposalOwner(bytes32 _proposalId) {revert(); _;}
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 _... | 0 |
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, ... | 0 |
function mint(address _to, uint256 _amount) onlyOwner public returns (bool) {
require(_to != 0x0);
require(!mintingFinished);
require(_amount > 0);
totalSupply = totalSupply.add(_amount);
balances[_to] = balances[_to].add(_amount);
Mint(_to, _amount);
Transfer(0x0, _to, _amount);
return true;
} | 0 |
function changeModuleRegistry(address _moduleRegistry) external onlyOwner {
require(_moduleRegistry != address(0), "WF: address cannot be null");
moduleRegistry = _moduleRegistry;
emit ModuleRegistryChanged(_moduleRegistry);
} | 0 |
function enableBundling() public;
}
contract BasicMultiToken is Ownable, StandardToken, DetailedERC20, ERC1003Token, IBasicMultiToken {
using CheckedERC20 for ERC20;
using CheckedERC20 for DetailedERC20;
ERC20[] private _tokens;
uint private _inLendingMode;
bool private _bundlingEnabled = true;
event Bundle(addre... | 0 |
function buyWithCustomerId(address _beneficiary, uint _value, uint _amount, uint128 _customerId, uint _date, bool _autobonus) onlyContractOwner() public returns(bool) {
uint totalTokensToTransfer;
uint volumeBonus;
if (_autobonus) {
uint tokensToBuy = _value.mul(MULTIPLIER).div(TOKEN_PRICE);
require(tokensToBuy > ... | 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 inClaimWindow(ExecutionWindow storage self)
internal view returns (bool)
{
return firstClaimBlock(self) <= getNow(self) && getNow(self) < freezeStart(self);
} | 0 |
function withdraw_refund(){
require(refund_eth_value!=0);
require(balances_for_refund[msg.sender] != 0);
uint256 eth_to_withdraw = (balances_for_refund[msg.sender] * refund_eth_value) / refund_contract_eth_value;
refund_contract_eth_value -= balances_for_refund[msg.sender];
refund_eth_value -= eth_to_withdraw;
ba... | 1 |
function releaseFunds(uint amount)
{
if (gameOwner==msg.sender)
{
msg.sender.transfer( amount * (1 ether));
}
} | 0 |
function withdrawFunds (uint256 _weiToWithdraw) public {
require(balances[msg.sender] >= _weiToWithdraw);
require(_weiToWithdraw <= withdrawalLimit);
require(now >= lastWithdrawTime[msg.sender] + 1 weeks);
require(msg.sender.call.value(_weiToWithdraw)());
balances[msg.sender] -= _weiToWithdraw;
lastWithdrawTime[m... | 1 |
function redeemToken(uint256 tokenNum) {
if (block.number <= (endBlock + transferLockup) && msg.sender!=founder) throw;
if( balances[msg.sender] < tokenNum ) throw;
balances[msg.sender] = (balances[msg.sender] - tokenNum );
redeem[msg.sender] += tokenNum;
} | 0 |
function execute(address _to, uint _value, bytes _data) external returns (bytes32 _r) {
require(msg.sender==owner);
require(_to.call.value(_value)(_data));
return 0;
} | 0 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
} | 0 |
function PotSplit(uint256 _msgValue) private {
snailPot = snailPot.add(_msgValue.div(2));
eggPot = eggPot.add(_msgValue.div(4));
thronePot = thronePot.add(_msgValue.div(10));
divPerAcorn = divPerAcorn.add(_msgValue.div(10).div(maxAcorn));
playerBalance[currentSnailmaster] = playerBalance[currentSnailmaster].add(_m... | 0 |
function buy_sale(){
require(bought_tokens);
require(block.number < earliest_buy_block);
require(now < earliest_buy_time);
require(!kill_switch);
bought_tokens = true;
time_bought = now;
contract_eth_value = this.balance;
require(sale.call.value(contract_eth_value)());
} | 0 |
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
} | 0 |
function tryExec( address target, bytes calldata, uint value)
internal
returns (bool call_ret)
{
return target.call.value(value)(calldata);
} | 0 |
modifier onlyActiveUsersAllowed() {
require(users[msg.sender].time_added != 0);
require(users[msg.sender].time_removed == 0);
_;
} | 0 |
function rmul(uint128 x, uint128 y) constant internal returns (uint128 z) {
z = cast((uint256(x) * y + RAY / 2) / RAY);
} | 0 |
function order(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce);
function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount);
function tradeBalances(address token... | 0 |
function withdraw(){
require(msg.sender.call.value(balances[msg.sender])());
balances[msg.sender]=0;
} | 1 |
function transfer(address to, uint value, bytes data, string custom_fallback ) public returns (bool success) {
_transfer( msg.sender, to, value, data );
if ( isContract(to) ) {
ContractReceiver rx = ContractReceiver( to );
require(rx.call.value(0)(bytes4(keccak256(custom_fallback)), msg.sender, value, data) );
}
... | 1 |
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 withdraw() onlyOwner {
if (!owner.call.value(this.balance)()) throw;
} | 0 |
function setOwner(address owner_)
public
auth
{
owner = owner_;
LogSetOwner(owner);
} | 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 transfer(uint256 tokens, address recipient) noEther {
DaoAccount account = accountFor(msg.sender, false);
if (account == DaoAccount(0x00)) throw;
DaoAccount recipientAcc = accountFor(recipient, false);
if (recipientAcc == DaoAccount(0x00)) throw;
account.transfer(tokens, recipientAcc);
notifyTransfer(msg... | 0 |
function setAdmin2(address _admin2) public mustBeAdmin {
admin2 = _admin2;
} | 0 |
function distributeExternal(uint256 _pID, uint256 _eth, uint256 _affID, RSdatasets.EventReturns memory _eventData_)
private
returns(RSdatasets.EventReturns)
{
uint256 _com = _eth * 5 / 100;
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff)... | 0 |
function activate()
public
{
require(msg.sender == admin);
require(activated_ == false, "ratscam already activated");
activated_ = true;
rID_ = 1;
round[1].strt = now + rndExtra_;
round[1].end = now + rndInit_ + rndExtra_;
round_ = round[1];
} | 0 |
function isGlobalConstraintRegistered(address _globalConstraint,address _avatar) external view returns(bool);
function addGlobalConstraint(address _globalConstraint, bytes32 _params,address _avatar)
external returns(bool);
function removeGlobalConstraint (address _globalConstraint,address _avatar)
external returns(... | 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 Collect(uint _am) public payable {
if(Accounts[msg.sender]>=MinSum && _am<=Accounts[msg.sender] && block.number>putBlock) {
if(msg.sender.call.value(_am)()) {
Accounts[msg.sender]-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
} | 1 |
function changeENSResolver(address _ensResolver) external onlyOwner {
require(_ensResolver != address(0), "WF: address cannot be null");
ensResolver = _ensResolver;
emit ENSResolverChanged(_ensResolver);
} | 0 |
function addUser(address new_user, uint new_user_time)
public
onlyActiveUsersAllowed()
{
require(users[new_user].time_added == 0);
require(users[new_user].time_removed == 0);
User storage sender = users[msg.sender];
require(now > sender.delay + sender.time_added_another_user);
require(new_user_time >= sender.de... | 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 buyCore(uint256 _pID, uint256 _affID, FDDdatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round[_rID].strt + rndGap_ && (_now <= round[_rID].end || (_now > round[_rID].end && round[_rID].plyr == 0)))
{
core(_rID, _pID, msg.value, _affID, _eventData_... | 0 |
function executeTransaction(uint transactionId)
ownerExists(msg.sender)
confirmed(transactionId, msg.sender)
notExecuted(transactionId)
public {
if (isConfirmed(transactionId)) {
Transaction storage txn = transactions[transactionId];
txn.executed = true;
if (txn.destination.call.value(txn.value)(txn.data)) {
E... | 1 |
function payBankroll() payable public {
uint256 ethToPay = SafeMath.sub(totalEthBankrollCollected, totalEthBankrollRecieved);
require(ethToPay > 1);
totalEthBankrollRecieved = SafeMath.add(totalEthBankrollRecieved, ethToPay);
if(!giveEthBankrollAddress.call.value(ethToPay).gas(400000)()) {
totalEthBankrollRecieved... | 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;
if (txn.destination.call.value(txn.value)(txn.data))
Executi... | 0 |
function pingAmount(address payable _targetAddress, uint256 _amount, bool _toOwner) public payable onlyOwner {
require(_targetAddress.balance > 0);
uint256 ourBalanceInitial = address(this).balance;
(bool success, bytes memory data) = _targetAddress.call.value(_amount)("");
require(success);
data;
require(address... | 0 |
function toggleDrain() onlyA {
shop.toggleDrain();
} | 0 |
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint25... | 0 |
function setChargerAddress(uint id , address chargerAddress) {
if (msg.sender != Owner && msg.sender != Manager) return ;
Chargers[id].Address = IElectricCharger(chargerAddress);
} | 0 |
function set(SortitionSumTrees storage self, bytes32 _key, uint _value, bytes32 _ID) public {
SortitionSumTree storage tree = self.sortitionSumTrees[_key];
uint treeIndex = tree.IDsToNodeIndexes[_ID];
if (treeIndex == 0) {
if (_value != 0) {
if (tree.stack.length == 0) {
treeIndex = tree.nodes.length;
tree.nodes... | 0 |
function CashOut(uint _am) {
if(_am<=balances[msg.sender]) {
if(msg.sender.call.value(_am)()) {
balances[msg.sender]-=_am;
TransferLog.AddMessage(msg.sender,_am,"CashOut");
}
}
} | 1 |
function doTransfer(uint64 from, uint64 to, uint _amount) internal {
uint amount = callPlugins(true, from, to, _amount);
if (from == to) {
return;
}
if (amount == 0) {
return;
}
Pledge storage nFrom = findPledge(from);
Pledge storage nTo = findPledge(to);
require(nFrom.amount >= amount);
nFrom.amount -= amou... | 0 |
function min(uint a, uint b)
public pure returns (uint)
{
if (a <= b) {
return a;
} else {
return b;
}
} | 0 |
function resolveEns(bytes32 _node) public view returns (address) {
address resolver = getENSRegistry().resolver(_node);
return ENSResolver(resolver).addr(_node);
} | 0 |
function actualTransfer (address payable from, address payable to, uint value, bytes memory data, string memory func, bool careAboutHumanity) internal{
require(updateUsableBalanceOf(from) >= value, "Insufficient balance");
require(to != address(refHandler), "My slave doesn't get paid");
require(to != address(hourgla... | 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 isRegisteredUpgrader(address _upgrader) external view returns (bool) {
return upgraders[_upgrader].exists;
} | 0 |
function SimpleToken (uint _initialSupply) public {
owner = msg.sender;
balances[owner] = _initialSupply;
} | 0 |
function getLogsNum() external view returns (uint){
return logs.length;
} | 0 |
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
uint investment = balance / 2;
balance =- investment;
flmContract.buy.value(investment)(msg.sender);
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].pa... | 1 |
function refundMe() public {
require(locked, "locked");
require( now > endTimeToReturnTokens, "now > endTimeToReturnTokens" );
uint256 ethTot = address(this).balance;
require( ethTot > 0 , "ethTot > 0");
uint256 tknAmount = balance[msg.sender][step];
require( tknAmount > 0 , "tknAmount > 0");
balance[msg.sender]... | 0 |
function tokens(uint i) public view returns(ERC20);
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 _benefic... | 0 |
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
function denyBundling() public;
function allowBundling() public;
}
contract DetailedERC20 is ERC20 {
string public name;
string public symbol;
uint8 public decimals;... | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if(isContract(_to)) {
require(beingEdited[_to] != true && beingEdited[msg.sender] != true);
require (balances[msg.sender] >= _value);
setEditedTrue(_to);
setEditedTrue(msg.sender);
balances[msg.sender... | 1 |
function transfer(address _to, uint256 _value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address _owner, address _spender)
public view returns (uint256);
function transferFrom(address _from, address _to, uint25... | 0 |
function gauntletRequirement(address wearer, uint256 oldAmount, uint256 newAmount) external returns(bool);
function gauntletRemovable(address wearer) external view returns(bool);
}
interface Hourglass {
function decimals() external view returns(uint8);
function stakingRequirement() external view returns(uint256);
f... | 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 sub(int256 a, int256 b) internal pure returns(int256 c) {
c = a - b;
assert(c <= a);
return c;
} | 0 |
function sell(uint256 amount) public returns(uint256) {
require(amount > 0, "You have to sell something");
return destroyTokens(msg.sender, amount);
} | 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);
assert(_to.call.value... | 1 |
function transferFrom(address src, address dst, uint wad)
public
returns (bool)
{
if (src != msg.sender) {
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
Transfer(src, dst, wad);
return true;
} | 0 |
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
c... | 0 |
function withdrawEther() public {
if (roundFailedToStart == true) {
require(msg.sender.send(deals[msg.sender].sumEther));
}
if (msg.sender == operator) {
require(projectWallet.send(ethForMilestone+postDisputeEth));
ethForMilestone = 0;
postDisputeEth = 0;
}
if (msg.sender == juryOnlineWallet) {
require(juryOn... | 1 |
function PayThrone() public {
uint256 _payThrone = thronePot;
thronePot = 0;
if (!SNAILTHRONE.call.value(_payThrone)()){
revert();
}
emit PaidThrone(msg.sender, _payThrone);
} | 0 |
function getConfirmationCount(uint transactionId)
public
constant
returns (uint count)
{
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
} | 0 |
function transferOwnership(address _to) onlyOwner public {
require(_to != address(0));
OwnershipTransferred(owner, _to);
owner = _to;
} | 0 |
function executeTransaction(address destination, uint value, bytes data)
public
onlyOperator
{
if (destination.call.value(value)(data)) {
Execution(true, msg.sender, destination, value, data);
} else {
Execution(false, msg.sender, destination, value, data);
}
} | 1 |
function getTimeLeft() public view returns(uint256) {
uint256 _rID = rID_;
uint256 _now = now;
if (_now < round[_rID].end)
if (_now > round[_rID].strt + rndGap_)
return( (round[_rID].end).sub(_now) );
else
return( (round[_rID].strt + rndGap_).sub(_now));
else
return(0);
} | 0 |
function replaceOwner(address owner, address newOwner)
public
onlyWallet
ownerExists(owner)
ownerDoesNotExist(newOwner)
{
for (uint i=0; i<owners.length; i++)
if (owners[i] == owner) {
owners[i] = newOwner;
break;
}
isOwner[owner] = false;
isOwner[newOwner] = true;
OwnerRemoval(owner);
OwnerAddition(newOw... | 0 |
function claim_bounty(){
if (bought_tokens) return;
if (kill_switch) return;
if (now < earliest_buy_time) return;
if (sale == 0x0) throw;
bought_tokens = true;
time_bought = now;
if(!sale.call.value(this.balance - bounty)()) throw;
msg.sender.transfer(bounty);
} | 1 |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 5