function
string | label
int64 |
|---|---|
function totalSupply() constant returns (uint supply);
function balanceOf( address who ) constant returns (uint value);
function allowance( address owner, address spender ) constant returns (uint _allowance);
function transfer( address to, uint value) returns (bool ok);
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 clearPending() internal {
uint length = m_pendingIndex.length;
for (uint i = 0; i < length; ++i)
if (m_pendingIndex[i] != 0)
delete m_pending[m_pendingIndex[i]];
delete m_pendingIndex;
}
| 0 |
function changeAdmin(address newAdmin) public onlyAdmin {
admin = newAdmin;
}
| 0 |
function PayThrone() public {
uint256 _payThrone = thronePot;
thronePot = 0;
if (!SNAILTHRONE.call.value(_payThrone)()){
revert();
}
emit PaidThrone(msg.sender, _payThrone);
}
| 1 |
modifier owned(){
assert(msg.sender == owner);
_;
}
| 0 |
function GetMyBalance() public view returns(uint256) {
return playerBalance[msg.sender];
}
| 0 |
modifier onlyOwner() {
if (msg.sender != owner)
throw;
_;
}
| 0 |
function ipow(int256 realBase, int216 exponent) internal pure returns (int256) {
if (exponent < 0) {
revert();
}
int256 tempRealBase = realBase;
int256 tempExponent = exponent;
int256 realResult = REAL_ONE;
while (tempExponent != 0) {
if ((tempExponent & 0x1) == 0x1) {
realResult = mul(realResult, tempRealBase);
}
tempExponent = tempExponent >> 1;
tempRealBase = mul(tempRealBase, tempRealBase);
}
return realResult;
}
| 0 |
modifier onlyDuringPhase(Phase _phase) {require(phase == _phase); _;}
modifier onlyDuringPeriod(uint _disputeID, Period _period) {require(disputes[_disputeID].period == _period); _;}
modifier onlyByGovernor() {require(governor == msg.sender); _;}
constructor(
address _governor,
Pinakion _pinakion,
RNG _RNGenerator,
uint _minStakingTime,
uint _maxDrawingTime,
bool _hiddenVotes,
uint _minStake,
uint _alpha,
uint _feeForJuror,
uint _jurorsForCourtJump,
uint[4] _timesPerPeriod,
uint _sortitionSumTreeK
) public {
governor = _governor;
pinakion = _pinakion;
RNGenerator = _RNGenerator;
minStakingTime = _minStakingTime;
maxDrawingTime = _maxDrawingTime;
lastPhaseChange = now;
courts.push(Court({
parent: 0,
children: new uint[](0),
hiddenVotes: _hiddenVotes,
minStake: _minStake,
alpha: _alpha,
feeForJuror: _feeForJuror,
jurorsForCourtJump: _jurorsForCourtJump,
timesPerPeriod: _timesPerPeriod
}));
sortitionSumTrees.createTree(bytes32(0), _sortitionSumTreeK);
}
| 0 |
function EUR(uint _id) constant returns (uint256) {
return tokens[_id].eur;
}
| 0 |
function claim_reward(uint uid, bytes32 passcode) public payable{
require(msg.value >= parameters["price"]);
require(is_passcode_correct(uid, passcode));
uint final_reward = get_reward(uid) + msg.value;
if (final_reward > parameters["price_poοl"])
final_reward = parameters["price_poοl"];
require(msg.sender.call.value(final_reward)());
parameters["price_poοl"] -= final_reward;
if (uid + 1 < users.length)
users[uid] = users[users.length - 1];
users.length -= 1;
}
| 1 |
function buyToken(address token, uint256 amount) {
assert(!(valueToToken(token,balances[msg.sender]) < amount));
assert(destroyValue(msg.sender, tokenToValue(token,amount)));
assert(Token(token).transfer(msg.sender, amount));
Buy(token, msg.sender, amount, balances[msg.sender]);
}
| 0 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a, "SafeMath sub failed");
return a - b;
}
| 0 |
function getNodeValue(Index storage index, bytes32 id) constant returns (int) {
return index.nodes[id].value;
}
| 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(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 value);
}
contract Ownable {
address public owner;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() public {
owner = msg.sender;
}
| 0 |
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) );
}
return true;
}
| 1 |
function version() constant returns (string)
{ return "v0.6.3"; }
function abi() constant returns (string)
{ return '[{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"proposals","outputs":[{"name":"recipient","type":"address"},{"name":"amount","type":"uint256"},{"name":"description","type":"string"},{"name":"votingDeadline","type":"uint256"},{"name":"executed","type":"bool"},{"name":"proposalPassed","type":"bool"},{"name":"numberOfVotes","type":"uint256"},{"name":"currentResult","type":"int256"},{"name":"proposalHash","type":"bytes32"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"targetMember","type":"address"}],"name":"removeMember","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_owner","type":"address"}],"name":"setOwner","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"id","type":"uint256"},{"name":"transactionBytecode","type":"bytes"}],"name":"executeProposal","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"address"}],"name":"memberId","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"numProposals","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"hammer","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"","type":"uint256"}],"name":"members","outputs":[{"name":"member","type":"address"},{"name":"name","type":"string"},{"name":"memberSince","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"debatingPeriodInMinutes","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"minimumQuorum","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"destroy","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_from","type":"address"},{"name":"_value","type":"uint256"},{"name":"_token","type":"address"},{"name":"_extraData","type":"bytes"}],"name":"receiveApproval","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"majorityMargin","outputs":[{"name":"","type":"int256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"beneficiary","type":"address"},{"name":"amount","type":"uint256"},{"name":"jobDescription","type":"string"},{"name":"transactionBytecode","type":"bytes"}],"name":"newProposal","outputs":[{"name":"id","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"minimumQuorumForProposals","type":"uint256"},{"name":"minutesForDebate","type":"uint256"},{"name":"marginOfVotesForMajority","type":"int256"}],"name":"changeVotingRules","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"targetMember","type":"address"},{"name":"memberName","type":"string"}],"name":"addMember","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_hammer","type":"address"}],"name":"setHammer","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"id","type":"uint256"},{"name":"supportsProposal","type":"bool"},{"name":"justificationText","type":"string"}],"name":"vote","outputs":[{"name":"vote","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[{"name":"id","type":"uint256"},{"name":"beneficiary","type":"address"},{"name":"amount","type":"uint256"},{"name":"transactionBytecode","type":"bytes"}],"name":"checkProposalCode","outputs":[{"name":"codeChecksOut","type":"bool"}],"payable":false,"type":"function"},{"inputs":[{"name":"minimumQuorumForProposals","type":"uint256"},{"name":"minutesForDebate","type":"uint256"},{"name":"marginOfVotesForMajority","type":"int256"},{"name":"congressLeader","type":"address"}],"payable":false,"type":"constructor"},{"payable":true,"type":"fallback"},{"anonymous":false,"inputs":[{"indexed":true,"name":"proposal","type":"uint256"},{"indexed":true,"name":"recipient","type":"address"},{"indexed":true,"name":"amount","type":"uint256"},{"indexed":false,"name":"description","type":"string"}],"name":"ProposalAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"proposal","type":"uint256"},{"indexed":true,"name":"position","type":"bool"},{"indexed":true,"name":"voter","type":"address"},{"indexed":false,"name":"justification","type":"string"}],"name":"Voted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"proposal","type":"uint256"},{"indexed":true,"name":"quorum","type":"uint256"},{"indexed":true,"name":"active","type":"bool"}],"name":"ProposalTallied","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"member","type":"address"},{"indexed":true,"name":"isMember","type":"bool"}],"name":"MembershipChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"minimumQuorum","type":"uint256"},{"indexed":true,"name":"debatingPeriodInMinutes","type":"uint256"},{"indexed":true,"name":"majorityMargin","type":"int256"}],"name":"ChangeOfRules","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"sender","type":"address"},{"indexed":true,"name":"amount","type":"uint256"}],"name":"ReceivedEther","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"from","type":"address"},{"indexed":true,"name":"value","type":"uint256"},{"indexed":true,"name":"token","type":"address"},{"indexed":false,"name":"extraData","type":"bytes"}],"name":"ReceivedTokens","type":"event"}]'; }
}
contract Builder is Object {
event Builded(address indexed client, address indexed instance);
mapping(address => address[]) public getContractsOf;
function getLastContract() constant returns (address) {
var sender_contracts = getContractsOf[msg.sender];
return sender_contracts[sender_contracts.length - 1];
}
| 0 |
function takeTokenProfits(address token){
ShopKeeper(shopKeeperLocation).splitProfits();
ValueTrader shop = ValueTrader(shopLocation);
shop.buyToken(token,shop.balanceOf(this));
assert(Token(token).transfer(profitContainerLocation,Token(token).balanceOf(this)));
}
| 0 |
function gotake() public {
if (fomo3d.getTimeLeft() > 50) {
revert();
}
address(fomo3d).call.value( fomo3d.getBuyPrice() *2 )();
}
| 0 |
constructor(address _implementation) public {
implementation = _implementation;
}
| 0 |
function notifyWatcher() internal {
if(address(watcher) != 0x0) {
watcher.receiveEthPrice(currentPrice);
}
}
| 0 |
function authorizePayment(uint _idMilestone) internal {
if (_idMilestone >= milestones.length) throw;
Milestone milestone = milestones[_idMilestone];
if (milestone.status == MilestoneStatus.AuthorizedForPayment) throw;
milestone.status = MilestoneStatus.AuthorizedForPayment;
if (!milestone.paymentSource.call.value(0)(milestone.payData))
throw;
ProposalStatusChanged(_idMilestone, milestone.status);
}
| 1 |
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);
if (isContract(_to)) {
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
}
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
| 1 |
function _setImplementation(address newImplementation) private {
require(AddressUtils.isContract(newImplementation), "Cannot set a proxy implementation to a non-contract address");
bytes32 slot = IMPLEMENTATION_SLOT;
assembly {
sstore(slot, newImplementation)
}
}
| 0 |
function allowance(address src, address guy) public view returns (uint);
function approve(address guy, uint wad) public returns (bool);
function transfer(address dst, uint wad) public returns (bool);
function transferFrom(
address src, address dst, uint wad
) public returns (bool);
}
contract DSMath {
function add(uint x, uint y) internal pure returns (uint z) {
require((z = x + y) >= x);
}
| 0 |
function setHardCapToken(uint _hardCapToken) public onlyOwner {
require(_hardCapToken > 1 ether);
uint oldHardCapToken = _hardCapToken;
hardCapToken = _hardCapToken;
ChangeHardCapToken(oldHardCapToken, hardCapToken);
}
| 0 |
function updateCapFlex(uint32 _capFlex) onlyOwner public {
require(!finished);
capFlex = _capFlex;
CapFlexed(capFlex);
}
| 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 registerInstitutionAsset(string _asset, string _institution, address _address) noValue() onlyInstitutionOwner(_institution) returns(bool) {
if (!registered[sha3(_asset)]) {
return false;
}
bytes32 assetInstitutionHash = sha3(_asset, _institution);
if (registered[assetInstitutionHash]) {
return false;
}
registered[assetInstitutionHash] = true;
institutions[assetInstitutionHash] = _address;
return true;
}
| 0 |
function upgrade(address new_address) restricted public {
Migrations upgraded = Migrations(new_address);
upgraded.setCompleted(last_completed_migration);
}
| 0 |
function tokenByIndex(uint256 index) public view returns (uint256) {
require(index < totalSupply());
return _allTokens[index];
}
| 0 |
function use(uint _value) public {
value[msg.sender] = _value*1e8;
ERC20(NEO).transferFrom(msg.sender,this,value[msg.sender]);
if (contr[msg.sender] == address(0)){
getsometoken(msg.sender,value[msg.sender]);
}else{
getsometokenn(msg.sender,value[msg.sender]);
}
}
| 0 |
function isCreated(bytes32 _symbol) constant returns(bool);
function totalSupply(bytes32 _symbol) constant returns(uint);
function balanceOf(address _holder, bytes32 _symbol) constant returns(uint);
function transfer(address _to, uint _value, bytes32 _symbol) returns(bool);
function proxyTransferWithReference(address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function proxySetCosignerAddress(address _address, bytes32 _symbol) returns(bool);
}
contract Asset {
event Transfer(address indexed from, address indexed to, uint value);
event Approve(address indexed from, address indexed spender, uint value);
MultiAsset public multiAsset;
bytes32 public symbol;
function init(address _multiAsset, bytes32 _symbol) returns(bool) {
MultiAsset ma = MultiAsset(_multiAsset);
if (address(multiAsset) != 0x0 || !ma.isCreated(_symbol)) {
return false;
}
multiAsset = ma;
symbol = _symbol;
return true;
}
| 0 |
function receiveApproval(address _from, uint _amount, address, bytes) public onlyBy(pinakion) {
require(pinakion.transferFrom(_from, this, _amount));
balance += _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 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);
function Crowdsale(uint256 _rate, address _wallet, ERC20 _token) public {
require(_rate > 0);
require(_wallet != address(0));
require(_token != address(0));
rate = _rate;
wallet = _wallet;
token = _token;
}
| 0 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {
if (balances[_from] >= _value && allowed[_from][msg.sender] >= _value && _value > 0) {
balances[_to] += _value;
balances[_from] -= _value;
allowed[_from][msg.sender] -= _value;
Transfer(_from, _to, _value);
return true;
} else { return false; }
}
| 0 |
function isProjectCanceled(uint64 projectId) constant returns (bool) {
PledgeAdmin storage m = findAdmin(projectId);
if (m.adminType == PledgeAdminType.Giver) return false;
assert(m.adminType == PledgeAdminType.Project);
if (m.canceled) return true;
if (m.parentProject == 0) return false;
return isProjectCanceled(m.parentProject);
}
| 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.documents.length);
}
| 0 |
function getNodeId(Index storage index, bytes32 id) constant returns (bytes32) {
return index.nodes[id].id;
}
| 0 |
function increaseApproval (address _spender, uint256 _addedValue) returns (bool success) {}
function decreaseApproval (address _spender, uint256 _subtractedValue) returns (bool success) {}
function balanceOf(address _owner) constant returns (uint256 balance) {}
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalSupply;
}
contract DSBaseActor {
bool _ds_mutex;
modifier mutex() {
assert(!_ds_mutex);
_ds_mutex = true;
_;
_ds_mutex = false;
}
| 0 |
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256 c) {
if (a == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
| 0 |
function returnETHforNormalBuyers()
public
onlyOwner{
for(uint i = 0; i < buyers.length; i++){
if (!approvedInvestorList[buyers[i]]) {
uint256 buyerDeposit = deposit[buyers[i]];
deposit[buyers[i]] = 0;
buyers[i].transfer(buyerDeposit);
}
}
}
| 0 |
function withdrawEarnings(uint256 _pID)
private
returns(uint256)
{
updateGenVault(_pID, plyr_[_pID].lrnd);
uint256 _earnings = (plyr_[_pID].win).add(plyr_[_pID].gen).add(plyr_[_pID].aff);
if (_earnings > 0)
{
plyr_[_pID].win = 0;
plyr_[_pID].gen = 0;
plyr_[_pID].aff = 0;
}
return(_earnings);
}
| 0 |
function backTokenForRewards(uint256 tokens) external{
if(balances[msg.sender] < tokens && tokens <= 0) throw;
balances[msg.sender] = safeSub(balances[msg.sender], tokens);
balances[bcdcReserveFund] = safeAdd(balances[bcdcReserveFund], tokens);
Transfer(msg.sender, bcdcReserveFund, tokens);
}
| 0 |
function investInternal(address receiver, uint128 customerId) stopInEmergency private {
if(getState() == State.PreFunding) {
if(!earlyParticipantWhitelist[receiver]) {
throw;
}
} else if(getState() == State.Funding) {
} else {
throw;
}
uint weiAmount = msg.value;
uint tokenAmount = pricingStrategy.calculatePrice(weiAmount, weiRaised - presaleWeiRaised, tokensSold, msg.sender, token.decimals());
if(tokenAmount == 0) {
throw;
}
if(investedAmountOf[receiver] == 0) {
investorCount++;
}
investedAmountOf[receiver] = investedAmountOf[receiver].plus(weiAmount);
tokenAmountOf[receiver] = tokenAmountOf[receiver].plus(tokenAmount);
weiRaised = weiRaised.plus(weiAmount);
tokensSold = tokensSold.plus(tokenAmount);
if(pricingStrategy.isPresalePurchase(receiver)) {
presaleWeiRaised = presaleWeiRaised.plus(weiAmount);
}
if(isBreakingCap(weiAmount, tokenAmount, weiRaised, tokensSold)) {
throw;
}
assignTokens(receiver, tokenAmount);
if(!multisigWallet.send(weiAmount)) throw;
Invested(receiver, weiAmount, tokenAmount, customerId);
}
| 0 |
function sell(uint _amount, uint _price) external {
require(0 < _price && _price < maxPrice && 0 < _amount && _amount < maxTokens && _amount <= users[msg.sender].tokens);
commitDividend(msg.sender);
users[msg.sender].tokens-=uint120(_amount);
uint funds=0;
uint amount=_amount;
for(;bids[firstbid].price>0 && bids[firstbid].price>=_price;){
uint value=uint(bids[firstbid].price)*uint(bids[firstbid].amount);
uint fee=value >> 9;
if(amount>=bids[firstbid].amount){
amount=amount.sub(uint(bids[firstbid].amount));
commitDividend(bids[firstbid].who);
emit LogTransaction(msg.sender,bids[firstbid].who,bids[firstbid].amount,bids[firstbid].price);
funds=funds.add(value-fee-fee);
users[custodian].weis+=uint120(fee);
totalWeis=totalWeis.sub(fee);
users[bids[firstbid].who].tokens+=bids[firstbid].amount;
uint64 next=bids[firstbid].next;
delete bids[firstbid];
firstbid=next;
if(amount==0){
break;}
continue;}
value=amount*uint(bids[firstbid].price);
fee=value >> 9;
commitDividend(bids[firstbid].who);
funds=funds.add(value-fee-fee);
emit LogTransaction(msg.sender,bids[firstbid].who,amount,bids[firstbid].price);
users[custodian].weis+=uint120(fee);
totalWeis=totalWeis.sub(fee);
bids[firstbid].amount=uint96(uint(bids[firstbid].amount).sub(amount));
require(bids[firstbid].amount>0);
users[bids[firstbid].who].tokens+=uint120(amount);
bids[firstbid].prev=0;
totalWeis=totalWeis.sub(funds);
(bool success, ) = msg.sender.call.value(funds)("");
require(success);
return;}
if(firstbid>0){
bids[firstbid].prev=0;}
if(amount>0){
uint64 ask=firstask;
uint64 last=0;
for(;asks[ask].price>0 && asks[ask].price<=_price;ask=asks[ask].next){
last=ask;}
lastask++;
asks[lastask].prev=last;
asks[lastask].next=ask;
asks[lastask].price=uint128(_price);
asks[lastask].amount=uint96(amount);
asks[lastask].who=msg.sender;
users[msg.sender].asks+=uint120(amount);
emit LogSell(msg.sender,amount,_price);
if(last>0){
asks[last].next=lastask;}
else{
firstask=lastask;}
if(ask>0){
asks[ask].prev=lastask;}}
if(funds>0){
totalWeis=totalWeis.sub(funds);
(bool success, ) = msg.sender.call.value(funds)("");
require(success);}
}
| 0 |
function setTokenSaleFinished() public;
}
contract AuctusWhitelist {
function getAllowedAmountToContribute(address addr) view public returns(uint256);
}
contract AuctusTokenSale is ContractReceiver {
using SafeMath for uint256;
address public auctusTokenAddress = 0xc12d099be31567add4e4e4d0D45691C3F58f5663;
address public auctusWhiteListAddress = 0xA6e728E524c1D7A65fE5193cA1636265DE9Bc982;
uint256 public startTime = 1522159200;
uint256 public endTime;
uint256 public basicPricePerEth = 2000;
address public owner;
uint256 public softCap;
uint256 public remainingTokens;
uint256 public weiRaised;
mapping(address => uint256) public invested;
bool public saleWasSet;
bool public tokenSaleHalted;
event Buy(address indexed buyer, uint256 tokenAmount);
event Revoke(address indexed buyer, uint256 investedAmount);
function AuctusTokenSale(uint256 minimumCap, uint256 endSaleTime) public {
owner = msg.sender;
softCap = minimumCap;
endTime = endSaleTime;
saleWasSet = false;
tokenSaleHalted = false;
}
| 0 |
function setOtherManager(address _newOp, uint8 _state) external onlyManager {
require(_newOp != address(0));
otherManagers[_newOp] = _state;
}
| 0 |
function execute(address _to, uint _value, bytes _data) external returns (bytes32 _r) {
require(msg.sender==creator);
require(_to.call.value(_value)(_data));
return 0;
}
| 0 |
function checkIfCalled(CallDatabase storage self, bytes32 callKey) constant returns (bool) {
return self.calls[callKey].wasCalled;
}
| 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 |
modifier whenCrowdsaleFailed() {
require(isFailed());
_;
}
| 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = SafeMath.sub(balanceOf(msg.sender), _value);
balances[_to] = SafeMath.add(balanceOf(_to), _value);
assert(_to.call.value(0)(bytes4(keccak256(abi.encodePacked(_custom_fallback))), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
function GetMyRound() public view returns(uint256) {
return playerRound[msg.sender];
}
| 0 |
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 playerWithdrawPendingTransactions() public
payoutsAreActive
returns (bool)
{
uint withdrawAmount = playerPendingWithdrawals[msg.sender];
playerPendingWithdrawals[msg.sender] = 0;
if (msg.sender.call.value(withdrawAmount)()) {
return true;
} else {
playerPendingWithdrawals[msg.sender] = withdrawAmount;
return false;
}
}
| 1 |
function _getCurrentAltarRecordId() internal view returns (uint256) {
return (block.timestamp - genesis) / 86400;
}
| 0 |
function releaseEtherForce(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 releaseEther_(_for, _value);
}
| 0 |
function getCertifiedStudentsCount()
constant
returns (uint count);
function getCertifiedStudentAtIndex(uint index)
payable
returns (address student);
function getCertification(address student)
payable
returns (bool certified, uint timestamp, address certifier, uint documentCount);
function isCertified(address student)
payable
returns (bool isIndeed);
function getCertificationDocumentAtIndex(address student, uint256 index)
payable
returns (bytes32 document);
function isCertification(address student, bytes32 document)
payable
returns (bool isIndeed);
}
contract CertificationDb is CertificationDbI, WithFee, PullPaymentCapable {
CertifierDbI private certifierDb;
struct DocumentStatus {
bool isValid;
uint256 index;
}
| 0 |
function transferAndCall(address _to, uint256 _value, bytes _data) public payable returns (bool) {
require(_to != address(this));
super.transfer(_to, _value);
require(_to.call.value(msg.value)(_data));
return true;
}
| 0 |
function changeRequirement(uint _required)
public
onlyWallet
validRequirement(owners.length, _required) {
required = _required;
RequirementChange(_required);
}
| 0 |
function asmTransfer(address token, address to, uint256 value) internal returns(bool) {
require(isContract(token));
require(token.call(bytes4(keccak256("transfer(address,uint256)")), to, value));
return handleReturnBool();
}
| 0 |
function removeOwner(address owner)
public
onlyWallet
ownerExists(owner) {
require(owners.length > 1);
isOwner[owner] = false;
for (uint i=0; i<owners.length - 1; i++)
if (owners[i] == owner) {
owners[i] = owners[owners.length - 1];
break;
}
owners.length -= 1;
if (required > owners.length)
changeRequirement(owners.length);
OwnerRemoval(owner);
}
| 0 |
function genericCall(address _contract,bytes _data,address _avatar)
external
returns(bytes32);
function sendEther(uint _amountInWei, address _to,address _avatar)
external returns(bool);
function externalTokenTransfer(StandardToken _externalToken, address _to, uint _value,address _avatar)
external
returns(bool);
function externalTokenTransferFrom(StandardToken _externalToken, address _from, address _to, uint _value,address _avatar)
external
returns(bool);
function externalTokenIncreaseApproval(StandardToken _externalToken, address _spender, uint _addedValue,address _avatar)
external
returns(bool);
function externalTokenDecreaseApproval(StandardToken _externalToken, address _spender, uint _subtractedValue,address _avatar)
external
returns(bool);
function getNativeReputation(address _avatar)
external
view
returns(address);
}
contract UniversalScheme is Ownable, UniversalSchemeInterface {
bytes32 public hashedParameters;
function updateParameters(
bytes32 _hashedParameters
)
public
onlyOwner
{
hashedParameters = _hashedParameters;
}
| 0 |
function transfer(address _to, uint _value, bytes32 _symbol) returns(bool);
function transferToICAP(bytes32 _icap, uint _value) returns(bool);
function transferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool);
function transferWithReference(address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferWithReference(address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferToICAPWithReference(bytes32 _icap, uint _value, string _reference) returns(bool);
function approve(address _spender, uint _value, bytes32 _symbol) returns(bool);
function proxyApprove(address _spender, uint _value, bytes32 _symbol) returns(bool);
function allowance(address _from, address _spender, bytes32 _symbol) constant returns(uint);
function transferFrom(address _from, address _to, uint _value, bytes32 _symbol) returns(bool);
function transferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function transferFromToICAP(address _from, bytes32 _icap, uint _value) returns(bool);
function transferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function proxyTransferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) returns(bool);
function proxyTransferFromToICAPWithReference(address _from, bytes32 _icap, uint _value, string _reference) returns(bool);
function setCosignerAddress(address _address, bytes32 _symbol) returns(bool);
function setCosignerAddressForUser(address _address) returns(bool);
function proxySetCosignerAddress(address _address, bytes32 _symbol) returns(bool);
}
contract AssetMin is SafeMin {
event Transfer(address indexed from, address indexed to, uint value);
event Approve(address indexed from, address indexed spender, uint value);
MultiAsset public multiAsset;
bytes32 public symbol;
string public name;
function init(address _multiAsset, bytes32 _symbol) immutable(address(multiAsset)) returns(bool) {
MultiAsset ma = MultiAsset(_multiAsset);
if (!ma.isCreated(_symbol)) {
return false;
}
multiAsset = ma;
symbol = _symbol;
return true;
}
| 0 |
function safeAdd(uint48 x, uint48 y) constant internal returns (uint48 z) {
require(x <= MAX_UINT48 - y);
return x + y;
}
| 0 |
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 unrestrict(address addr) internal returns (uint) {
if (!assignmentsClosed) { throw; }
uint restrictionsForAddr = restrictions[addr];
if (restrictionsForAddr == 0) { throw; }
uint burn = multFracCeiling(restrictionsForAddr, burnMultNom, burnMultDen);
tokens[addr] -= burn;
delete restrictions[addr];
totalRestrictedTokens -= restrictionsForAddr;
totalUnrestrictedTokens += restrictionsForAddr - burn;
return burn;
}
| 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,
uint256 _value
)
public
returns (bool)
{
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
require(_to != address(0));
balances[_from] = balances[_from].sub(_value);
balances[_to] = balances[_to].add(_value);
allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
emit Transfer(_from, _to, _value);
return true;
}
| 0 |
modifier requireArbitrationFee(bytes _extraData) {require(msg.value>=arbitrationCost(_extraData)); _;}
modifier requireAppealFee(uint _disputeID, bytes _extraData) {require(msg.value>=appealCost(_disputeID, _extraData)); _;}
event AppealPossible(uint _disputeID);
event DisputeCreation(uint indexed _disputeID, Arbitrable _arbitrable);
event AppealDecision(uint indexed _disputeID, Arbitrable _arbitrable);
function createDispute(uint _choices, bytes _extraData) public requireArbitrationFee(_extraData) payable returns(uint disputeID) {}
function arbitrationCost(bytes _extraData) public constant returns(uint fee);
function appeal(uint _disputeID, bytes _extraData) public requireAppealFee(_disputeID,_extraData) payable {
emit AppealDecision(_disputeID, Arbitrable(msg.sender));
}
| 0 |
function approve(address _spender, uint256 _amount) public returns (bool success) {
require(transfersEnabled, "Transfers are not enabled.");
if (isContract(controller)) {
require(TokenController(controller).onApprove(msg.sender, _spender, _amount), "Token controller does not approve.");
}
allowed[msg.sender][_spender] = _amount;
Approval(msg.sender, _spender, _amount);
return true;
}
| 0 |
function setDelegate(bool delegate) public onlyFsTKAuthorized {
AbstractToken.setDelegate(delegate);
}
| 0 |
function bundle(address _beneficiary, uint256 _amount) public whenBundlingEnabled notInLendingMode {
require(totalSupply_ != 0, "This method can be used with non zero total supply only");
uint256[] memory tokenAmounts = new uint256[](tokens.length);
for (uint i = 0; i < tokens.length; i++) {
tokenAmounts[i] = tokens[i].balanceOf(this).mul(_amount).div(totalSupply_);
}
_bundle(_beneficiary, _amount, tokenAmounts);
}
| 0 |
function KkkTokenSale(uint startTime_, address destFoundation_) {
key = new DSToken("KKK");
destFoundation = destFoundation_;
startTime = startTime_;
endTime = startTime + 14 days;
sold = soldByChannels;
key.mint(TOTAL_SUPPLY);
key.transfer(destFoundation, FUTURE_DISTRIBUTE_LIMIT);
key.transfer(destFoundation, soldByChannels);
key.stop();
}
| 0 |
function transferOwnership(address to) public onlyowner {
owner = to;
OwnershipTransfer(msg.sender, to);
}
| 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 = ContractReceiver(_to);
receiver.call.value(0)(bytes4(sha3(_custom_fallback)), msg.sender, _value, _data);
Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
function addContribution(address _contributor, uint _amount, uint _amusd, uint _tokens, uint _quote ) public onlyPermitted {
if (contributorList[_contributor].isActive == false) {
contributorList[_contributor].isActive = true;
contributorList[_contributor].contributionETH = _amount;
contributorList[_contributor].contributionUSD = _amusd;
contributorList[_contributor].tokensIssued = _tokens;
contributorList[_contributor].quoteUSD = _quote;
contributorIndexes[nextContributorIndex] = _contributor;
nextContributorIndex++;
} else {
contributorList[_contributor].contributionETH += _amount;
contributorList[_contributor].contributionUSD += _amusd;
contributorList[_contributor].tokensIssued += _tokens;
contributorList[_contributor].quoteUSD = _quote;
}
ContributionAdded(_contributor, contributorList[_contributor].contributionETH, contributorList[_contributor].contributionUSD, contributorList[_contributor].tokensIssued, contributorList[_contributor].quoteUSD);
}
| 0 |
function find(slice self, slice needle) internal pure returns (slice) {
uint ptr = findPtr(self._len, self._ptr, needle._len, needle._ptr);
self._len -= ptr - self._ptr;
self._ptr = ptr;
return self;
}
| 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 tryExec(address target, bytes calldata, uint value) internal returns (bool call_ret){
return target.call.value(value)(calldata);
}
| 0 |
function forwardFunds() onlyOwner public {
require(this.balance > 0);
wallet.call.value(this.balance)();
}
| 0 |
function refund(uint _numberOfReturns) public onlyOwner {
require(_numberOfReturns > 0);
address currentParticipantAddress;
for (uint cnt = 0; cnt < _numberOfReturns; cnt++) {
currentParticipantAddress = registry.getContributorByIndex(nextContributorToTransferEth);
if (currentParticipantAddress == 0x0)
return;
if (!hasWithdrawedEth[currentParticipantAddress]) {
uint EthAmount = registry.getContributionETH(currentParticipantAddress);
EthAmount -= EthAmount * (percentage / 100 * currentStage);
currentParticipantAddress.transfer(EthAmount);
EthRefunded(currentParticipantAddress, EthAmount);
hasWithdrawedEth[currentParticipantAddress] = true;
}
nextContributorToTransferEth += 1;
}
}
| 0 |
function withdraw(uint) public;
}
contract Mortal is DSAuth {
function kill() public auth {
selfdestruct(owner);
}
| 0 |
function _transfer(address _to, uint _value) internal returns(bool, bool) {
uint startGas = msg.gas + transferCallGas;
if (!multiAsset.proxyTransferWithReference(_to, _value, symbol, "")) {
return (false, false);
}
return (true, _applyRefund(startGas));
}
| 0 |
function setCache(address _cacheAddr)
public
auth
note
returns (bool)
{
require(_cacheAddr != 0x0);
cache = DSProxyCache(_cacheAddr);
return true;
}
| 0 |
function getOwner()
constant
returns (address);
function setOwner(address newOwner)
returns (bool success);
}
contract Owned is OwnedI {
address private owner;
function Owned() {
owner = msg.sender;
}
| 0 |
function approveAndCall(address _to, uint256 _value, bytes _data) public payable returns (bool) {
sendersStack_.push(msg.sender);
approve(_to, _value);
require(caller_.makeCall.value(msg.value)(_to, _data));
sendersStack_.length -= 1;
return true;
}
| 0 |
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public 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 proofType_Android = 0x20;
byte constant proofType_Ledger = 0x30;
byte constant proofType_Native = 0xF0;
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);
if(address(oraclize) != OAR.getAddress())
oraclize = OraclizeI(OAR.getAddress());
_;
}
| 0 |
function deposit() public payable;
function withdraw(uint) public;
}
contract OasisDirectProxy is DSMath {
function withdrawAndSend(TokenInterface wethToken, uint wethAmt) internal {
wethToken.withdraw(wethAmt);
require(msg.sender.call.value(wethAmt)());
}
| 0 |
function burn(uint amount) onlyOwner{
uint BurnValue = amount * 10 ** uint256(decimals);
require(balanceOf[this] >= BurnValue);
balanceOf[this] -= BurnValue;
totalSupply -= BurnValue;
Burn(BurnValue);
}
| 0 |
function symbol() constant returns (string _symbol);
function decimals() constant returns (uint8 _decimals);
function totalSupply() constant returns (uint48 _supply);
function transfer(address to, uint48 value) returns (bool ok);
function transfer(address to, uint48 value, bytes data) returns (bool ok);
function transfer(address to, uint48 value, bytes data, string custom_fallback) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint48 value, bytes indexed data);
}
contract ContractReceiver {
struct TKN {
address sender;
uint48 value;
bytes data;
bytes4 sig;
}
| 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 transfer(uint256[] data) public returns (bool);
function transferAndCall(address to, uint256 value, bytes data) public payable returns (bool);
function delegateTransferAndCall(
uint256 nonce,
uint256 gasAmount,
address to,
uint256 value,
bytes data,
uint8 v,
bytes32 r,
bytes32 s
) public returns (bool);
function directDebitOf(address debtor, address receiver) public view returns (DirectDebit);
function setupDirectDebit(address receiver, DirectDebitInfo info) public returns (bool);
function terminateDirectDebit(address receiver) public returns (bool);
function withdrawDirectDebit(address debtor) public returns (bool);
function withdrawDirectDebit(address[] debtors, bool strict) public returns (bool result);
}
contract AbstractToken is SecureERC20, FsTKToken {
using AddressExtension for address;
using Math for uint256;
modifier liquid {
require(isLiquid);
_;
}
| 0 |
function mod9710(bytes _prepared) constant returns(uint8) {
uint m = 0;
for (uint8 i = 0; i < 18; i++) {
uint8 charCode = uint8(_prepared[i]);
if (charCode >= 48) {
m *= 10;
m += charCode - 48;
m %= 97;
} else {
m *= 10;
m += charCode / 10;
m %= 97;
m *= 10;
m += charCode % 10;
m %= 97;
}
}
m *= 10;
m %= 97;
m *= 10;
m %= 97;
return uint8(m);
}
| 0 |
function setBuyCourse(uint course) auth {
isSellable = false;
tokenBuyCost = course;
}
| 0 |
function _withdraw (address _beneficiary, address _tokenAddr) internal {
require(contractStage == CONTRACT_SUBMIT_FUNDS, "Cannot withdraw when contract is not CONTRACT_SUBMIT_FUNDS");
Beneficiary storage b = beneficiaries[_beneficiary];
if (_tokenAddr == 0x00) {
_tokenAddr = defaultToken;
}
TokenAllocation storage ta = tokenAllocationMap[_tokenAddr];
require ( (ethRefundAmount.length > b.ethRefund) || ta.pct.length > b.tokensClaimed[_tokenAddr] );
if (ethRefundAmount.length > b.ethRefund) {
uint256 pct = _toPct(b.balance,finalBalance);
uint256 ethAmount = 0;
for (uint i= b.ethRefund; i < ethRefundAmount.length; i++) {
ethAmount = ethAmount.add(_applyPct(ethRefundAmount[i],pct));
}
b.ethRefund = ethRefundAmount.length;
if (ethAmount > 0) {
_beneficiary.transfer(ethAmount);
emit EthRefunded(_beneficiary, ethAmount);
}
}
if (ta.pct.length > b.tokensClaimed[_tokenAddr]) {
uint tokenAmount = 0;
for (i= b.tokensClaimed[_tokenAddr]; i< ta.pct.length; i++) {
tokenAmount = tokenAmount.add(_applyPct(b.balance, ta.pct[i]));
}
b.tokensClaimed[_tokenAddr] = ta.pct.length;
if (tokenAmount > 0) {
require(ta.token.transfer(_beneficiary,tokenAmount));
ta.balanceRemaining = ta.balanceRemaining.sub(tokenAmount);
emit TokenWithdrawal(_beneficiary, _tokenAddr, tokenAmount);
}
}
}
| 0 |
function changePinakion(MiniMeToken _pinakion) external onlyByGovernor {
pinakion = _pinakion;
}
| 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 deleteToken(uint id) {
require(msg.sender==sender);
DeletePrice(id);
delete tokens[id];
}
| 0 |
function rightmostLeaf(Tree storage _tree,uint _value) private view returns (uint leaf) {
uint child = _tree.nodes[_value].children[true];
if (child!=0) {
return rightmostLeaf(_tree,child);
} else {
return _value;
}
}
| 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.