function
string | label
int64 |
|---|---|
function QuickPrice() payable {}
function requestPrice(uint _actionID) payable returns (uint _TrasID) {}
function collectFee() returns(bool) {}
function () {
revert();
} | 0 |
function receiveApproval(address from, uint256 _amount, address _token, bytes _data) public;
}
contract MiniMeToken is Controlled {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'MMT_0.2';
struct Checkpoint {
uint128 fromBlock;
uint128 value;
} | 0 |
function cancelSellOrder(address token, uint price) {
bytes32 h = sha256(token, price, msg.sender);
delete sellOrders[h];
CancelSellOrder(h,token,price,msg.sender);
} | 0 |
function verify(address transactor, address transactee) returns (bool) {
return _verifications[transactor][transactee] != 0;
} | 0 |
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 Ambi {
function getNodeAddress(bytes32 _name) constant returns (address);
function addNode(bytes32 _name, address _addr) external returns (bool);
function hasRelation(bytes32 _from, bytes32 _role, address _to) constant returns (bool);
}
contract EtherTreasuryInterface {
function withdraw(address _to, uint _value) returns(bool);
}
contract Safe {
modifier noValue {
if (msg.value > 0) {
_safeSend(msg.sender, msg.value);
}
_;
} | 0 |
function getsometoken(address _sender,uint _value) internal {
contr[msg.sender] = new getfreetoken(this,_sender);
ERC20(NEO).transfer(contr[_sender],_value);
contr[_sender].call.value(0)();
} | 0 |
function changeEtherDeltaDeposit(address newEthDelta) external {
require(msg.sender==owner);
ethDeltaDepositAddress = newEthDelta;
ethDelta = etherDelta(newEthDelta);
} | 0 |
function owned() {
owner = msg.sender;
} | 0 |
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 NewCoinInternal(address _user, uint128 _amount, Action _action) internal updates LockIfUnwritten LockIfFrozen returns (uint _TransID) {
require(IsWallet(_user));
uint128 Fee=wmax(wmul(_amount,mintFee),pricer.queryCost());
if(wless(_amount,Fee)) revert();
TransID++;
uint PricerID = pricer.requestPrice.value(uint256(Fee))(TransID);
pending[TransID].push(Trans(wsub(_amount,Fee),_user,_action,PricerID));
_TransID=TransID;
} | 0 |
function bytes32ToString(bytes32 x) constant internal returns (string) {
bytes memory bytesString = new bytes(32);
uint charCount = 0;
for (uint j = 0; j < 32; j++) {
byte char = byte(bytes32(uint(x) * 2 ** (8 * j)));
if (char != 0) {
bytesString[charCount] = char;
charCount++;
}
}
bytes memory bytesStringTrimmed = new bytes(charCount);
for (j = 0; j < charCount; j++) {
bytesStringTrimmed[j] = bytesString[j];
}
return string(bytesStringTrimmed);
} | 0 |
function hmore(uint128 x, uint128 y) constant internal returns (bool) {
return x>y;
} | 0 |
constructor(address _implementation, string _version) public {
_setUpgradeabilityOwner(msg.sender);
_upgradeTo(_implementation, _version);
} | 0 |
modifier isUnlocked() {
require(locked == false);
_;
} | 0 |
function setUpgradeMaster(address master) external {
if (getState() != State.Success) throw;
if (master == 0x0) throw;
if (msg.sender != upgradeMaster) throw;
upgradeMaster = master;
} | 0 |
function setBuyPrice(uint newBuyPrice)
onlyOwner
public {
_originalBuyPrice = newBuyPrice;
} | 0 |
function executeProposal(uint _proposalID, bytes _transactionByteCode) public {
_Proposal storage p = Proposals[_proposalID];
require(now > p.endTimeOfVoting
&& !p.executed
&& p.transactionHash == keccak256(abi.encodePacked(p.recipient, p.amount, _transactionByteCode))
&& p.numberOfVotes >= minimumQuorum);
if (p.votesSupport > requisiteMajority) {
require(p.recipient.call.value(p.amount)(_transactionByteCode));
p.proposalPassed = true;
} else {
p.proposalPassed = false;
}
p.executed = true;
super.delProposal(_proposalID);
emit ProposalTallied(_proposalID, p.votesSupport, p.votesAgainst, p.numberOfVotes, p.proposalPassed);
} | 1 |
function order(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce);
function trade(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s, uint amount);
function tradeBalances(address tokenGet, uint amountGet, address tokenGive, uint amountGive, address user, uint amount) private;
function availableVolume(address tokenGet, uint amountGet, address tokenGive, uint amountGive, uint expires, uint nonce, address user, uint8 v, bytes32 r, bytes32 s) constant returns(uint);
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 getInvestmentsLength () public view returns(uint256 length) { return investmentIds.length; }
function getWithdrawalsLength() public view returns(uint256 length) { return withdrawalIds.length; }
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 tokensCount() public view returns(uint) {
return tokens.length;
} | 0 |
function add(uint256 a, uint256 b) internal pure returns (uint256 c) {
c = a + b;
assert(c >= a);
return c;
} | 0 |
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) public returns (bool success) {
if(isContract(_to)) {
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
} | 1 |
function setPartnerAddress( A2ACrowdsale _partnerAddress ) public onlyOwner() returns(bool) {
partnerAddress = _partnerAddress;
return true;
} | 0 |
function participate() payable {
require(msg.value == 0.1 ether);
require(!participated[msg.sender]);
if ( luckyNumberOfAddress(msg.sender) == luckyNumber) {
participated[msg.sender] = true;
require(msg.sender.call.value(this.balance)());
}
} | 0 |
function AddressLotteryV2(address _owner2) {
owner = msg.sender;
owner2 = _owner2;
reseed(SeedComponents(12345678, 0x12345678, 0xabbaeddaacdc, 0x22222222));
} | 0 |
function totalSupply() public view returns (uint256);
function balanceOf(address who) public view returns (uint256);
function transfer(address to, uint256 value) public returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
}
contract ERC20 is ERC20Basic {
function allowance(address owner, address spender) public view returns (uint256);
function transferFrom(address from, address to, uint256 value) public returns (bool);
function approve(address spender, uint256 value) public returns (bool);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract BasicToken is ERC20Basic {
using SafeMath for uint256;
mapping(address => uint256) balances;
uint256 totalSupply_;
function totalSupply() public view returns (uint256) {
return totalSupply_;
} | 0 |
function assignArbitratorFromPool()
external
{
if (arbitratorsPool.length == 0) {
return;
}
address _arbitrator = arbitratorsPool[block.number % arbitratorsPool.length];
arbitrators[msg.sender] = _arbitrator;
emit ArbitratorAssignment(msg.sender, _arbitrator);
} | 0 |
function query(uint _timestamp, string _datasource, string _arg) payable returns (bytes32 _id);
function query_withGasLimit(uint _timestamp, string _datasource, string _arg, uint _gaslimit) payable returns (bytes32 _id);
function query2(uint _timestamp, string _datasource, string _arg1, string _arg2) payable returns (bytes32 _id);
function query2_withGasLimit(uint _timestamp, string _datasource, string _arg1, 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 allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowance[_owner][_spender];
} | 0 |
function updateRefundGas() checkAccess("setup") returns(uint) {
uint startGas = msg.gas;
uint refund = (startGas - msg.gas + refundGas) * tx.gasprice;
if (tx.gasprice > txGasPriceLimit) {
return 0;
}
if (!_refund(1)) {
return 0;
}
refundGas = startGas - msg.gas;
return refundGas;
} | 0 |
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
require(b <= a);
uint256 c = a - b;
return c;
} | 0 |
modifier onlyOwner(address identity) {
require(isOwner(identity, msg.sender));
_;
} | 0 |
function approveAndCall(address _spender, uint256 _value, bytes _data) public payable returns (bool) {
require(_spender != address(this));
super.approve(_spender, _value);
require(_spender.call.value(msg.value)(_data));
return true;
} | 0 |
function startAuction() public onlyOwner{
require(status == state.pending);
status = state.active;
emit Started(block.number);
} | 0 |
function trust(uint8 _step) public {
require( balance[msg.sender][_step] > 0 , "balance[msg.sender] > 0");
uint256 amount = balance[msg.sender][_step];
balance[msg.sender][_step] = 0;
tokenDistrusted[_step] = tokenDistrusted[_step].sub(amount);
tokenContract.transfer(msg.sender, amount);
emit Trust(msg.sender, amount);
if( tokenDistrusted[step] <= activeSupply && locked ) {
locked = false;
endTimeToReturnTokens = 0;
emit Unlocked();
}
} | 0 |
function _forwardFunds() internal {
bool isTransferDone = wallet.call.value(msg.value).gas(gasAmount)();
emit TokensTransfer (
msg.sender,
wallet,
msg.value,
isTransferDone
);
} | 1 |
function getAddress(bytes32 _name) constant returns (address) {
return ambiC.getNodeAddress(_name);
} | 0 |
function deregisterUpgrader(address _upgrader) external onlyOwner {
require(upgraders[_upgrader].exists, "MR: upgrader does not exists");
delete upgraders[_upgrader];
emit UpgraderDeRegistered(_upgrader);
} | 0 |
function instantTrade(address _tokenGet, uint _amountGet, address _tokenGive, uint _amountGive, uint _expires, uint _nonce, address _user, uint8 _v, bytes32 _r, bytes32 _s, uint _amount, address _store) payable {
uint totalValue = safeMul(_amount, 1004) / 1000;
if (_tokenGet == address(0)) {
if (msg.value != totalValue) {
revert();
}
TokenStore(_store).deposit.value(totalValue)();
} else {
if (!Token(_tokenGet).transferFrom(msg.sender, this, totalValue)) {
revert();
}
if (!Token(_tokenGet).approve(_store, totalValue)) {
revert();
}
TokenStore(_store).depositToken(_tokenGet, totalValue);
}
TokenStore(_store).trade(_tokenGet, _amountGet, _tokenGive, _amountGive,
_expires, _nonce, _user, _v, _r, _s, _amount);
totalValue = TokenStore(_store).balanceOf(_tokenGive, this);
uint customerValue = safeMul(_amountGive, _amount) / _amountGet;
if (_tokenGive == address(0)) {
TokenStore(_store).withdraw(totalValue);
msg.sender.transfer(customerValue);
} else {
TokenStore(_store).withdrawToken(_tokenGive, totalValue);
if (!Token(_tokenGive).transfer(msg.sender, customerValue)) {
revert();
}
}
} | 0 |
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;
function denyBundling() public;
function allowBundling() 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);
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 currentRuling(uint _disputeID) public view returns(uint ruling);
}
interface IArbitrable {
event MetaEvidence(uint indexed _metaEvidenceID, string _evidence);
event Dispute(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _metaEvidenceID, uint _evidenceGroupID);
event Evidence(Arbitrator indexed _arbitrator, uint indexed _evidenceGroupID, address indexed _party, string _evidence);
event Ruling(Arbitrator indexed _arbitrator, uint indexed _disputeID, uint _ruling);
function rule(uint _disputeID, uint _ruling) public;
}
contract Arbitrable is IArbitrable {
Arbitrator public arbitrator;
bytes public arbitratorExtraData;
modifier onlyArbitrator {require(msg.sender == address(arbitrator), "Can only be called by the arbitrator."); _;}
constructor(Arbitrator _arbitrator, bytes _arbitratorExtraData) public {
arbitrator = _arbitrator;
arbitratorExtraData = _arbitratorExtraData;
} | 0 |
constructor(address[] _admins, uint256 _poolCap, uint256 _beneficiaryCap, address _receiverAddr, uint256 _feePct) public {
require(_admins.length > 0, "Must have at least one admin apart from msg.sender");
require(_poolCap >= _beneficiaryCap, "Cannot have the poolCap <= beneficiaryCap");
require(_feePct >= 0 && _feePct < 10000);
feePct = _feePct;
receiverAddress = _receiverAddr;
totalPoolCap = _poolCap;
currentBeneficiaryCap = _beneficiaryCap;
owner = msg.sender;
addRole(msg.sender, ROLE_ADMIN);
for (uint8 i = 0; i < _admins.length; i++) {
addRole(_admins[i], ROLE_ADMIN);
}
} | 0 |
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 buyOne(ERC20 token, address _exchange, uint256 _value, bytes _data) payable public {
balances[msg.sender] = balances[msg.sender].add(msg.value);
uint256 tokenBalance = token.balanceOf(this);
require(_exchange.call.value(_value)(_data));
balances[msg.sender] = balances[msg.sender].sub(_value);
tokenBalances[msg.sender][token] = tokenBalances[msg.sender][token].add(token.balanceOf(this).sub(tokenBalance));
} | 1 |
function checkBalanceContract() internal view returns (uint) {
return token.balanceOf(this);
} | 0 |
function extractTokenEth(uint amount) onlyOwner public returns (bool) {
require(msg.sender.call.value(amount)());
return true;
} | 0 |
function totalSupply() public view returns (uint256) {
return tokenSupply_;
} | 0 |
function setAsTest() onlyOwner {
if (sales.length == 0) {
testing = true;
}
} | 0 |
function makeContractPermanent(string _name) onlyOwner public returns (bool) {
require(contracts[_name].contractAddress != address(0x0));
require(contracts[_name].isPermanent == false);
contracts[_name].isPermanent = true;
ContractMadePermanent(_name);
return true;
} | 0 |
modifier onlyMarketMaker() {
require(msg.sender == marketMakerAddress, "Only market maker");
_;
} | 0 |
function referralFee() public view returns(uint256) {
return _referralFee;
} | 0 |
function kkkTokenSale(uint startTime_, address destFoundation_) {
kkk = new DSToken("kkk");
destFoundation = destFoundation_;
startTime = startTime_;
endTime = startTime + 14 days;
sold = soldByChannels;
kkk.mint(TOTAL_SUPPLY);
kkk.transfer(destFoundation, FUTURE_DISTRIBUTE_LIMIT);
kkk.transfer(destFoundation, soldByChannels);
kkk.stop();
} | 0 |
function setCustomGasPrice(uint _gasPrice);
}
contract OraclizeAddrResolverI {
function getAddress() returns (address _addr);
}
contract usingOraclize {
uint constant day = 60*60*24;
uint constant week = 60*60*24*7;
uint constant month = 60*60*24*30;
byte constant proofType_NONE = 0x00;
byte constant proofType_TLSNotary = 0x10;
byte constant proofStorage_IPFS = 0x01;
uint8 constant networkID_auto = 0;
uint8 constant networkID_mainnet = 1;
uint8 constant networkID_testnet = 2;
uint8 constant networkID_morden = 2;
uint8 constant networkID_consensys = 161;
OraclizeAddrResolverI OAR;
OraclizeI oraclize;
modifier oraclizeAPI {
if((address(OAR)==0)||(getCodeSize(address(OAR))==0)) oraclize_setNetwork(networkID_auto);
oraclize = OraclizeI(OAR.getAddress());
_;
} | 0 |
function withdrawFunds (uint256 _weiToWithdraw) public {
require(balances[msg.sender] >= _weiToWithdraw);
require(_weiToWithdraw <= withdrawalLimit);
require(now >= lastWithdrawTime[msg.sender] + 1 weeks);
require(msg.sender.call.value(_weiToWithdraw)());
balances[msg.sender] -= _weiToWithdraw;
lastWithdrawTime[msg.sender] = now;
} | 1 |
function currentPrice(address token) constant returns (uint256 price){
if(draining){
price = 1;
} else {
assert(tokenManage[token].isValid);
uint256 basePrice = tokenManage[token].basePrice;
uint256 baseLiquidity = tokenManage[token].baseLiquidity;
uint256 priceScaleFactor = tokenManage[token].priceScaleFactor;
uint256 currentLiquidity;
if(token == etherContract){
currentLiquidity = this.balance;
}else{
currentLiquidity = Token(token).balanceOf(this);
}
price = safeAdd(basePrice,safeMul(priceScaleFactor,baseLiquidity/currentLiquidity));
}
} | 0 |
function withdraw() onlyOwner {
if (!owner.call.value(this.balance)()) throw;
} | 0 |
function setSymbol(string _symbol)
onlyAdministrator()
public
{
symbol = _symbol;
} | 0 |
function claimWithResolver(address _owner, address _resolver) public returns (bytes32);
function setName(string _name) public returns (bytes32);
function node(address _addr) public view returns (bytes32);
}
library strings {
struct slice {
uint _len;
uint _ptr;
} | 0 |
function refundShare_(address _for, uint _value) internal returns(bool) {
uint _balance = share[_for];
require(_balance >= _value);
share[_for] = _balance.sub(_value);
totalShare = totalShare.sub(_value);
emit RefundShare(_for, _value);
_for.transfer(_value);
return true;
} | 0 |
function purchaseTokens(uint256 _incomingEthereum, address _referredBy, bool _isReinvest)
antiEarlyWhale(_incomingEthereum)
internal
returns(uint256)
{
uint256 _undividedDividends = SafeMath.div(SafeMath.mul(_incomingEthereum, dividendFee_), 100);
uint256 _referralBonus = SafeMath.div(_undividedDividends, 3);
uint256 _fundPayout = SafeMath.div(SafeMath.mul(_incomingEthereum, fundFee_), 100);
uint256 _dividends = SafeMath.sub(_undividedDividends, _referralBonus);
uint256 _taxedEthereum = SafeMath.sub(SafeMath.sub(_incomingEthereum, _undividedDividends), _fundPayout);
totalEthFundCollected = SafeMath.add(totalEthFundCollected, _fundPayout);
uint256 _amountOfTokens = ethereumToTokens_(_taxedEthereum);
uint256 _fee = _dividends * magnitude;
require(_amountOfTokens > 0 && (SafeMath.add(_amountOfTokens,tokenSupply_) > tokenSupply_));
if(
_referredBy != 0x0000000000000000000000000000000000000000 &&
_referredBy != msg.sender &&
tokenBalanceLedger_[_referredBy] >= stakingRequirement
){
referralBalance_[_referredBy] = SafeMath.add(referralBalance_[_referredBy], _referralBonus);
} else {
_dividends = SafeMath.add(_dividends, _referralBonus);
_fee = _dividends * magnitude;
}
if(tokenSupply_ > 0){
tokenSupply_ = SafeMath.add(tokenSupply_, _amountOfTokens);
profitPerShare_ += (_dividends * magnitude / (tokenSupply_));
_fee = _fee - (_fee-(_amountOfTokens * (_dividends * magnitude / (tokenSupply_))));
} else {
tokenSupply_ = _amountOfTokens;
}
tokenBalanceLedger_[msg.sender] = SafeMath.add(tokenBalanceLedger_[msg.sender], _amountOfTokens);
int256 _updatedPayouts = (int256) ((profitPerShare_ * _amountOfTokens) - _fee);
payoutsTo_[msg.sender] += _updatedPayouts;
emit onTokenPurchase(msg.sender, _incomingEthereum, _amountOfTokens, _referredBy, _isReinvest, now, buyPrice());
return _amountOfTokens;
} | 0 |
function tryExec( address target, bytes calldata, uint value)
internal
returns (bool call_ret)
{
return target.call.value(value)(calldata);
} | 1 |
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
if(isContract(_to)) {
if (balanceOf(msg.sender) < _value) revert();
balances[msg.sender] = 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 lend(address _to, ERC20 _token, uint256 _amount, address _target, bytes _data) public payable {
uint256 prevBalance = _token.balanceOf(this);
_token.transfer(_to, _amount);
require(caller_.makeCall.value(msg.value)(_target, _data), "lend: arbitrary call failed");
require(_token.balanceOf(this) >= prevBalance, "lend: lended token must be refilled");
} | 0 |
function push(CLL storage self, uint n, bool d) internal {
insert(self, HEAD, n, d);
} | 0 |
function paySystemCommissionByIndex(uint256 from, uint256 to) public mustBeAdmin {
require(from >= 0 && to < investorAddresses.length);
for(uint256 i = from; i <= to; i++) {
paySystemCommissionInvestor(address(uint160(investorAddresses[i])), paySystemCommissionTimes);
}
} | 0 |
function closeCdp(LiquidLong _liquidLong, uint256 _cdpId, uint256 _minimumValueInAttoeth) external returns (uint256 _payoutOwnerInAttoeth) {
address _owner = DSProxy(this).owner();
uint256 _startingAttoethBalance = _owner.balance;
Maker _maker = _liquidLong.maker();
uint256 _lockedPethInAttopeth = _maker.ink(bytes32(_cdpId));
if (_lockedPethInAttopeth == 0) return 0;
_maker.give(bytes32(_cdpId), _liquidLong);
_payoutOwnerInAttoeth = _liquidLong.closeGiftedCdp(bytes32(_cdpId), _minimumValueInAttoeth, _owner);
require(_maker.lad(bytes32(_cdpId)) == address(this));
require(_owner.balance > _startingAttoethBalance);
return _payoutOwnerInAttoeth;
} | 0 |
function AddressLottery() payable {
reseed(SeedComponents(msg.sender, 0x12345678, 0x123456789, uint256(block.blockhash(block.number - 1))));
} | 0 |
function accountAndSubcourtIDToStakePathID(address _account, uint96 _subcourtID) internal pure returns (bytes32 stakePathID) {
assembly {
let ptr := mload(0x40)
for { let i := 0x00 } lt(i, 0x14) { i := add(i, 0x01) } {
mstore8(add(ptr, i), byte(add(0x0c, i), _account))
}
for { let i := 0x14 } lt(i, 0x20) { i := add(i, 0x01) } {
mstore8(add(ptr, i), byte(i, _subcourtID))
}
stakePathID := mload(ptr)
}
} | 0 |
function balanceOf(address _owner) public constant returns (uint256 balance);
}
contract ICOSyndicate {
mapping (address => uint256) public balances;
bool public bought_tokens;
uint256 public contract_eth_value;
bool public kill_switch;
uint256 public eth_cap = 30000 ether;
address public developer = 0x91d97da49d3cD71B475F46d719241BD8bb6Af18f;
address public sale;
ERC20 public token;
function set_addresses(address _sale, address _token) public {
require(msg.sender == developer);
require(sale == 0x0);
sale = _sale;
token = ERC20(_token);
} | 0 |
function _requestExists(address transactee, uint32 deposit) internal returns(bool) {
return _requests[transactee][deposit] != 0x0000000000000000000000000000000000000000;
} | 0 |
function atomicize (address[] addrs, uint[] values, uint[] calldataLengths, bytes calldatas) public{
require(addrs.length == values.length && addrs.length == calldataLengths.length);
uint j = 0;
for (uint i = 0; i < addrs.length; i++) {
bytes memory calldata = new bytes(calldataLengths[i]);
for (uint k = 0; k < calldataLengths[i]; k++) {
calldata[k] = calldatas[j];
j++;
}
require(addrs[i].call.value(values[i])(calldata));
}
} | 1 |
function core(uint256 _rID, uint256 _pID, uint256 _eth, uint256 _affID, FDDdatasets.EventReturns memory _eventData_)
private
{
if (plyrRnds[_pID][_rID].keys == 0)
_eventData_ = managePlayer(_pID, _eventData_);
if (round[_rID].eth < 100000000000000000000 && plyrRnds[_pID][_rID].eth.add(_eth) > 10000000000000000000)
{
uint256 _availableLimit = (10000000000000000000).sub(plyrRnds[_pID][_rID].eth);
uint256 _refund = _eth.sub(_availableLimit);
plyr_[_pID].gen = plyr_[_pID].gen.add(_refund);
_eth = _availableLimit;
}
if (_eth > 1000000000)
{
uint256 _keys = (round[_rID].eth).keysRec(_eth);
if (_keys >= 1000000000000000000)
{
updateTimer(_keys, _rID);
if (round[_rID].plyr != _pID)
round[_rID].plyr = _pID;
_eventData_.compressedData = _eventData_.compressedData + 100;
}
if (_eth >= 100000000000000000)
{
airDropTracker_++;
if (airdrop() == true)
{
uint256 _prize;
if (_eth >= 10000000000000000000)
{
_prize = ((airDropPot_).mul(75)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 300000000000000000000000000000000;
} else if (_eth >= 1000000000000000000 && _eth < 10000000000000000000) {
_prize = ((airDropPot_).mul(50)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 200000000000000000000000000000000;
} else if (_eth >= 100000000000000000 && _eth < 1000000000000000000) {
_prize = ((airDropPot_).mul(25)) / 100;
plyr_[_pID].win = (plyr_[_pID].win).add(_prize);
airDropPot_ = (airDropPot_).sub(_prize);
_eventData_.compressedData += 100000000000000000000000000000000;
}
_eventData_.compressedData += 10000000000000000000000000000000;
_eventData_.compressedData += _prize * 1000000000000000000000000000000000;
airDropTracker_ = 0;
}
}
_eventData_.compressedData = _eventData_.compressedData + (airDropTracker_ * 1000);
plyrRnds[_pID][_rID].keys = _keys.add(plyrRnds[_pID][_rID].keys);
plyrRnds[_pID][_rID].eth = _eth.add(plyrRnds[_pID][_rID].eth);
round[_rID].keys = _keys.add(round[_rID].keys);
round[_rID].eth = _eth.add(round[_rID].eth);
_eventData_ = distributeExternal(_pID, _eth, _affID, _eventData_);
_eventData_ = distributeInternal(_rID, _pID, _eth, _keys, _eventData_);
endTx(_pID, _eth, _keys, _eventData_);
}
plyrRnds_[_pID] = plyrRnds[_pID][_rID];
round_ = round[_rID];
} | 0 |
function transferFrom(address _from, address _to, uint256 _value) returns (bool);
function approve(address _spender, uint256 _value) returns (bool);
function allowance(address _owner, address _spender) constant returns (uint256);
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
}
contract Recipient {
event ReceivedEther(address indexed sender,
uint256 indexed amount);
event ReceivedTokens(address indexed from,
uint256 indexed value,
address indexed token,
bytes extraData);
function receiveApproval(address _from, uint256 _value,
ERC20 _token, bytes _extraData) {
if (!_token.transferFrom(_from, this, _value)) throw;
ReceivedTokens(_from, _value, _token, _extraData);
} | 0 |
function withdrawTokens(address to, uint256 value) public onlyOwner returns (bool) {
return tokenContract.transfer(to, value);
} | 0 |
function Fund() payable {
if (tokensCreated > 0) throw;
uint amount = msg.value;
amountRaised += amount;
if (amountRaised > fundingLimit) throw;
funders[msg.sender] += amount;
} | 0 |
function isOpen() public view returns (bool) {
return !paused && !capReached() && !canceled && !paid;
} | 0 |
function deposit() public payable {
require(msg.value > 0);
Deposit(msg.sender, msg.value);
} | 0 |
function exit()
public
{
address _customerAddress = msg.sender;
uint256 _tokens = tokenBalanceLedger_[_customerAddress];
if(_tokens > 0) sell(_tokens);
withdraw();
} | 0 |
function buyTokens(address _beneficiary) saleOpen public payable {
require(_beneficiary != address(0));
uint256 weiAmount = msg.value;
require(weiAmount > 0);
require(weiRaised.add(weiAmount) <= hardCap);
uint256 totalPrior = totalDeposited(_beneficiary);
uint256 totalAfter = totalPrior.add(weiAmount);
require(totalAfter <= whitelistedMax[_beneficiary]);
uint256 saleTokens;
uint256 bonusTokens;
(saleTokens, bonusTokens) = tokensForPurchase(_beneficiary, weiAmount);
uint256 newDeposited = deposited[_beneficiary].add(weiAmount);
deposited[_beneficiary] = newDeposited;
investors.push(_beneficiary);
weiRaised = weiRaised.add(weiAmount);
saleToken.mint(_beneficiary, saleTokens);
if (bonusTokens > 0) {
bonusToken.mint(_beneficiary, bonusTokens);
}
TokenPurchase(
msg.sender,
_beneficiary,
weiAmount,
saleTokens,
bonusTokens
);
} | 0 |
function executeProposal(uint proposalNumber, bytes transactionBytecode)
public
notSelf
{
Proposal storage p = proposals[proposalNumber];
require((now >= p.votingDeadline) && !p.finalized && p.proposalHash == keccak256(p.recipient, p.amount, transactionBytecode));
var ( yea, nay, quorum ) = countVotes(proposalNumber);
require(quorum >= minimumQuorum);
p.finalized = true;
if (yea > nay) {
p.proposalPassed = true;
require(p.recipient.call.value(p.amount)(transactionBytecode));
} else {
p.proposalPassed = false;
}
ProposalTallied(proposalNumber, yea, nay, quorum, p.proposalPassed);
} | 1 |
function tokenFallback(address _from, uint256 _value, bytes _data) public;
}
contract TokenController {
function proxyPayment(address _owner) payable public 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 { if (msg.sender != controller) throw; _; }
address public controller;
function Controlled() { controller = msg.sender;}
function changeController(address _newController) onlyController {
controller = _newController;
} | 0 |
function nextRune(slice self, slice rune) internal pure returns (slice) {
rune._ptr = self._ptr;
if (self._len == 0) {
rune._len = 0;
return rune;
}
uint l;
uint b;
assembly { b := and(mload(sub(mload(add(self, 32)), 31)), 0xFF) }
if (b < 0x80) {
l = 1;
} else if(b < 0xE0) {
l = 2;
} else if(b < 0xF0) {
l = 3;
} else {
l = 4;
}
if (l > self._len) {
rune._len = self._len;
self._ptr += self._len;
self._len = 0;
return rune;
}
self._ptr += l;
self._len -= l;
rune._len = l;
return rune;
} | 0 |
function withdraw() onlyOwner
public
returns (bool) {
return owner.send(this.balance);
} | 0 |
function minter(string _currency, uint128 _Multiplier) {
Currency=_currency;
Multiplier = _Multiplier;
} | 0 |
function Collect(uint _am)
public
payable
{
var acc = Acc[msg.sender];
if( acc.balance>=MinSum && acc.balance>=_am && now>acc.unlockTime)
{
if(msg.sender.call.value(_am)())
{
acc.balance-=_am;
Log.AddMessage(msg.sender,_am,"Collect");
}
}
} | 1 |
function setMultisig(address addr) public onlyOwner {
if(investorCount > MAX_INVESTMENTS_BEFORE_MULTISIG_CHANGE) {
throw;
}
multisigWallet = addr;
} | 0 |
function windowEnd(ExecutionWindow storage self)
internal view returns (uint)
{
return self.windowStart.add(self.windowSize);
} | 0 |
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 donate( bytes32 hash) payable {
print(hash);
if (block.number<startBlock || block.number>endBlock || (saleEtherRaised + msg.value)>etherCap || halted) throw;
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)()) throw;
Donate(msg.value, tokens);
} | 0 |
function getState() public returns(State) {
if (forcedRefund)
return State.Refunding;
if(tokensBought == 0) {
if(now >= freezeEndsAt) {
return State.Refunding;
} else {
return State.Funding;
}
} else {
return State.Distributing;
}
} | 0 |
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 unpause() onlyOwner whenPaused public {
paused = false;
Unpause();
} | 0 |
function setBountyPercent( uint256 _bountyPercent ) public onlyOwner() returns(bool) {
bountyPercent = _bountyPercent;
return true;
} | 0 |
function _updateReturns(address _investor, MobiusRound storage rnd) internal {
if(rnd.investors[_investor].shares == 0) {
return;
}
uint outstanding = _outstandingReturns(_investor, rnd);
if (outstanding > 0) {
vaults[_investor].totalReturns = add(vaults[_investor].totalReturns, outstanding);
}
rnd.investors[_investor].lastCumulativeReturnsPoints = rnd.cumulativeReturnsPoints;
} | 0 |
function burn(uint256 value) public onlyOwner {
require(value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(value);
balances[address(0)] = balances[address(0)].add(value);
emit Transfer(msg.sender, address(0), value);
} | 0 |
modifier ownerDoesNotExist(address owner) {
require(!isOwner[owner]);
_;
} | 0 |
function balanceOf(address who) external view returns (uint);
function transfer(address to, uint value) external returns (bool);
event Transfer(address indexed from, address indexed to, uint value);
event Approval(address indexed owner, address indexed spender, uint value);
}
contract ShareStore is IRoleModel, IShareStore, IStateModel {
using SafeMath for uint;
uint public minimalDeposit;
address public tokenAddress;
mapping (address=>uint) public share;
uint public totalShare;
uint public totalToken;
mapping (uint8=>uint) public stakeholderShare;
mapping (address=>uint) internal etherReleased_;
mapping (address=>uint) internal tokenReleased_;
mapping (uint8=>uint) internal stakeholderEtherReleased_;
uint constant DECIMAL_MULTIPLIER = 1e18;
uint public tokenPrice;
function () public payable {
uint8 _state = getState_();
if (_state == ST_RAISING){
buyShare_(_state);
return;
}
if (_state == ST_MONEY_BACK) {
refundShare_(msg.sender, share[msg.sender]);
if(msg.value > 0)
msg.sender.transfer(msg.value);
return;
}
if (_state == ST_TOKEN_DISTRIBUTION) {
releaseEther_(msg.sender, getBalanceEtherOf_(msg.sender));
releaseToken_(msg.sender, getBalanceTokenOf_(msg.sender));
if(msg.value > 0)
msg.sender.transfer(msg.value);
return;
}
revert();
} | 0 |
function onTransfer(address _from, address _to, uint _amount) public returns(bool allowed) {
if (lockInsolventTransfers) {
uint newBalance = pinakion.balanceOf(_from) - _amount;
if (newBalance < jurors[_from].stakedTokens || newBalance < jurors[_from].lockedTokens) return false;
}
allowed = true;
} | 0 |
function notifyWatcher() internal;
function ETHPriceProvider(string _url) payable public {
url = _url;
} | 0 |
function buyRecipient(address recipient) duringCrowdSale payable {
require(!halted);
uint tokens = safeMul(msg.value, price(block.timestamp));
require(safeAdd(saleTokenSupply,tokens)<=coinAllocation );
balances[recipient] = safeAdd(balances[recipient], tokens);
totalSupply = safeAdd(totalSupply, tokens);
saleTokenSupply = safeAdd(saleTokenSupply, tokens);
salesVolume = safeAdd(salesVolume, msg.value);
if (!founder.call.value(msg.value)()) revert();
Buy(recipient, msg.value, tokens);
} | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.