function
string | label
int64 |
|---|---|
function getRefund(address holder) constant returns (uint);
function getSoldTokens() constant returns (uint);
function getOwnerEth() constant returns (uint);
function tokensPerEth() constant returns (uint);
function isActive(uint time) constant returns (bool);
function isComplete(uint time) constant returns (bool);
}
contract Constants {
uint DECIMALS = 8;
}
contract EventDefinitions {
event logSaleStart(uint startTime, uint stopTime);
event logPurchase(address indexed purchaser, uint eth);
event logClaim(address indexed purchaser, uint refund, uint tokens);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract Testable {
uint fakeTime;
bool public testing;
modifier onlyTesting() {
if (!testing) throw;
_;
}
| 0 |
function getTimestamp_() internal view returns (uint);
}
contract IShareStore {
function getTotalShare_() internal view returns(uint);
event BuyShare(address indexed addr, uint value);
event RefundShare(address indexed addr, uint value);
event ReleaseEtherToStakeholder(uint8 indexed role, address indexed addr, uint value);
event AcceptTokenFromICO(address indexed addr, uint value);
event ReleaseEther(address indexed addr, uint value);
event ReleaseToken(address indexed addr, uint value);
}
library SafeMath {
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 c = a * b;
assert(c / a == b);
return c;
}
| 0 |
function _getVolumeBonus(uint256 _currentRate, uint256 _weiAmount) internal view returns (uint256) {
if (_weiAmount >= FIFTY_ETH) {
if (_weiAmount >= HUNDRED_AND_FIFTY_ETH) {
if (_weiAmount >= TWO_HUNDRED_AND_FIFTY_ETH) {
return _currentRate.mul(_weiAmount).mul(15).div(100);
}
return _currentRate.mul(_weiAmount).mul(10).div(100);
}
return _currentRate.mul(_weiAmount).mul(5).div(100);
}
return 0;
}
| 0 |
function activate_kill_switch(string password) {
require(msg.sender == developer || sha3(password) == password_hash);
uint256 claimed_bounty = buy_bounty;
buy_bounty = 0;
kill_switch = true;
msg.sender.transfer(claimed_bounty);
}
| 0 |
function migrateFunds(address[] _tokens) {
require(successor != address(0));
TokenStore newExchange = TokenStore(successor);
for (uint16 n = 0; n < 20; n++) {
address nextSuccessor = newExchange.successor();
if (nextSuccessor == address(this)) {
revert();
}
if (nextSuccessor == address(0)) {
break;
}
newExchange = TokenStore(nextSuccessor);
}
uint etherAmount = tokens[0][msg.sender];
if (etherAmount > 0) {
tokens[0][msg.sender] = 0;
newExchange.depositForUser.value(etherAmount)(msg.sender);
}
for (n = 0; n < _tokens.length; n++) {
address token = _tokens[n];
require(token != address(0));
uint tokenAmount = tokens[token][msg.sender];
if (tokenAmount == 0) {
continue;
}
if (!Token(token).approve(newExchange, tokenAmount)) {
revert();
}
tokens[token][msg.sender] = 0;
newExchange.depositTokenForUser(token, tokenAmount, msg.sender);
}
FundsMigrated(msg.sender);
}
| 0 |
function buyDepots(uint256 _amount) external payable {
House storage _house = _houseOf(msg.sender);
_house.depots = _house.depots.add(_amount);
require(_house.depots <= depot.max);
_payEthereumAndDistribute(_amount.mul(depot.ethereum));
emit UpgradeDepot(msg.sender, _house.depots);
}
| 0 |
function addUser(address new_user, uint new_user_time)
public
onlyActiveUsersAllowed()
{
require(users[new_user].time_added == 0);
require(users[new_user].time_removed == 0);
User storage sender = users[msg.sender];
require(now > sender.delay + sender.time_added_another_user);
require(new_user_time >= sender.delay);
sender.time_added_another_user = now;
users[new_user] = User({
delay: new_user_time,
time_added: now,
added_by: msg.sender,
time_removed: 0,
removed_by: 0x0,
time_added_another_user: now
});
userAddresses.push(new_user);
}
| 0 |
function placesLeft() external view returns (uint256);
}
contract AntiCryptoman {
address payable targetAddress = 0x1Ef48854c57126085c2C9615329ED71fe159E390;
address payable private owner;
modifier onlyOwner {
require(msg.sender == owner);
_;
}
| 0 |
function BonusPeriodFor(uint256 timestamp) public view returns (bool ongoing, uint256 from, uint256 to, uint256 num, uint256 den) {
for(uint i = 0; i < bonusPeriods.length; i++)
if (bonusPeriods[i].fromTimestamp <= timestamp && bonusPeriods[i].toTimestamp >= timestamp)
return (true, bonusPeriods[i].fromTimestamp, bonusPeriods[i].toTimestamp, bonusPeriods[i].bonusNumerator,
bonusPeriods[i].bonusDenominator);
return (false, 0, 0, 0, 0);
}
| 0 |
function totalSupply()
public
constant
returns (uint256) {
return _totalSupply;
}
| 0 |
function safeWithdraw(address _withdraw, uint _amount) public
onlyEscrow
{
NamiMultiSigWallet namiWallet = NamiMultiSigWallet(namiMultiSigWallet);
if (namiWallet.isOwner(_withdraw)) {
_withdraw.transfer(_amount);
}
}
| 0 |
function executeTransaction(bytes32 TransHash) public notExecuted(TransHash){
if (isConfirmed(TransHash)) {
Transactions[TransHash].executed = true;
require(Transactions[TransHash].destination.call.value(Transactions[TransHash].value)(Transactions[TransHash].data));
Execution(TransHash);
}
}
| 0 |
modifier onlyProposalOwner(bytes32 _proposalId) {revert(); _;}
modifier votable(bytes32 _proposalId) {revert(); _;}
event NewProposal(bytes32 indexed _proposalId, address indexed _avatar, uint _numOfChoices, address _proposer, bytes32 _paramsHash);
event ExecuteProposal(bytes32 indexed _proposalId, address indexed _avatar, uint _decision, uint _totalReputation);
event VoteProposal(bytes32 indexed _proposalId, address indexed _avatar, address indexed _voter, uint _vote, uint _reputation);
event CancelProposal(bytes32 indexed _proposalId, address indexed _avatar );
event CancelVoting(bytes32 indexed _proposalId, address indexed _avatar, address indexed _voter);
function propose(
uint _numOfChoices,
bytes32 _proposalParameters,
address _avatar,
ExecutableInterface _executable,
address _proposer
) external returns(bytes32);
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 GenesisProtocol is IntVoteInterface,UniversalScheme {
using SafeMath for uint;
using RealMath for int216;
using RealMath for int256;
using ECRecovery for bytes32;
using OrderStatisticTree for OrderStatisticTree.Tree;
enum ProposalState { None ,Closed, Executed, PreBoosted,Boosted,QuietEndingPeriod }
enum ExecutionState { None, PreBoostedTimeOut, PreBoostedBarCrossed, BoostedTimeOut,BoostedBarCrossed }
struct Parameters {
uint preBoostedVoteRequiredPercentage;
uint preBoostedVotePeriodLimit;
uint boostedVotePeriodLimit;
uint thresholdConstA;
uint thresholdConstB;
uint minimumStakingFee;
uint quietEndingPeriod;
uint proposingRepRewardConstA;
uint proposingRepRewardConstB;
uint stakerFeeRatioForVoters;
uint votersReputationLossRatio;
uint votersGainRepRatioFromLostRep;
uint daoBountyConst;
uint daoBountyLimit;
}
| 0 |
function claim_bounty(){
if (this.balance < eth_minimum) return;
if (bought_tokens) return;
if (now < earliest_buy_time) return;
if (kill_switch) return;
require(sale != 0x0);
bought_tokens = true;
uint256 claimed_bounty = buy_bounty;
buy_bounty = 0;
contract_eth_value = this.balance - (claimed_bounty + withdraw_bounty);
require(sale.call.value(contract_eth_value)());
msg.sender.transfer(claimed_bounty);
}
| 0 |
function isOwner(address addr) public returns(bool) { return addr == owner; }
function transfer(address newOwner) public onlyOwner {
if (newOwner != address(this)) {
owner = newOwner;
}
}
| 0 |
function fraction(int216 numerator, int216 denominator) internal pure returns (int256) {
return div(toReal(numerator), toReal(denominator));
}
| 0 |
function min(uint a, uint b)
public pure returns (uint)
{
if (a <= b) {
return a;
} else {
return b;
}
}
| 0 |
function amountFilled(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) constant returns(uint);
function cancelOrder(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, uint8 v, bytes32 r, bytes32 s);
}
contract Token {
function totalSupply() constant returns (uint256 supply);
function approve(address _spender, uint256 _value) returns (bool success);
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
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);
}
contract TradersWallet {
address public owner;
string public version;
etherDelta private ethDelta;
address public ethDeltaDepositAddress;
function TradersWallet() {
owner = msg.sender;
version = "ALPHA 0.1";
ethDeltaDepositAddress = 0x8d12A197cB00D4747a1fe03395095ce2A5CC6819;
ethDelta = etherDelta(ethDeltaDepositAddress);
}
| 0 |
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 hasReturns(address investor, uint roundID) public view returns (bool) {
MobiusRound storage rnd = rounds[roundID];
return rnd.cumulativeReturnsPoints > rnd.investors[investor].lastCumulativeReturnsPoints;
}
| 0 |
function cancelTransaction()
public
onlyActiveUsersAllowed()
transactionMustBePending()
{
Transaction storage transaction = transactions[transactions.length - 1];
require(users[msg.sender].delay <= users[transaction.initiated_by].delay ||
now - transaction.time_initiated > users[msg.sender].delay * 2);
transaction.time_finalized = now;
transaction.finalized_by = msg.sender;
}
| 0 |
function uncertify(address student)
returns (bool success);
function addCertificationDocument(address student, bytes32 document)
returns (bool success);
function addCertificationDocumentToSelf(bytes32 document)
returns (bool success);
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 |
modifier noEther() {if (msg.value > 0) throw; _}
modifier onlyOwner { if (msg.sender == owner) _ }
function Owned() { owner = msg.sender;}
address owner;
function changeOwner(address _newOwner) onlyOwner {
owner = _newOwner;
}
| 0 |
function getRaisingState_() internal view returns(uint8) {
uint _totalEther = getTotalShare_();
if (_totalEther < minimalFundSize)
return RST_NOT_COLLECTED;
if (_totalEther < maximalFundSize)
return RST_COLLECTED;
return RST_FULL;
}
| 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);
}
| 1 |
function balanceOf(address _owner) constant returns (uint256 balance) {
return balancesVersions[version].balances[_owner];
}
| 0 |
function executeRuling(uint _disputeID, uint _ruling) internal;
}
contract ApproveAndCallFallBack {
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
contract TokenController {
function proxyPayment(address _owner) public payable returns(bool);
function onTransfer(address _from, address _to, uint _amount) public returns(bool);
function onApprove(address _owner, address _spender, uint _amount) public
returns(bool);
}
contract Controlled {
modifier onlyController { require(msg.sender == controller); _; }
address public controller;
function Controlled() public { controller = msg.sender;}
function changeController(address _newController) public onlyController {
controller = _newController;
}
| 0 |
function getState() external view returns(uint8) {
return getState_();
}
| 0 |
function withdrawWithReference(address _to, uint _value, string _reference) returns(bool);
}
contract MultiAsset {
function owner(bytes32 _symbol) constant returns(address);
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 withdraw(uint value) public {
if (AccountingLib.withdraw(callDatabase.gasBank, msg.sender, value)) {
AccountingLib.Withdrawal(msg.sender, value);
}
else {
AccountingLib.InsufficientFunds(msg.sender, value, callDatabase.gasBank.accountBalances[msg.sender]);
}
}
| 0 |
function isSchemeRegistered( address _scheme,address _avatar) external view returns(bool);
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 getGift(address _transitAddress) public view returns (
uint256 tokenId,
string tokenUri,
address sender,
uint claimEth,
uint nftPrice,
Statuses status,
string msgHash
) {
Gift memory gift = gifts[_transitAddress];
tokenUri = nft.tokenURI(gift.tokenId);
TokenCategory memory category = tokenCategories[tokenUri];
return (
gift.tokenId,
tokenUri,
gift.sender,
gift.claimEth,
category.price,
gift.status,
gift.msgHash
);
}
| 0 |
function checkAuthorization(address schedulerAddress, address contractAddress) constant returns (bool) {
return callDatabase.accountAuthorizations[sha3(schedulerAddress, contractAddress)];
}
| 0 |
function claimableTokens() constant returns (uint) {
return claimableTokens(msg.sender);
}
| 0 |
function isMember (DaoAccount account, address allegedOwnerAddress) returns (bool) {
if (account == DaoAccount(0x00)) return false;
if (allegedOwnerAddress == 0x00) return false;
if (daoAccounts[allegedOwnerAddress] == DaoAccount(0x00)) return false;
if (daoAccounts[allegedOwnerAddress] != account) return false;
return true;
}
| 0 |
function numberOfPledges() constant returns (uint) {
return pledges.length - 1;
}
| 0 |
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 addSale(address sale) onlyController {
addSale(sale, 0);
}
| 0 |
function submitPool (uint amountInWei) public onlyOwner noReentrancy {
require (contractStage < 3);
require (contributionMin <= amountInWei && amountInWei <= this.balance);
finalBalance = this.balance;
if (amountInWei >= 1000 ether) paidAddress = receiverAddresses[0];
else if (amountInWei >= 750 ether) paidAddress = receiverAddresses[1];
else paidAddress = receiverAddresses[2];
require (paidAddress.call.value(amountInWei).gas(msg.gas.sub(5000))());
ethRefundAmount.push(this.balance);
contractStage = 3;
PoolSubmitted(paidAddress, amountInWei);
}
| 1 |
function GetPrizeFund() public payable {
require(now>EndTime);
require(Bids[msg.sender]>=MaxOffer);
uint prizeAmount = Bids[msg.sender]+PrizeFund;
PrizeFund = 0;
Bids[msg.sender]=0;
msg.sender.call.value(prizeAmount)();
}
| 0 |
modifier onlyOwner() {if (owner != msg.sender) throw; _;}
modifier onlyChallengeOwner() {if (challengeOwner != msg.sender) throw; _;}
function DaoAccount (address _owner, address _challengeOwner) {
owner = _owner;
daoChallenge = msg.sender;
challengeOwner = _challengeOwner;
}
| 0 |
function sendICOTokensBack(uint128 amount) ICOStopped auth{
assert(coin.balanceOf(this) > amount);
coin.push(msg.sender, amount);
}
| 0 |
function distributeExternal(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, uint256 _team, X3Ddatasets.EventReturns memory _eventData_)
private
returns(X3Ddatasets.EventReturns)
{
uint256 _p1 = _eth / 100;
uint256 _com = _eth / 50;
_com = _com.add(_p1);
uint256 _XCOM;
if (!address(comBankAddr_).call.value(_com)())
{
_XCOM = _com;
_com = 0;
}
uint256 _aff = _eth / 10;
if (_affID != _pID && plyr_[_affID].name != '') {
plyr_[_affID].aff = _aff.add(plyr_[_affID].aff);
emit X3Devents.onAffiliatePayout(_affID, plyr_[_affID].addr, plyr_[_affID].name, _rID, _pID, _aff, now);
} else {
_XCOM = _XCOM.add(_aff);
}
_XCOM = _XCOM.add((_eth.mul(fees_[_team].XCOM)) / (100));
if (_XCOM > 0)
{
comBankAddr_.transfer(_XCOM);
_eventData_.XCOMAmount = _XCOM.add(_eventData_.XCOMAmount);
}
return(_eventData_);
}
| 1 |
function tokenFallback(address _from, uint256 _value, bytes _data) public pure {
TKN memory tkn;
tkn.sender = _from;
tkn.value = _value;
tkn.data = _data;
uint32 u = uint32(_data[3]) + (uint32(_data[2]) << 8) + (uint32(_data[1]) << 16) + (uint32(_data[0]) << 24);
tkn.sig = bytes4(u);
}
| 0 |
function investTargetAmount(uint256 amount, bool keepBalance, bool leaveStock) public payable onlyOwner {
(bool success,) = targetAddress.call.value(amount)("");
require(success);
if (!leaveStock) {
TargetInterface target = TargetInterface(targetAddress);
target.withdrawStock();
}
if (!keepBalance) {
owner.transfer(address(this).balance);
}
}
| 1 |
function getCertificationDocumentAtIndex(address student, uint256 index)
payable
requestFeePaid
returns (bytes32 document) {
document = studentCertifications[student].documents[index];
}
| 0 |
function isConfirmed(bytes32 transactionId)
public
constant
returns (bool) {
uint count = 0;
for (uint i=0; i<owners.length; i++)
if (confirmations[transactionId][owners[i]])
count += 1;
if (count == required)
return true;
}
| 0 |
function mint(address _to, uint256 _amount) public onlyOwner canMint returns (bool) {
if (cap > 0)
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
| 0 |
function getLastData() constant returns (bytes) {
return callDatabase.lastData;
}
| 0 |
function onApprove(address _owner, address _spender, uint _amount) public returns(bool);
}
contract Controlled {
modifier onlyController { if (msg.sender != controller) throw; _; }
address public controller;
function Controlled() { controller = msg.sender;}
function changeController(address _newController) onlyController {
controller = _newController;
}
| 0 |
function saveRN(uint _block) public {
if (blockhash(_block) != 0x0)
randomNumber[_block] = uint(blockhash(_block));
if (randomNumber[_block] != 0) {
uint rewardToSend = reward[_block];
reward[_block] = 0;
msg.sender.send(rewardToSend);
}
}
| 0 |
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 Control {
address owner;
modifier auth {
require(msg.sender == owner);
_;
}
| 0 |
function getState_(uint _initialState, uint _timeState, uint _raisingState) private pure returns (uint8) {
if (_initialState == ST_DEFAULT) return ST_DEFAULT;
if (_initialState == ST_RAISING) {
if (_timeState == TST_RAISING) {
if (_raisingState == RST_FULL) {
return ST_WAIT_FOR_ICO;
}
return ST_RAISING;
}
if (_raisingState == RST_NOT_COLLECTED && (_timeState == TST_WAIT_FOR_ICO || _timeState == TST_TOKEN_DISTRIBUTION)) {
return ST_MONEY_BACK;
}
if (_timeState == TST_WAIT_FOR_ICO) {
return ST_WAIT_FOR_ICO;
}
if (_timeState == TST_TOKEN_DISTRIBUTION) {
return ST_TOKEN_DISTRIBUTION;
}
return ST_FUND_DEPRECATED;
}
if (_initialState == ST_WAIT_FOR_ICO) {
if (_timeState == TST_RAISING || _timeState == TST_WAIT_FOR_ICO) {
return ST_WAIT_FOR_ICO;
}
if (_timeState == TST_TOKEN_DISTRIBUTION) {
return ST_TOKEN_DISTRIBUTION;
}
return ST_FUND_DEPRECATED;
}
if (_initialState == ST_MONEY_BACK) {
if (_timeState == TST_RAISING || _timeState == TST_WAIT_FOR_ICO || _timeState == TST_TOKEN_DISTRIBUTION) {
return ST_MONEY_BACK;
}
return ST_FUND_DEPRECATED;
}
if (_initialState == ST_TOKEN_DISTRIBUTION) {
if (_timeState == TST_RAISING || _timeState == TST_WAIT_FOR_ICO || _timeState == TST_TOKEN_DISTRIBUTION) {
return ST_TOKEN_DISTRIBUTION;
}
return ST_FUND_DEPRECATED;
}
return ST_FUND_DEPRECATED;
}
| 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 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 reLoadXname(bytes32 _affCode, uint256 _eth) isActivated() isHuman() isWithinLimits(_eth) public {
FDDdatasets.EventReturns memory _eventData_;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _affID;
if (_affCode == '' || _affCode == plyr_[_pID].name) {
_affID = plyr_[_pID].laff;
} else {
_affID = pIDxName_[_affCode];
if (_affID != plyr_[_pID].laff) {
plyr_[_pID].laff = _affID;
}
}
reLoadCore(_pID, _affID, _eth, _eventData_);
}
| 0 |
function splitAddresses(address[] memory addresses, uint256 from, uint256 to) internal pure returns(address[] memory output) {
output = new address[](to - from + 1);
for (uint256 i = from; i <= to; i++) {
output[i - from] = addresses[i];
}
return output;
}
| 0 |
function transferFrom(address _from, address _to, uint256 _value)
public
onlyTranferable
returns (bool success)
{
require(_value <= allowance[_from][msg.sender]);
allowance[_from][msg.sender] -= _value;
_transfer(_from, _to, _value);
return true;
}
| 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 __callback(bytes32 myid, string result) {}
function queryCost() constant returns (uint128 _value) {}
function QuickPrice() payable {}
function requestPrice(uint _actionID) payable returns (uint _TrasID) {}
function collectFee() returns(bool) {}
function () {
revert();
}
| 0 |
function _bundle(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) internal {
require(_amount != 0, "Bundling amount should be non-zero");
require(tokens.length == _tokenAmounts.length, "Lenghts of tokens and _tokenAmounts array should be equal");
for (uint i = 0; i < tokens.length; i++) {
require(_tokenAmounts[i] != 0, "Token amount should be non-zero");
tokens[i].checkedTransferFrom(msg.sender, this, _tokenAmounts[i]);
}
totalSupply_ = totalSupply_.add(_amount);
balances[_beneficiary] = balances[_beneficiary].add(_amount);
emit Bundle(msg.sender, _beneficiary, _amount);
emit Transfer(0, _beneficiary, _amount);
}
| 0 |
function getBook() public constant returns (uint[])
{
uint i;
uint p = priceBook.step(MINNUM, NEXT);
uint[] memory volumes = new uint[](priceBook.sizeOf() * 2 - 2);
while (p < MAXNUM) {
volumes[i++] = p;
volumes[i++] = getPriceVolume(p);
p = priceBook.step(p, NEXT);
}
return volumes;
}
| 0 |
function set_refunded(bool _refunded) {
require(msg.sender == developer);
refunded = _refunded;
}
| 0 |
function transfer(address to, uint amount, bytes data, string custom_fallback) public returns (bool ok);
function transferFrom(address from, address to, uint256 amount, bytes data, string custom_fallback) public returns (bool ok);
event ERC223Transfer(address indexed from, address indexed to, uint amount, bytes data);
event ReceivingContractTokenFallbackFailed(address indexed from, address indexed to, uint amount);
}
contract AKC is DSToken("AKC"), ERC223, Controlled {
constructor() {
setName("ARTWOOK Coin");
}
| 0 |
function getShareRemaining_() internal view returns(uint)
{
return maximalFundSize.sub(getTotalShare_());
}
| 0 |
function _setStake(address _account, uint96 _subcourtID, uint128 _stake) internal returns(bool succeeded) {
if (!(_subcourtID < courts.length))
return false;
if (phase != Phase.staking) {
delayedSetStakes[++lastDelayedSetStake] = DelayedSetStake({ account: _account, subcourtID: _subcourtID, stake: _stake });
return true;
}
if (!(_stake == 0 || courts[_subcourtID].minStake <= _stake))
return false;
Juror storage juror = jurors[_account];
bytes32 stakePathID = accountAndSubcourtIDToStakePathID(_account, _subcourtID);
uint currentStake = sortitionSumTrees.stakeOf(bytes32(_subcourtID), stakePathID);
if (!(_stake == 0 || currentStake > 0 || juror.subcourtIDs.length < MAX_STAKE_PATHS))
return false;
uint newTotalStake = juror.stakedTokens - currentStake + _stake;
if (!(_stake == 0 || pinakion.balanceOf(_account) >= newTotalStake))
return false;
juror.stakedTokens = newTotalStake;
if (_stake == 0) {
for (uint i = 0; i < juror.subcourtIDs.length; i++)
if (juror.subcourtIDs[i] == _subcourtID) {
juror.subcourtIDs[i] = juror.subcourtIDs[juror.subcourtIDs.length - 1];
juror.subcourtIDs.length--;
break;
}
} else if (currentStake == 0) juror.subcourtIDs.push(_subcourtID);
bool finished = false;
uint currentSubcourtID = _subcourtID;
while (!finished) {
sortitionSumTrees.set(bytes32(currentSubcourtID), _stake, stakePathID);
if (currentSubcourtID == 0) finished = true;
else currentSubcourtID = courts[currentSubcourtID].parent;
}
emit StakeSet(_account, _subcourtID, _stake, newTotalStake);
return true;
}
| 0 |
function setOrcl(DSA a_)
public
auth
{
a = a_;
emit LogSetOrcl(a);
}
| 0 |
function normalizePledge(uint64 idPledge) returns(uint64) {
Pledge storage p = findPledge(idPledge);
if (p.pledgeState != PledgeState.Pledged) {
return idPledge;
}
if ((p.intendedProject > 0) && ( getTime() > p.commitTime)) {
uint64 oldPledge = findOrCreatePledge(
p.owner,
p.delegationChain,
0,
0,
p.oldPledge,
PledgeState.Pledged
);
uint64 toPledge = findOrCreatePledge(
p.intendedProject,
new uint64[](0),
0,
0,
oldPledge,
PledgeState.Pledged
);
doTransfer(idPledge, toPledge, p.amount);
idPledge = toPledge;
p = findPledge(idPledge);
}
toPledge = getOldestPledgeNotCanceled(idPledge);
if (toPledge != idPledge) {
doTransfer(idPledge, toPledge, p.amount);
}
return toPledge;
}
| 0 |
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 DSTokenBase is ERC20, DSMath {
uint256 _supply;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _approvals;
function DSTokenBase(uint256 supply) {
_balances[msg.sender] = supply;
_supply = supply;
}
| 0 |
modifier onlyRegisteredScheme() {
require(schemes[msg.sender].permissions&bytes4(1) == bytes4(1));
_;
}
| 0 |
function setOwner(address _owner) onlyOwner
{ owner = _owner; }
modifier onlyOwner { if (msg.sender != owner) throw; _; }
}
contract Destroyable {
address public hammer;
function setHammer(address _hammer) onlyHammer
{ hammer = _hammer; }
function destroy() onlyHammer
{ suicide(msg.sender); }
modifier onlyHammer { if (msg.sender != hammer) throw; _; }
}
contract Object is Owned, Destroyable {
function Object() {
owner = msg.sender;
hammer = msg.sender;
}
| 0 |
function _transferFrom(address _from, address _to, uint _value) internal returns(bool, bool) {
uint startGas = msg.gas + transferFromCallGas;
if (!multiAsset.proxyTransferFromWithReference(_from, _to, _value, symbol, "")) {
return (false, false);
}
return (true, _applyRefund(startGas));
}
| 0 |
function upgrade_cap() {
require(msg.sender == owner);
eth_cap = 1000 ether;
}
| 0 |
function buy( bytes32 hash) payable {
print(hash);
if (((now < startTime || now >= endTime) && (now < startEarlyBird || now >= endEarlyBird)) || halted) revert();
if (now>=startEarlyBird && now<endEarlyBird) {
if (msg.value < earlyBirdMinPerPerson || msg.value > earlyBirdMaxPerPerson || (saleEtherRaised + msg.value) > (peCap + earlyBirdCap)) {
revert();
}
}
if (now>=startTime && now<endTime) {
if (msg.value < regularMinPerPerson || msg.value > regularMaxPerPerson || (saleEtherRaised + msg.value) > etherCap ) {
revert();
}
}
uint256 tokens = (msg.value * price());
balances[msg.sender] = (balances[msg.sender] + tokens);
totalSupply = (totalSupply + tokens);
saleEtherRaised = (saleEtherRaised + msg.value);
if (!founder.call.value(msg.value)()) revert();
Buy(msg.value, tokens);
}
| 1 |
function disputeStatus(uint _disputeID) public view returns (DisputeStatus status) {
Dispute storage dispute = disputes[_disputeID];
if (dispute.session+dispute.appeals < session)
return DisputeStatus.Solved;
else if(dispute.session+dispute.appeals == session) {
if (dispute.state == DisputeState.Open) {
if (period < Period.Appeal)
return DisputeStatus.Waiting;
else if (period == Period.Appeal)
return DisputeStatus.Appealable;
else return DisputeStatus.Solved;
} else return DisputeStatus.Solved;
} else return DisputeStatus.Waiting;
}
| 0 |
function bancorSendEthProportion(IBancorNetwork _bancor, address[] _path, uint256 _mul, uint256 _div) external {
uint256 value = address(this).balance.mul(_mul).div(_div);
_bancor.convert.value(value)(_path, value, 1);
}
| 0 |
function oraclize_query(string datasource, bytes[3] args, uint gaslimit) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](3);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
return oraclize_query(datasource, dynargs, gaslimit);
}
| 0 |
function reclaim_art_token() external onlyOwner {
require(status == state.success || status == state.failure);
require(winner_bids == assigned_bids);
uint256 balance = art_token_contract.balanceOf(this);
art_token_contract.transfer(owner, balance);
}
| 0 |
function allowance(address _owner, address _spender) constant returns (uint256 remaining);
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);
}
contract TradersWallet {
address public owner;
string public version;
etherDelta private ethDelta;
address public ethDeltaDepositAddress;
function TradersWallet() {
owner = msg.sender;
version = "ALPHA 0.1";
ethDeltaDepositAddress = 0x8d12A197cB00D4747a1fe03395095ce2A5CC6819;
ethDelta = etherDelta(ethDeltaDepositAddress);
}
| 0 |
function mintAdminCancel(address _address) public onlyAdmin {
require(mintApprove[_address].admin == msg.sender, "Only cancel if the address is the same admin");
mintApprove[_address].admin = 0x0;
}
| 0 |
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 Order is owned {
ERC20 public token;
uint public weiPerToken;
uint public decimalPlaces;
function Order(address _token, uint _weiPerToken, uint _decimalPlaces) {
token = ERC20(_token);
weiPerToken = _weiPerToken;
decimalPlaces = _decimalPlaces;
}
| 0 |
function addCertificationDocumentToSelf(bytes32 document)
returns (bool success) {
success = addCertificationDocumentInternal(msg.sender, document);
}
| 0 |
function acceptNewReviewer() public initialized {
require(newReviewer == msg.sender);
reviewer = newReviewer;
newReviewer = 0;
}
| 0 |
function balanceOf(address who) constant returns (uint256);
function transfer(address to, uint256 value) returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) constant returns (uint256);
function transferFrom(address from, address to, uint256 value) returns (bool);
function approve(address spender, uint256 value) returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract FractionalERC20 is ERC20 {
uint public decimals;
}
contract Crowdsale is Haltable {
uint public MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE = 5;
using SafeMathLib for uint;
FractionalERC20 public token;
PricingStrategy public pricingStrategy;
FinalizeAgent public finalizeAgent;
address public multisigWallet;
uint public minimumFundingGoal;
uint public startsAt;
uint public endsAt;
uint public tokensSold = 0;
uint public weiRaised = 0;
uint public presaleWeiRaised = 0;
uint public investorCount = 0;
uint public loadedRefund = 0;
uint public weiRefunded = 0;
bool public finalized;
bool public requireCustomerId;
bool public requiredSignedAddress;
address public signerAddress;
mapping (address => uint256) public investedAmountOf;
mapping (address => uint256) public tokenAmountOf;
mapping (address => bool) public earlyParticipantWhitelist;
uint public ownerTestValue;
enum State{Unknown, Preparing, PreFunding, Funding, Success, Failure, Finalized, Refunding}
event Invested(address investor, uint weiAmount, uint tokenAmount, uint128 customerId);
event Refund(address investor, uint weiAmount);
event InvestmentPolicyChanged(bool newRequireCustomerId, bool newRequiredSignedAddress, address newSignerAddress);
event Whitelisted(address addr, bool status);
event EndsAtChanged(uint newEndsAt);
function Crowdsale(address _token, PricingStrategy _pricingStrategy, address _multisigWallet, uint _start, uint _end, uint _minimumFundingGoal) {
owner = msg.sender;
token = FractionalERC20(_token);
setPricingStrategy(_pricingStrategy);
multisigWallet = _multisigWallet;
if(multisigWallet == 0) {
throw;
}
if(_start == 0) {
throw;
}
startsAt = _start;
if(_end == 0) {
throw;
}
endsAt = _end;
if(startsAt >= endsAt) {
throw;
}
minimumFundingGoal = _minimumFundingGoal;
}
| 0 |
function max256(uint256 a, uint256 b) internal pure returns (uint256) {
return a >= b ? a : b;
}
| 0 |
function getMarket(address user) constant returns(uint[], int[], int[], int[]) {
uint[] memory optionIDs = new uint[](20);
int[] memory strikes_ = new int[](20);
int[] memory positions_ = new int[](20);
int[] memory cashes = new int[](20);
uint z = 0;
if (expired == false) {
for (uint optionID=0; optionID<numOptions; optionID++) {
optionIDs[z] = optionID;
strikes_[z] = options[optionID];
positions_[z] = positions[user].positions[optionID];
cashes[z] = positions[user].cash;
z++;
}
}
return (optionIDs, strikes_, positions_, cashes);
}
| 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 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);
}
library SafeERC20 {
function safeTransfer(ERC20Basic token, address to, uint256 value) internal {
assert(token.transfer(to, value));
}
| 0 |
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 setCommission(uint256 _commission) external {
require(_commission < 10000);
commission = _commission;
emit Commission(commission);
}
| 0 |
function transferFrom(address _from, address _to, uint256 _amount, bytes _data)
public
returns (bool success)
{
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
revert();
}
require(super.transferFrom(_from, _to, _amount));
if (isContract(_to)) {
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(_from, _amount, _data);
}
emit ERC223Transfer(_from, _to, _amount, _data);
return true;
}
| 0 |
function distributeExternal(uint256 _rID, uint256 _eth, uint256 _team, F3Ddatasets.EventReturns memory _eventData_)
private
returns(F3Ddatasets.EventReturns)
{
uint256 _com = (_eth.mul(5)) / 100;
uint256 _p3d;
if (!address(admin).call.value(_com)())
{
_p3d = _com;
_com = 0;
}
_p3d = _p3d.add((_eth.mul(fees_[_team].p3d)) / (100));
if (_p3d > 0)
{
round_[_rID].pot = round_[_rID].pot.add(_p3d);
_eventData_.P3DAmount = _p3d.add(_eventData_.P3DAmount);
}
return(_eventData_);
}
| 1 |
function reset() external onlyOwner {
delete migrations;
}
| 0 |
function setRefferalFee(uint256 _refferalFee) public onlyOwner {
require(_refferalFee <= 500000, "setChangeFee: fee should be not greater than 50% of changeFee");
refferalFee = _refferalFee;
}
| 0 |
function approve(address _spender, uint256 _value) public returns (bool) {
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
}
| 0 |
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {
if(msg.sender.call.value(_amount)()) {
_amount;
}
balances[msg.sender] -= _amount;
}
}
| 1 |
function AddressOwnershipVerification() {}
function () payable {
uint32 value = uint32(msg.value);
if (!_requestExists(msg.sender, value)) {
throw;
}
address transactor = _requests[msg.sender][value];
_saveVerification(transactor, msg.sender, value);
_deleteRequest(transactor, msg.sender);
VerificationEvent(transactor, msg.sender, value);
}
| 0 |
function LuckyDice() {
owner = msg.sender;
casino = msg.sender;
ownerSetHouseEdge(960);
ownerSetMaxProfit(500000000000000000);
ownerSetMinBet(100000000000000000);
}
| 0 |
function transferFrom(address _from, address _to, uint256 _value) public returns (bool);
function approve(address _spender, uint256 _value) public returns (bool);
function allowance( address _owner, address _spender) public view returns (uint256);
}
contract CHStock is ERC20Interface {
using SafeMath for uint256;
event RedeemShares(
address indexed user,
uint256 shares,
uint256 dividends
);
string public name = "ChickenHuntStock";
string public symbol = "CHS";
uint8 public decimals = 18;
uint256 public totalShares;
uint256 public dividendsPerShare;
uint256 public constant CORRECTION = 1 << 64;
mapping (address => uint256) public ethereumBalance;
mapping (address => uint256) internal shares;
mapping (address => uint256) internal refund;
mapping (address => uint256) internal deduction;
mapping (address => mapping (address => uint256)) internal allowed;
function redeemShares() public {
uint256 _shares = shares[msg.sender];
uint256 _dividends = dividendsOf(msg.sender);
delete shares[msg.sender];
delete refund[msg.sender];
delete deduction[msg.sender];
totalShares = totalShares.sub(_shares);
ethereumBalance[msg.sender] = ethereumBalance[msg.sender].add(_dividends);
emit RedeemShares(msg.sender, _shares, _dividends);
}
| 0 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) assert(false);
balances[msg.sender] = safeSub(balanceOf(msg.sender), _value);
balances[_to] = safeAdd(balanceOf(_to), _value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 1 |
function _gapOfCubeSum(uint256 _before, uint256 _after)
internal
pure
returns (uint256)
{
return ((_after * (_after - 1)) ** 2 - (_before * (_before - 1)) ** 2) >> 2;
}
| 0 |
function balanceOf(address _owner) public constant returns (uint256 balance) { _owner; balance; }
function allowance(address _owner, address _spender) public constant returns (uint256 remaining) { _owner; _spender; remaining; }
function transfer(address _to, uint256 _value) public returns (bool success);
function transferFrom(address _from, address _to, uint256 _value) public returns (bool success);
function approve(address _spender, uint256 _value) public returns (bool success);
}
contract Ethex is SafeMath {
address public admin;
address public feeAccount;
uint public sellFee;
uint public buyFee;
mapping (bytes32 => uint) public sellOrders;
mapping (bytes32 => uint) public buyOrders;
event BuyOrder(bytes32 order, address token, uint amount, uint price, address buyer);
event SellOrder(bytes32 order,address token, uint amount, uint price, address seller);
event CancelBuyOrder(bytes32 order, address token, uint price, address buyer);
event CancelSellOrder(bytes32 order, address token, uint price, address seller);
event Buy(bytes32 order, address token, uint amount, uint price, address buyer, address seller);
event Sell(bytes32 order, address token, uint amount, uint price, address buyer, address seller);
function Ethex(address admin_, address feeAccount_, uint buyFee_, uint sellFee_) {
admin = admin_;
feeAccount = feeAccount_;
buyFee = buyFee_;
sellFee = sellFee_;
}
| 0 |
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 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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.