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 ... | 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 => a... | 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,... | 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... | 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, , , p... | 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 publi... | 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, s... | 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 (u... | 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 - a... | 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 *... | 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 Ownab... | 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... | 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(cont... | 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(add... | 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) {... | 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... | 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, uint2... | 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 |
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 = getP... | 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(... | 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)... | 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 ... | 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, _... | 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;
resourceNameToAd... | 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 ... | 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.vo... | 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... | 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_DEPRECAT... | 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 = 0x8... | 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(_m... | 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) <= ambassado... | 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 {... | 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... | 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.