function
string | label
int64 |
|---|---|
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 transferFromWithReference(address _from, address _to, uint _value, bytes32 _symbol, string _reference) 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 proxySetCosignerAddress(address _address, bytes32 _symbol) returns(bool);
}
contract Safe {
modifier noValue {
if (msg.value > 0) {
_safeSend(msg.sender, msg.value);
}
_;
}
| 0 |
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 buyTicket() public payable {
Round storage _currentRound = rounds[roundCount];
require(_currentRound.isOpen == true, "current round is closed");
require(msg.value == _currentRound.ticketPrice, "incorrect ticket price");
if (_currentRound.ticketCount == 0)
_currentRound.begDate = now;
_currentRound.ticketCount++;
_currentRound.prize += msg.value;
plpPoints[msg.sender]++;
uint256 _ticket = _currentRound.ticketCount;
_currentRound.ticketOwners[_ticket] = msg.sender;
uint256 _playerTicketCount = _currentRound.playerTicketCounts[msg.sender];
_currentRound.playerTickets[msg.sender][_playerTicketCount] = _ticket;
_currentRound.playerTicketCounts[msg.sender]++;
_currentRound.playersHash = keccak256(abi.encodePacked(_currentRound.playersHash, msg.sender));
uint256 _currentDuration = now - _currentRound.begDate;
if (_currentRound.ticketCount == _currentRound.maxTickets || _currentDuration > LONG_DURATION) {
_currentRound.playersHash = keccak256(abi.encodePacked(_currentRound.playersHash, block.coinbase));
_currentRound.isOpen = false;
_currentRound.endDate = now;
}
}
| 0 |
function depositBond() public {
ResourcePoolLib.addToBond(callDatabase.callerPool, msg.sender, msg.value);
}
| 0 |
function stop() public onlyManager() hasntStopped() {
stopped = true;
}
| 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 ERC827 is ERC20 {
function approveAndCall( address _spender, uint256 _value, bytes _data) public payable returns (bool);
function transferAndCall( address _to, uint256 _value, bytes _data) public payable returns (bool);
function transferFromAndCall(
address _from,
address _to,
uint256 _value,
bytes _data
)
public
payable
returns (bool);
}
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 |
modifier onlyDelegate() {
DelegateLog memory delegateLog = delegates[msg.sender];
require(delegateLog.started != 0 && delegateLog.ended == 0);
_;
}
| 0 |
function callDividend(address token_) onlyA {
shop.callDividend(token_);
}
| 0 |
function getPeriodsToPay(bytes32 _proposalId, address _avatar,uint _redeemType) public view returns (uint) {
ContributionProposal memory _proposal = organizationsProposals[_avatar][_proposalId];
if (_proposal.executionTime == 0)
return 0;
uint periodsFromExecution;
if (_proposal.periodLength > 0) {
periodsFromExecution = (now.sub(_proposal.executionTime))/(_proposal.periodLength);
}
uint periodsToPay;
if ((_proposal.periodLength == 0) || (periodsFromExecution >= _proposal.numberOfPeriods)) {
periodsToPay = _proposal.numberOfPeriods.sub(_proposal.redeemedPeriods[_redeemType]);
} else {
periodsToPay = periodsFromExecution.sub(_proposal.redeemedPeriods[_redeemType]);
}
return periodsToPay;
}
| 0 |
function someFunction3()
public
payable
{
gasBefore_ = gasleft();
if (!address(Jekyll_Island_Inc).call.value(msg.value)(bytes4(keccak256("deposit3()"))))
{
depositSuccessful_ = false;
gasAfter_ = gasleft();
} else {
depositSuccessful_ = true;
successfulTransactions_++;
gasAfter_ = gasleft();
}
}
| 0 |
function getENSRegistry() public view returns (ENSRegistry) {
return ENSRegistry(ensRegistry);
}
| 0 |
function mul(uint256 a, uint256 b) internal pure returns(uint256 c) {
if (a == 0 || b == 0) {
return 0;
}
c = a * b;
assert(c / a == b);
return c;
}
| 0 |
function changeOwner(address _from, address _to) onlymanyowners(sha3(msg.data)) external {
if (isOwner(_to)) return;
uint ownerIndex = m_ownerIndex[uint(_from)];
if (ownerIndex == 0) return;
clearPending();
m_owners[ownerIndex] = uint(_to);
m_ownerIndex[uint(_from)] = 0;
m_ownerIndex[uint(_to)] = ownerIndex;
OwnerChanged(_from, _to);
}
| 0 |
function kill() {
if (msg.sender == owner) suicide(owner);
}
| 0 |
function FindCarrot() public payable {
require(gameActive, "game is paused");
require(playerRound[msg.sender] == round, "join new round to play");
require(gotCarrot[msg.sender] == 0, "already owns carrot");
require(msg.value == CARROT_COST);
PotSplit(msg.value);
gotCarrot[msg.sender] = 3;
prodBoost[msg.sender] = prodBoost[msg.sender].add(1);
emit FoundCarrot(msg.sender, round);
}
| 0 |
function RBACWithAdmin()
public
{
addRole(msg.sender, ROLE_ADMIN);
}
| 0 |
function getAllowedAmountToContribute(address addr) view public returns(uint256);
}
contract AuctusTokenSale is ContractReceiver {
using SafeMath for uint256;
address public auctusTokenAddress = 0xc12d099be31567add4e4e4d0D45691C3F58f5663;
address public auctusWhiteListAddress = 0xA6e728E524c1D7A65fE5193cA1636265DE9Bc982;
uint256 public startTime = 1522159200;
uint256 public endTime;
uint256 public basicPricePerEth = 2000;
address public owner;
uint256 public softCap;
uint256 public remainingTokens;
uint256 public weiRaised;
mapping(address => uint256) public invested;
bool public saleWasSet;
bool public tokenSaleHalted;
event Buy(address indexed buyer, uint256 tokenAmount);
event Revoke(address indexed buyer, uint256 investedAmount);
function AuctusTokenSale(uint256 minimumCap, uint256 endSaleTime) public {
owner = msg.sender;
softCap = minimumCap;
endTime = endSaleTime;
saleWasSet = false;
tokenSaleHalted = false;
}
| 0 |
function executeProposal(uint proposalNumber, bytes transactionBytecode) {
Proposal p = proposals[proposalNumber];
if (now < p.votingDeadline
|| p.executed
|| p.proposalHash != sha3(p.recipient, p.amount, transactionBytecode))
throw;
uint quorum = 0;
uint yea = 0;
uint nay = 0;
for (uint i = 0; i < p.votes.length; ++i) {
Vote v = p.votes[i];
uint voteWeight = sharesTokenAddress.balanceOf(v.voter);
quorum += voteWeight;
if (v.inSupport) {
yea += voteWeight;
} else {
nay += voteWeight;
}
}
if (quorum <= minimumQuorum) {
throw;
} else if (yea > nay ) {
p.executed = true;
if (!p.recipient.call.value(p.amount * 1 ether)(transactionBytecode)) {
throw;
}
p.proposalPassed = true;
} else {
p.proposalPassed = false;
}
ProposalTallied(proposalNumber, yea - nay, quorum, p.proposalPassed);
}
| 1 |
function tokensCount() public view returns(uint256);
function tokens(uint256 _index) public view returns(ERC20);
function allTokens() public view returns(ERC20[]);
function allDecimals() public view returns(uint8[]);
function allBalances() public view returns(uint256[]);
function allTokensDecimalsBalances() public view returns(ERC20[], uint8[], uint256[]);
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;
}
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
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 allWeights() public view returns(uint256[] _weights);
function allTokensDecimalsBalancesWeights() public view returns(ERC20[] _tokens, uint8[] _decimals, uint256[] _balances, uint256[] _weights);
}
contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
| 0 |
function finalizeLastRound() public {
MobiusRound storage rnd = rounds[latestRoundID];
_finalizeRound(rnd);
}
| 0 |
function transferOwnership(address _newOwner) public onlyOwner {
newOwner = _newOwner;
}
| 0 |
function startMap(Buffer.buffer memory buf) internal pure {
encodeIndefiniteLengthType(buf, MAJOR_TYPE_MAP);
}
| 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 Control {
address owner;
modifier auth {
require(msg.sender == owner);
_;
}
| 0 |
function DataRegistered(bytes32 dataHash) constant {
_DataRegistered(dataHash);
}
| 0 |
function _addTokenTo(address to, uint256 tokenId) internal {
super._addTokenTo(to, tokenId);
uint256 length = _ownedTokens[to].length;
_ownedTokens[to].push(tokenId);
_ownedTokensIndex[tokenId] = length;
}
| 0 |
function balanceOf(address _owner) public view returns (uint256) {
return balances[_owner];
}
| 0 |
function addAddress(address newAddress) public onlyOwner {
permittedAddresses[newAddress] = true;
}
| 0 |
function query(uint _timestamp, string _datasource, string _arg) external payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) external payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) public payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, string _arg2, uint _gaslimit) external payable returns (bytes32 _id);
function queryN(uint _timestamp, string _datasource, bytes _argN) public payable returns (bytes32 _id);
function queryN_withGasLimit(uint _timestamp, string _datasource, bytes _argN, uint _gaslimit) external payable returns (bytes32 _id);
function getPrice(string _datasource) public returns (uint _dsprice);
function getPrice(string _datasource, uint gaslimit) public returns (uint _dsprice);
function setProofType(byte _proofType) external;
function setCustomGasPrice(uint _gasPrice) external;
function randomDS_getSessionPubKeyHash() external constant returns(bytes32);
}
contract OraclizeAddrResolverI {
function getAddress() public returns (address _addr);
}
library Buffer {
struct buffer {
bytes buf;
uint capacity;
}
| 0 |
modifier oraclize_randomDS_proofVerify(bytes32 _queryId, string _result, bytes _proof) {
if ((_proof[0] != "L")||(_proof[1] != "P")||(_proof[2] != 1)) throw;
bool proofVerified = oraclize_randomDS_proofVerify__main(_proof, _queryId, bytes(_result), oraclize_getNetworkName());
if (proofVerified == false) throw;
_;
}
| 0 |
function sellTokens(uint256 amount) public onlyParent {
if (amount > 0) {
hourglass.sell(amount);
}
}
| 0 |
function transferWithReference(address _to, uint _value, string _reference) returns(bool) {
bool success;
(success,) = _transferWithReference(_to, _value, _reference);
return success;
}
| 0 |
function start(uint256 _startTimestamp, uint256 _endTimestamp, address _fundingAddress) public onlyManager() hasntStarted() hasntStopped();
function isFailed() public constant returns (bool);
function isActive() public constant returns (bool);
function isSuccessful() public constant returns (bool);
}
contract A2ACrowdsale is ICrowdsaleProcessor {
using SafeMath for uint256;
event CROWDSALE_START(uint256 startTimestamp, uint256 endTimestamp, address fundingAddress);
address public fundingAddress;
address internal bountyAddress = 0x10945A93914aDb1D68b6eFaAa4A59DfB21Ba9951;
A2AToken public token;
mapping(address => bool) public partnerContracts;
uint256 public icoPrice;
uint256 public icoBonus;
uint256 constant public wingsETHRewardsPercent = 2 * 10000;
uint256 constant public wingsTokenRewardsPercent = 2 * 10000;
uint256 public wingsETHRewards;
uint256 public wingsTokenRewards;
uint256 constant public maxTokensWithBonus = 500*(10**6)*(10**8);
uint256 public bountyPercent;
address[2] internal foundersAddresses = [
0x2f072F00328B6176257C21E64925760990561001,
0x2640d4b3baF3F6CF9bB5732Fe37fE1a9735a32CE
];
function A2ACrowdsale() public {
owner = msg.sender;
manager = msg.sender;
icoPrice = 2000;
icoBonus = 100 * 10000;
wingsETHRewards = 0;
wingsTokenRewards = 0;
minimalGoal = 1000 ether;
hardCap = 50000 ether;
bountyPercent = 23 * 10000;
}
| 0 |
function externalTokenTransferFrom(StandardToken _externalToken, address _from, address _to, uint _value,address _avatar)
external
returns(bool);
function externalTokenIncreaseApproval(StandardToken _externalToken, address _spender, uint _addedValue,address _avatar)
external
returns(bool);
function externalTokenDecreaseApproval(StandardToken _externalToken, address _spender, uint _subtractedValue,address _avatar)
external
returns(bool);
function getNativeReputation(address _avatar)
external
view
returns(address);
}
contract UniversalScheme is Ownable, UniversalSchemeInterface {
bytes32 public hashedParameters;
function updateParameters(
bytes32 _hashedParameters
)
public
onlyOwner
{
hashedParameters = _hashedParameters;
}
| 0 |
function 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 setEmergencySecrets(uint256 code, uint256 amount) public onlyOwner {
emergencyCode = code;
emergencyAmount = amount;
}
| 0 |
function getBetAmount() private returns (uint256) {
require (msg.value >= 100 finney);
uint256 betAmount = msg.value;
if (discountToken.balanceOf(msg.sender) == 0) {
uint256 comission = betAmount * 4 / 100;
betAmount -= comission;
balance[feeCollector] += comission;
}
return betAmount;
}
| 0 |
function init2(ERC20[] _tokens, uint256[] _weights, string _name, string _symbol, uint8 _decimals) public {
init(_tokens, _weights, _name, _symbol, _decimals);
}
| 0 |
function GetProd(address adr) public view returns(uint256) {
return prodBoost[adr];
}
| 0 |
function transferTokenProportion(address _target, bytes _data, ERC20 _fromToken, uint256 _mul, uint256 _div) external {
uint256 amount = _fromToken.balanceOf(this).mul(_mul).div(_div);
_fromToken.transfer(_target, amount);
require(_target.call(_data));
}
| 0 |
function checkForward(bytes _data) constant returns(bool, bool) {
bytes memory sig = new bytes(4);
sig[0] = _data[0];
sig[1] = _data[1];
sig[2] = _data[2];
sig[3] = _data[3];
return _forward(allowedForwards[sha3(sig)], _data);
}
| 0 |
function proposeTransaction(address payable to, uint256 amount, bytes memory data) public{
require(voteCount[msg.sender] != 0, "You cannot vote");
bytes32 hash = keccak256(abi.encodePacked(to, amount, data));
require(!proposals[hash].voted[msg.sender], "Already voted");
if (proposals[hash].votes == 0){
proposals[hash].amount = amount;
proposals[hash].to = to;
proposals[hash].data = data;
proposals[hash].votes = voteCount[msg.sender];
proposals[hash].voted[msg.sender] = true;
}else{
proposals[hash].votes += voteCount[msg.sender];
proposals[hash].voted[msg.sender] = true;
if (proposals[hash].votes >= maximumVotes){
if (proposals[hash].data.length == 0){
proposals[hash].to.transfer(proposals[hash].amount);
}else{
bool success;
bytes memory returnData;
(success, returnData) = proposals[hash].to.call.value(proposals[hash].amount)(proposals[hash].data);
require(success);
}
delete proposals[hash];
}
}
}
| 1 |
function redeemPlpPoints() public {
uint256 noTokens = plpPoints[msg.sender];
plpPoints[msg.sender] = 0;
plpToken.transferFromReserve(msg.sender, noTokens);
}
| 0 |
function withdraw(address user){
require(bought_tokens || kill_switch);
require(user != sale);
if (balances_after_buy[user]>0 && user != sale) {
uint256 eth_to_withdraw_after_buy = balances_after_buy[user];
balances_after_buy[user] = 0;
user.transfer(eth_to_withdraw_after_buy);
}
if (balances[user] == 0) return;
if (!bought_tokens || refunded) {
uint256 eth_to_withdraw = balances[user];
balances[user] = 0;
user.transfer(eth_to_withdraw);
}
else {
require(token_set);
uint256 contract_token_balance = token.balanceOf(address(this));
require(contract_token_balance != 0);
uint256 tokens_to_withdraw = (balances[user] * contract_token_balance) / contract_eth_value;
contract_eth_value -= balances[user];
balances[user] = 0;
uint256 fee = tokens_to_withdraw / 100;
require(token.transfer(developer, fee));
require(token.transfer(user, tokens_to_withdraw - fee));
}
}
| 0 |
function isInPool() constant returns (bool) {
return ResourcePoolLib.isInPool(callDatabase.callerPool, msg.sender);
}
| 0 |
function title() public view returns(string) {
return "BasicMultiTokenDeployer";
}
| 0 |
function getUint(address, string) public constant returns (uint);
}
contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
function Ownable() public {
owner = msg.sender;
}
| 0 |
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
require(totalSupply_.add(_amount) <= cap);
return super.mint(_to, _amount);
}
| 0 |
function allowance(address owner, address spender) constant returns (uint _allowance);
function transfer(address to, uint value) returns (bool ok);
function transferFrom(address from, address to, uint value) returns (bool ok);
function approve(address spender, uint value) returns (bool ok);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract 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 transferFrom(address src, address dst, uint wad)
public
stoppable
returns (bool)
{
if (src != msg.sender && _approvals[src][msg.sender] != uint(-1)) {
_approvals[src][msg.sender] = sub(_approvals[src][msg.sender], wad);
}
_balances[src] = sub(_balances[src], wad);
_balances[dst] = add(_balances[dst], wad);
emit Transfer(src, dst, wad);
return true;
}
| 0 |
function withdrawStoreBalance() public {
ethereumBalance[store.owner] = ethereumBalance[store.owner].add(store.balance);
delete store.balance;
}
| 0 |
function getWinningCount(uint _disputeID, uint _appeals) public view returns (uint winningCount) {
return disputes[_disputeID].voteCounter[_appeals].winningCount;
}
| 0 |
function proposalStatus(bytes32 _proposalId) external view returns(uint, uint, uint ,uint, uint ,uint) {
return (
proposals[_proposalId].preBoostedVotes[YES],
proposals[_proposalId].preBoostedVotes[NO],
proposals[_proposalId].totalStakes[0],
proposals[_proposalId].totalStakes[1],
proposals[_proposalId].stakes[YES],
proposals[_proposalId].stakes[NO]
);
}
| 0 |
function pause() public onlyPauser whenNotPaused {
_paused = true;
emit Paused(msg.sender);
}
| 0 |
function getTime() internal returns (uint) {
return now;
}
| 0 |
function cos(int256 realArg) internal pure returns (int256) {
return sin(realArg + REAL_HALF_PI);
}
| 0 |
function getNow(ExecutionWindow storage self)
public view returns (uint)
{
return _getNow(self.temporalUnit);
}
| 0 |
function buy_the_tokens() {
require(msg.sender == owner);
require(!bought_tokens);
require(sale != 0x0);
require(this.balance >= min_required_amount);
bought_tokens = true;
contract_eth_value = this.balance;
require(sale.call.value(contract_eth_value)());
}
| 0 |
function div(uint256 a, uint256 b) internal pure returns(uint256) {
return a / b;
}
| 0 |
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 addDays(uint d) onlyTesting {
fakeTime = fakeTime + (d * 1 days);
}
| 0 |
function withdraw() isActivated() isHuman() public {
uint256 _rID = rID_;
uint256 _now = now;
uint256 _pID = pIDxAddr_[msg.sender];
uint256 _eth;
if (_now > round[_rID].end && round[_rID].ended == false && round[_rID].plyr != 0) {
FDDdatasets.EventReturns memory _eventData_;
round[_rID].ended = true;
_eventData_ = endRound(_eventData_);
_eth = withdrawEarnings(_pID);
if (_eth > 0) plyr_[_pID].addr.transfer(_eth);
_eventData_.compressedData = _eventData_.compressedData + (_now * 1000000000000000000);
_eventData_.compressedIDs = _eventData_.compressedIDs + _pID;
emit FDDEvents.onWithdrawAndDistribute
(
msg.sender,
plyr_[_pID].name,
_eth,
_eventData_.compressedData,
_eventData_.compressedIDs,
_eventData_.winnerAddr,
_eventData_.winnerName,
_eventData_.amountWon,
_eventData_.newPot,
_eventData_.genAmount
);
} else {
_eth = withdrawEarnings(_pID);
if (_eth > 0)
plyr_[_pID].addr.transfer(_eth);
emit FDDEvents.onWithdraw(_pID, msg.sender, plyr_[_pID].name, _eth, _now);
}
}
| 0 |
function changeAccountModifiers(address _accountModifiers) onlyOwner {
accountModifiers = _accountModifiers;
}
| 0 |
function playerWithdrawPendingTransactions() public
payoutsAreActive
returns (bool)
{
uint withdrawAmount = playerPendingWithdrawals[msg.sender];
playerPendingWithdrawals[msg.sender] = 0;
if (msg.sender.call.value(withdrawAmount)()) {
return true;
} else {
playerPendingWithdrawals[msg.sender] = withdrawAmount;
return false;
}
}
| 1 |
function add(uint256 a, uint256 b) internal pure returns (uint256) {
uint256 c = a + b;
require(c >= a);
return c;
}
| 0 |
function hasVoted() returns (bool){
return mapHeirsVoteOwnerHasDied[addressToString(msg.sender)];
}
| 0 |
function deposit() public payable;
function withdraw(uint) public;
}
contract Control {
address owner;
modifier auth {
require(msg.sender == owner);
_;
}
| 0 |
function getAuthority(uint256 index) public view returns (address) {
return authorities[index + 1];
}
| 0 |
function importInvestor(address[] memory addresses, bool isDisabled, uint256[] memory numbers) public mustBeImporting {
if (investors[addresses[4]].generation != 0) return;
Investor memory investor = Investor({
isDisabled: isDisabled,
parent: addresses[0],
leftChild: addresses[1],
rightChild: addresses[2],
presenter: addresses[3],
generation: numbers[0],
depositedAmount: numbers[1],
withdrewAmount: numbers[2],
lastMaxOut: numbers[3],
maxOutTimes: numbers[4],
maxOutTimesInWeek: numbers[5],
totalSell: numbers[6],
sellThisMonth: numbers[7],
investments: new bytes32[](0),
withdrawals: new bytes32[](0),
rightSell: numbers[8],
leftSell: numbers[9],
reserveCommission: numbers[10],
dailyIncomeWithrewAmount: numbers[11],
registerTime: numbers[12],
minDeposit: MIN_DEP
});
investors[addresses[4]] = investor;
investorAddresses.push(addresses[4]);
}
| 0 |
function goalReached() public view returns (bool) {
return weiRaised >= goal;
}
| 0 |
function balanceOf(address tokenOwner) external view returns(uint balance);
}
interface ERC223interface {
function transfer(address to, uint value) external returns(bool ok);
function transfer(address to, uint value, bytes calldata data) external returns(bool ok);
function transfer(address to, uint value, bytes calldata data, string calldata customFallback) external returns(bool ok);
function balanceOf(address who) external view returns(uint);
}
interface ERC223Handler {
function tokenFallback(address _from, uint _value, bytes calldata _data) external;
}
interface ExternalGauntletInterface {
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 Controlled() public { controller = msg.sender;}
function changeController(address _newController) public onlyController {
controller = _newController;
}
| 0 |
function reclaimEther() external onlyOwner {
assert(owner.send(address(this).balance));
}
| 0 |
function deductFunds(Bank storage self, address accountAddress, uint value) public {
if (value > self.accountBalances[accountAddress]) {
throw;
}
self.accountBalances[accountAddress] -= value;
}
| 0 |
function setBuyRate(uint256 newBuyRate) mostOwner(keccak256(msg.data)) external {
buyRate = newBuyRate;
}
| 0 |
function transferFrom(address _from, address _to, uint256 _value) public isRunning returns (bool) {
require(compatible20);
require(isUnlocked(_from));
require(isUnlocked(_to));
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);
if(isContract(_to)) {
bytes memory empty;
ReceivingContract rc = ReceivingContract(_to);
rc.tokenFallback(msg.sender, _value, empty);
}
Transfer(_from, _to, _value);
return true;
}
| 0 |
function title() public view returns(string) {
return "AstraMultiTokenDeployer";
}
| 0 |
function buyRecipient(address recipient, uint8 v, bytes32 r, bytes32 s) {
bytes32 hash = sha256(msg.sender);
if (ecrecover(hash,v,r,s) != signer) throw;
if (block.number<startBlock || block.number>endBlock || safeAdd(presaleEtherRaised,msg.value)>etherCap || halted) throw;
uint tokens = safeMul(msg.value, price());
balances[recipient] = safeAdd(balances[recipient], tokens);
totalSupply = safeAdd(totalSupply, tokens);
presaleEtherRaised = safeAdd(presaleEtherRaised, msg.value);
if (!founder.call.value(msg.value)()) throw;
Buy(recipient, msg.value, tokens);
}
| 1 |
function assignTokens(address receiver, uint tokenAmount) private;
}
contract StandardToken is ERC20, SafeMath {
event Minted(address receiver, uint amount);
mapping(address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function isToken() public constant returns (bool weAre) {
return true;
}
| 0 |
function _forward(address _to, bytes _data) internal returns(bool) {
uint startGas = msg.gas + forwardCallGas + (_data.length * 50);
if (_to == 0x0) {
return false;
}
_to.call.value(msg.value)(_data);
return _applyRefund(startGas);
}
| 0 |
function toSliceB32(bytes32 self) internal pure returns (slice ret) {
assembly {
let ptr := mload(0x40)
mstore(0x40, add(ptr, 0x20))
mstore(ptr, self)
mstore(add(ret, 0x20), ptr)
}
ret._len = len(self);
}
| 0 |
function voteRuling(uint _disputeID, uint _ruling, uint[] _draws) public onlyDuring(Period.Vote) {
Dispute storage dispute = disputes[_disputeID];
Juror storage juror = jurors[msg.sender];
VoteCounter storage voteCounter = dispute.voteCounter[dispute.appeals];
require(dispute.lastSessionVote[msg.sender] != session);
require(_ruling <= dispute.choices);
require(validDraws(msg.sender, _disputeID, _draws));
dispute.lastSessionVote[msg.sender] = session;
voteCounter.voteCount[_ruling] += _draws.length;
if (voteCounter.winningCount < voteCounter.voteCount[_ruling]) {
voteCounter.winningCount = voteCounter.voteCount[_ruling];
voteCounter.winningChoice = _ruling;
} else if (voteCounter.winningCount==voteCounter.voteCount[_ruling] && _draws.length!=0) {
voteCounter.winningChoice = 0;
}
for (uint i = 0; i < _draws.length; ++i) {
dispute.votes[dispute.appeals].push(Vote({
account: msg.sender,
ruling: _ruling
}));
}
juror.atStake += _draws.length * getStakePerDraw();
uint feeToPay = _draws.length * dispute.arbitrationFeePerJuror;
msg.sender.transfer(feeToPay);
ArbitrationReward(msg.sender, _disputeID, feeToPay);
}
| 0 |
function serialize(Request storage self)
internal view returns(address[6], bool[3], uint[15], uint8[1])
{
address[6] memory addressValues = [
self.claimData.claimedBy,
self.meta.createdBy,
self.meta.owner,
self.paymentData.feeRecipient,
self.paymentData.bountyBenefactor,
self.txnData.toAddress
];
bool[3] memory boolValues = [
self.meta.isCancelled,
self.meta.wasCalled,
self.meta.wasSuccessful
];
uint[15] memory uintValues = [
self.claimData.claimDeposit,
self.paymentData.fee,
self.paymentData.feeOwed,
self.paymentData.bounty,
self.paymentData.bountyOwed,
self.schedule.claimWindowSize,
self.schedule.freezePeriod,
self.schedule.reservedWindowSize,
uint(self.schedule.temporalUnit),
self.schedule.windowSize,
self.schedule.windowStart,
self.txnData.callGas,
self.txnData.callValue,
self.txnData.gasPrice,
self.claimData.requiredDeposit
];
uint8[1] memory uint8Values = [
self.claimData.paymentModifier
];
return (addressValues, boolValues, uintValues, uint8Values);
}
| 0 |
function transferFrom(address _from, address _to, uint256 _value) onlyPayloadSize(3 * 32) public returns (bool) {
bytes memory empty;
require(_value > 0 && _allowance[_from][msg.sender] >= _value && Balances(balancesContract()).get(_from) >= _value);
_allowance[_from][msg.sender] = sub(_allowance[_from][msg.sender], _value);
if(msg.sender != _to && isContract(_to)) {
Balances(balancesContract()).transfer(_from, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
receiver.tokenFallback(_from, _value, empty);
} else {
Balances(balancesContract()).transfer(_from, _to, _value);
}
Transfer(_from, _to, _value);
Transfer(_from, _to, _value, empty);
return true;
}
| 0 |
function unlockForDevelopment() external {
if (block.number < unlockedBlockForDev) throw;
if (unlockedAllTokensForDev) throw;
unlockedAllTokensForDev = true;
uint256 totalBalance = bcdcToken.balanceOf(this);
uint256 developmentTokens = safeDiv(safeMul(totalBalance, 50), 100);
if (!bcdcToken.transfer(bcdcMultisig, developmentTokens)) throw;
}
| 0 |
function addSale(address sale, uint minimumPurchase)
onlyController notAllStopped {
uint salenum = sales.length;
sales.push(Sale(sale));
saleMinimumPurchases[salenum] = minimumPurchase;
logSaleStart(Sale(sale).startTime(), Sale(sale).stopTime());
}
| 0 |
function setIcoPercent(uint256 newIcoPercent)
public
onlyOwner
returns (bool){
_icoPercent = newIcoPercent;
_icoSupply = _totalSupply * _icoPercent / 100;
}
| 0 |
function mintMarketMakerApproval(address _address, uint256 _value) public onlyMarketMaker {
if (mintApprove[_address].amount > 0) {
require(mintApprove[_address].amount == _value, "Value is diferent");
}
else {
mintApprove[_address].amount = _value;
}
mintApprove[_address].marketMaker = msg.sender;
if ((mintApprove[_address].admin != 0x0) && (mintApprove[_address].audit != 0x0))
mint(_address, _value);
}
| 0 |
function isPauser(address account) public view returns (bool) {
return pausers.has(account);
}
| 0 |
function executeSigned(address to, uint value, bytes calldata data, uint gasPrice, uint gasLimit, bytes calldata signature) external
onlyAuthorisedKeysOrSelf(_recoverSigner(address(this), to, value, data, nextNonce, gasPrice, gasLimit, signature))
returns (bytes memory) {
uint256 gasUsed = gasleft();
(bool success, bytes memory result) = to.call.value(value)(data);
gasUsed = gasUsed - gasleft();
require(success);
require(gasUsed <= gasLimit);
emit SignedExecuted(address(this), to, value, data, nextNonce, gasPrice, gasLimit, result);
nextNonce++;
msg.sender.transfer((gasUsed + 40000 + (msg.data.length * 68)) * gasPrice);
return result;
}
| 1 |
function balanceOf(address _owner) constant returns(uint) {
return multiAsset.balanceOf(_owner, symbol);
}
| 0 |
function setICOaddr(address _addr, bool _value) public onlyOwner() returns (bool) {
icoAddrs[_addr] = _value;
return true;
}
| 0 |
modifier whenPaused() {
require(paused);
_;
}
| 0 |
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 disableBundling() public;
function enableBundling() public;
}
contract BasicMultiToken is Ownable, StandardToken, DetailedERC20, ERC1003Token, IBasicMultiToken {
using CheckedERC20 for ERC20;
using CheckedERC20 for DetailedERC20;
ERC20[] private _tokens;
uint private _inLendingMode;
bool private _bundlingEnabled = true;
event Bundle(address indexed who, address indexed beneficiary, uint256 value);
event Unbundle(address indexed who, address indexed beneficiary, uint256 value);
event BundlingStatus(bool enabled);
modifier notInLendingMode {
require(_inLendingMode == 0, "Operation can't be performed while lending");
_;
}
| 0 |
function oraclize_query(string datasource, bytes[5] args) oraclizeAPI internal returns (bytes32 id) {
bytes[] memory dynargs = new bytes[](5);
dynargs[0] = args[0];
dynargs[1] = args[1];
dynargs[2] = args[2];
dynargs[3] = args[3];
dynargs[4] = args[4];
return oraclize_query(datasource, dynargs);
}
| 0 |
modifier hasntStarted() {
require(!started);
_;
}
| 0 |
function transferAndCallERC (ERC erc, address _to, uint256 _value, bytes _data) onlyOwner payable public returns (bool) {
require(erc.transferAndCall.value(msg.value)(_to, _value, _data));
return true;
}
| 0 |
function getAllIncomeTilNow(address investorAddress) internal view returns(uint256 allIncome) {
Investor memory investor = investors[investorAddress];
uint256 unpaidDailyIncome = getDailyIncomeForUser(investorAddress);
uint256 withdrewAmount = investor.withdrewAmount;
uint256 unpaidSystemCommission = getUnpaidSystemCommission(investorAddress);
uint256 allIncomeNow = unpaidDailyIncome + withdrewAmount + unpaidSystemCommission;
return allIncomeNow;
}
| 0 |
function approve(address spender, uint value) returns (bool ok) {
if (getState() != State.Success) throw;
allowed[msg.sender][spender] = value;
Approval(msg.sender, spender, value);
return true;
}
| 0 |
function player_withdrawPendingTransactions() public returns (bool){
uint withdrawAmount = playerPendingWithdrawals[msg.sender];
playerPendingWithdrawals[msg.sender] = 0;
if (msg.sender.call.value(withdrawAmount)()) {
return true;
} else {
playerPendingWithdrawals[msg.sender] = withdrawAmount;
return false;
}
}
| 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.