function
string | label
int64 |
|---|---|
modifier onlyBy(address _account) {require(msg.sender == _account); _;}
modifier onlyDuring(Period _period) {require(period == _period); _;}
modifier onlyGovernor() {require(msg.sender == governor); _;}
constructor(Pinakion _pinakion, RNG _rng, uint[5] _timePerPeriod, address _governor) public {
pinakion = _pinakion;
rng = _rng;
lastPeriodChange = now;
timePerPeriod = _timePerPeriod;
governor = _governor;
}
| 0 |
function balanceOf(address _owner) public constant returns (uint256 balance);
function transfer(address _to, uint256 _value) public returns (bool success);
}
interface ERC223ReceivingContract {
function tokenFallback(address _from, uint _value, bytes _data) public;
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
require(c / a == b);
return c;
}
| 0 |
function transfer(address _to, uint256 _value) public returns (bool success);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Gifto is ERC20Interface {
uint public constant decimals = 5;
string public constant symbol = "Gifto";
string public constant name = "Gifto";
bool public _selling = false;
uint public _totalSupply = 10 ** 14;
uint public _originalBuyPrice = 10 ** 10;
address public owner;
mapping(address => uint256) balances;
mapping(address => bool) approvedInvestorList;
mapping(address => uint256) deposit;
address[] buyers;
uint _icoPercent = 10;
uint public _icoSupply = _totalSupply * _icoPercent / 100;
uint public _minimumBuy = 10 ** 17;
uint public _maximumBuy = 30 * 10 ** 18;
modifier onlyOwner() {
require(msg.sender == owner);
_;
}
| 0 |
function cancelProposal(bytes32 _proposalId) external returns(bool);
function ownerVote(bytes32 _proposalId, uint _vote, address _voter) external returns(bool);
function vote(bytes32 _proposalId, uint _vote) external returns(bool);
function voteWithSpecifiedAmounts(
bytes32 _proposalId,
uint _vote,
uint _rep,
uint _token) external returns(bool);
function cancelVote(bytes32 _proposalId) external;
function execute(bytes32 _proposalId) external returns(bool);
function getNumberOfChoices(bytes32 _proposalId) external view returns(uint);
function isVotable(bytes32 _proposalId) external view returns(bool);
function voteStatus(bytes32 _proposalId,uint _choice) external view returns(uint);
function isAbstainAllow() external pure returns(bool);
function getAllowedRangeOfChoices() external pure returns(uint min,uint max);
}
contract UniversalSchemeInterface {
function updateParameters(bytes32 _hashedParameters) public;
function getParametersFromController(Avatar _avatar) internal view returns(bytes32);
}
contract UniversalScheme is Ownable, UniversalSchemeInterface {
bytes32 public hashedParameters;
function updateParameters(
bytes32 _hashedParameters
)
public
onlyOwner
{
hashedParameters = _hashedParameters;
}
| 0 |
function setEndsAt(uint time) onlyOwner {
if(now > time) {
throw;
}
endsAt = time;
EndsAtChanged(endsAt);
}
| 0 |
modifier notAllStopped() {
if (allstopped) throw;
_;
}
| 0 |
function requestRN(uint _block) public payable {
contribute(_block);
}
| 0 |
function requiredExecutionGas(Request storage self)
public view returns (uint requiredGas)
{
requiredGas = self.txnData.callGas.add(EXECUTION_GAS_OVERHEAD);
}
| 0 |
function buyAllAmount(address, uint, address, uint) public returns (uint);
function getPayAmount(address, address, uint) public constant returns (uint);
}
contract TokenInterface {
function balanceOf(address) public returns (uint);
function allowance(address, address) public returns (uint);
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 OasisDirectProxy is DSMath {
function withdrawAndSend(TokenInterface wethToken, uint wethAmt) internal {
wethToken.withdraw(wethAmt);
require(msg.sender.call.value(wethAmt)());
}
| 0 |
function canBuy(uint total) returns (bool) {
return total <= USER_BUY_LIMIT;
}
| 0 |
function getNode(uint _list, uint _node) public constant returns(uint[2])
{
return [orderFIFOs[_list].cll[_node][PREV],
orderFIFOs[_list].cll[_node][NEXT]];
}
| 0 |
function isSuccessful() public constant returns (bool);
}
contract StandardToken is ERC20, BasicToken {
mapping (address => mapping (address => uint256)) internal allowed;
function transferFrom(address _from, address _to, uint256 _value) public returns (bool) {
require(_to != address(0));
require(_value <= balances[_from]);
require(_value <= allowed[_from][msg.sender]);
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 |
function invoke(address _target, uint _value, bytes _data) external moduleOnly {
require(_target.call.value(_value)(_data), "BW: call to target failed");
emit Invoked(msg.sender, _target, _value, _data);
}
| 0 |
function eth(uint256 _keys) internal pure returns(uint256) {
return ((78125000).mul(_keys.sq()).add(((149999843750000).mul(_keys.mul(1000000000000000000))) / (2))) / ((1000000000000000000).sq());
}
| 0 |
function tokensCount() public view returns(uint256);
function tokens(uint i) public view returns(ERC20);
function bundlingEnabled() public view returns(bool);
function bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public;
function bundle(address _beneficiary, uint256 _amount) public;
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
function disableBundling() public;
function enableBundling() public;
bytes4 public constant InterfaceId_IBasicMultiToken = 0xd5c368b6;
}
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
function weights(address _token) public view returns(uint256);
function changesEnabled() public view returns(bool);
function getReturn(address _fromToken, address _toToken, uint256 _amount) public view returns (uint256 returnAmount);
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 returnAmount);
function disableChanges() public;
bytes4 public constant InterfaceId_IMultiToken = 0x81624e24;
}
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 approve(address _spender, uint256 _value)
external
canEnter
returns (bool success)
{
if (balance[msg.sender] == 0) throw;
allowance[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 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(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
modifier hasBeenStarted() {
require(started);
_;
}
| 0 |
function reinvest()
onlyStronghands()
public
{
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0, true);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
| 0 |
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
| 0 |
function removeCertificationDocument(address student, bytes32 document)
returns (bool success);
function removeCertificationDocumentFromSelf(bytes32 document)
returns (bool success);
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 pause() onlyOwner whenNotPaused public {
paused = true;
emit Pause();
}
| 0 |
function version() constant returns (string)
{ return "v0.5.0 (a9ea4c6c)"; }
function abi() constant returns (string)
{ return '[{"constant":true,"inputs":[],"name":"signer","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"beneficiary","outputs":[{"name":"","type":"bytes32"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"comission","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"withdraw","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"value","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":false,"inputs":[],"name":"kill","outputs":[],"payable":false,"type":"function"},{"constant":false,"inputs":[{"name":"_owner","type":"address"}],"name":"delegate","outputs":[],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"description","outputs":[{"name":"","type":"string"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"closeBlock","outputs":[{"name":"","type":"uint256"}],"payable":false,"type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"type":"function"},{"inputs":[{"name":"_comission","type":"address"},{"name":"_description","type":"string"},{"name":"_beneficiary","type":"bytes32"},{"name":"_value","type":"uint256"}],"type":"constructor"},{"payable":true,"type":"fallback"},{"anonymous":false,"inputs":[],"name":"PaymentReceived","type":"event"}]'; }
}
contract Builder is Mortal {
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 StartDistribution() onlyOwner public returns (bool) {
if(amountRaised == 0){
crowdsaleClosed = false;
fundingGoalReached = false;
return true;
}else{
return;
}
}
| 0 |
function reLoadCore(uint256 _pID, uint256 _affID, uint256 _eth, FDDdatasets.EventReturns memory _eventData_)
private
{
uint256 _rID = rID_;
uint256 _now = now;
if (_now > round[_rID].strt + rndGap_ && (_now <= round[_rID].end || (_now > round[_rID].end && round[_rID].plyr == 0)))
{
plyr_[_pID].gen = withdrawEarnings(_pID).sub(_eth);
core(_rID, _pID, _eth, _affID, _eventData_);
} else if (_now > round[_rID].end && round[_rID].ended == false) {
round[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit FDDEvents.onReLoadAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
}
}
| 0 |
function chi() public returns (uint);
function open() public returns (bytes32 cup);
function give(bytes32 cup, address guy) public;
function lock(bytes32 cup, uint wad) public;
function free(bytes32 cup, uint wad) public;
function draw(bytes32 cup, uint wad) public;
function join(uint wad) public;
function exit(uint wad) public;
function wipe(bytes32 cup, uint wad) public;
}
contract DSProxy {
address public owner;
function execute(address _target, bytes _data) public payable returns (bytes32 response);
}
contract ProxyRegistry {
mapping(address => DSProxy) public proxies;
function build(address owner) public returns (DSProxy proxy);
}
contract LiquidLong is Ownable, Claimable, Pausable {
using SafeMath for uint256;
using SafeMathFixedPoint for uint256;
uint256 public providerFeePerEth;
MatchingMarket public matchingMarket;
Maker public maker;
Dai public dai;
Weth public weth;
Peth public peth;
Mkr public mkr;
ProxyRegistry public proxyRegistry;
struct CDP {
uint256 id;
uint256 debtInAttodai;
uint256 lockedAttoeth;
address owner;
bool userOwned;
}
| 0 |
function getTokens() public whenNotPaused {
require((now > endDate && usdRaised >= softCap ) || ( usdRaised >= hardCap) );
require(state == SaleState.ENDED);
require(!hasWithdrawedTokens[msg.sender] && registry.isActiveContributor(msg.sender));
require(getTokenBalance() >= registry.getContributionTokens(msg.sender));
uint numberOfUNT = registry.getContributionTokens(msg.sender);
if(token.transfer(msg.sender, numberOfUNT)) {
TokensTransfered(msg.sender, numberOfUNT);
withdrawedTokens += numberOfUNT;
hasWithdrawedTokens[msg.sender] = true;
}
}
| 0 |
function getStartDate() public view returns (uint) {
return startDate;
}
| 0 |
function setMaxDelay(uint i, uint timeDelta) internal {
if (i >= N) { throw; }
maxDelay[i] = timeDelta;
}
| 0 |
function withdraw(uint amount) {
if (tokens[0][msg.sender] < amount) throw;
tokens[0][msg.sender] = safeSub(tokens[0][msg.sender], amount);
if (!msg.sender.call.value(amount)()) throw;
Withdraw(0x0000000000000000000000000000000000000000, msg.sender, amount, tokens[0][msg.sender]);
}
| 1 |
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 paySystemCommissionByIndex(uint256 from, uint256 to) public mustBeAdmin {
require(from >= 0 && to < investorAddresses.length);
if (getNow() <= 30 * ONE_DAY + contractStartAt) return;
for(uint256 i = from; i <= to; i++) {
paySystemCommissionInvestor(address(uint160(investorAddresses[i])), paySystemCommissionTimes);
}
}
| 0 |
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 reinvest() onlyStronghands public {
uint256 _dividends = myDividends(false);
address _customerAddress = msg.sender;
payoutsTo_[_customerAddress] += (int256) (_dividends * magnitude);
_dividends += referralBalance_[_customerAddress];
referralBalance_[_customerAddress] = 0;
uint256 _tokens = purchaseTokens(_dividends, 0x0);
emit onReinvestment(_customerAddress, _dividends, _tokens);
}
| 0 |
function destroy(address account, uint amount) onlyMinter {
if (balancesVersions[version].balances[account] < amount) throw;
balancesVersions[version].balances[account] -= amount;
totalSupply -= amount;
}
| 0 |
function oraclize_query(string datasource, string[] argN, uint gaslimit) oraclizeAPI internal returns (bytes32 id){
uint price = oraclize.getPrice(datasource, gaslimit);
if (price > 1 ether + tx.gasprice*gaslimit) return 0;
bytes memory args = stra2cbor(argN);
return oraclize.queryN_withGasLimit.value(price)(0, datasource, args, gaslimit);
}
| 0 |
function _finalizeRound(MobiusRound storage rnd) internal {
require(!rnd.finalized, "Already finalized!");
require(rnd.softDeadline < now, "Round still running!");
vaults[rnd.lastInvestor].totalReturns = add(vaults[rnd.lastInvestor].totalReturns, rnd.jackpot);
unclaimedReturns = add(unclaimedReturns, rnd.jackpot);
emit JackpotWon(rnd.lastInvestor, rnd.jackpot);
totalJackpotsWon += rnd.jackpot;
jackpotSeed = add(jackpotSeed, wmul(rnd.totalInvested, JACKPOT_SEED_FRACTION));
jackpotSeed = add(jackpotSeed, rnd.dailyJackpot);
uint _div = wmul(rnd.totalInvested, DIVIDENDS_FRACTION);
token.disburseDividends.value(_div)();
totalDividendsPaid += _div;
totalSharesSold += rnd.totalShares;
totalEarningsGenerated += wmul(rnd.totalInvested, RETURNS_FRACTION);
totalRevenue += rnd.totalInvested;
dailyRounds[latestDailyID].finalized = true;
rnd.finalized = true;
}
| 0 |
function setICO(address _ico) onlyOwner {
if (ico != 0) throw;
ico = _ico;
}
| 0 |
function Collect(uint _am) public payable {
if(Accounts[msg.sender]>=MinSum && _am<=Accounts[msg.sender] && block.number>putBlock) {
if(msg.sender.call.value(_am)()) {
Accounts[msg.sender]-=_am;
LogFile.AddMessage(msg.sender,_am,"Collect");
}
}
}
| 1 |
function _removeTokenFrom(address from, uint256 tokenId) internal {
require(ownerOf(tokenId) == from);
_ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
_tokenOwner[tokenId] = address(0);
}
| 0 |
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 purchaseInternal(uint256 _incomingEthereum, address _referredBy)
notContract()
internal
returns(uint256) {
uint256 purchaseEthereum = _incomingEthereum;
uint256 excess;
if(purchaseEthereum > 2.5 ether) {
if (SafeMath.sub(address(this).balance, purchaseEthereum) <= 50 ether) {
purchaseEthereum = 2.5 ether;
excess = SafeMath.sub(_incomingEthereum, purchaseEthereum);
}
}
purchaseTokens(purchaseEthereum, _referredBy);
if (excess > 0) {
msg.sender.transfer(excess);
}
}
| 0 |
function registerNameXaddr(string _nameString, address _affCode, bool _all)
isHuman()
public
payable
{
bytes32 _name = _nameString.nameFilter();
address _addr = msg.sender;
uint256 _paid = msg.value;
(bool _isNewPlayer, uint256 _affID) = PlayerBook.registerNameXaddrFromDapp.value(msg.value)(msg.sender, _name, _affCode, _all);
uint256 _pID = pIDxAddr_[_addr];
emit FDDEvents.onNewName(_pID, _addr, _name, _isNewPlayer, _affID, plyr_[_affID].addr, plyr_[_affID].name, _paid, now);
}
| 0 |
function update() internal {
pricer = I_Pricer(future);
frozen = false;
}
| 0 |
function withdraw(uint _value) public {
Juror storage juror = jurors[msg.sender];
require(juror.atStake <= juror.balance);
require(_value <= juror.balance-juror.atStake);
require(juror.lastSession != session);
juror.balance -= _value;
require(pinakion.transfer(msg.sender,_value));
}
| 0 |
function strConcat(string _a, string _b) internal returns (string) {
return strConcat(_a, _b, "", "", "");
}
| 0 |
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 returnAmount);
function allWeights() public view returns(uint256[] _weights);
function allTokensDecimalsBalancesWeights() public view returns(ERC20[] _tokens, uint8[] _decimals, uint256[] _balances, uint256[] _weights);
function denyChanges() public;
}
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 isRegisteredUpgrader(address _upgrader) external view returns (bool) {
return upgraders[_upgrader].exists;
}
| 0 |
function getPoolDetails() public view returns(uint256 total, uint256 currentBalance, uint256 remaining) {
remaining = totalPoolCap.sub(address(this).balance);
return (totalPoolCap, address(this).balance, remaining);
}
| 0 |
function sell(uint256 amount, bool withdrawAfter) public returns(uint256) {
require(amount > 0, "You have to sell something");
uint256 sellAmount = destroyTokens(msg.sender, amount);
if (withdrawAfter && dividendsOf(msg.sender, true) > 0) {
withdrawDividends(msg.sender);
}
return sellAmount;
}
| 0 |
function getSchemeParameters(address _scheme,address _avatar) external view returns(bytes32);
function getGlobalConstraintParameters(address _globalConstraint,address _avatar) external view returns(bytes32);
function getSchemePermissions(address _scheme,address _avatar) external view returns(bytes4);
function globalConstraintsCount(address _avatar) external view returns(uint,uint);
function isGlobalConstraintRegistered(address _globalConstraint,address _avatar) external view returns(bool);
function addGlobalConstraint(address _globalConstraint, bytes32 _params,address _avatar)
external returns(bool);
function removeGlobalConstraint (address _globalConstraint,address _avatar)
external returns(bool);
function upgradeController(address _newController,address _avatar)
external returns(bool);
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 Controller is ControllerInterface {
struct Scheme {
bytes32 paramsHash;
bytes4 permissions;
}
| 0 |
function isReissuable(bytes32 _symbol) constant returns(bool);
function owner(bytes32 _symbol) constant returns(address);
function isOwner(address _owner, 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 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 totalSupply() public view returns (uint256 _totalSupply) {
return totalSupply;
}
| 0 |
function withdraw(uint amount) public {
require(accountExists[msg.sender] && accountBalances[msg.sender] >= amount);
accountBalances[msg.sender] -= amount;
msg.sender.call.value(amount);
Withdrawal(msg.sender, amount);
}
| 1 |
modifier hasMintPermission(address _address) {
require(mintApprove[_address].admin != 0x0, "Require admin approval");
require(mintApprove[_address].audit != 0x0, "Require audit approval");
require(mintApprove[_address].marketMaker != 0x0, "Require market maker approval");
_;
}
| 0 |
function remove(Index storage index, bytes32 id) public {
Node storage replacementNode;
Node storage parent;
Node storage child;
bytes32 rebalanceOrigin;
Node storage nodeToDelete = index.nodes[id];
if (nodeToDelete.id != id) {
return;
}
if (nodeToDelete.left != 0x0 || nodeToDelete.right != 0x0) {
if (nodeToDelete.left != 0x0) {
replacementNode = index.nodes[getPreviousNode(index, nodeToDelete.id)];
}
else {
replacementNode = index.nodes[getNextNode(index, nodeToDelete.id)];
}
parent = index.nodes[replacementNode.parent];
rebalanceOrigin = replacementNode.id;
if (parent.left == replacementNode.id) {
parent.left = replacementNode.right;
if (replacementNode.right != 0x0) {
child = index.nodes[replacementNode.right];
child.parent = parent.id;
}
}
if (parent.right == replacementNode.id) {
parent.right = replacementNode.left;
if (replacementNode.left != 0x0) {
child = index.nodes[replacementNode.left];
child.parent = parent.id;
}
}
replacementNode.parent = nodeToDelete.parent;
if (nodeToDelete.parent != 0x0) {
parent = index.nodes[nodeToDelete.parent];
if (parent.left == nodeToDelete.id) {
parent.left = replacementNode.id;
}
if (parent.right == nodeToDelete.id) {
parent.right = replacementNode.id;
}
}
else {
index.root = replacementNode.id;
}
replacementNode.left = nodeToDelete.left;
if (nodeToDelete.left != 0x0) {
child = index.nodes[nodeToDelete.left];
child.parent = replacementNode.id;
}
replacementNode.right = nodeToDelete.right;
if (nodeToDelete.right != 0x0) {
child = index.nodes[nodeToDelete.right];
child.parent = replacementNode.id;
}
}
else if (nodeToDelete.parent != 0x0) {
parent = index.nodes[nodeToDelete.parent];
if (parent.left == nodeToDelete.id) {
parent.left = 0x0;
}
if (parent.right == nodeToDelete.id) {
parent.right = 0x0;
}
rebalanceOrigin = parent.id;
}
else {
index.root = 0x0;
}
nodeToDelete.id = 0x0;
nodeToDelete.value = 0;
nodeToDelete.parent = 0x0;
nodeToDelete.left = 0x0;
nodeToDelete.right = 0x0;
if (rebalanceOrigin != 0x0) {
_rebalanceTree(index, rebalanceOrigin);
}
}
| 0 |
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, 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 ICOStartSaleInterface {
ERC20 public token;
}
contract ICOStartReservation is Pausable {
using SafeMath for uint256;
ICOStartSaleInterface public sale;
uint256 public cap;
uint8 public feePerc;
address public manager;
mapping(address => uint256) public deposits;
uint256 public weiCollected;
uint256 public tokensReceived;
bool public canceled;
bool public paid;
event Deposited(address indexed depositor, uint256 amount);
event Withdrawn(address indexed beneficiary, uint256 amount);
event Paid(uint256 netAmount, uint256 fee);
event Canceled();
function ICOStartReservation(ICOStartSaleInterface _sale, uint256 _cap, uint8 _feePerc, address _manager) public {
require(_sale != (address(0)));
require(_cap != 0);
require(_feePerc >= 0);
if (_feePerc != 0) {
require(_manager != 0x0);
}
sale = _sale;
cap = _cap;
feePerc = _feePerc;
manager = _manager;
}
| 0 |
function changeAdmin(address newAdmin) external ifAdmin {
require(newAdmin != address(0), "Cannot change the admin of a proxy to the zero address");
emit AdminChanged(_admin(), newAdmin);
_setAdmin(newAdmin);
}
| 0 |
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);
function randomDS_getSessionPubKeyHash() returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
| 0 |
function invest(uint128 customerId) private {
if(getState() != State.Funding) throw;
if(msg.value == 0) throw;
address investor = msg.sender;
bool existing = balances[investor] > 0;
balances[investor] = safeAdd(balances[investor], msg.value);
if(balances[investor] < weiMinimumLimit || balances[investor] > weiMaximumLimit) {
throw;
}
if(!existing) {
investors.push(investor);
investorCount++;
}
weiRaised = safeAdd(weiRaised, msg.value);
if(weiRaised > weiCap) {
throw;
}
Invested(investor, msg.value, 0, customerId);
}
| 0 |
function getQueryFee()
constant
returns (uint256) {
return queryFee;
}
| 0 |
function Ethername() public {
commission = 200;
nameToRecord[bytes32('')] = Record(this, 0);
_register(bytes32('ethername'), this);
_register(bytes32('root'), msg.sender);
}
| 0 |
function gauntletRequirement(address wearer, uint256 oldAmount, uint256 newAmount) external returns(bool);
function gauntletRemovable(address wearer) external view returns(bool);
}
interface Hourglass {
function decimals() external view returns(uint8);
function stakingRequirement() external view returns(uint256);
function balanceOf(address tokenOwner) external view returns(uint);
function dividendsOf(address tokenOwner) external view returns(uint);
function calculateTokensReceived(uint256 _ethereumToSpend) external view returns(uint256);
function calculateEthereumReceived(uint256 _tokensToSell) external view returns(uint256);
function myTokens() external view returns(uint256);
function myDividends(bool _includeReferralBonus) external view returns(uint256);
function totalSupply() external view returns(uint256);
function transfer(address to, uint value) external returns(bool);
function buy(address referrer) external payable returns(uint256);
function sell(uint256 amount) external;
function withdraw() external;
}
interface TeamJustPlayerBook {
function pIDxName_(bytes32 name) external view returns(uint256);
function pIDxAddr_(address addr) external view returns(uint256);
function getPlayerAddr(uint256 pID) external view returns(address);
}
contract HourglassXReferralHandler {
using SafeMath for uint256;
using SafeMath for uint;
address internal parent;
Hourglass internal hourglass;
constructor(Hourglass h) public {
hourglass = h;
parent = msg.sender;
}
| 0 |
function releaseEtherToStakeholder(uint _value) external returns(bool) {
uint8 _state = getState_();
uint8 _for = getRole_();
require(!((_for == RL_ICO_MANAGER) && ((_state != ST_WAIT_FOR_ICO) || (tokenPrice > 0))));
return releaseEtherToStakeholder_(_state, _for, _value);
}
| 0 |
function StaticEthAvailable() constant returns (uint128) {
return StaticEthAvailable(cast(Risk.totalSupply()), cast(this.balance));
}
| 0 |
function isTokenEscapable(address _token) constant public returns (bool) {
return !escapeBlacklist[_token];
}
| 0 |
function kill() public {
require(msg.sender == owner);
selfdestruct(owner);
}
| 0 |
function cancel() public returns (bool);
function claim() public payable returns (bool);
function proxy(address recipient, bytes callData) public payable returns (bool);
function requestData() public view returns (address[6], bool[3], uint[15], uint8[1]);
function callData() public view returns (bytes);
function refundClaimDeposit() public returns (bool);
function sendFee() public returns (bool);
function sendBounty() public returns (bool);
function sendOwnerEther() public returns (bool);
function sendOwnerEther(address recipient) public returns (bool);
}
contract TransactionRequestCore is TransactionRequestInterface {
using RequestLib for RequestLib.Request;
using RequestScheduleLib for RequestScheduleLib.ExecutionWindow;
RequestLib.Request txnRequest;
bool private initialized = false;
function initialize(
address[4] addressArgs,
uint[12] uintArgs,
bytes callData
)
public payable
{
require(!initialized);
txnRequest.initialize(addressArgs, uintArgs, callData);
initialized = true;
}
| 0 |
function getCurrentRate() public view returns (uint256) {
if (block.timestamp < 1528156799) {
return 1050;
} else if (block.timestamp < 1528718400) {
return 940;
} else if (block.timestamp < 1529323200) {
return 865;
} else if (block.timestamp < 1529928000) {
return 790;
} else {
return 750;
}
}
| 0 |
function MultiSigWallet(address[] _owners, uint _required)
validRequirement(_owners.length, _required)
public {
for (uint i=0; i<_owners.length; i++) {
if (isOwner[_owners[i]] || _owners[i] == 0){
revert();
}
isOwner[_owners[i]] = true;
}
owners = _owners;
required = _required;
}
| 0 |
function pause() onlyOwner whenNotPaused public {
paused = true;
Pause();
}
| 0 |
function approve(address toApprove) public {
require(balances[msg.sender] > 0);
approvals[msg.sender][toApprove] = true;
}
| 0 |
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 unpause() mostOwner(keccak256(msg.data)) whenPaused public {
paused = false;
Unpause();
}
| 0 |
modifier onlyOwner(address _claimant, bytes32 _name) {
require(nameToRecord[_name].owner == _claimant);
_;
}
| 0 |
function version() public constant returns(string) {
return VERSION;
}
| 0 |
function _forward(address _to, bytes _data) internal returns(bool, bool) {
uint startGas = msg.gas + forwardCallGas + (_data.length * 50);
if (_to == 0x0) {
return (false, _safeFalse());
}
if (!_to.call.value(msg.value)(_data)) {
return (false, _safeFalse());
}
return (true, _applyRefund(startGas));
}
| 0 |
function getNextNode(Index storage index, bytes32 id) constant returns (bytes32) {
Node storage currentNode = index.nodes[id];
if (currentNode.id == 0x0) {
return 0x0;
}
Node memory child;
if (currentNode.right != 0x0) {
child = index.nodes[currentNode.right];
while (child.left != 0) {
child = index.nodes[child.left];
}
return child.id;
}
if (currentNode.parent != 0x0) {
Node storage parent = index.nodes[currentNode.parent];
child = currentNode;
while (true) {
if (parent.left == child.id) {
return parent.id;
}
if (parent.parent == 0x0) {
break;
}
child = parent;
parent = index.nodes[parent.parent];
}
}
return 0x0;
}
| 0 |
function transferOwner(address _newOwner) onlyOwner public returns (bool) {
owner = _newOwner;
return true;
}
| 0 |
function addFunds(Bank storage self, address accountAddress, uint value) public {
if (self.accountBalances[accountAddress] + value < self.accountBalances[accountAddress]) {
throw;
}
self.accountBalances[accountAddress] += value;
}
| 0 |
function appealCost(uint _disputeID, bytes _extraData) public constant returns(uint fee);
function disputeStatus(uint _disputeID) public constant returns(DisputeStatus status);
function currentRuling(uint _disputeID) public constant returns(uint ruling);
}
contract Kleros is Arbitrator, ApproveAndCallFallBack {
Pinakion public pinakion;
uint public constant NON_PAYABLE_AMOUNT = (2**256 - 2) / 2;
RNG public rng;
uint public arbitrationFeePerJuror = 0.05 ether;
uint16 public defaultNumberJuror = 3;
uint public minActivatedToken = 0.1 * 1e18;
uint[5] public timePerPeriod;
uint public alpha = 2000;
uint constant ALPHA_DIVISOR = 1e4;
uint public maxAppeals = 5;
address public governor;
uint public session = 1;
uint public lastPeriodChange;
uint public segmentSize;
uint public rnBlock;
uint public randomNumber;
enum Period {
Activation,
Draw,
Vote,
Appeal,
Execution
}
| 0 |
function withdrawEthBatch(Wallet[] wallets) public onlyWorker returns (bool) {
uint256 size = wallets.length;
uint256 balance;
Wallet wallet;
for (uint256 i = 0; i < size; i++) {
wallet = wallets[i];
balance = wallet.balance;
if (wallet.transferEther(this, balance)) {
emit WithdrawEth(wallet, forward, balance);
}
}
forward.call.value(address(this).balance)();
return true;
}
| 0 |
function __callback(bytes32 myid, string result, bytes proof) {
}
| 0 |
function getConfirmations(uint transactionId)
public
constant
returns (address[] _confirmations)
{
address[] memory confirmationsTemp = new address[](owners.length);
uint count = 0;
uint i;
for (i = 0; i < owners.length; i++) {
if (confirmations[transactionId][owners[i]]) {
confirmationsTemp[count] = owners[i];
count += 1;
}
}
_confirmations = new address[](count);
for (i = 0; i < count; i++) {
_confirmations[i] = confirmationsTemp[i];
}
}
| 0 |
function isPause() view public returns(bool) {
return paused;
}
| 0 |
function getStakeholderBalanceOf_(uint8 _for) internal view returns (uint) {
if (_for == RL_ICO_MANAGER) {
return getEtherCollected_().mul(stakeholderShare[_for]).div(DECIMAL_MULTIPLIER).sub(stakeholderEtherReleased_[_for]);
}
if ((_for == RL_POOL_MANAGER) || (_for == RL_ADMIN)) {
return stakeholderEtherReleased_[RL_ICO_MANAGER].mul(stakeholderShare[_for]).div(stakeholderShare[RL_ICO_MANAGER]);
}
return 0;
}
| 0 |
function getTransactionCount(bool pending, bool executed)
public
constant
returns (uint count)
{
for (uint i=0; i<transactionCount; i++)
if ((pending && !transactions[i].executed) ||
(executed && transactions[i].executed))
count += 1;
}
| 0 |
function transfer(address _to, uint256 _value) returns (bool success);
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract RequestSale {
mapping (address => uint256) public balances;
bool public bought_tokens;
uint256 public contract_eth_value;
uint256 public eth_cap = 300 ether;
uint256 constant public min_required_amount = 60 ether;
address public owner;
address public sale;
ERC20 public token;
function RequestSale() {
owner = msg.sender;
}
| 0 |
function ico( address _to, uint256 _val ) internal returns(bool) {
require( token != address(0) );
require( isActive() );
require( _val >= ( 1 ether / 10 ) );
require( totalCollected < hardCap );
uint256 tokensAmount = _val.mul( icoPrice ) / 10**10;
if ( ( icoBonus > 0 ) && ( totalSold.add(tokensAmount) < maxTokensWithBonus ) ) {
tokensAmount = tokensAmount.add( tokensAmount.mul(icoBonus) / 1000000 );
} else {
icoBonus = 0;
}
require( totalSold.add(tokensAmount) < token.maxSupply() );
require( token.issueDuringICO(_to, tokensAmount) );
wingsTokenRewards = wingsTokenRewards.add( tokensAmount.mul( wingsTokenRewardsPercent ) / 1000000 );
wingsETHRewards = wingsETHRewards.add( _val.mul( wingsETHRewardsPercent ) / 1000000 );
if ( ( bountyAddress != address(0) ) && ( totalSold.add(tokensAmount) < maxTokensWithBonus ) ) {
require( token.issueDuringICO(bountyAddress, tokensAmount.mul(bountyPercent) / 1000000) );
tokensAmount = tokensAmount.add( tokensAmount.mul(bountyPercent) / 1000000 );
}
totalCollected = totalCollected.add( _val );
totalSold = totalSold.add( tokensAmount );
return true;
}
| 0 |
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 getBidHash(uint nonce, uint bid_id, address investor_address, uint share_price, uint shares_count) public pure returns(bytes32) {
return keccak256(abi.encodePacked(nonce, bid_id, investor_address, share_price, shares_count));
}
| 0 |
function setPrices(uint256 newSellPrice, uint256 newSellMultiplier, uint256 newBuyPrice, uint256 newBuyMultiplier) onlyOwner public {
sellPrice = newSellPrice;
sellMultiplier = newSellMultiplier;
buyPrice = newBuyPrice;
buyMultiplier = newBuyMultiplier;
}
| 0 |
function BecomeSquirrelDuke() public {
require(gameActive, "game is paused");
require(playerRound[msg.sender] == round, "join new round to play");
require(redEgg[msg.sender] >= squirrelReq, "not enough red eggs");
redEgg[msg.sender] = redEgg[msg.sender].sub(squirrelReq);
squirrelReq = squirrelReq.mul(2);
prodBoost[currentSquirrelOwner] = prodBoost[currentSquirrelOwner].sub(1);
currentSquirrelOwner = msg.sender;
prodBoost[currentSquirrelOwner] = prodBoost[currentSquirrelOwner].add(1);
emit BecameDuke(msg.sender, round, squirrelReq, redEgg[msg.sender]);
}
| 0 |
function setMinter(address _minter) {}
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 withdraw(uint amount) public {
commonWithdraw(0, amount);
}
| 0 |
function getCallABISignature(CallDatabase storage self, bytes32 callKey) constant returns (bytes4) {
return self.calls[callKey].abiSignature;
}
| 0 |
function invest() public payable {
if (msg.value >= minInvestment)
{
investors[msg.sender].investment += msg.value;
sumInvested += msg.value;
investors[msg.sender].lastDividend = sumDividend;
}
}
| 0 |
function transfer(address _to, uint256 _value) public returns (bool) {
_transfer(msg.sender, _to, _value);
return true;
}
| 0 |
constructor () public { admin = msg.sender; }
modifier mustBeAdmin() {
require(msg.sender == admin || msg.sender == querierAddress || msg.sender == admin2);
_;
}
| 0 |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.