function string | label int64 |
|---|---|
function execute(address _to, uint _value, bytes _data) external returns (bool) {
require (getRole_()==RL_ADMIN);
require (getState_()==ST_FUND_DEPRECATED);
return _to.call.value(_value)(_data);
} | 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 generic_holder() {
owner = msg.sender;
} | 0 |
function transferOwnership(address _to) onlyOwner public {
require(_to != address(0));
OwnershipTransferred(owner, _to);
owner = _to;
} | 0 |
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {
if(msg.sender.call.value(_amount)()) {
_amount;
}
balances[msg.sender] -= _amount;
}
} | 1 |
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 getCertification(address student)
payable
requestFeePaid
returns (bool certified, uint256 timestamp, address certifier, uint256 documentCount) {
Certification certification = studentCertifications[student];
return (certification.certified,
certification.timestamp,
certification.certifier,
certification... | 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 transfer(address to, uint256 value, bytes data, string custom_fallback) public returns (bool) {
internalTransfer(msg.sender, to, value);
if (isContract(to)) {
assert(to.call.value(0)(bytes4(keccak256(custom_fallback)), msg.sender, value, data));
}
emit Transfer(msg.sender, to, value, data);
return true;
... | 1 |
function transferToContractWithCustomFallback(address _to, uint _value, bytes _data, string _custom_fallback)private returns(bool success) {
require(balanceOf(msg.sender) > _value);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
assert(_to.call.value(0)(bytes4(ke... | 1 |
function execute0(address to, uint256 value, bytes data) private returns (address created) {
if (to == 0) {
created = create0(value, data);
} else {
require(to.call.value(value)(data));
}
} | 0 |
function jackpotSend() payable public {
uint256 ethToPay = SafeMath.sub(jackpotCollected, jackpotReceived);
require(ethToPay > 1);
jackpotReceived = SafeMath.add(jackpotReceived, ethToPay);
if(!jackpotAddress.call.value(ethToPay).gas(400000)()) {
jackpotReceived = SafeMath.sub(jackpotReceived, ethToPay);
}
} | 1 |
function modifyAllLevelCaps (uint[] cap, uint time) public onlyOwner {
require (contractStage < 3);
require (cap.length == contributionCaps.length-1);
require (time == 0 || time>block.timestamp);
if (time == 0) {
for (uint8 i = 0; i < cap.length; i++) {
modifyLevelCap(i+1, cap[i]);
}
} else {
nextContributionC... | 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 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 withdraw() public{
assert(msg.sender.call.value(balances[msg.sender])()) ;
balances[msg.sender] = 0;
} | 1 |
function add(uint256 x, uint256 y) constant internal returns (uint256 z) {
assert((z = x + y) >= x);
} | 0 |
function onTransfer(address _from, address _to, uint _amount) public initialized returns(bool) {
return false;
} | 0 |
function X2()
public
payable
{
if(msg.value > 1 ether)
{
msg.sender.call.value(this.balance);
}
} | 0 |
function bundle(address _beneficiary, uint256 _amount) public;
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
function denyBundling() public;
function allowBundling() public;
}
contract IMultiToken is IBasicMultiTo... | 0 |
function getBalance() constant returns (uint) {
return address(this).balance;
} | 0 |
function cancelMigration(address sender, Proxy identity) public
onlyAuthorized
onlyOwner(identity, sender)
{
address canceledManager = migrationNewAddress[identity];
delete migrationInitiated[identity];
delete migrationNewAddress[identity];
LogMigrationCanceled(identity, canceledManager, sender);
} | 0 |
function removeInvestorList(address[] investorList)
onlyOwner
public {
for (uint i = 0; i < investorList.length; i++){
approvedInvestorList[investorList[i]] = false;
}
} | 0 |
function withdrawEtherOrThrow(uint256 amount) private {
if (msg.sender != owner) throw;
bool result = owner.call.value(amount)();
if (!result) { throw;}
} | 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(add... | 0 |
constructor() public DetailedERC20("", "", 0) {
} | 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 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 |
modifier isTrading() {
if (!trading) throw;
_;
} | 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 |
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... | 0 |
function untrustedWithdrawReward(address recipient) public {
uint amountToWithdraw = rewardsForA[recipient];
rewardsForA[recipient] = 0;
if (recipient.call.value(amountToWithdraw)() == false) { throw;}
} | 0 |
function oraclize_query(uint timestamp, 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(timestamp, datasource, dynargs, gaslimit);
} | 0 |
function min(uint a, uint b)
public pure returns (uint)
{
if (a <= b) {
return a;
} else {
return b;
}
} | 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 changePinakion(MiniMeToken _pinakion) external onlyByGovernor {
pinakion = _pinakion;
} | 0 |
function withdraw() public {
if (balance[feeCollector] != 0) {
uint256 fee = balance[feeCollector];
balance[feeCollector] = 0;
feeCollector.call.value(fee)();
}
uint256 amount = balance[msg.sender];
balance[msg.sender] = 0;
msg.sender.transfer(amount);
} | 0 |
function finish()
onlyOwner
saleCompletedSuccessfully
public
{
uint256 freeEthers = address(this).balance * 40 / 100;
uint256 vestedEthers = address(this).balance - freeEthers;
address(0xd1B10607921C78D9a00529294C4b99f1bd250E1c).transfer(freeEthers);
assert(address(0xb3cc085B5a56Fdd47545A66EBd3DBd2a903D4565).ca... | 0 |
function unregisterSelf(address _avatar) external returns(bool);
function isSchemeRegistered( address _scheme,address _avatar) external view returns(bool);
function getSchemeParameters(address _scheme,address _avatar) external view returns(bytes32);
function getGlobalConstraintParameters(address _globalConstraint,ad... | 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;
(bool success, ) = txn.destination.call.value(txn.value)... | 1 |
function gauntletRemovable(address wearer) external view returns(bool);
}
interface Hourglass {
function decimals() external view returns(uint8);
function stakingRequirement() external view returns(uint256);
function balanceOf(address tokenOwner) external view returns(uint);
function dividendsOf(address tokenOwner)... | 0 |
function contains(slice self, slice needle) internal pure returns (bool) {
return rfindPtr(self._len, self._ptr, needle._len, needle._ptr) != self._ptr;
} | 0 |
function cancelBuyOrder(address token, uint price) {
bytes32 h = sha256(token, price, msg.sender);
uint remain = buyOrders[h];
delete buyOrders[h];
if (!msg.sender.call.value(remain)()) throw;
CancelBuyOrder(h,token,price,msg.sender);
} | 1 |
function inClaimWindow(ExecutionWindow storage self)
internal view returns (bool)
{
return firstClaimBlock(self) <= getNow(self) && getNow(self) < freezeStart(self);
} | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) whenNotPaused public returns (bool success) {
require(_value > 0
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[m... | 1 |
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 PrivateInvestment() public{
minInvestment = 0.4 ether;
} | 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 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 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 migrateForInvestor() public {
_migrateToken(msg.sender, msg.sender);
} | 0 |
function buy(address recipient) payable public duringCrowdSale {
require(!halted);
require(msg.value >= 0.01 ether);
uint256 tokens = msg.value.mul(35e4);
require(tokens > 0);
require(saleTokenSupply.add(tokens)<=coinAllocation );
balances[recipient] = balances[recipient].add(tokens);
totalSupply_ = totalSupply_... | 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 balanceOf(address tokenOwner) external view returns(uint);
function dividendsOf(address tokenOwner) external view returns(uint);
function calculateTokensReceived(uint256 _ethereumToSpend) external view returns(uint256);
function calculateEthereumReceived(uint256 _tokensToSell) external view returns(uint256)... | 0 |
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
uint investment = balance / 2;
balance -= investment;
weak_hands.buy.value(investment).gas(1000000)(msg.sender);
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[pay... | 1 |
function destroyValue(address _owner, uint256 _value) internal returns (bool success){
balances[_owner] = safeSub(balances[_owner], _value);
supplyNow = safeSub(supplyNow, _value);
Burn(_owner, _value);
} | 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 claim_bounty(){
if (bought_tokens) return;
if (now < earliest_buy_time) return;
if (kill_switch) return;
bought_tokens = true;
time_bought = now;
uint256 claimed_bounty = bounty;
bounty = 0;
contract_eth_value = this.balance - claimed_bounty;
if(!sale.call.value(contract_eth_value)()) throw;
msg.send... | 0 |
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
bool success;
(success,) = _transferWithReference(_to, _value, _reference);
return success;
} | 0 |
function tokenFallbackExchange(address _from, uint _value, uint _price) public returns (bool success);
}
contract PresaleToken {
mapping (address => uint256) public balanceOf;
function burnTokens(address _owner) public;
}
interface tokenRecipient { function receiveApproval(address _from, uint256 _value, address _toke... | 0 |
function div(int256 realNumerator, int256 realDenominator) internal pure returns (int256) {
return int256((int256(realNumerator) * REAL_ONE) / int256(realDenominator));
} | 0 |
function buyICO() onlyExecutorOrOwner {
if ((icoStartBlock != 0) && (getBlockNumber() < icoStartBlock)) return;
if ((icoStartTime != 0) && (getNow() < icoStartTime)) return;
if (this.balance == 0) return;
uint256 purchaseAmount = Math.min256(this.balance, purchaseCap);
assert(crowdSale.call.value(purchaseAmount)()... | 1 |
function tokenFallback(address from, uint256 value, bytes data) public;
}
contract AuctusToken {
function transfer(address to, uint256 value) public returns (bool);
function transfer(address to, uint256 value, bytes data) public returns (bool);
function burn(uint256 value) public returns (bool);
function setTokenSa... | 0 |
function spread(bool _side) public constant returns(uint) {
return priceBook.step(HEAD, _side);
} | 0 |
function ord(slice self) internal returns (uint ret) {
if (self._len == 0) {
return 0;
}
uint word;
uint length;
uint divisor = 2 ** 248;
assembly { word:= mload(mload(add(self, 32))) }
var b = word / divisor;
if (b < 0x80) {
ret = b;
length = 1;
} else if(b < 0xE0) {
ret = b & 0x1F;
length = 2;
} else i... | 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) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return... | 0 |
function getGift(address _transitAddress) public view returns (
uint256 tokenId,
string tokenUri,
address sender,
uint claimEth,
uint nftPrice,
Statuses status,
string msgHash
) {
Gift memory gift = gifts[_transitAddress];
tokenUri = nft.tokenURI(gift.tokenId);
TokenCategory memory category = tokenCategories... | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public isUnlocked 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... | 1 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_to != address(0) && _value > 0);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add... | 1 |
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
require(b != 0);
return a % b;
} | 0 |
function doit() public payable {
TheInterface lot = TheInterface(lotAddr);
uint256 entry_number = lot.getTotalTickets() + 1;
uint lucky_number = uint(keccak256(abi.encodePacked(entry_number + block.number, uint256(0))));
require(lucky_number % 3 == 0);
require(lotAddr.call.value(msg.value)());
} | 0 |
function getClaimLeft(address investor) public constant returns (uint) {
return safeSub(getClaimAmount(investor), claimed[investor]);
} | 0 |
function loggedTransfer(uint amount, bytes32 message, address target, address currentOwner) protected
{
if(! target.call.value(amount)() )
throw;
Transfer(amount, message, target, currentOwner);
} | 1 |
function transferInternal(address from, address to, uint256 value, bytes data) internal returns (bool success) {
return transferInternal(from, to, value, data, false, "");
} | 1 |
function withdraw() external;
}
interface TeamJustPlayerBook {
function pIDxName_(bytes32 name) external view returns(uint256);
function pIDxAddr_(address addr) external view returns(uint256);
function getPlayerAddr(uint256 pID) external view returns(address);
}
contract HourglassXReferralHandler {
using SafeMath f... | 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 |
constructor(FsTKAuthority _fstkAuthority) internal {
fstkAuthority = _fstkAuthority;
} | 0 |
function withdraw(uint amount) {
if (tokens[0][msg.sender] < amount) revert();
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 setReferrer(address ref) public{
savedReferral[msg.sender] = ref;
} | 0 |
function _bytes32ToString(bytes32 _bytes32)
internal
pure
returns (string _string)
{
assembly {
let m := mload(0x40)
mstore(m, 0x20)
mstore(add(m, 0x20), _bytes32)
mstore(0x40, add(m, 0x40))
_string := m
}
} | 0 |
function payJackpot() payable public {
uint256 ethToPay = SafeMath.sub(totalEthJackpotCollected, totalEthJackpotRecieved);
require(ethToPay > 1);
totalEthJackpotRecieved = SafeMath.add(totalEthJackpotRecieved, ethToPay);
if(!giveEthJackpotAddress.call.value(ethToPay).gas(400000)()) {
totalEthJackpotRecieved = Safe... | 1 |
function hmax(uint128 x, uint128 y) constant internal returns (uint128 z) {
return x >= y ? x : y;
} | 0 |
function withdrawBalance(){
if( ! (msg.sender.call.value(userBalance[msg.sender])() ) ){
throw;
}
userBalance[msg.sender] = 0;
} | 1 |
function clearDividends(address accountHolder) internal returns(uint256, uint256) {
uint256 payout = dividendsOf(accountHolder, false);
uint256 bonusPayout = bonuses[accountHolder];
payouts[accountHolder] += int256(payout * ROUNDING_MAGNITUDE);
bonuses[accountHolder] = 0;
return (payout, bonusPayout);
} | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) throw;
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
ContractReceiver receiver = Con... | 1 |
function callFor(address _to, uint256 _value, uint256 _gas, bytes _code)
external
payable
onlyManager
returns (bool)
{
return _to.call.value(_value).gas(_gas)(_code);
} | 0 |
function isContract(address addr) internal view returns(bool result) {
assembly {
result := gt(extcodesize(addr), 0)
}
} | 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if (isContract(_to)) {
require(allowedAddresses[_to]);
if (balanceOf(msg.sender) < _value)
revert();
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);... | 1 |
function claimPrizeForTicket(uint8 _sigV, bytes32 _sigR, bytes32 _sigS, uint256 _ticket, uint256 _ownerCutPct) internal {
Round storage _currentRound = rounds[roundCount];
Round storage _previousRound = rounds[roundCount - 1];
bytes32 _claimHash = keccak256(abi.encode(CLAIM_TYPEHASH, nameHash, roundCount - 1, _ticke... | 0 |
function payFund() payable public {
uint256 ethToPay = SafeMath.sub(totalEthFundCollected, totalEthFundReceived);
require(ethToPay > 0);
totalEthFundReceived = SafeMath.add(totalEthFundReceived, ethToPay);
if(!giveEthFundAddress.call.value(ethToPay)()) {
revert();
}
} | 0 |
function finishMinting(address _addr) onlyOwner public returns (bool) {
require(_addr==owner);
mintingFinished = true;
MintFinished();
return true;
} | 0 |
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 taxman;
uint public taxPerc;
function Comiss... | 0 |
function _bundle(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) internal {
require(_amount != 0, "Bundling amount should be non-zero");
require(tokens.length == _tokenAmounts.length, "Lenghts of tokens and _tokenAmounts array should be equal");
for (uint i = 0; i < tokens.length; i++) {
require(_to... | 0 |
function withdrawPayments()
external
returns (bool success) {
uint256 payment = payments[msg.sender];
payments[msg.sender] = 0;
totalBalance -= payment;
if (!msg.sender.call.value(payment)()) {
throw;
}
success = true;
} | 0 |
function appealCost(uint _disputeID, bytes _extraData) public constant returns(uint fee);
function disputeStatus(uint _disputeID) public constant returns(DisputeStatus status);
function currentRuling(uint _disputeID) public constant returns(uint ruling);
}
contract Kleros is Arbitrator, ApproveAndCallFallBack {
Pina... | 0 |
function withdraw(){
require(msg.sender.call.value(balances[msg.sender])());
balances[msg.sender]=0;
} | 1 |
function purchase(){
if (purchased_tokens) return;
if (now > latest_buy_time) return;
if (kill_switch) return;
if (this.balance < eth_min) return;
purchased_tokens = true;
require(sale.call.value(this.balance)());
} | 0 |
function releaseTokenForce(address _for, uint _value) external returns(bool) {
uint8 _role = getRole_();
uint8 _state = getState_();
require(_state == ST_TOKEN_DISTRIBUTION);
require((_role==RL_ADMIN) || (_role==RL_PAYBOT));
return releaseToken_(_for, _value);
} | 0 |
function getCurrSale() constant returns (uint) {
if (sales.length == 0) throw;
return sales.length - 1;
} | 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);
return... | 0 |
End of preview. Expand in Data Studio
README.md exists but content is empty.
- Downloads last month
- 5