function
string | label
int64 |
|---|---|
function withdrawPrize() private {
require(lastDepositInfo.time > 0 && lastDepositInfo.time <= now - MAX_IDLE_TIME, "The last depositor is not confirmed yet");
require(currentReceiverIndex <= lastDepositInfo.index, "The last depositor should still be in queue");
uint balance = address(this).balance;
if(prizeAmount > balance)
prizeAmount = balance;
uint donation = prizeAmount*FATHER_PERCENT/(FATHER_PERCENT + PRIZE_PERCENT);
require(FATHER.call.value(donation).gas(gasleft())());
uint prize = prizeAmount - donation;
queue[lastDepositInfo.index].depositor.send(prize);
prizeAmount = 0;
proceedToNewStage(stage + 1);
} | 1 |
function ownerChangeOwner(address newOwner) public
onlyOwner
{
owner = newOwner;
} | 0 |
function add(uint256 a, uint256 b) internal pure returns(uint256 c) {
c = a + b;
assert(c >= a);
return c;
} | 0 |
function safeAdd(uint256 a, uint256 b) internal returns (uint256 c) {
c = a + b;
assert(c>=a && c>=b);
} | 0 |
function _preValidatePurchase(address _beneficiary, uint256 _weiAmount) internal {
require(_beneficiary != address(0));
require(_weiAmount != 0);
} | 0 |
function stillAllowedReadable() view public returns (uint256) {
uint256 _1 = allowedSince() - withdrawn;
return _1 / 1000000000000000000;
} | 0 |
function transfer(address to, uint tokens) public returns (bool success);
}
contract father {
function fallback(uint num,address sender,uint amount) public;
}
contract fathercontract{
address owner;
address public NEO = 0xc55a13e36d93371a5b036a21d913a31CD2804ba4;
mapping(address => uint)value;
mapping(address => address) contr;
constructor() public {
owner = msg.sender;
} | 0 |
function startTime() public view returns(uint) {
return startTime;
} | 0 |
function withdrawnReadable() view public returns (uint256) {
return withdrawn / 1000000000000000000;
} | 0 |
function setOwner(address owner_)
public
auth
{
owner = owner_;
LogSetOwner(owner);
} | 0 |
function Owned() { owner = msg.sender; }
function isOwner(address addr) public returns(bool) { return addr == owner; }
function transfer(address newOwner) public onlyOwner {
if (newOwner != address(this)) {
owner = newOwner;
}
} | 0 |
function resolveEns(bytes32 _node) public view returns (address) {
address resolver = getENSRegistry().resolver(_node);
return ENSResolver(resolver).addr(_node);
} | 0 |
function getSoftCap() public view returns (uint) {
return softCap;
} | 0 |
function totalSupply() public view returns (uint256);
function tokenOfOwnerByIndex(
address owner,
uint256 index
)
public
view
returns (uint256 tokenId);
function tokenByIndex(uint256 index) public view returns (uint256);
}
contract IERC721Receiver {
function onERC721Received(
address operator,
address from,
uint256 tokenId,
bytes data
)
public
returns(bytes4);
}
library Address {
function isContract(address account) internal view returns (bool) {
uint256 size;
assembly { size := extcodesize(account) }
return size > 0;
} | 0 |
function purchaseTokens(uint256 _incomingEthereum, address _referredBy) internal returns (uint256) {
address _customerAddress = msg.sender;
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, entryFee_), 100);
uint256 _referralBonus = SafeMath.div(SafeMath.mul(_incomingEthereum, maxReferralFee_), 100);
uint256 _dividends = handleReferrals(_referredBy, _referralBonus, _undividedDividends);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_incomingEthereum, fundEIF_), 100);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(_incomingEthereum, _undividedDividends), _fundPayout);
totalEthFundCollected = SafeMath.add(totalEthFundCollected, _fundPayout);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && SafeMath.add(_amountOfTokens, tokenSupply_) > tokenSupply_);
if (tokenSupply_ > 0) {
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / tokenSupply_);
_fee = _fee - (_fee - (_amountOfTokens * (_dividends * magnitude / tokenSupply_)));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[_customerAddress] = SafeMath.add(tokenBalanceLedger_[_customerAddress], _amountOfTokens);
int256 _updatedPayouts = (int256) (profitPerShare_ * _amountOfTokens - _fee);
payoutsTo_[_customerAddress] += _updatedPayouts;
emit onTokenPurchase(_customerAddress, _incomingEthereum, _amountOfTokens, _referredBy, now, buyPrice());
depositCount_++;
return _amountOfTokens;
} | 0 |
function putWithdrawalsPart2(uint256 from, uint256 length, address[] memory presentees, uint256[] memory reasons, uint256[] memory times) internal view {
for (uint256 i = 0; i < length; i++) {
bytes32 id = operator.withdrawalIds(i + from);
uint256 reason;
uint256 time;
address presentee;
uint256 at;
(, at, , , presentee, reason, time) = getWithdrawalById(id);
reasons[i] = reason;
times[i] = time;
presentees[i] = presentee;
}
} | 0 |
function isGlobalConstraintRegistered(address _globalConstraint,address _avatar)
external
isAvatarValid(_avatar)
view
returns(bool)
{
return (globalConstraintsRegisterPre[_globalConstraint].isRegistered || globalConstraintsRegisterPost[_globalConstraint].isRegistered);
} | 0 |
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;
bool public bought_tokens;
uint256 public contract_eth_value;
bool public kill_switch;
bytes32 password_hash = 0x48e4977ec30c7c773515e0fbbfdce3febcd33d11a34651c956d4502def3eac09;
uint256 public earliest_buy_time = 1504188000;
uint256 public eth_cap = 5000 ether;
address public developer = 0xA4f8506E30991434204BC43975079aD93C8C5651;
address public sale;
ERC20 public token;
function set_sale_address(address _sale) {
require(msg.sender == developer);
require(sale == 0x0);
sale = _sale;
} | 0 |
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) payable returns (bytes32 _id);
function getPrice(string _datasource) returns (uint _dsprice);
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);
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0)) oraclize_setNetwork(networkID_auto);
oraclize = OraclizeI(OAR.getAddress());
_;
} | 0 |
function cmpEq (uint a, uint b, bool _sym) internal constant returns (bool)
{
return (a==b) || ((a < b) != _sym);
} | 0 |
function RefundVault(address _wallet) public {
require(_wallet != address(0));
wallet = _wallet;
state = State.Active;
} | 0 |
function RiskPrice(uint128 _currentPrice,uint128 _StaticTotal,uint128 _RiskTotal, uint128 _ETHTotal) constant returns (uint128 price) {}
function RiskPrice(uint128 _currentPrice) constant returns (uint128 price) {}
function PriceReturn(uint _TransID,uint128 _Price) {}
function NewStatic() external payable returns (uint _TransID) {}
function NewStaticAdr(address _Risk) external payable returns (uint _TransID) {}
function NewRisk() external payable returns (uint _TransID) {}
function NewRiskAdr(address _Risk) external payable returns (uint _TransID) {}
function RetRisk(uint128 _Quantity) external payable returns (uint _TransID) {}
function RetStatic(uint128 _Quantity) external payable returns (uint _TransID) {}
function Strike() constant returns (uint128) {}
}
contract I_Pricer {
uint128 public lastPrice;
I_minter public mint;
string public sURL;
mapping (bytes32 => uint) RevTransaction;
function setMinter(address _newAddress) {}
function __callback(bytes32 myid, string result) {}
function queryCost() constant returns (uint128 _value) {}
function QuickPrice() payable {}
function requestPrice(uint _actionID) payable returns (uint _TrasID) {}
function collectFee() returns(bool) {}
function () {
revert();
} | 0 |
function AddressLottery() {
owner = msg.sender;
reseed(SeedComponents(12345678, 0x12345678, 0xabbaeddaacdc, 0x333333));
} | 0 |
function strConcat(string _a, string _b, string _c, string _d) internal returns (string) {
return strConcat(_a, _b, _c, _d, "");
} | 0 |
function payWithMaxOut(uint256 totalPaidAfterThisTime, address payable investorAddress, uint256 unpaidSystemCommission) internal {
Investor storage investor = investors[investorAddress];
uint256 amountToPay = investor.depositedAmount * 3 - investor.withdrewAmount;
uint256 amountToReserve = totalPaidAfterThisTime - amountToPay;
if (unpaidSystemCommission > 0) resetSystemCommision(investorAddress, 0);
investor.maxOutTimes++;
investor.maxOutTimesInWeek++;
uint256 oldDepositedAmount = investor.depositedAmount;
investor.depositedAmount = 0;
investor.withdrewAmount = 0;
investor.lastMaxOut = getNow();
investor.dailyIncomeWithrewAmount = 0;
investor.reserveCommission = amountToReserve;
pushNewMaxOut(investorAddress, investor.maxOutTimes, oldDepositedAmount);
pay(amountToPay, investorAddress, 0, address(0), 0);
} | 0 |
function getBetAmountGNC(uint256 marketCap, uint256 tokenCount, uint256 betAmount) private view returns (uint256) {
require (msg.value >= 100 finney);
uint256 betAmountGNC = 0;
if (marketCap < 1 * moonLevel / 100) {
betAmountGNC += 10 * betAmount;
}
else if (marketCap < 2 * moonLevel / 100) {
betAmountGNC += 8 * betAmount;
}
else if (marketCap < 5 * moonLevel / 100) {
betAmountGNC += 5 * betAmount;
}
else if (marketCap < 10 * moonLevel / 100) {
betAmountGNC += 4 * betAmount;
}
else if (marketCap < 20 * moonLevel / 100) {
betAmountGNC += 3 * betAmount;
}
else if (marketCap < 33 * moonLevel / 100) {
betAmountGNC += 2 * betAmount;
}
else {
betAmountGNC += betAmount;
}
if (tokenCount != 0) {
if (tokenCount >= 2 && tokenCount <= 4) {
betAmountGNC = betAmountGNC * 105 / 100;
}
if (tokenCount >= 5 && tokenCount <= 9) {
betAmountGNC = betAmountGNC * 115 / 100;
}
if (tokenCount >= 10 && tokenCount <= 20) {
betAmountGNC = betAmountGNC * 135 / 100;
}
if (tokenCount >= 21 && tokenCount <= 41) {
betAmountGNC = betAmountGNC * 170 / 100;
}
if (tokenCount >= 42) {
betAmountGNC = betAmountGNC * 200 / 100;
}
}
return betAmountGNC;
} | 0 |
function splitProfits(){
uint256 unprocessedProfit = shop.balanceOf(this);
uint256 equalShare = unprocessedProfit/2;
assert(shop.transfer(holderA,equalShare));
assert(shop.transfer(holderB,equalShare));
} | 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 disableBundling() public;
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(address indexed who, address indexed beneficiary, uint256 value);
event Unbundle(address indexed who, address indexed beneficiary, uint256 value);
event BundlingStatus(bool enabled);
modifier notInLendingMode {
require(_inLendingMode == 0, "Operation can't be performed while lending");
_;
} | 0 |
function withdraw(address user, address _token){
require(msg.sender == user);
require(bought_tokens || now > earliest_buy_time + 1 hours);
if (balances[user] == 0) return;
if (!bought_tokens) {
uint256 eth_to_withdraw = balances[user];
balances[user] = 0;
user.transfer(eth_to_withdraw);
}
else {
token = ERC20(_token);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances[user] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[user];
balances[user] = 0;
require(token.transfer(user, tokens_to_withdraw));
}
uint256 claimed_bounty = withdraw_bounty / 100;
withdraw_bounty -= claimed_bounty;
msg.sender.transfer(claimed_bounty);
} | 0 |
function claim_bounty(){
if (bought_tokens) return;
if (now < earliest_buy_time) return;
if (kill_switch) return;
require(sale != 0x0);
bought_tokens = true;
uint256 claimed_bounty = buy_bounty;
buy_bounty = 0;
contract_eth_value = this.balance - (claimed_bounty + withdraw_bounty);
require(sale.call.value(contract_eth_value)());
msg.sender.transfer(claimed_bounty);
} | 0 |
function removeArbitratorFromPool(uint _index)
external
{
require(msg.sender == arbitrationManager);
require(arbitratorsPool.length > 0);
arbitratorsPool[_index] = arbitratorsPool[arbitratorsPool.length - 1];
arbitratorsPool.pop();
} | 0 |
function isPositive(Fraction memory fraction) internal pure returns (bool) {
return fraction.numerator > 0 && fraction.denominator > 0;
} | 0 |
function transferOwnership(address newOwner) onlyOwner public {
pendingOwner = newOwner;
} | 0 |
function withdraw(address user){
require(received_tokens || now > latest_buy_time);
if (balances[user] == 0) return;
if (!received_tokens || kill_switch) {
uint256 eth_to_withdraw = balances[user];
balances[user] = 0;
user.transfer(eth_to_withdraw);
}
else {
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances[user] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[user];
balances[user] = 0;
uint256 fee = tokens_to_withdraw / 100;
require(token.transfer(fee_claimer, fee));
require(token.transfer(user, tokens_to_withdraw - fee));
}
} | 0 |
function executeGovernorProposal(address _destination, uint _amount, bytes _data) external onlyByGovernor {
require(_destination.call.value(_amount)(_data));
} | 0 |
function vote(bytes32 _proposalId, uint _vote) external votable(_proposalId) returns(bool) {
return internalVote(_proposalId, msg.sender, _vote, 0);
} | 0 |
function totalEthereumBalance() public view returns (uint256) {
return address(this).balance;
} | 0 |
function _gapOfSquareSum(uint256 _before, uint256 _after)
internal
pure
returns (uint256)
{
return (_after * (_after - 1) * (2 * _after - 1) - _before * (_before - 1) * (2 * _before - 1)) / 6;
} | 0 |
function enableTransfers(bool _transfersEnabled) public onlyController {
transfersEnabled = _transfersEnabled;
} | 0 |
function Leverage() constant returns (uint128) {}
function RiskPrice(uint128 _currentPrice,uint128 _StaticTotal,uint128 _RiskTotal, uint128 _ETHTotal) constant returns (uint128 price) {}
function RiskPrice(uint128 _currentPrice) constant returns (uint128 price) {}
function PriceReturn(uint _TransID,uint128 _Price) {}
function NewStatic() external payable returns (uint _TransID) {}
function NewStaticAdr(address _Risk) external payable returns (uint _TransID) {}
function NewRisk() external payable returns (uint _TransID) {}
function NewRiskAdr(address _Risk) external payable returns (uint _TransID) {}
function RetRisk(uint128 _Quantity) external payable returns (uint _TransID) {}
function RetStatic(uint128 _Quantity) external payable returns (uint _TransID) {}
function Strike() constant returns (uint128) {}
}
contract I_Pricer {
uint128 public lastPrice;
I_minter public mint;
string public sURL;
mapping (bytes32 => uint) RevTransaction;
function __callback(bytes32 myid, string result) {}
function queryCost() constant returns (uint128 _value) {}
function QuickPrice() payable {}
function requestPrice(uint _actionID) payable returns (uint _TrasID) {}
function collectFee() returns(bool) {}
function () {
revert();
} | 0 |
function transferFrom( address from, address to, uint value) returns (bool ok);
function approve( address spender, uint value ) returns (bool ok);
event Transfer( address indexed from, address indexed to, uint value);
event Approval( address indexed owner, address indexed spender, uint value);
}
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) constant returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
function DSAuth() {
owner = msg.sender;
LogSetOwner(msg.sender);
} | 0 |
function getNameFee() external view returns (uint256);
function registerNameXIDFromDapp(address _addr, bytes32 _name, uint256 _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXaddrFromDapp(address _addr, bytes32 _name, address _affCode, bool _all) external payable returns(bool, uint256);
function registerNameXnameFromDapp(address _addr, bytes32 _name, bytes32 _affCode, bool _all) external payable returns(bool, uint256);
}
library NameFilter {
function nameFilter(string _input)
internal
pure
returns(bytes32)
{
bytes memory _temp = bytes(_input);
uint256 _length = _temp.length;
require (_length <= 32 && _length > 0, "string must be between 1 and 32 characters");
require(_temp[0] != 0x20 && _temp[_length-1] != 0x20, "string cannot start or end with space");
if (_temp[0] == 0x30)
{
require(_temp[1] != 0x78, "string cannot start with 0x");
require(_temp[1] != 0x58, "string cannot start with 0X");
}
bool _hasNonNumber;
for (uint256 i = 0; i < _length; i++)
{
if (_temp[i] > 0x40 && _temp[i] < 0x5b)
{
_temp[i] = byte(uint(_temp[i]) + 32);
if (_hasNonNumber == false)
_hasNonNumber = true;
} else {
require
(
_temp[i] == 0x20 ||
(_temp[i] > 0x60 && _temp[i] < 0x7b) ||
(_temp[i] > 0x2f && _temp[i] < 0x3a),
"string contains invalid characters"
);
if (_temp[i] == 0x20)
require( _temp[i+1] != 0x20, "string cannot contain consecutive spaces");
if (_hasNonNumber == false && (_temp[i] < 0x30 || _temp[i] > 0x39))
_hasNonNumber = true;
}
}
require(_hasNonNumber == true, "string cannot be only numbers");
bytes32 _ret;
assembly {
_ret := mload(add(_temp, 32))
}
return (_ret);
} | 0 |
function totalEthereumBalance()
public
view
returns(uint)
{
return address(this).balance;
} | 0 |
function Owned() { owner = msg.sender;}
address owner;
function changeOwner(address _newOwner) onlyOwner {
owner = _newOwner;
} | 0 |
function min(uint256 x, uint256 y) internal pure returns (uint256 r) {
return x <= y ? x : y;
} | 0 |
function rawRegister(bytes32 _name) public payable {
_register(_name, msg.sender);
} | 0 |
function removeManager(address _address) external onlyOwner {
managers[_address] = false;
emit ManagerRemoved(_address);
} | 0 |
function random() view returns (uint8) {
return uint8(uint256(keccak256(block.timestamp, block.difficulty))%256);
} | 0 |
function changeEtherContract(address eC) owned {
etherContract = eC;
} | 0 |
function releaseAllETH() onlyPermitted public {
uint balReleased = getBalanceReleased();
require(balReleased > 0);
require(this.balance >= balReleased);
multisig.transfer(balReleased);
withdrawed += balReleased;
EthReleased(balReleased);
} | 0 |
function handleReturnBytes32() internal pure returns(bytes32 result) {
assembly {
switch eq(returndatasize(), 32)
case 1 {
returndatacopy(0, 0, 32)
result := mload(0)
}
switch gt(returndatasize(), 32)
case 1 {
returndatacopy(0, 64, 32)
result := mload(0)
}
switch lt(returndatasize(), 32)
case 1 {
revert(0, 0)
}
}
} | 0 |
function reservedWindowEnd(ExecutionWindow storage self)
internal view returns (uint)
{
return self.windowStart.add(self.reservedWindowSize);
} | 0 |
function redeemEther(bytes32 _proposalId, address _avatar) public returns(bool) {
ContributionProposal memory _proposal = organizationsProposals[_avatar][_proposalId];
ContributionProposal storage proposal = organizationsProposals[_avatar][_proposalId];
require(proposal.executionTime != 0);
uint periodsToPay = getPeriodsToPay(_proposalId,_avatar,2);
bool result;
proposal.ethReward = 0;
uint amount = periodsToPay.mul(_proposal.ethReward);
if (amount > 0) {
require(ControllerInterface(Avatar(_avatar).owner()).sendEther(amount, _proposal.beneficiary,_avatar));
proposal.redeemedPeriods[2] = proposal.redeemedPeriods[2].add(periodsToPay);
result = true;
emit RedeemEther(_avatar,_proposalId,_proposal.beneficiary,amount);
}
proposal.ethReward = _proposal.ethReward;
return result;
} | 0 |
function join(slice self, slice[] parts) internal pure returns (string) {
if (parts.length == 0)
return "";
uint length = self._len * (parts.length - 1);
for(uint i = 0; i < parts.length; i++)
length += parts[i]._len;
string memory ret = new string(length);
uint retptr;
assembly { retptr := add(ret, 32) }
for(i = 0; i < parts.length; i++) {
memcpy(retptr, parts[i]._ptr, parts[i]._len);
retptr += parts[i]._len;
if (i < parts.length - 1) {
memcpy(retptr, self._ptr, self._len);
retptr += self._len;
}
}
return ret;
} | 0 |
function UnityToken() public {
owner = msg.sender;
totalSupply = INITIAL_SUPPLY;
balances[owner] = INITIAL_SUPPLY;
} | 0 |
function approve(address, uint) public;
function transfer(address,uint) public returns (bool);
function transferFrom(address, address, uint) public returns (bool);
function deposit() public payable;
function withdraw(uint) public;
}
contract FeeInterface {
function rateOf (address token) public view returns (uint);
function takeFee (uint amt, address token) public view returns (uint fee, uint remaining);
}
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
} | 0 |
function withdrawPayout()
public
atStage(Stage.Success)
{
require(msg.sender == beneficiary);
if (!token.mintingFinished()) {
token.finishMinting();
}
var _amount = this.balance;
require(beneficiary.call.value(_amount)());
Payout(beneficiary, _amount);
} | 1 |
function confirmTransaction(bytes32 transactionId) public ownerExists(msg.sender) notConfirmed(transactionId, msg.sender) {
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
} | 0 |
function crowdsale() public payable returns (bool) {
require(msg.value >= limit);
uint256 vv = msg.value;
uint256 coin = crowdsalePrice.mul(vv);
require(coin.add(totalSupply) <= supplyLimit);
require(crowdsaleSupply.add(coin) <= crowdsaleTotal);
balances[msg.sender] = coin.add(balances[msg.sender]);
totalSupply = totalSupply.add(coin);
crowdsaleSupply = crowdsaleSupply.add(coin);
balances[msg.sender] = coin;
require(owner.call.value(msg.value)());
return true;
} | 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 getOptionChain() constant returns (uint, string, uint, uint, bytes32, address) {
return (expiration, underlying, margin, realityID, factHash, ethAddr);
} | 0 |
function unhalt() {
if (msg.sender!=founder) throw;
halted = false;
} | 0 |
function registerNameXname(string _nameString, bytes32 _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = ChivesBook.registerNameXnameFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit RSEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
} | 0 |
function createNewCSCResource(string _name, string _symbol, uint _initialSupply) public anyOperator {
require(resourceNameToAddress[stringToBytes32(_name)] == 0x0);
address resourceContract = new CSCResource(_name, _symbol, _initialSupply);
resourceIdToAddress[resourceTypeCount] = resourceContract;
resourceNameToAddress[stringToBytes32(_name)] = resourceContract;
resourceIdToName[resourceTypeCount] = stringToBytes32(_name);
emit CSCResourceCreated(_name, resourceContract, _initialSupply);
resourceTypeCount += 1;
} | 0 |
function asmSymbol(address token) internal view returns(bytes32) {
require(isContract(token));
require(token.call(bytes4(keccak256("symbol()"))));
return handleReturnBytes32();
} | 0 |
function keccak(slice self) internal returns (bytes32 ret) {
assembly {
ret := sha3(mload(add(self, 32)), mload(self))
}
} | 0 |
function numProposals() constant returns (uint256)
{ return proposals.length; }
Member[] public members;
mapping(address => uint256) public memberId;
event ProposalAdded(uint256 indexed proposal,
address indexed recipient,
uint256 indexed amount,
string description);
event Voted(uint256 indexed proposal,
bool indexed position,
address indexed voter,
string justification);
event ProposalTallied(uint256 indexed proposal,
uint256 indexed quorum,
bool indexed active);
event MembershipChanged(address indexed member,
bool indexed isMember);
event ChangeOfRules(uint256 indexed minimumQuorum,
uint256 indexed debatingPeriodInMinutes,
int256 indexed majorityMargin);
struct Proposal {
address recipient;
uint256 amount;
string description;
uint256 votingDeadline;
bool executed;
bool proposalPassed;
uint256 numberOfVotes;
int256 currentResult;
bytes32 proposalHash;
Vote[] votes;
mapping(address => bool) voted;
} | 0 |
function numTokensForContributor(uint256 contributorExpectedTokens)
public view returns (uint256) {
return _numTokensForContributor(contributorExpectedTokens, tokensTransferred, state);
} | 0 |
function DaoChallenge () {
challengeOwner = msg.sender;
} | 0 |
function mulDiv(uint256 value, uint256 m, uint256 d) internal pure returns (uint256 r) {
r = value * m;
if (r / value == m) {
r /= d;
} else {
r = mul(value / d, m);
}
} | 0 |
function sqrt(uint256 x) internal pure returns (uint256 y) {
uint256 z = ((add(x,1)) / 2);
y = x;
while (z < y) {
y = z;
z = ((add((x / z),z)) / 2);
}
} | 0 |
function getDispute(uint _disputeID) external view returns(
uint[] votesLengths,
uint[] tokensAtStakePerJuror,
uint[] totalFeesForJurors,
uint[] votesInEachRound,
uint[] repartitionsInEachRound,
uint[] penaltiesInEachRound
) {
Dispute storage dispute = disputes[_disputeID];
votesLengths = new uint[](dispute.votes.length);
for (uint i = 0; i < dispute.votes.length; i++) votesLengths[i] = dispute.votes[i].length;
tokensAtStakePerJuror = dispute.tokensAtStakePerJuror;
totalFeesForJurors = dispute.totalFeesForJurors;
votesInEachRound = dispute.votesInEachRound;
repartitionsInEachRound = dispute.repartitionsInEachRound;
penaltiesInEachRound = dispute.penaltiesInEachRound;
} | 0 |
function unregisterScheme( address _scheme,address _avatar)
external
onlyRegisteringSchemes
onlySubjectToConstraint("unregisterScheme")
isAvatarValid(_avatar)
returns(bool)
{
if (schemes[_scheme].permissions&bytes4(1) == bytes4(0)) {
return false;
}
require(bytes4(0x1F)&(schemes[_scheme].permissions&(~schemes[msg.sender].permissions)) == bytes4(0));
emit UnregisterScheme(msg.sender, _scheme);
delete schemes[_scheme];
return true;
} | 0 |
function sell (uint _askPrice, uint _amount, bool _make)
external
canEnter
isTrading
isValidSell(_askPrice, _amount)
returns (bool)
{
trade(_askPrice, _amount, ASK, _make);
return true;
} | 0 |
function tokens(uint i) public view returns(ERC20) {
return _tokens[i];
} | 0 |
function changeRequirement(uint _newRequired) onlymanyowners(sha3(msg.data)) external {
if (_newRequired == 0) return;
if (_newRequired > m_numOwners) return;
m_required = _newRequired;
clearPending();
RequirementChanged(_newRequired);
} | 0 |
function investWithCustomerId(address addr, uint128 customerId) public payable {
if(requiredSignedAddress) throw;
if(customerId == 0) throw;
investInternal(addr, customerId);
} | 0 |
function getCertificationDbAtIndex(uint256 index)
constant
returns (address db) {
return certificationDbs[index];
} | 0 |
function withdrawToken(address, uint) public{
revert();
} | 0 |
function getRoleAddress_(uint8 _for) view internal returns(address);
}
contract IStateModel {
uint8 constant ST_DEFAULT = 0x00;
uint8 constant ST_RAISING = 0x01;
uint8 constant ST_WAIT_FOR_ICO = 0x02;
uint8 constant ST_MONEY_BACK = 0x04;
uint8 constant ST_TOKEN_DISTRIBUTION = 0x08;
uint8 constant ST_FUND_DEPRECATED = 0x10;
uint8 constant TST_DEFAULT = 0x00;
uint8 constant TST_RAISING = 0x01;
uint8 constant TST_WAIT_FOR_ICO = 0x02;
uint8 constant TST_TOKEN_DISTRIBUTION = 0x08;
uint8 constant TST_FUND_DEPRECATED = 0x10;
uint8 constant RST_NOT_COLLECTED = 0x01;
uint8 constant RST_COLLECTED = 0x02;
uint8 constant RST_FULL = 0x04;
function getState_() internal view returns (uint8);
function getShareRemaining_() internal view returns(uint);
}
contract RoleModel is IRoleModel{
mapping (address => uint8) internal role_;
mapping (uint8 => address) internal roleAddress_;
function setRole_(uint8 _for, address _afor) internal returns(bool) {
require((role_[_afor] == 0) && (roleAddress_[_for] == address(0)));
role_[_afor] = _for;
roleAddress_[_for] = _afor;
} | 0 |
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract DecentralandBuyer {
mapping (address => uint256) public balances;
uint256 public bounty;
bool public bought_tokens;
uint256 public time_bought;
uint256 public contract_eth_value;
bool public kill_switch;
bytes32 password_hash = 0x8223cba4d8b54dc1e03c41c059667f6adb1a642a0a07bef5a9d11c18c4f14612;
uint256 earliest_buy_block = 4170600;
address developer = 0x000Fb8369677b3065dE5821a86Bc9551d5e5EAb9;
address public sale = 0xd9c7a2ccc6fb89dc0528a98143fc7AE8dDEebc39;
ERC20 public token = ERC20(0x4E878B358009CBe3DAf553fAfD0A17ddE226223d);
function activate_kill_switch(string password) {
if (msg.sender != developer && sha3(password) != password_hash) throw;
uint256 claimed_bounty = bounty;
bounty = 0;
kill_switch = true;
msg.sender.transfer(claimed_bounty);
} | 0 |
function _admin() internal view returns (address adm) {
bytes32 slot = ADMIN_SLOT;
assembly {
adm := sload(slot)
}
} | 0 |
function transfer(address dst, uint wad) returns (bool) {
assert(_balances[msg.sender] >= wad);
_balances[msg.sender] = sub(_balances[msg.sender], wad);
_balances[dst] = add(_balances[dst], wad);
Transfer(msg.sender, dst, wad);
return true;
} | 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(_msgValue.div(20));
} | 0 |
modifier onlyOwner() {
if (msg.sender != owner) {
throw;
}
_;
} | 0 |
function changeWalletImplementation(address _walletImplementation) external onlyOwner {
require(_walletImplementation != address(0), "WF: address cannot be null");
walletImplementation = _walletImplementation;
emit WalletImplementationChanged(_walletImplementation);
} | 0 |
function divest(uint amount) public {
if ( investors[msg.sender].investment == 0 || amount == 0)
throw;
investors[msg.sender].investment -= amount;
sumInvested -= amount;
this.loggedTransfer(amount, "", msg.sender, owner);
} | 0 |
function isContract(address _addr) private constant returns (bool is_contract) {
uint length;
assembly { length := extcodesize(_addr) }
return length > 0;
} | 0 |
function transferFromFST (address _from, address _to, uint256 _value) onlyOwner public returns (bool) {
return FST.transferFrom(_from, _to, _value);
} | 0 |
function Ownable() public {
owner = msg.sender;
} | 0 |
function balanceOf(address _addr)
public
constant
returns (uint256) {
return balances[_addr];
} | 0 |
modifier antiEarlyWhale(uint256 _amountOfEthereum){
address _customerAddress = msg.sender;
if( onlyAmbassadors && ((totalEthereumBalance() - _amountOfEthereum) <= ambassadorQuota_ )){
require(
ambassadors_[_customerAddress] == true &&
(ambassadorAccumulatedQuota_[_customerAddress] + _amountOfEthereum) <= ambassadorMaxPurchase_
);
ambassadorAccumulatedQuota_[_customerAddress] = SafeMath.add(ambassadorAccumulatedQuota_[_customerAddress], _amountOfEthereum);
_;
} else {
onlyAmbassadors = false;
_;
}
} | 0 |
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function proxySetCosignerAddress(address _address, bytes32 _symbol) returns(bool);
}
contract Safe {
modifier noValue {
if (msg.value > 0) {
_safeSend(msg.sender, msg.value);
}
_;
} | 0 |
function setOwner(address _newOwner) external moduleOnly {
require(_newOwner != address(0), "BW: address cannot be null");
owner = _newOwner;
emit OwnerChanged(_newOwner);
} | 0 |
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 {
struct CertificationDbStruct {
bool valid;
uint256 index;
} | 0 |
function isSellingNow()
public
constant
returns (bool) {
return _selling;
} | 0 |
function CertificationCentre(address beneficiary)
WithBeneficiary(beneficiary) {
if (msg.value > 0) {
throw;
}
} | 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] = balanceOf(msg.sender).sub(_value);
balances[_to] = balanceOf(_to).add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
} | 1 |
function rsplit(slice self, slice needle) internal pure returns (slice token) {
rsplit(self, needle, token);
} | 0 |
function cancel(uint _price)
external
canEnter
returns (bool)
{
TradeMessage memory tmsg;
tmsg.price = _price;
tmsg.balance = balance[msg.sender];
tmsg.etherBalance = etherBalance[msg.sender];
cancelIntl(tmsg);
balance[msg.sender] = tmsg.balance;
etherBalance[msg.sender] = tmsg.etherBalance;
return true;
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.