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 |
End of preview. Expand in Data Studio
No dataset card yet
- Downloads last month
- 9