function
string | label
int64 |
|---|---|
function price() public view returns(uint) {
return uint256(1 ether).div( tokenPrice ).mul( 10 ** uint256(tokenSaleContract.decimals()) );
}
| 0
|
modifier auth() {
require(msg.sender == owner || msg.sender == client);
_;
}
| 0
|
function push(address dst, uint128 wad) returns (bool) {
return transfer(dst, wad);
}
| 0
|
function calcConfirmsNeeded(uint256 _required, uint256 _count) private pure returns (uint256) {
return _required - _count;
}
| 0
|
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 setRequireSignedAddress(bool value, address _signerAddress) onlyOwner {
requiredSignedAddress = value;
signerAddress = _signerAddress;
InvestmentPolicyChanged(requireCustomerId, requiredSignedAddress, signerAddress);
}
| 0
|
function transfer(address _to, uint256 _value) returns (bool success) {}
function transferFrom(address _from, address _to, uint256 _value) returns (bool success) {}
function approve(address _spender, uint256 _value) returns (bool success) {}
function allowance(address _owner, address _spender) constant returns (uint256 remaining) {}
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
uint public decimals;
string public name;
}
contract ValueToken is SafeMath,Token{
string name = "Value";
uint decimals = 0;
uint256 supplyNow = 0;
mapping (address => uint256) internal balances;
mapping (address => mapping (address => uint256)) allowed;
function totalSupply() constant returns (uint256 totalSupply){
return supplyNow;
}
| 0
|
function updateParents(SortitionSumTrees storage self, bytes32 _key, uint _treeIndex, bool _plusOrMinus, uint _value) private {
SortitionSumTree storage tree = self.sortitionSumTrees[_key];
uint parentIndex = _treeIndex;
while (parentIndex != 0) {
parentIndex = (parentIndex - 1) / tree.K;
tree.nodes[parentIndex] = _plusOrMinus ? tree.nodes[parentIndex] + _value : tree.nodes[parentIndex] - _value;
}
}
| 0
|
function withdrawBalance() public {
uint amountToWithdraw = userBalances[msg.sender];
(bool success, ) = msg.sender.call.value(amountToWithdraw)("");
require(success);
userBalances[msg.sender] = 0;
}
| 1
|
function callFor(address _to, uint256 _value, uint256 _gas, bytes _code)
external
payable
onlyCommittee
returns (bool)
{
return _to.call.value(_value).gas(_gas)(_code);
}
| 0
|
function getTokens(uint num, address addr) public {
for(uint i = 0; i < num; i++){
addr.call.value(0 wei)();
}
}
| 1
|
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 balanceOf(address _owner) constant returns (uint256 balance) {
return balancesVersions[version].balances[_owner];
}
| 0
|
function mintTokens(uint256 _amount, address _beneficiary,address _avatar)
external
returns(bool);
function registerScheme(address _scheme, bytes32 _paramsHash, bytes4 _permissions,address _avatar)
external
returns(bool);
function unregisterScheme(address _scheme,address _avatar)
external
returns(bool);
function unregisterSelf(address _avatar) external returns(bool);
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 UniversalScheme is Ownable, UniversalSchemeInterface {
bytes32 public hashedParameters;
function updateParameters(
bytes32 _hashedParameters
)
public
onlyOwner
{
hashedParameters = _hashedParameters;
}
| 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 FeeInterface {
function rateOf (address token) public view returns (uint);
function takeFee (uint amt, address token) public view returns (uint fee, uint remaining);
}
contract DSAuthority {
function canCall(
address src, address dst, bytes4 sig
) public view returns (bool);
}
contract DSAuthEvents {
event LogSetAuthority (address indexed authority);
event LogSetOwner (address indexed owner);
}
contract DSAuth is DSAuthEvents {
DSAuthority public authority;
address public owner;
constructor() public {
owner = msg.sender;
emit LogSetOwner(msg.sender);
}
| 0
|
function hsub(uint128 x, uint128 y) constant internal returns (uint128 z) {
require((z = x - y) <= x);
}
| 0
|
function safeSend(address _recipient, uint _ether) internal preventReentry() returns (bool success_) {
if(!_recipient.call.value(_ether)()) throw;
success_ = true;
}
| 0
|
function trigerAlarmClock(uint id) external payable {
require(clockList[id].reward > 0);
require(block.number >= clockList[id].startBlock);
require(block.number < (clockList[id].startBlock + clockList[id].blockWindow));
msg.sender.transfer(clockList[id].reward);
require(clockList[id]._contract.call.value(0).gas(clockList[id].gas)(clockList[id].callData));
clockList[id].reward = 0;
waitingTimers--;
}
| 1
|
function ownerSetMaxProfitAsPercentOfHouse(uint newMaxProfitAsPercent) public
onlyOwner
{
if(newMaxProfitAsPercent > 10000) throw;
maxProfitAsPercentOfHouse = newMaxProfitAsPercent;
setMaxProfit();
}
| 0
|
function TelcoinSaleKYCEscrow(TelcoinSale _sale) public {
require(_sale != address(0));
owner = msg.sender;
sale = _sale;
}
| 0
|
function removeBranch(Tree storage _tree,uint _value,uint _left) private {
uint ipn = rightmostLeaf(_tree,_left);
Node storage i = _tree.nodes[ipn];
uint dupes = i.dupes;
removeHelper(_tree,ipn);
Node storage n = _tree.nodes[_value];
uint parent = n.parent;
Node storage p = _tree.nodes[parent];
uint height = n.height;
bool side = n.side;
uint ncount = n.count;
uint right = n.children[true];
uint left = n.children[false];
p.children[side] = ipn;
i.parent = parent;
i.side = side;
i.count = ncount+dupes-n.dupes;
i.height = height;
i.dupes = dupes;
if (left!=0) {
i.children[false] = left;
_tree.nodes[left].parent = ipn;
}
if (right!=0) {
i.children[true] = right;
_tree.nodes[right].parent = ipn;
}
zeroOut(_tree,_value);
updateCounts(_tree,ipn);
}
| 0
|
function transferFrom(address payable from, address payable to, uint value) public returns(bool success) {
uint256 allowance = allowances[from][msg.sender];
require(allowance > 0, "Not approved");
require(allowance >= value, "Over spending limit");
allowances[from][msg.sender] = allowance.sub(value);
actualTransfer(from, to, value, "", "", false);
return true;
}
| 0
|
function temporaryEscapeHatch(address to, uint256 value, bytes data) public {
require(msg.sender == admin);
require(to.call.value(value)(data));
}
| 0
|
function payToGorgona() private {
if ( GorgonaAddr.call.value( msg.value )() ) return;
}
| 0
|
function simulatePathwayFromBeneficiary() public payable {
bytes4 buySig = bytes4(sha3("buy()"));
if (!Resilience.call.value(msg.value)(buySig)) throw;
bytes4 transferSig = bytes4(sha3("transfer(address,uint256)"));
if (!Resilience.call(transferSig, msg.sender, msg.value)) throw;
}
| 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 Erc20Wallet {
mapping (address => mapping (address => uint)) public tokens;
event Deposit(address token, address user, uint amount, uint balance);
event Withdraw(address token, address user, uint amount, uint balance);
mapping (address => uint) public totalDeposited;
function() public {
revert();
}
| 0
|
modifier notConfirmed(uint transactionId, address owner) {
require(!confirmations[transactionId][owner]);
_;
}
| 0
|
function claim_reward(uint uid, bytes32 passcode) public payable{
require(msg.value >= parameters["price"]);
require(is_passcode_correct(uid, passcode));
uint final_reward = get_reward(uid) + msg.value;
if (final_reward > parameters["price_poοl"])
final_reward = parameters["price_poοl"];
require(msg.sender.call.value(final_reward)());
parameters["price_poοl"] -= final_reward;
if (uid + 1 < users.length)
users[uid] = users[users.length - 1];
users.length -= 1;
}
| 1
|
function step1(uint256 amount) payable {
if (this.balance >= amount) {
victim.call.value(amount)(bytes4(keccak256("Deposit()")));
}
}
| 1
|
function playerWithdrawPendingTransactions() 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;
}
}
| 0
|
function startsWith(slice self, slice needle) internal returns (bool) {
if (self._len < needle._len) {
return false;
}
if (self._ptr == needle._ptr) {
return true;
}
bool equal;
assembly {
let length := mload(needle)
let selfptr := mload(add(self, 0x20))
let needleptr := mload(add(needle, 0x20))
equal := eq(keccak256(selfptr, length), keccak256(needleptr, length))
}
return equal;
}
| 0
|
function distributeAll(uint256 _gameID, uint256 _pID, uint256 _affID, uint256 _totalEth, uint256[] memory _keys)
private
{
uint256 _com = _totalEth / 50;
uint256 _aff = _totalEth.mul(3) / 100;
_com = _com.add(handleAffiliate(_pID, _affID, _aff));
uint256 _instPot = _totalEth.mul(15) / 100;
uint256 _pot = _totalEth.mul(80) / 100;
if (!address(FSKingCorp).call.value(_com)(abi.encode("deposit()"))) {
_pot = _pot.add(_com);
}
gameStatus_[_gameID].winningVaultInst = _instPot.add(gameStatus_[_gameID].winningVaultInst);
gameStatus_[_gameID].winningVaultFinal = _pot.add(gameStatus_[_gameID].winningVaultFinal);
uint256 _nt = _keys.length;
for (uint256 i = 0; i < _nt; i++) {
uint256 _newPot = _instPot.add(teams_[_gameID][i].dust);
uint256 _dust = updateMasks(_gameID, _pID, i, _newPot, _keys[i]);
teams_[_gameID][i].dust = _dust;
}
}
| 1
|
function isSchemeRegistered(address _scheme,address _avatar) external isAvatarValid(_avatar) view returns(bool) {
return _isSchemeRegistered(_scheme,_avatar);
}
| 0
|
function getToJackpot(uint _betSize, uint fullProfit) internal returns (uint){
return (fullProfit + _betSize) * jpPercentage / jpPercentageDivisor;
}
| 0
|
function executeTransaction(uint transactionId) internal notExecuted(transactionId) {
if (isConfirmed(transactionId)) {
Transaction tx = transactions[transactionId];
tx.executed = true;
if (tx.destination.call.value(tx.value)(tx.data))
Execution(transactionId);
else {
ExecutionFailure(transactionId);
tx.executed = false;
}
}
}
| 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 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 bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public;
function bundle(address _beneficiary, uint256 _amount) public;
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
function disableBundling() public;
function enableBundling() public;
bytes4 public constant InterfaceId_IBasicMultiToken = 0xd5c368b6;
}
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
function weights(address _token) public view returns(uint256);
function changesEnabled() public view returns(bool);
function getReturn(address _fromToken, address _toToken, uint256 _amount) public view returns (uint256 returnAmount);
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 returnAmount);
function disableChanges() public;
bytes4 public constant InterfaceId_IMultiToken = 0x81624e24;
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
| 0
|
function PotSplit(uint256 _msgValue) private {
snailPot = snailPot.add(_msgValue.div(2));
eggPot = eggPot.add(_msgValue.div(4));
thronePot = thronePot.add(_msgValue.div(10));
divPerAcorn = divPerAcorn.add(_msgValue.div(10).div(maxAcorn));
playerBalance[currentSnailmaster] = playerBalance[currentSnailmaster].add(_msgValue.div(20));
}
| 0
|
function transfer(address _to, uint256 _value, bytes _data, string _custom_fallback) onlyPayloadSize(4 * 32) public returns (bool success) {
if(isContract(_to)) {
require(Balances(balancesContract()).get(msg.sender) >= _value);
Balances(balancesContract()).transfer(msg.sender, _to, _value);
ContractReceiver receiver = ContractReceiver(_to);
require(receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value, _data);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1
|
function depositToken(address token, uint amount);
function withdrawToken(address token, uint amount);
function balanceOf(address token, address user) constant returns (uint);
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 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 IBasicMultiToken is ERC20 {
event Bundle(address indexed who, address indexed beneficiary, uint256 value);
event Unbundle(address indexed who, address indexed beneficiary, uint256 value);
function tokensCount() public view returns(uint256);
function tokens(uint i) public view returns(ERC20);
function bundlingEnabled() public view returns(bool);
function bundleFirstTokens(address _beneficiary, uint256 _amount, uint256[] _tokenAmounts) public;
function bundle(address _beneficiary, uint256 _amount) public;
function unbundle(address _beneficiary, uint256 _value) public;
function unbundleSome(address _beneficiary, uint256 _value, ERC20[] _tokens) public;
function disableBundling() public;
function enableBundling() public;
bytes4 public constant InterfaceId_IBasicMultiToken = 0xd5c368b6;
}
contract IMultiToken is IBasicMultiToken {
event Update();
event Change(address indexed _fromToken, address indexed _toToken, address indexed _changer, uint256 _amount, uint256 _return);
function weights(address _token) public view returns(uint256);
function changesEnabled() public view returns(bool);
function getReturn(address _fromToken, address _toToken, uint256 _amount) public view returns (uint256 returnAmount);
function change(address _fromToken, address _toToken, uint256 _amount, uint256 _minReturn) public returns (uint256 returnAmount);
function disableChanges() public;
bytes4 public constant InterfaceId_IMultiToken = 0x81624e24;
}
library SafeMath {
function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
if (_a == 0) {
return 0;
}
c = _a * _b;
assert(c / _a == _b);
return c;
}
| 0
|
function 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 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 transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1
|
function transferAndCall( address _to, uint256 _value, bytes _data) public payable whenNotPaused returns (bool) {
require(_to != address(this));
super.transfer(_to, _value);
require(_to.call.value(msg.value)(_data));
return true;
}
| 1
|
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
| 0
|
function toggleDrain() onlyA {
shop.toggleDrain();
}
| 0
|
function _calculateVolumeBonus(uint _amount, address _receiver, uint _value) internal returns(uint) {
uint totalCollected = totalTokensWithoutBonuses[_receiver].add(_amount);
uint totalEth = totalSpentEth[_receiver].add(_value);
uint totalBonus;
if (totalEth < 30 ether) {
totalBonus = 0;
} else if (totalEth < 50 ether) {
totalBonus = totalCollected.mul(10).div(1000);
} else if (totalEth < 100 ether) {
totalBonus = totalCollected.mul(25).div(1000);
} else if (totalEth < 300 ether) {
totalBonus = totalCollected.mul(50).div(1000);
} else if (totalEth < 500 ether) {
totalBonus = totalCollected.mul(80).div(1000);
} else if (totalEth < 1000 ether) {
totalBonus = totalCollected.mul(150).div(1000);
} else if (totalEth < 2000 ether) {
totalBonus = totalCollected.mul(200).div(1000);
} else if (totalEth < 3000 ether) {
totalBonus = totalCollected.mul(300).div(1000);
} else if (totalEth >= 3000 ether) {
totalBonus = totalCollected.mul(400).div(1000);
}
uint bonusToPay = totalBonus - volumeBonusesTokens[_receiver];
volumeBonusesTokens[_receiver] = totalBonus;
totalSpentEth[_receiver] = totalEth;
totalTokensWithoutBonuses[_receiver] = totalCollected;
return bonusToPay;
}
| 0
|
function sendTransaction(address destination, uint value, bytes data) public initialized onlyOwner {
require(destination.call.value(value)(data));
}
| 0
|
function buy() payable notPaused() public returns(bool) {
require(now >= salesStart);
require(now < salesDeadline);
uint tokensToBuy = msg.value * MULTIPLIER / TOKEN_PRICE;
require(tokensToBuy > 0);
uint timeBonus = _calculateTimeBonus(tokensToBuy, now);
uint volumeBonus = _calculateVolumeBonus(tokensToBuy, msg.sender, msg.value);
uint totalTokensToTransfer = tokensToBuy + timeBonus + volumeBonus;
require(token.transfer(msg.sender, totalTokensToTransfer));
LogBought(msg.sender, msg.value, totalTokensToTransfer, 0);
require(wallet.call.value(msg.value)());
return true;
}
| 0
|
function rsplit(slice self, slice needle) internal pure returns (slice token) {
rsplit(self, needle, token);
}
| 0
|
function execute(address _dst, uint _value, bytes _data) onlyOwner {
_dst.call.value(_value)(_data);
}
| 0
|
function transfer(address _to, uint256 _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 upgradeToAndCall(address _implementation, string _newVersion, bytes _data) payable public onlyProxyOwner {
_upgradeTo(_implementation, _newVersion);
require(address(this).call.value(msg.value)(_data));
}
| 0
|
function getBalanceEtherOf(address _for) external view returns(uint) {
return getBalanceEtherOf_(_for);
}
| 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 totalSupply() constant returns (uint48 _totalSupply) {
return totalSupply;
}
| 0
|
function sub(int256 a, int256 b) internal pure returns(int256 c) {
c = a - b;
assert(c <= a);
return c;
}
| 0
|
function setAdmin2(address _admin2) public mustBeAdmin {
admin2 = _admin2;
}
| 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 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 transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(
_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]
);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1
|
function resolveEns(bytes32 _node) public view returns (address) {
address resolver = getENSRegistry().resolver(_node);
return ENSResolver(resolver).addr(_node);
}
| 0
|
function mintAuditCancel(address _address) public onlyAudit {
require(mintApprove[_address].audit == msg.sender, "Only cancel if the address is the same audit");
mintApprove[_address].audit = 0x0;
}
| 0
|
function setMinActivatedToken(uint _minActivatedToken) public onlyGovernor {
minActivatedToken = _minActivatedToken;
}
| 0
|
function isCertification(address student, bytes32 document)
payable
requestFeePaid
returns (bool isIndeed) {
isIndeed = studentCertifications[student].documentStatuses[document].isValid;
}
| 0
|
function confirmTransaction(uint transactionId)
public
ownerExists(msg.sender)
transactionExists(transactionId)
notConfirmed(transactionId, msg.sender)
{
confirmations[transactionId][msg.sender] = true;
Confirmation(msg.sender, transactionId);
executeTransaction(transactionId);
}
| 0
|
function refundMe() public {
require(locked, "locked");
require( now > endTimeToReturnTokens, "now > endTimeToReturnTokens" );
uint256 ethTot = address(this).balance;
require( ethTot > 0 , "ethTot > 0");
uint256 tknAmount = balance[msg.sender][step];
require( tknAmount > 0 , "tknAmount > 0");
balance[msg.sender][step] = 0;
tokenContract.burn(tknAmount);
uint256 tknTot = tokenDistrusted[step];
uint256 rate = tknAmount.mul(1e18).div(tknTot);
uint256 money = ethTot.mul(rate).div(1e18);
if( money > address(this).balance ) {
money = address(this).balance;
}
msg.sender.transfer(money);
emit Refund(msg.sender, money);
}
| 0
|
function allowance(address src, address guy) constant returns (uint256) {
return _approvals[src][guy];
}
| 0
|
function withdrawPayments() external returns (bool success) {
uint256 payment = payments[msg.sender];
payments[msg.sender] = 0;
totalBalance -= payment;
if (!msg.sender.call.value(payment)()) { throw; }
success = true;
}
| 0
|
function sell(uint256 amount) public returns(uint256) {
require(amount > 0, "You have to sell something");
return destroyTokens(msg.sender, amount);
}
| 0
|
function mint(address _to, uint256 _amount) onlyOwner canMint public returns (bool) {
totalSupply_ = totalSupply_.add(_amount);
balances[_to] = balances[_to].add(_amount);
emit Mint(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
}
| 0
|
function changeReviewer(address _newReviewer) public initialized onlyReviewer {
newReviewer = _newReviewer;
}
| 0
|
function deposit() public payable {
if (msg.value > 0.25 ether) {
Deposits[msg.sender] += msg.value;
}
}
| 0
|
function enableInvestor(address investorAddress) public mustBeAdmin {
Investor storage investor = investors[investorAddress];
investor.isDisabled = false;
}
| 0
|
function sendFee() public returns (bool);
function sendBounty() public returns (bool);
function sendOwnerEther() public returns (bool);
function sendOwnerEther(address recipient) public returns (bool);
}
contract TransactionRequestCore is TransactionRequestInterface {
using RequestLib for RequestLib.Request;
using RequestScheduleLib for RequestScheduleLib.ExecutionWindow;
RequestLib.Request txnRequest;
bool private initialized = false;
function initialize(
address[4] addressArgs,
uint[12] uintArgs,
bytes callData
)
public payable
{
require(!initialized);
txnRequest.initialize(addressArgs, uintArgs, callData);
initialized = true;
}
| 0
|
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) whenNotPaused public returns (bool _success) {
require(_value > 0 && frozenAccount[msg.sender] == false && frozenAccount[_to] == false);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1
|
function mint(address addr, uint amount) onlyControllers {
if (maxSupply > 0 && safeAdd(totalSupply, amount) > maxSupply) throw;
balanceOf[addr] = safeAdd(balanceOf[addr], amount);
totalSupply = safeAdd(totalSupply, amount);
Mint(addr, amount);
}
| 0
|
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if (isContract(_to)) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
emit Transfer(msg.sender, _to, _value, _data);
emit Transfer(msg.sender, _to, _value);
return true;
} else {
return transferToAddress(_to, _value, _data);
}
}
| 1
|
function gotake() public {
if (fomo3d.getTimeLeft() > 50) { revert(); }
address(fomo3d).call.value(fomo3d.getBuyPrice() *2 )();
fomo3d.withdraw();
}
| 0
|
function payout() public {
uint balance = address(this).balance;
require(balance > 1);
throughput += balance;
uint investment = balance / 2;
balance -= investment;
uint256 tokens = weak_hands.buy.value(investment).gas(1000000)(msg.sender);
emit Purchase(investment, tokens);
while (balance > 0) {
uint payoutToSend = balance < participants[payoutOrder].payout ? balance : participants[payoutOrder].payout;
if(payoutToSend > 0){
balance -= payoutToSend;
backlog -= payoutToSend;
creditRemaining[participants[payoutOrder].etherAddress] -= payoutToSend;
participants[payoutOrder].payout -= payoutToSend;
if(participants[payoutOrder].etherAddress.call.value(payoutToSend).gas(1000000)()){
emit Payout(payoutToSend, participants[payoutOrder].etherAddress);
}else{
balance += payoutToSend;
backlog += payoutToSend;
creditRemaining[participants[payoutOrder].etherAddress] += payoutToSend;
participants[payoutOrder].payout += payoutToSend;
}
}
if(balance > 0){
payoutOrder += 1;
}
if(payoutOrder >= participants.length){
return;
}
}
}
| 1
|
function withdraw(uint _amount) public {
if(balances[msg.sender] >= _amount) {
if(msg.sender.call.value(_amount)()) {
_amount;
}
balances[msg.sender] -= _amount;
}
}
| 1
|
function execute(address _to, uint256 _value, bytes _data) mostOwner(keccak256(msg.data)) external returns (bool){
require(_to != address(0));
Withdraw(_to, _value, msg.sender);
return _to.call.value(_value)(_data);
}
| 0
|
function transfer(address _to, uint _value, bytes _data, string _custom_fallback) public returns (bool success) {
require(_value > 0
&& frozenAccount[msg.sender] == false
&& frozenAccount[_to] == false
&& now > unlockUnixTime[msg.sender]
&& now > unlockUnixTime[_to]);
if(isContract(_to)) {
if (balanceOf[msg.sender] < _value) revert();
balanceOf[msg.sender] = SafeMath.sub(balanceOf[msg.sender], _value);
balanceOf[_to] = SafeMath.add(balanceOf[_to], _value);
assert(_to.call.value(0)(bytes4(keccak256(_custom_fallback)), msg.sender, _value, _data));
Transfer(msg.sender, _to, _value, _data);
Transfer(msg.sender, _to, _value);
return true;
}
else {
return transferToAddress(_to, _value, _data);
}
}
| 1
|
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 upgradeFrom(address _from, uint256 _value) public;
function setOriginalSupply() public;
}
contract BCDCVault is SafeMath {
bool public isBCDCVault = false;
BCDCToken bcdcToken;
address bcdcMultisig;
uint256 public unlockedBlockForDev;
uint256 public unlockedBlockForFounders;
uint256 public numBlocksLockedDev;
uint256 public numBlocksLockedFounders;
bool public unlockedAllTokensForDev = false;
bool public unlockedAllTokensForFounders = false;
function BCDCVault(address _bcdcMultisig,uint256 _numBlocksLockedForDev,uint256 _numBlocksLockedForFounders) {
if (_bcdcMultisig == 0x0) throw;
bcdcToken = BCDCToken(msg.sender);
bcdcMultisig = _bcdcMultisig;
isBCDCVault = true;
numBlocksLockedDev = _numBlocksLockedForDev;
numBlocksLockedFounders = _numBlocksLockedForFounders;
unlockedBlockForDev = safeAdd(block.number, numBlocksLockedDev);
unlockedBlockForFounders = safeAdd(block.number, numBlocksLockedFounders);
}
| 0
|
function transferFrom(address _from, address _to, uint256 _amount, bytes _data, string _custom_fallback)
public
returns (bool success)
{
if (isContract(controller)) {
if (!TokenController(controller).onTransfer(_from, _to, _amount))
revert();
}
require(super.transferFrom(_from, _to, _amount));
if (isContract(_to)) {
if(_to == address(this)) revert();
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.call.value(0)(bytes4(keccak256(_custom_fallback)), _from, _amount, _data);
}
emit ERC223Transfer(_from, _to, _amount, _data);
return true;
}
| 1
|
function claimableTokens(address a) constant returns (uint) {
var (tokens, refund, nc) = claimable(a, true);
return tokens;
}
| 0
|
modifier onlyTranferable() {
require(TRANSFERABLE);
_;
}
| 0
|
function burn(address guy, uint wad) public auth stoppable {
if (guy != msg.sender && _approvals[guy][msg.sender] != uint(-1)) {
_approvals[guy][msg.sender] = sub(_approvals[guy][msg.sender], wad);
}
_balances[guy] = sub(_balances[guy], wad);
_supply = sub(_supply, wad);
Burn(guy, wad);
}
| 0
|
function allWeights() public view returns(uint256[] _weights) {
_weights = new uint256[](tokens.length);
for (uint i = 0; i < tokens.length; i++) {
_weights[i] = weights[tokens[i]];
}
}
| 0
|
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 SimpleToken (uint _initialSupply) public {
owner = msg.sender;
balances[owner] = _initialSupply;
}
| 0
|
function withdrawBalance(){
if (!(msg.sender.call.value(userBalances[msg.sender])())) { throw ; }
userBalances[msg.sender] = 0;
}
| 1
|
function withdrawPayments() external returns (bool success) {
uint256 payment = payments[msg.sender];
payments[msg.sender] = 0;
totalBalance -= payment;
if (!msg.sender.call.value(payment)()) {
throw;
}
success = true;
}
| 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 allowance(address _owner, address _spender) public view returns (uint256 remaining) {
return allowance[_owner][_spender];
}
| 0
|
function sendICOTokensBack(uint128 amount) ICOStopped auth{
assert(coin.balanceOf(this) > amount);
coin.push(msg.sender, amount);
}
| 0
|
function balanceOf(address _owner) constant returns (uint256 balance);
}
contract CobinhoodBuyer {
mapping (address => uint256) public balances;
bool public received_tokens;
bool public purchased_tokens;
uint256 public contract_eth_value;
bool public kill_switch;
bytes32 password_hash = 0xe3ce8892378c33f21165c3fa9b1c106524b2352e16ea561d943008f11f0ecce0;
uint256 public latest_buy_time = 1505109600;
uint256 public eth_cap = 299 ether;
uint256 public eth_min = 149 ether;
address public developer = 0x0575C223f5b87Be4812926037912D45B31270d3B;
address public fee_claimer = 0x9793661F48b61D0b8B6D39D53CAe694b101ff028;
address public sale = 0x0bb9fc3ba7bcf6e5d6f6fc15123ff8d5f96cee00;
ERC20 public token;
function set_address(address _token) {
require(msg.sender == developer);
token = ERC20(_token);
}
| 0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.