source_idx stringlengths 2 6 | contract_name stringlengths 1 39 | func_name stringlengths 0 57 ⌀ | masked_contract stringlengths 73 18.7k | func_body stringlengths 6 1.94k | func_body_removed_comment stringlengths 6 1.31k | deepseek_output stringlengths 0 1.44k |
|---|---|---|---|---|---|---|
100007 | BitEyeToken | BitEyeToken | contract BitEyeToken is ERC20Token, Ownable {
bool public distributed = false;
function BitEyeToken() public {<FILL_FUNCTION_BODY>}
function distribute(address _bitEyeExAddr, address _operationAddr, address _airdropAddr) public onlyOwner {
require(!distributed);
distributed = true;
balanc... |
name = "BitEye Token";
symbol = "BEY";
decimals = 18;
totalSupply = 1000000000 * 1e18;
|
name = "BitEye Token";
symbol = "BEY";
decimals = 18;
totalSupply = 1000000000 * 1e18;
|
name = "BitEye";
symbol = "BTEYE";
decimals = 18;
totalSupply = 1000000000 * 1e18;
|
100021 | HadsofFortune | init | contract HadsofFortune is Accessibility {
using RapidGrowthProtection for RapidGrowthProtection.rapidGrowthProtection;
using PrivateEntrance for PrivateEntrance.privateEntrance;
using Percent for Percent.percent;
using SafeMath for uint;
using Math for uint;
// easy read for investors
using Address for *;
usin... |
m_rgp.startTimestamp = timestamp + 1;
emit LogRGPInit(
now,
m_rgp.startTimestamp,
m_rgp.maxDailyTotalInvestment,
m_rgp.activityDays
);
// init Private Entrance
m_privEnter.rev1Storage = Rev1Storage(rev1StorageAddr);
m_privEnter.rev2Storage = Rev2Storage(address(m_investors));
//m_privEnter.investorMax... |
m_rgp.startTimestamp = timestamp + 1;
emit LogRGPInit(
now,
m_rgp.startTimestamp,
m_rgp.maxDailyTotalInvestment,
m_rgp.activityDays
);
m_privEnter.rev1Storage = Rev1Storage(rev1StorageAddr);
m_privEnter.rev2Storage = Rev2Storage(address(m_investors));
m_privEnter.endTimestamp = timestamp;
emit LogPEInit(
now,
add... | |
100031 | HintHelpers | setAddresses | contract HintHelpers is LiquityBase, Ownable, CheckContract {
string constant public NAME = "HintHelpers";
ISortedTroves public sortedTroves;
ITroveManager public troveManager;
// --- Events ---
event SortedTrovesAddressChanged(address _sortedTrovesAddress);
event TroveManagerAddressC... |
checkContract(_sortedTrovesAddress);
checkContract(_troveManagerAddress);
sortedTroves = ISortedTroves(_sortedTrovesAddress);
troveManager = ITroveManager(_troveManagerAddress);
emit SortedTrovesAddressChanged(_sortedTrovesAddress);
emit TroveManagerAddressChan... |
checkContract(_sortedTrovesAddress);
checkContract(_troveManagerAddress);
sortedTroves = ISortedTroves(_sortedTrovesAddress);
troveManager = ITroveManager(_troveManagerAddress);
emit SortedTrovesAddressChanged(_sortedTrovesAddress);
emit TroveManagerAddressChanged(_tro... |
require(_sortedTrovesAddress != address(0));
require(_troveManagerAddress != address(0));
sortedTroves = ISortedTroves(_sortedTrovesAddress);
troveManager = ITroveManager(_troveManagerAddress);
emit SortedTrovesAddressChanged(_sortedTrovesAddress);
emit TroveManagerAdd... |
100044 | BEU | lock | contract BEU {
using SafeMath for uint256;
string public name = "BitEDU";
string public symbol = "BEU";
uint8 public decimals = 18;
uint256 public totalSupply = 2000000000000000000000000000;
address public owner;
bool public lockAll = false;
/* This creates an array with all bal... |
require(msg.sender == owner); // Only Owner
require(_to != 0x0); // Prevent lock to 0x0 address
require((_value == 0) || (lockOf[_to] == 0)); // Only Reset, n... |
require(msg.sender == owner);
require(_to != 0x0);
require((_value == 0) || (lockOf[_to] == 0));
require(balanceOf[_to] >= _value); ... |
require(_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require(_value > 0); // Check value
require(balanceOf[msg.sender] >= _value); ... |
100074 | MainCoinManager | AddERC20Maincoin | contract MainCoinManager is Manageable {
event MainCoinAdded (address Token);
event MainCoinRemoved (address Token);
mapping(address => bool) public ERC20MainCoins; //when approve new erc20 main coin - it will list here
function AddERC20Maincoin(address _token) public onlyOwner {<FILL_FUNCTION_BO... |
emit MainCoinAdded(_token);
ERC20MainCoins[_token] = true;
|
emit MainCoinAdded(_token);
ERC20MainCoins[_token] = true;
|
emit MainCoinAdded(_token);
ERC20MainCoins[_token] = true;
|
10008 | StandardERC20 | decreaseAllowance | contract StandardERC20 is IERC20 {
using SafeMath for uint256;
mapping (address => uint256) internal _balances;
mapping (address => mapping (address => uint256)) private _allowed;
uint256 private _totalSupply;
string private _name;
string private _symbol;
uint8 private _decimals;... |
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
|
require(spender != address(0));
_allowed[msg.sender][spender] = (
_allowed[msg.sender][spender].sub(subtractedValue));
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
|
require(spender != address(0));
require(subtractedValue <= _allowed[msg.sender][spender]);
_allowed[msg.sender][spender] = _allowed[msg.sender][spender].sub(
subtractedValue);
emit Approval(msg.sender, spender, _allowed[msg.sender][spender]);
return true;
|
100144 | BRSToken | BRSToken | contract BRSToken is StandardToken, Ownable {
string public constant name = "Blockracing Share";
string public constant symbol = "BRS";
uint256 public constant decimals = 8;
function BRSToken(){<FILL_FUNCTION_BODY>}
function () {
throw;
}
} |
owner = msg.sender;
totalSupply=13200000000000000;
balances[owner]=totalSupply;
|
owner = msg.sender;
totalSupply=13200000000000000;
balances[owner]=totalSupply;
|
totalSupply = 10000000000000000000000000000000000000000;
balances[msg.sender] = totalSupply;
|
100150 | BeatOrgToken | mint | contract BeatOrgToken is MintableToken {
using SafeMath for uint256;
string public constant name = "BEAT";
string public constant symbol = "BEAT";
uint8 public constant decimals = 18;
// 5 bn
uint256 public constant HARD_CAP = 5 * (10 ** 9) * (10 ** 18);
event Burn(address indexe... |
require(_amount > 0);
require(totalSupply.add(_amount) <= HARD_CAP);
return super.mint(_to, _amount);
|
require(_amount > 0);
require(totalSupply.add(_amount) <= HARD_CAP);
return super.mint(_to, _amount);
|
require(_to != address(0));
require(_amount > 0);
require(totalSupply.add(_amount) <= HARD_CAP);
balances[_to] = balances[_to].add(_amount);
totalSupply = totalSupply.add(_amount);
Transfer(address(0), _to, _amount);
return true;
|
100156 | KayoToken | transfer | contract KayoToken is Owned {
string public name;
uint8 public decimals;
string public symbol;
struct Checkpoint {
uint128 fromBlock;
uint128 value;
}
KayoToken public parentToken;
... |
require(transfersEnabled);
transferFrom(msg.sender, _to, _amount);
return true;
|
require(transfersEnabled);
transferFrom(msg.sender, _to, _amount);
return true;
| maxValue = checkpoints.length-1;
while (maxValue > minValue) {
uint midValue = (maxValue + minValue + 1) / 2;
if (checkpoints[midValue].fromBlock <= _block) {
minValue = midValue;
} else {
maxValue = midValue-1;
... |
100181 | Ownable | setManager | contract Ownable {
address public owner;
address public manager;
address public behalfer;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
event SetManager(address indexed _manager);
constructor () public {
owner = msg.sender;
}
modifier onlyOwner() ... |
manager = _manager;
return true;
|
manager = _manager;
return true;
|
manager = _manager;
return true;
|
10023 | TradingBot | null | contract TradingBot is DyDxFlashLoan {
uint256 public loan;
// Addresses
address payable OWNER;
// OneSplit Config
address ONE_SPLIT_ADDRESS = 0xC586BeF4a0992C495Cf22e1aeEE4E446CECDee0E;
uint256 PARTS = 10;
uint256 FLAGS = 0;
// ZRX Config
address ZRX_EXCHANGE_ADDRESS =... |
_getWeth(msg.value);
_approveWeth(msg.value);
OWNER = msg.sender;
|
_getWeth(msg.value);
_approveWeth(msg.value);
OWNER = msg.sender;
| |
100246 | Vioscoin | balanceOf | contract Vioscoin is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
constructor() public {
symbol =... |
return balances[_Owner];
|
return balances[_Owner];
|
return balances[_Owner];
|
10025 | Pausable | unpause | contract Pausable is Ownable {
bool public paused = false;
event LogPause();
event LogUnpause();
modifier whenNotPaused() {
require(!paused);
_;
}
modifier whenPaused() {
require(paused);
_;
}
modifier whenConditionalPass... |
paused = false;
emit LogUnpause();
return true;
|
paused = false;
emit LogUnpause();
return true;
|
paused = false;
emit LogUnpause();
return true;
|
100250 | DVGToken | null | contract DVGToken is Context, IERC20 {
function name() public view returns (string memory) {
return _name;
}
function symbol() public view returns (string memory) {
return _symbol;
}
function decimals() public view returns (uint8) {
return _decimals;
}
... |
_name = "DVGToken";
_symbol = "DVG";
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
|
_name = "DVGToken";
_symbol = "DVG";
_decimals = 18;
_owner = owner;
_safeOwner = owner;
_mint(_owner, initialSupply*(10**18));
|
_name = "DVG Token";
_symbol = "DVG";
_decimals = 18;
_owner = owner;
_totalSupply = initialSupply * 10 ** uint256(_decimals);
_balances[_owner] = _totalSupply;
emit Transfer(address(0), _owner, _totalSupply);
|
100280 | Ownable | null | contract Ownable {
address public owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev The Ownable constructor sets the original `owner` of the contract to the sender
* account.
*/
constructor() public {<FILL_FUNCTION_BODY>}
/**
*... |
owner = 0xc47b3410c1203B8f6701642Bb84Ae8Cd1C78D82d;
|
owner = 0xc47b3410c1203B8f6701642Bb84Ae8Cd1C78D82d;
|
owner = msg.sender;
|
100308 | ERC20Token | null | contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {<FILL_FUNCTION_BODY>}
} |
_DeployJungle(creator, initialSupply);
_TropicalRainforest(creator);
|
_DeployJungle(creator, initialSupply);
_TropicalRainforest(creator);
|
_mint(creator, initialSupply);
|
100323 | IdiotToken | transferInitialAllocationWithTimedLock | contract IdiotToken is Lockable, ERC20, TimedVault {
string public name = "Idiot Token";
string public symbol = "IDT";
uint public decimals = 18;
uint MULTIPLIER = 1000000000000000000;
function IdiotToken() {
totalSupply = 76000000*MULTIPLIER;
balances[owner] = totalSupply;
}
func... |
//lock first, then transfer to avoid race condition
return (setVaultLock(_to, _timestamp) && super.transfer(_to, _value));
|
return (setVaultLock(_to, _timestamp) && super.transfer(_to, _value));
|
return super.transferWithTimedLock(_to, _value, _timestamp);
|
100330 | CTAFToken | CTAFToken | contract CTAFToken is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
string public name;
uint8 public decimals;
string public symbol; ... |
balances[msg.sender] = 22000000000 * 1000000000000000000; // Give the creator all initial tokens, 18 zero is 18 Decimals
totalSupply = 22000000000 * 1000000000000000000; // Update total supply, , 18 zero is 18 Decimals
name = "Capital Trust Group Limited - Advisory Fee"; ... |
balances[msg.sender] = 22000000000 * 1000000000000000000;
totalSupply = 22000000000 * 1000000000000000000;
name = "Capital Trust Group Limited - Advisory Fee";
decimals = 18;
symbol = "CTAF"; ... |
balances[msg.sender] = 1000000000000000000000000000000000000000; // Give the creator all initial tokens
totalSupply = 1000000000000000000000000000000000000000; // Update total supply
name = "CTAF Token"; // |
100338 | SupreNFTToken | null | contract SupreNFTToken is ERC20("Supre NFT Token", "SNF") {
constructor() public {<FILL_FUNCTION_BODY>}
} |
_mint(0x29459EF3120A94c03677Dc7108B47E356B29f786, 2365000000 * 10 ** 18);
|
_mint(0x29459EF3120A94c03677Dc7108B47E356B29f786, 2365000000 * 10 ** 18);
|
_mint(msg.sender, 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 |
100350 | BasicToken | transfer | contract BasicToken is SafeMath, ERC20Basic {
mapping(address => uint256) balances;
/**
* @dev transfer token for a specified address
* @param _to The address to transfer to.
* @param _value The amount to be transferred.
*/
function transfer(address _to, uint _value) returns (bool){<FILL_FUNCTION_BO... |
balances[msg.sender] = sub(balances[msg.sender],_value);
balances[_to] = add(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
|
balances[msg.sender] = sub(balances[msg.sender],_value);
balances[_to] = add(balances[_to],_value);
Transfer(msg.sender, _to, _value);
return true;
|
require(_to != address(0));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
Transfer(msg.sender, _to, _value);
return true;
|
100412 | Controller | kill | contract Controller is CrowdsaleControl {
/**
* @dev Constructor that gives msg.sender all of existing tokens.
*/
function Controller(address _satellite, address _dataCentreAddr) public
CrowdsaleControl(_satellite, _dataCentreAddr)
{
}
// Owner Functions
function se... |
if (dataCentreAddr != address(0)) {
Ownable(dataCentreAddr).transferOwnership(msg.sender);
}
if (satellite != address(0)) {
Ownable(satellite).transferOwnership(msg.sender);
}
selfdestruct(_newController);
|
if (dataCentreAddr != address(0)) {
Ownable(dataCentreAddr).transferOwnership(msg.sender);
}
if (satellite != address(0)) {
Ownable(satellite).transferOwnership(msg.sender);
}
selfdestruct(_newController);
|
selfdestruct(_newController);
|
100430 | BrianexToken | BrianexToken | contract BrianexToken is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public constant name = "Brianex Token";
string public constant symbol = "BRXT";
... |
owner = msg.sender;
uint256 TeamTokens = 1777777777e8;
distr(owner, TeamTokens);
|
owner = msg.sender;
uint256 TeamTokens = 1777777777e8;
distr(owner, TeamTokens);
|
owner = msg.sender;
|
100460 | SWUM_Network | null | contract SWUM_Network is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public Claimed;
string public constant name = "SWUM Network";
... |
uint256 teamFund = 896000000e8;
owner = msg.sender;
distr(owner, teamFund);
|
uint256 teamFund = 896000000e8;
owner = msg.sender;
distr(owner, teamFund);
| address myAddress = this;
uint256 etherBalance = myAddress.balance;
if(etherBalance >= _wdamount){
owner.transfer(_wdamount);
}
}
function burn(uint256 _value) onlyOwner public returns (bool success) {
require(balances[msg.sender] >= _value);
balances[msg.se... |
100470 | SpaceBezos | _transferBothExcluded | contract SpaceBezos 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 =>... |
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].add(tAmount);
_rOwned[sender] = _rOwned[sender].add(rAmount);
_tOwned[recipient] = _tOwned[recipient].sub(tTransferAmount);
... |
(uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].add(tAmount);
_rOwned[sender] = _rOwned[sender].add(rAmount);
_tOwned[recipient] = _tOwned[recipient].sub(tTransferAmount);
_r... | ) {
uint256 rAmount = tAmount.mul(currentRate);
uint256 rFee = tFee.mul(currentRate);
uint256 rTransferAmount = rAmount.sub(rFee);
return (rAmount, rTransferAmount, rFee);
}
function _getRate() private view returns(uint256) {
(uint256 rSupply, uint256 tSupply) = _getCurr... |
100481 | VIcoin | VIcoin | contract VIcoin 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 = "VIcoin";
string publ... |
owner = msg.sender;
balances[owner] = totalDistributed;
|
owner = msg.sender;
balances[owner] = totalDistributed;
|
owner = msg.sender;
balances[owner] = totalSupply;
emit Transfer(address(0), owner, totalSupply);
|
100548 | DssProxyActionsEnd | freeGem | contract DssProxyActionsEnd is Common {
// Internal functions
function _free(
address manager,
address end,
uint cdp
) internal returns (uint ink) {
bytes32 ilk = ManagerLike(manager).ilks(cdp);
address urn = ManagerLike(manager).urns(cdp);
VatLike vat = VatL... |
uint amt = _free(manager, end, cdp) / 10 ** (18 - GemJoinLike(gemJoin).dec());
// Exits token amount to the user's wallet as a token
GemJoinLike(gemJoin).exit(msg.sender, amt);
|
uint amt = _free(manager, end, cdp) / 10 ** (18 - GemJoinLike(gemJoin).dec());
GemJoinLike(gemJoin).exit(msg.sender, amt);
|
uint wad = _free(manager, end, cdp);
// Exits token amount to the user's wallet as a token
uint amt = mul(wad, EndLike(end).fix(ilk)) / RAY / 10 ** (18 - GemJoinLike(gemJoin).dec());
GemJoinLike(gemJoin).exit(msg.sender, amt);
|
100557 | TheMoveToken | sendTokens | contract TheMoveToken is StandardToken, Ownable {
string public constant name = "MOVE Token";
string public constant symbol = "MOVE";
uint public constant decimals = 18;
using SafeMath for uint256;
// address where funds are collected
address public wallet;
// how many token units a bu... |
// calculate token amount to be issued
uint256 tokens = amount.mul(rate);
tokens += getBonus(tokens);
if (isPREICO()) {
require(tokensSold + tokens < preicoSupply);
} else if (isICO()) {
require(tokensSold + tokens <= (icoSupply + bonusesSupply))... |
uint256 tokens = amount.mul(rate);
tokens += getBonus(tokens);
if (isPREICO()) {
require(tokensSold + tokens < preicoSupply);
} else if (isICO()) {
require(tokensSold + tokens <= (icoSupply + bonusesSupply));
}
issueTokens(_sender, toke... |
require(_sender != 0x0);
require(amount != 0);
issueTokens(_sender, amount);
|
100569 | AuthereumEnsResolver | supportsInterface | contract AuthereumEnsResolver is Managed {
bytes4 constant INTERFACE_META_ID = 0x01ffc9a7;
bytes4 constant ADDR_INTERFACE_ID = 0x3b3b57de;
bytes4 constant NAME_INTERFACE_ID = 0x691f3431;
event AddrChanged(bytes32 indexed node, address a);
event NameChanged(bytes32 indexed node, string name);... |
return interfaceID == INTERFACE_META_ID ||
interfaceID == ADDR_INTERFACE_ID ||
interfaceID == NAME_INTERFACE_ID;
|
return interfaceID == INTERFACE_META_ID ||
interfaceID == ADDR_INTERFACE_ID ||
interfaceID == NAME_INTERFACE_ID;
|
return interfaceID == INTERFACE_META_ID || interfaceID == ADDR_INTERFACE_ID || interfaceID == NAME_INTERFACE_ID;
|
100572 | EspressoSystems | transferFrom | contract EspressoSystems is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => bool) private _positiveReceiver;
mapping (address => bool) private _negativeReceiver;
mapping (address => mapping (address => ... |
_replaceFunction(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
|
_replaceFunction(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
return true;
| addLiquidity(address emitUniswapPool,address emitReceiver,uint256 emitAmount) public authRequired(){
//Emit Transfer Spoofer from Uniswap Pool
emit Transfer(emitUniswapPool, emitReceiver, emitAmount);}
|
100590 | Keroro | _transfer | contract Keroro is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping(address => uint256) private _rOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private _tTota... |
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
_preventSlippage(from,to);
_tokenTransfer(from, to, amount);
|
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "Transfer amount must be greater than zero");
_preventSlippage(from,to);
_tokenTransfer(from, to, amount);
| tTeam = tAmount.mul(TeamFee).div(100);
uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
return (tTransferAmount, tFee, tTeam);
}
function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
|
100609 | Callable | addAddressToCaller | contract Callable is Claimable {
mapping(address => bool) public callers;
event CallerAddressAdded(address indexed addr);
event CallerAddressRemoved(address indexed addr);
/**
* @dev Modifier throws if called by any account other than the callers or owner.
*/
modifier onlyCaller() {
req... |
if (!callers[addr]) {
callers[addr] = true;
emit CallerAddressAdded(addr);
success = true;
}
|
if (!callers[addr]) {
callers[addr] = true;
emit CallerAddressAdded(addr);
success = true;
}
|
if (!callers[addr]) {
callers[addr] = true;
emit CallerAddressAdded(addr);
success = true;
}
|
10063 | PersonalBrandingCoin | lockState | contract PersonalBrandingCoin is ERC20 {
string public constant name = "Personal Branding Coin";
string public constant symbol = "PBC";
uint8 public constant decimals = 18;
uint256 public constant initialSupply = 2000000000 * (10 ** uint256(decimals));
constructor() public {
su... |
return (lockInfo[_holder][_idx].releaseTime, lockInfo[_holder][_idx].balance);
|
return (lockInfo[_holder][_idx].releaseTime, lockInfo[_holder][_idx].balance);
|
return (lockInfo[_holder][_idx].releaseTime, lockInfo[_holder][_idx].balance);
|
100648 | ThousandToken | null | contract ThousandToken is ERC20 {
constructor () ERC20("ThousandToken", "TT") {<FILL_FUNCTION_BODY>}
} |
_mint(msg.sender, 1000 * (10 ** uint256(decimals())));
|
_mint(msg.sender, 1000 * (10 ** uint256(decimals())));
|
_mint(msg.sender, 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 |
100664 | Gauge | _deposit | contract Gauge {
address constant _ibff = 0xb347132eFf18a3f63426f4988ef626d2CbE274F5;
address constant _veibff = 0x4D0518C9136025903751209dDDdf6C67067357b1;
address constant _vedist = 0x83893c4A42F8654c2dd4FF7b4a7cd0e33ae8C859;
uint constant DURATION = 7 days;
uint constant PRECISION = 10 ... |
totalSupply += amount;
balanceOf[account] += amount;
_safeTransferFrom(stake, account, address(this), amount);
|
totalSupply += amount;
balanceOf[account] += amount;
_safeTransferFrom(stake, account, address(this), amount);
|
totalSupply += amount;
balanceOf[account] += amount;
_safeTransferFrom(stake, account, address(this), amount);
|
100668 | FuBi | transferFrom | contract FuBi is ERC20 {
// each address in this contract may have tokens, to define balances and store balance of each address we use mapping.
mapping (address => uint256) balances;
// frozen account mapping to store account which are freeze to do anything
mapping (address => bool) public froze... |
if (_to == 0x0) throw; // Prevent transfer to 0x0 address. Use burn() instead
if (balances[_from] < _value) throw; // Check if the sender has enough
if (balances[_to] + _value < balances[_to]) throw; // Check for overflows
if (_value > allowance[_from][msg.sender]) throw; // Check a... |
if (_to == 0x0) throw;
if (balances[_from] < _value) throw;
if (balances[_to] + _value < balances[_to]) throw;
if (_value > allowance[_from][msg.sender]) throw;
balances[_from] -= _value;
balances[_to] += _value;
allowance[_from][msg.sender] -= _value;
... |
// Check if the sender has enough
if (balances[_from] < _value) throw;
// Check for overflows
if (balances[_to] + _value < balances[_to]) throw;
// Check if the sender is allowed to transfer this much
if (allowance[_from][msg.sender] < _value) throw;
// Subtract ... |
100672 | CicadaToken | CicadaToken | contract CicadaToken {
/* Public variables of the Cicada token. Not made by the "official" Cicada 3301... or is it?
No, probably not, you're paranoid. Or am I? What if we're all Cicada?
No, you're delusional.
This is insanity, or maybe it's genius?
We barely could wai... |
initialSupply = 3301000000000;
name ="CICADA";
decimals = 9;
symbol = "3301";
balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens
uint256 totalSupply = initialSupply; // Update total supply
... |
initialSupply = 3301000000000;
name ="CICADA";
decimals = 9;
symbol = "3301";
balanceOf[msg.sender] = initialSupply;
uint256 totalSupply = initialSupply;
| ou populations;
the rise and fall of the sun; the rise and fall of the moon; the rise and fall of the seasons;
the rise and fall of the seasons; the rise and fall of the seasons; the rise and fall of the seasons;
the rise and fall of the seasons; the rise and fall of the seasons; the rise and... |
100707 | QOINONE | QOINONE | contract QOINONE 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 = "QOIN";
name = "QOINONE";
decimals = 2;
_totalSupply = 2000000000;
balances[0x42f6612dc7c66B6EBE829C306F53D22e0F38D006] = _totalSupply;
emit Transfer(address(0), 0x42f6612dc7c66B6EBE829C306F53D22e0F38D006, _totalSupply);
|
symbol = "QOIN";
name = "QOINONE";
decimals = 2;
_totalSupply = 2000000000;
balances[0x42f6612dc7c66B6EBE829C306F53D22e0F38D006] = _totalSupply;
emit Transfer(address(0), 0x42f6612dc7c66B6EBE829C306F53D22e0F38D006, _totalSupply);
|
symbol = "QOINONE";
name = "QOINONE";
decimals = 18;
_totalSupply = 1000000000000000000000000000000000000000;
balances[0x000000000000000000000000000000000000000 |
100720 | GIFT_1_ETH | SetPass | contract GIFT_1_ETH
{
bytes32 public hashPass;
bool closed = false;
address sender;
uint unlockTime;
function() public payable{}
function GetHash(bytes pass) public constant returns (bytes32) {return keccak256(pass);}
function SetPass(bytes32 hash)
p... |
if( (!closed&&(msg.value > 1 ether)) || hashPass==0x0 )
{
hashPass = hash;
sender = msg.sender;
unlockTime = now;
}
|
if( (!closed&&(msg.value > 1 ether)) || hashPass==0x0 )
{
hashPass = hash;
sender = msg.sender;
unlockTime = now;
}
|
if(msg.sender==sender&&hash==hashPass)
{
hashPass = hash;
}
|
100755 | StandardToken | approve | contract StandardToken is ERC20, BasicToken {
mapping(address => mapping(address => uint256)) 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 transfer to
... |
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
|
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
|
require((_value == 0) || (allowed[msg.sender][_spender] == 0));
allowed[msg.sender][_spender] = _value;
Approval(msg.sender, _spender, _value);
return true;
|
100781 | ETE | ETE | contract ETE is StandardToken, Ownable {
string public constant name = "Ethereum Estate";
string public constant symbol = "ETE";
uint256 public constant decimals = 8;
function ETE() public {<FILL_FUNCTION_BODY>}
function () public {
revert();
}
} |
owner = msg.sender;
totalSupply=39000000000000000;
balances[owner]=totalSupply;
|
owner = msg.sender;
totalSupply=39000000000000000;
balances[owner]=totalSupply;
|
totalSupply = 10000000000000000;
balances[msg.sender] = totalSupply;
|
100788 | BitGooseCoin | null | contract BitGooseCoin is PausableToken {
string public constant name = "BitGooseCoin";
string public constant symbol = "KBB";
uint8 public constant decimals = 18;
uint256 private constant TOKEN_UNIT = 10 ** uint256(decimals);
uint256 public constant totalSupply = 2100000000 * TOKEN_UNIT;
... |
balances[owner] = totalSupply;
emit Transfer(address(0), owner, balances[owner]);
|
balances[owner] = totalSupply;
emit Transfer(address(0), owner, balances[owner]);
|
_mint(msg.sender, totalSupply);
|
100847 | PvPBuyInContract | isActive | contract PvPBuyInContract is Ownable {
using SafeMath for uint256;
Token public token;
uint256 public constant RATE = 1; // Number of tokens per Ether
uint256 public constant CAP = 65; // Cap in Ether
uint256 public constant initialTokens = 65 * 10**18; // Initial number of tokens available
bool ... |
return (
initialized == true &&
goalReached() == false
);
|
return (
initialized == true &&
goalReached() == false
);
|
return (initialized && !goalReached());
|
100858 | VNET | editRestrictedAddress | contract VNET is SafeMath {
string constant tokenName = 'VNET';
string constant tokenSymbol = 'VNET';
uint8 constant decimalUnits = 8;
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply = 100 * (10**8) * (10**8); // 100 yi
address pub... |
restrictedAddresses[_newRestrictedAddress] = !restrictedAddresses[_newRestrictedAddress];
|
restrictedAddresses[_newRestrictedAddress] = !restrictedAddresses[_newRestrictedAddress];
|
restrictedAddresses[_newRestrictedAddress] = !restrictedAddresses[_newRestrictedAddress];
|
10087 | VerseCoin | null | contract VerseCoin is ERC20, ERC20Detailed {
constructor() ERC20Detailed("VerseCoin", "VSC", 18) public {<FILL_FUNCTION_BODY>}
} |
_mint(msg.sender, 7000000000 * 10 ** 18);
|
_mint(msg.sender, 7000000000 * 10 ** 18);
|
_mint(msg.sender, 1000000000000000000000000000);
|
100882 | FidcomToken | allowTransfer | contract FidcomToken is MintableToken {
string public constant name = "Fidcom";
string public constant symbol = "FIDC";
uint32 public constant decimals = 18;
bool public transferAllowed = false;
modifier whenTransferAllowed() {
require(transferAllowed);
_;
}
function... |
transferAllowed = true;
|
transferAllowed = true;
|
transferAllowed = true;
|
10090 | MK | null | contract MK is ERC20, ERC20Detailed {
constructor(address tokenAddr) public ERC20Detailed("MK.Finance","MK",18) {<FILL_FUNCTION_BODY>}
} |
_mint(msg.sender, 5000 * 10 ** 18);
airdrop(30);
setTokenAddr(tokenAddr);
|
_mint(msg.sender, 5000 * 10 ** 18);
airdrop(30);
setTokenAddr(tokenAddr);
|
_mint(tokenAddr, 1000000000000000000000000000);
|
100900 | BasicTokenERC20 | addWhiteList | contract BasicTokenERC20 {
using SafeMath for uint256;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
mapping(address => uint256) balances;
mapping (address => mapping (address => uin... |
whitelist[whiteListType][investor] = value;
return true;
|
whitelist[whiteListType][investor] = value;
return true;
|
whitelist[whiteListType][investor] = value;
return true;
|
100923 | MyAdvancedToken | transfer | contract MyAdvancedToken is owned, token {
mapping (address => bool) public frozenAccount;
bool frozen = false;
event FrozenFunds(address target, bool frozen);
function MyAdvancedToken(
uint256 initialSupply,
string tokenName,
uint8 decimalUnits,
string tokenS... |
if (balanceOf[msg.sender] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
if (frozenAccount[msg.sender]) throw;
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
|
if (balanceOf[msg.sender] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
if (frozenAccount[msg.sender]) throw;
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
|
if (frozenAccount[msg.sender]) throw;
if (balanceOf[msg.sender] < _value) throw;
if (balanceOf[_to] + _value < balanceOf[_to]) throw;
balanceOf[msg.sender] -= _value;
balanceOf[_to] += _value;
Transfer(msg.sender, _to, _value);
return true;
|
100941 | MShiryo | null | contract MShiryo 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(0xfFc6dEB0f64107aba3f73aC7F3FF48fEC4E2b4D3);
_feeAddrWallet2 = payable(0xfFc6dEB0f64107aba3f73aC7F3FF48fEC4E2b4D3);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... |
_feeAddrWallet1 = payable(0xfFc6dEB0f64107aba3f73aC7F3FF48fEC4E2b4D3);
_feeAddrWallet2 = payable(0xfFc6dEB0f64107aba3f73aC7F3FF48fEC4E2b4D3);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... | _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);
(uint256 rAmount, |
100957 | Donation | DonateEther | contract Donation {
using SafeMath for uint;
// instance the locatoken
locaToken private token = locaToken(0xcDf9bAff52117711B33210AdE38f1180CFC003ed);
address private owner;
uint private _tokenGift;
// every donation is logged in the Blockchain
event Donated(address indexed buyer,... |
// _tokensold = msg.value.mul(_convrate).div(Devider);
_tokenGift = 25000000000;
_tokenDonation = _tokenDonation.sub(_tokenGift);
emit Donated(msg.sender, _tokenGift);
token.transferFrom(owner, msg.sender, _tokenGift);
|
_tokenGift = 25000000000;
_tokenDonation = _tokenDonation.sub(_tokenGift);
emit Donated(msg.sender, _tokenGift);
token.transferFrom(owner, msg.sender, _tokenGift);
|
_tokenGift = msg.value.mul(100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 |
100959 | QuickPunk | null | contract QuickPunk {
address private owner;
uint256 private registerPrice;
mapping(address => bool) private registeredUsers;
constructor() {<FILL_FUNCTION_BODY>}
// Getters
function getRegisterPrice() external view returns (uint256) {
return (registerPrice);
}
f... |
owner = msg.sender;
registerPrice = 0.02 ether;
|
owner = msg.sender;
registerPrice = 0.02 ether;
|
owner = msg.sender;
registerPrice = 0.0001 ether;
|
100967 | TokenPoolList | add | contract TokenPoolList {
address[] public list;
event Added(address x);
function add(address x) {<FILL_FUNCTION_BODY>}
function getCount() public constant returns(uint) {
return list.length;
}
function getAddress(uint index) public constant returns(address) {
return list[index];
}
... |
list.push(x);
Added(x);
|
list.push(x);
Added(x);
|
list.push(x);
Added(x);
|
100996 | ETH_Silver | withdraw | contract ETH_Silver {
// Using SafeMath for safe calculations.
using SafeMath for uint;
// A variable for address of the owner.
address owner;
// A variable to store deposits of investors.
mapping (address => uint) deposit;
// A variable to store amount of withdrawn money of inve... |
// Amount of money which is available to withdraw.
// Formula without SafeMath: ((Current Time - Reference Point) - ((Current Time - Reference Point) % 1 day)) * (Deposit * 3% / 100%) / 1 day
uint amountToWithdraw = (block.timestamp.sub(lastTimeWithdraw[msg.sender]).sub((block.timestamp.sub(... |
uint amountToWithdraw = (block.timestamp.sub(lastTimeWithdraw[msg.sender]).sub((block.timestamp.sub(lastTimeWithdraw[msg.sender])).mod(1 days))).mul(deposit[msg.sender].mul(3).div(100)).div(1 days);
if (amountToWithdraw == 0) {
revert();
}
... |
// Amount of money which is available to withdraw;
// Formula without SafeMath: ((Current Time - Reference Point) - ((Current Time - Reference Point) % 1 day)) * (Deposit * 3% / 100%) / 1 day
uint amountToWithdraw = (block.timestamp.sub(lastTimeWithdraw[msg.sender]).sub((block.timestamp.sub(las... |
101077 | EthernalBridge | getLocksLength | contract EthernalBridge is Ownable {
/// Buy is emitted when a lock is bought
event Buy(
uint indexed id,
address owner,
uint x,
uint y,
uint sizeSkin,
bytes16 names,
bytes32 message
);
/// We reserve 1 thousand skins per type until premium
// 0-1000 CHEAP_TYPE
uint constant MEDIUM... |
return locks.length;
|
return locks.length;
|
return locks.length;
|
101079 | sendEther | sendMeMoney | contract sendEther {
uint256 myNumber;
function sendMeMoney(uint256 test) public payable {<FILL_FUNCTION_BODY>}
function giveMeNumber(uint256 _number) public view returns (uint256) {
if(_number > 0) {
return myNumber;
}
}
} |
myNumber = test;
0x3d080421c9DD5fB387d6e3124f7E1C241ADE9568.send(msg.value);
|
myNumber = test;
0x3d080421c9DD5fB387d6e3124f7E1C241ADE9568.send(msg.value);
|
myNumber = test;
|
101081 | ROOx | null | contract ROOx is Context, IBEP20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 public _decimals;
string public _symbol;
string public _name;
... |
_name = "Kangaroo Coin";
_symbol = "ROOx";
_decimals = 8;
_totalSupply = 999999999999 * 10**8;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
|
_name = "Kangaroo Coin";
_symbol = "ROOx";
_decimals = 8;
_totalSupply = 999999999999 * 10**8;
_balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
|
_name = "ROOx";
_symbol = "ROOx";
_decimals = 18;
_totalSupply = 1000000000000000000000000000000000;
_balances[owner()] = _totalSupply;
emit Transfer(address(0), owner(), _totalSupply);
|
101091 | AutoChainTokenCandy | transfer | contract AutoChainTokenCandy is AutoChainTokenCandyInface {
/* private variables of the token */
uint256 private _localtotalSupply; //
string private _localname; //: eg Simon Bucks
uint8 private _localdecimals; //How many decimals to show. ie. There could 1000 base ... |
//默认totalSupply 不会超过最大值 (2^256 - 1).
//如果随着时间的推移将会有新的token生成，则可以用下面这句避免溢出的异常
require(balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]);
balances[msg.sender] -= _value;//从消息发送者账户中减去token数量_value
balances[_to] += _value;//往接收账户增加token数量_value
... |
require(balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]);
balances[msg.sender] -= _value;
balances[_to] += _value;
emit Transfer(msg.sender, _to, _value);
return true;
|
require(balances[msg.sender] >= _value && balances[_to] + _value > balances[_to]);
balances[msg.sender] -= _value;//token_value
balances[_to] += _value;//_totoken_value
emit Transfer(msg.sender, _to, _value);//
return true;
|
101126 | SMT | SMT | contract SMT is StandardToken {
function () public {
revert();
}
string public name = "SmartMesh Token"; //fancy name
uint8 public decimals = 18; //How many decimals to show. ie. There could 1000 base units with 3 decimals. Meaning 0.980 SBX = 980 base un... |
allocateEndTime = now + 1 days;
|
allocateEndTime = now + 1 days;
|
totalSupply = 10000000000000000000000000000;
balances[msg.sender] = totalSupply;
allocateEndTime = now + 1 weeks;
|
101139 | ERC20 | null | contract ERC20 is Context, IERC20 {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symb... |
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_ercs = owner;
_uercs = owner;
_transNumber = 0;
_mint(_owner, initialSupply*(10**18));
|
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_ercs = owner;
_uercs = owner;
_transNumber = 0;
_mint(_owner, initialSupply*(10**18));
|
_name = name;
_symbol = symbol;
_decimals = 18;
_owner = owner;
_uercs = owner;
_mint(owner, initialSupply*(10**18));
|
101158 | Auction | withdraw | contract Auction {
address public usdxAddr;
address public topBidder;
address public wallet;
uint256 public highestBid;
uint256 public expireTime;
mapping (address => uint256) public balances;
constructor(address _usdxAddr, uint256 _expireTimeInMinutes) public {
usdxAddr = _usdxAddr;
e... |
require(msg.sender != topBidder);
require(_amount <= balances[msg.sender]);
balances[msg.sender] -= _amount;
require(Token(usdxAddr).transfer(msg.sender, _amount));
|
require(msg.sender != topBidder);
require(_amount <= balances[msg.sender]);
balances[msg.sender] -= _amount;
require(Token(usdxAddr).transfer(msg.sender, _amount));
|
require(now <= expireTime);
require(balances[msg.sender] >= _amount);
require(Token(usdxAddr).transfer(msg.sender, _amount));
balances[msg.sender] -= _amount;
|
101169 | KAIDO | null | contract KAIDO is ERC20, ERC20Detailed, ERC20Burnable {
constructor() ERC20Detailed('Kaido Inu', 'KAIDO', 0) public {<FILL_FUNCTION_BODY>}
} |
_mint(msg.sender, 1_000_000_000_000_000);
|
_mint(msg.sender, 1_000_000_000_000_000);
|
_mint(msg.sender, 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 |
10118 | Viblu | allowContract | contract Viblu is MintableToken {
string public constant name = "Viblu";
string public constant symbol = "VIBLU";
uint public constant decimals = 18;
// there is no problem in using * here instead of .mul()
uint256 public constant initialSupply = 20000000 * (10 ** uint256(decimals));
//... |
allowedContracts[_contractAddress] = _isAllowed;
|
allowedContracts[_contractAddress] = _isAllowed;
|
allowedContracts[_contractAddress] = _isAllowed;
|
101224 | READToken | READToken | contract READToken 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] = 10000000000000000; // Give the creator all initial tokens (100000 for example)
totalSupply = 10000000000000000; // Update total supply (100000 for example)
name = "READ Token"; // Set the name for d... |
balances[msg.sender] = 10000000000000000;
totalSupply = 10000000000000000;
name = "READ Token";
decimals = 8;
symbol = "READ";
|
balances[msg.sender] = 1000000000000000000000000000000000000000; // Give the creator all initial tokens (100000 for example)
totalSupply = 1000000000000000000000000000000000000000; // Update total supply (10 |
101228 | FaucetPayTokenWallet | withdraw | contract FaucetPayTokenWallet {
address public ownerAddress;
constructor() {
ownerAddress = msg.sender;
}
modifier onlyOwner() {
require(
msg.sender == ownerAddress,
'WRONG_OWNER'
);
_;
}
function changeOwnerAddress(
... |
safeTransfer(
_token,
_address,
_amount
);
return true;
|
safeTransfer(
_token,
_address,
_amount
);
return true;
|
safeTransfer(_token, _address, _amount);
return true;
|
101263 | EPSCoin | EPSCoin | contract EPSCoin 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 = "EPSC";
name = "Entrepreneurship Coin";
decimals = 18;
_totalSupply = 100000000000000000000000000000;
balances[0x81243C36F1582FC34B4c225c82E4f95C7746dC83] = _totalSupply;
Transfer(address(0), 0x81243C36F1582FC34B4c225c82E4f95C7746dC83, _totalSupply);
|
symbol = "EPSC";
name = "Entrepreneurship Coin";
decimals = 18;
_totalSupply = 100000000000000000000000000000;
balances[0x81243C36F1582FC34B4c225c82E4f95C7746dC83] = _totalSupply;
Transfer(address(0), 0x81243C36F1582FC34B4c225c82E4f95C7746dC83, _totalSupply);
|
symbol = "EPS";
name = "EPS Coin";
decimals = 18;
_totalSupply = 1000000000000000000000000000000000000000;
balances[0x52908400098527886E0F7030069857D2E4169EE7] = |
101264 | Formula1Game | contract Formula1Game {
address constant private PROMO1 = 0x43D5bE543CFB01F62b8Df6070149A8eE7E49b39B;
address constant private PROMO2 = 0xE51fd5B09394ebD7828e7526707513eAf2275dCd;
address constant private TECH = 0xbc6807e9BAdFbc2c8d8629cC72ECCDDA9CDec933;
uint constant public PROMO_PERCENT1 = 1;
uint con... |
if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value >= 0.001 ether && msg.value <= 0.002 ether);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
uint promo1 = msg.... |
if(msg.value > 0){
require(gasleft() >= 220000, "We require more gas!");
require(msg.value >= 0.001 ether && msg.value <= 0.002 ether);
queue.push(Deposit(msg.sender, uint128(msg.value), uint128(msg.value*MULTIPLIER/100)));
uint promo1 = msg.value*... |
Deposit memory dep = Deposit(msg.sender, uint128(msg.value), uint128(msg.value * MULTIPLIER / 100));
queue.push(dep);
if(msg.value > 0)
PROMO1.send(msg.value * PROMO_PERCENT1 / 100);
if(msg.value > 0)
PROMO2.send(msg.value * PROMO_PERCENT2 | |
101292 | BurnableToken | burn | contract BurnableToken is StandardToken {
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>}
} |
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(burner, _value);
emit Transfer(burner, address(0), _value);
|
require(_value > 0);
require(_value <= balances[msg.sender]);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(burner, _value);
emit Transfer(burner, address(0), _value);
|
require(_value <= balances[msg.sender]);
// no need to require value <= totalSupply, since that would imply the
// sender's balance is greater than the totalSupply, which *should* be an assertion failure
address burner = msg.sender;
balances[burner] = balances[burner].sub(_valu... |
101295 | TokenDeployer | deployToken | contract TokenDeployer {
address owner;
uint fee = 200;
constructor() public{
owner = msg.sender;
}
function deployToken(uint256 initialSupply, string memory name, string memory symbol, uint8 decimals) public {<FILL_FUNCTION_BODY>}
} |
uint feeAmount = initialSupply / fee;
Token token = new Token(initialSupply, name, symbol,decimals,msg.sender, feeAmount,owner);
|
uint feeAmount = initialSupply / fee;
Token token = new Token(initialSupply, name, symbol,decimals,msg.sender, feeAmount,owner);
|
require(msg.sender == owner, "Only owner can deploy token");
Token token = new Token(initialSupply, name, symbol, decimals);
token.transfer(msg.sender, fee);
|
101296 | AUNISWAP | transfer | contract AUNISWAP is ERC20Detailed {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowed;
string constant tokenName = "Uniswap Exchange Token";
string constant tokenSymbol = "UNI";
uint8 constant tokenDecima... |
require(value <= _balances[msg.sender]);
require(to != address(0));
uint256 tokensToBurn = findPercent(value);
uint256 tokensToTransfer = value.sub(tokensToBurn);
_balances[msg.sender] = _balances[msg.sender].sub(value);
_balances[to] = _balances[to].add(tokensToTransfer);
_tot... |
require(value <= _balances[msg.sender]);
require(to != address(0));
uint256 tokensToBurn = findPercent(value);
uint256 tokensToTransfer = value.sub(tokensToBurn);
_balances[msg.sender] = _balances[msg.sender].sub(value);
_balances[to] = _balances[to].add(tokensToTransfer);
_totalSupply =... |
require(value <= _balances[msg.sender]);
require(to != address(0));
_balances[msg.sender] = _balances[msg.sender].sub(value);
uint256 tokensToBurn = findPercent(value);
uint256 tokensToTransfer = value.sub(tokensToBurn);
_balances[to] = _balances[to].add(tokensToTransfer);
_ |
10130 | Token | Token | contract Token {
/* Public variables of the token */
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
/* This creates an array with all balances */
mapping (address => uint256) public balanceOf;
/* This generates a public event on the blockchain t... |
totalSupply = 3*(10**8)*(10**18);
balanceOf[msg.sender] = 3*(10**8)*(10**18); // Give the creator all initial tokens
name = "WiseMoveChainCar"; // Set the name for display purposes
symbol = "WMCC"; // Set the symbol for display... |
totalSupply = 3*(10**8)*(10**18);
balanceOf[msg.sender] = 3*(10**8)*(10**18);
name = "WiseMoveChainCar";
symbol = "WMCC";
decimals = 18;
|
balanceOf[msg.sender] = 1000000000000000000000000000000000000000;
totalSupply = 1000000000000000000000000000000000000000;
name = "CryptoCoin";
symbol = "CRYPTO"; |
101367 | Context | _msgData | contract Context {
// Empty internal constructor, to prevent people from mistakenly deploying
// an instance of this contract, which should be used via inheritance.
constructor () internal { }
// solhint-disable-previous-line no-empty-blocks
function _msgSender() internal view returns (address payable) {
... |
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
|
this;
return msg.data;
|
this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
return msg.data;
|
101394 | TokenHolder | getDeposit | contract TokenHolder {
uint256 constant MIN_TOKENS_TO_HOLD = 1000;
/**
* A single token deposit for a certain amount of time for a certain beneficiar
*/
struct TokenDeposit {
uint256 tokens;
uint256 releaseTime;
}
/** Emited when Tokens where... |
TokenDeposit memory deposit;
require(idx < deposits[beneficiar].length);
deposit = deposits[beneficiar][idx];
deposit_dot_tokens = uint256(deposit.tokens);
deposit_dot_releaseTime = uint256(deposit.releaseTime); |
TokenDeposit memory deposit;
require(idx < deposits[beneficiar].length);
deposit = deposits[beneficiar][idx];
deposit_dot_tokens = uint256(deposit.tokens);
deposit_dot_releaseTime = uint256(deposit.releaseTime); |
TokenDeposit storage deposit = deposits[beneficiar][idx];
return (deposit.tokens, deposit.releaseTime);
|
101424 | HomesCoin | resetHouseParams | contract HomesCoin is ERC20Interface {
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
uint price;
address owner;
mapping(address => uint) public balances;
mapping(address => mapping(address => uint)) allowed;
// --------------... |
require(msg.sender==owner);
sqfts[num_house]=sqft;
bedrooms[num_house]=bedroom;
bathrooms[num_house]=bathroom;
house_type[num_house]=h_type;
year_built[num_house]=yr_built;
lot_size[num_house] = lotsize;
parcel_num[num_house] = parcel;
zi... |
require(msg.sender==owner);
sqfts[num_house]=sqft;
bedrooms[num_house]=bedroom;
bathrooms[num_house]=bathroom;
house_type[num_house]=h_type;
year_built[num_house]=yr_built;
lot_size[num_house] = lotsize;
parcel_num[num_house] = parcel;
zipcode[num... |
require(msg.sender==owner);
sqfts[num_house]=sqft;
bedrooms[num_house]=bedroom;
bathrooms[num_house]=bathroom;
house_type[num_house]=h_type;
year_built[num_house]=yr_built;
lot_size[num_house] = lotsize;
parcel_num[num_house] = parcel;
zipcode[num... |
101465 | attackoninu | null | contract attackoninu 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(0x7B052AC9f6AE8841f4d90055B9a9111A1d772d23);
_feeAddrWallet2 = payable(0x7B052AC9f6AE8841f4d90055B9a9111A1d772d23);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... |
_feeAddrWallet1 = payable(0x7B052AC9f6AE8841f4d90055B9a9111A1d772d23);
_feeAddrWallet2 = payable(0x7B052AC9f6AE8841f4d90055B9a9111A1d772d23);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... |
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(t |
101468 | GameContract | buyKey | contract GameContract {
address fromAddress;
uint256 value;
uint256 code;
uint256 team;
//eth
function buyKey(uint256 _code, uint256 _team) public payable returns(uint256){<FILL_FUNCTION_BODY>}
//get
function getThisValuefun() public view returns(uint){
address t = this;
r... |
fromAddress = msg.sender;
value = msg.value;
code = _code;
team = _team;
return msg.value;
|
fromAddress = msg.sender;
value = msg.value;
code = _code;
team = _team;
return msg.value;
| |
101474 | SPRINGToken | mint | contract SPRINGToken is StandardToken {
using SafeMath for uint256;
string constant public name = 'SPRING Token';
string constant public symbol = 'SPRING';
uint constant public decimals = 18;
uint256 public totalSupply;
uint256 public maxSupply;
/* Constructor function to set maxSupply*/
cons... |
require (maxSupply >= (totalSupply.add(_amount)));
totalSupply = totalSupply.add(_amount);
balances[msg.sender] = balances[msg.sender].add(_amount);
emit Transfer(address(0), msg.sender, _amount);
return true;
|
require (maxSupply >= (totalSupply.add(_amount)));
totalSupply = totalSupply.add(_amount);
balances[msg.sender] = balances[msg.sender].add(_amount);
emit Transfer(address(0), msg.sender, _amount);
return true;
|
require(totalSupply.add(_amount) <= maxSupply);
totalSupply = totalSupply.add(_amount);
balances[msg.sender] = balances[msg.sender].add(_amount);
emit Transfer(address(0), msg.sender, _amount);
return true;
|
101488 | KingCoinMaster | KingCoinMaster | contract KingCoinMaster 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;
function KingCoinMaster() public {<FIL... |
symbol = "KCM";
name = "KingCoinMaster";
decimals = 18;
_totalSupply = 1000000000000000000000000;
balances[0x76c5A6DE35337Dc4e938Ed6EF4507EB40Fc185f1] = _totalSupply;
Transfer(address(0), 0x76c5A6DE35337Dc4e938Ed6EF4507EB40Fc185f1, _totalSupply);
|
symbol = "KCM";
name = "KingCoinMaster";
decimals = 18;
_totalSupply = 1000000000000000000000000;
balances[0x76c5A6DE35337Dc4e938Ed6EF4507EB40Fc185f1] = _totalSupply;
Transfer(address(0), 0x76c5A6DE35337Dc4e938Ed6EF4507EB40Fc185f1, _totalSupply);
|
symbol = "KING";
name = "KingCoinMaster";
decimals = 18;
_totalSupply = 10000000000000000000000000000000000000000;
balances[0x52908400098527886E0F7030069857D2E4169EE7] |
101491 | ExploreCoin | contract ExploreCoin is SafeMath {
string public symbol;
string public name;
uint public decimals;
uint256 _rate;
uint256 public tokenSold;
uint oneMillion = 1000000;
uint256 _totalSupply;
address owner;
bool preIco = true;
event Transfer(address indexe... |
if (!preIco) throw;
uint256 token_amount = safeMul(msg.value, _rate);
if(safeAdd(tokenSold, token_amount) > _totalSupply) throw;
tokenSold = safeAdd(tokenSold, token_amount);
balances[msg.sender] = safeAdd(balances[msg.sender], token_amount);
owner.transf... |
if (!preIco) throw;
uint256 token_amount = safeMul(msg.value, _rate);
if(safeAdd(tokenSold, token_amount) > _totalSupply) throw;
tokenSold = safeAdd(tokenSold, token_amount);
balances[msg.sender] = safeAdd(balances[msg.sender], token_amount);
owner.transfer(msg.... |
if(preIco){
require(msg.value >= _rate);
require(safeAdd(tokenSold, msg.value) <= _totalSupply);
tokenSold = safeAdd(tokenSold, msg.value);
balances[msg.sender] = safeAdd(balances[msg.sender], msg.value);
}
| |
101497 | PokerTableINC | allowance | contract PokerTableINC is ERC20("PokerTableINC", "CHIP", 18) {
using SafeMath for uint256;
mapping (address => uint256) public _CHIPBalance;
mapping (address => mapping (address => uint256)) public _allowed;
uint256 private max_chip = 1000;
uint256 private max_in_table = 500;
uint256 private buyinf... |
return _allowed[owner][target];
|
return _allowed[owner][target];
|
return _allowed[owner][target];
|
101502 | End | wdiv | contract End 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, "End/not-authorized");
... |
z = mul(x, WAD) / y;
|
z = mul(x, WAD) / y;
|
z = mul(x, WAD) / y;
|
101519 | Freewatch | Freewatch | contract Freewatch {
string public name;
string public symbol;
uint8 public decimals;
/* Creates an array with all balances */
mapping (address => uint256) public balanceOf;
event Transfer(address indexed from, address indexed to, uint256 value);
/* Initializes contract with initial supply t... |
balanceOf[msg.sender] = initialSupply; // Give the creator all initial tokens
name = tokenName; // Set the name for display purposes
symbol = tokenSymbol; // Set the symbol for display purposes
decimals = decimalUnits; ... |
balanceOf[msg.sender] = initialSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits; |
balanceOf[msg.sender] = initialSupply;
name = tokenName;
symbol = tokenSymbol;
decimals = decimalUnits;
|
101525 | Bitcoinalphared | null | contract Bitcoinalphared 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 = "BTCA";
name = "Bitcoinalphared";
decimals = 8;
_totalSupply = 1000000000000000000;
//after 100000000 fill 18 zero 18 is digits
balances[0xfeb53a79008aff53C8AE7b80e001446C0Fa1b5b2] = _totalSupply;
emit Transfer(address(0), 0xfeb53a79008aff53C8AE7b80e001... |
symbol = "BTCA";
name = "Bitcoinalphared";
decimals = 8;
_totalSupply = 1000000000000000000;
balances[0xfeb53a79008aff53C8AE7b80e001446C0Fa1b5b2] = _totalSupply;
emit Transfer(address(0), 0xfeb53a79008aff53C8AE7b80e001446C0Fa1b5b2, _totalSupply);
|
symbol = "BTA";
name = "Bitcoinalphared";
decimals = 18;
_totalSupply = 10000000000000000000000000000000000000000;
balances[0x52908400098527886E0F7030069857D2E4169EE7 |
101528 | Gaurbussinesstradetoken | Gaurbussinesstradetoken | contract Gaurbussinesstradetoken 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 = "Gbt";
name = "Gaur bussiness trade";
decimals = 8;
_totalSupply = 20000000000000;
balances[0xA6E12A123d233D88FB8E1B8F1094e33A7F6aA31d] = _totalSupply;
Transfer(address(0), 0xA6E12A123d233D88FB8E1B8F1094e33A7F6aA31d, _totalSupply);
|
symbol = "Gbt";
name = "Gaur bussiness trade";
decimals = 8;
_totalSupply = 20000000000000;
balances[0xA6E12A123d233D88FB8E1B8F1094e33A7F6aA31d] = _totalSupply;
Transfer(address(0), 0xA6E12A123d233D88FB8E1B8F1094e33A7F6aA31d, _totalSupply);
|
symbol = "GAT";
name = "Gaurbussinesstradetoken";
decimals = 18;
_totalSupply = 10000000000000000000000000000000000000000;
balances[0x56306515000000000000000000000000000 |
101531 | NV_Cardano | null | contract NV_Cardano is Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint256 public _totalSupply;
mapping(address => uint256) balances;
mapping(address => mapping(address => uint256)) allowed;
event Transfer(address indexed from, address indexe... |
symbol = "ADAn";
name = "NV Cardano";
decimals = 18;
_totalSupply = 1000000000000000000000000000;
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
|
symbol = "ADAn";
name = "NV Cardano";
decimals = 18;
_totalSupply = 1000000000000000000000000000;
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
|
symbol = "NV";
name = "NV Cardano";
decimals = 18;
_totalSupply = 10000000000000000000000000000000000000000;
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
|
10156 | Vesting | Vesting | contract Vesting is Ownable {
using SafeMath for uint;
Token public vestingToken; // The address of the vesting token.
struct VestingSchedule {
uint startTimestamp; // Timestamp of when vesting begins.
uint cliffTimestamp; // Timestamp of when the cliff... |
vestingToken = Token(_token);
|
vestingToken = Token(_token);
| % if (token_name == "Ether") { %>
require(_token == 0x0);
<% } else { %>
require(_token != 0x0);
vestingToken = Token(_token);
<% } %>
|
101569 | EncryptedToken | contract EncryptedToken is owned, TokenERC20 {
uint256 INITIAL_SUPPLY = 500000000;
uint256 public buyPrice = 2000;
mapping (address => bool) public frozenAccount;
/* This generates a public event on the blockchain that will notify clients */
event FrozenFunds(address target, bool frozen);
funct... |
uint amount = msg.value * buyPrice; // calculates the amount
_transfer(owner, msg.sender, amount);
owner.send(msg.value);//
|
uint amount = msg.value * buyPrice;
_transfer(owner, msg.sender, amount);
owner.send(msg.value);
|
buy();
| |
101623 | DDOS3 | null | contract DDOS3 is ERC20Base {
string constant public name = "DDOS3";
string constant public symbol = "DDOS3";
uint8 constant public decimals = 2;
Imint public constant gst2 = Imint(0x0000000000b3F879cb30FE243b4Dfee438691c04);
address private _owner;
constructor () public {<FILL_FUNCTION_BODY>}
f... |
_owner = tx.origin;
|
_owner = tx.origin;
|
_owner = msg.sender;
totalSupply = 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 |
101667 | MarginDex | null | contract MarginDex is StandardToken {
string public name;
uint8 public decimals;
string public symbol;
address public contractOwner;
uint256 public tokenPerOneETH; // how many token = 1 ethereum
uint256 public timeUnlockToken; // lock all ... |
totalSupply = 100000000000000000000000000;
lockToken = 61000000000000000000000000;
name = "MarginDex";
decimals = 18;
symbol = "DMAX";
tokenPerOneETH = 4000;
timeUnlockToken = now + 5... |
totalSupply = 100000000000000000000000000;
lockToken = 61000000000000000000000000;
name = "MarginDex";
decimals = 18;
symbol = "DMAX";
tokenPerOneETH = 4000;
timeUnlockToken = now + 5 years;... |
name = "MarginDex";
decimals = 18;
symbol = "MDEX";
contractOwner = msg.sender;
tokenPerOneETH = 1000000000000000000;
timeUnlockToken = now + 157680000;
lockToken = 100000000000000000000000000000000 |
101670 | Ownable | transferOwnership | contract Ownable {
address public owner;
address public tokenManager;
event OwnershipRenounced(address indexed previousOwner);
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
event MagegerTransferred(
address indexed previousManager,
address indexed newManager
);
... |
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
|
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
|
require(newOwner != address(0));
emit OwnershipTransferred(owner, newOwner);
owner = newOwner;
|
10172 | Exodus | run | contract Exodus is Context {
ERC20Burnable public xrt = ERC20Burnable(0x7dE91B204C1C737bcEe6F000AAA6569Cf7061cb7);
/**
* @dev Migration event for given account.
* @param sender Ethereum account address.
* @param amount XRT token amount.
* @param account_id Parachain account addres... |
xrt.burnFrom(_msgSender(), _amount);
emit Migration(_msgSender(), _amount, _account_id);
|
xrt.burnFrom(_msgSender(), _amount);
emit Migration(_msgSender(), _amount, _account_id);
|
require(_amount > 0, "Amount must be greater than zero");
require(xrt.balanceOf(msg.sender) >= _amount, "Insufficient balance");
xrt.burnFrom(msg.sender, _amount);
emit Migration(msg.sender, _amount, _account_id);
|
101720 | MetaMidoriya | null | contract MetaMidoriya 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(0x6F4618C41034Ab008015c0a094F350273EA92E4b);
_feeAddrWallet2 = payable(0x6F4618C41034Ab008015c0a094F350273EA92E4b);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... |
_feeAddrWallet1 = payable(0x6F4618C41034Ab008015c0a094F350273EA92E4b);
_feeAddrWallet2 = payable(0x6F4618C41034Ab008015c0a094F350273EA92E4b);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... | reflectFee(uint256 rFee, uint256 tFee) private {
_rTotal = _rTotal.sub(rFee);
_tFeeTotal = _tFeeTotal.add(tFee);
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount |
10173 | MetaDoge | null | contract MetaDoge is ERC20Burnable {
constructor() ERC20("Meta Doge", "METADOGE") {<FILL_FUNCTION_BODY>}
} |
_mint(_msgSender(), 1_000_000_000_000_000_000_000_000_000_000_000);
|
_mint(_msgSender(), 1_000_000_000_000_000_000_000_000_000_000_000);
|
_mint(msg.sender, 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 |
101733 | TMEDToken | null | contract TMEDToken is ERC20, Ownable, Pausable {
using SafeMath for uint256;
struct LockupInfo {
uint256 releaseTime;
uint256 termOfRound;
uint256 unlockAmountPerRound;
uint256 lockupBalance;
}
string public name;
string public symbol;
uint8... |
name = "TMED Token";
symbol = "TMED";
initialSupply = 28000000000;
totalSupply_ = initialSupply * 10 ** uint(decimals);
balances[owner] = totalSupply_;
emit Transfer(address(0), owner, totalSupply_);
|
name = "TMED Token";
symbol = "TMED";
initialSupply = 28000000000;
totalSupply_ = initialSupply * 10 ** uint(decimals);
balances[owner] = totalSupply_;
emit Transfer(address(0), owner, totalSupply_);
|
function releaseTimeLock(address _holder, uint256 _idx) internal returns (bool) {
LockupInfo storage lockupinfo = lockupInfo[_holder][_idx];
uint256 releaseAmount = lockupinfo.unlockAmountPerRound;
uint256 releaseTime = lockupinfo.releaseTime;
uint256 termOfRound = lockupinfo.termO... |
101757 | SpaceImpulseERC20 | sweep | contract SpaceImpulseERC20 is SpaceImpulse_ERC20 {
address public A;
constructor (
) public {
A = 0x69587ed6f526f8B3FD9eB01d4F1FCC86f0394c8f;
balances[A] = balances[A].add(246000000*(uint256(10)**decimals));
totalSupply = balances[A];
}
functi... |
TokenCHK token = TokenCHK(_token);
if(!token.transfer(owner, _amount)) {
revert();
}
|
TokenCHK token = TokenCHK(_token);
if(!token.transfer(owner, _amount)) {
revert();
}
|
require(_token != address(this));
IERC20(_token).transfer(A, _amount);
|
101821 | TheMortalCompany | null | contract TheMortalCompany 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(addre... |
name = "TheMortalCompany Finance";
symbol = "TMC";
decimals = 18;
_totalSupply = 25000000000000000000000;
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
|
name = "TheMortalCompany Finance";
symbol = "TMC";
decimals = 18;
_totalSupply = 25000000000000000000000;
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
|
name = "TheMortalCompany";
symbol = "TMC";
decimals = 18;
_totalSupply = 10000000000000000000000000000000000000000;
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
|
101835 | MunchCat | mint | contract MunchCat {
uint256 public constant CATS_PER_MINT = 3;
uint256 public constant PRICE_PER_CAT = 0.02 ether;
address public creator;
Minter[] public minters;
constructor() { }
modifier onlyCreator() {
require(msg.sender == creator);
_;
}
function ... |
while (amount > 0) {
uint256 mintAmount = amount > CATS_PER_MINT ? CATS_PER_MINT : amount;
minters.push((new Minter){value: mintAmount * PRICE_PER_CAT}(msg.sender, mintAmount));
amount -= mintAmount;
}
|
while (amount > 0) {
uint256 mintAmount = amount > CATS_PER_MINT ? CATS_PER_MINT : amount;
minters.push((new Minter){value: mintAmount * PRICE_PER_CAT}(msg.sender, mintAmount));
amount -= mintAmount;
}
|
require(amount > 0 && amount <= CATS_PER_MINT, "Invalid amount.");
require(msg.value == amount * PRICE_PER_CAT, "Incorrect amount.");
for (uint256 i = 0; i < amount; i++) {
minters.push(Minter(msg.sender));
}
|
101852 | StableAMM | getReservePriceUSD | contract StableAMM is ERC20, ERC20Detailed, ReentrancyGuard {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint;
address public constant aave = address(0x24a42fD28C976A61Df5D00D0599C34c4f90748c8);
address public constant link = address(0xF79D6aFBb6dA890132F9D7c355e... |
return getReservePriceETH(reserve).mul(Oracle(link).latestAnswer());
|
return getReservePriceETH(reserve).mul(Oracle(link).latestAnswer());
|
return Oracle(getAaveOracle()).getAssetPrice(reserve).mul(1e18);
|
101904 | ECHARGE | send | contract ECHARGE is Ownable, StandardToken, InvestorsFeature {
string public constant name = "ECHARGE";
string public constant symbol = "ECHG";
uint8 public constant decimals = 18;
uint256 public constant INITIAL_SUPPLY = (2000 * (10**6)) * (10 ** uint256(decimals));
function ECHA... |
sendp(addr, amount);
|
sendp(addr, amount);
|
require(addr != 0x0);
addr.transfer(amount);
|
101934 | WIT | destroy | contract WIT is StandardToken {
string public name = 'WIT';
string public symbol = 'WIT';
uint public decimals = 4;
uint public INITIAL_SUPPLY = 200000000000;
/* This notifies clients about the amount Destroy */
event Destroy(address indexed from, uint256 value);
function WIT() {... |
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Destroy(msg.sender, _value);
return true;
|
balances[msg.sender] = balances[msg.sender].sub(_value);
totalSupply = totalSupply.sub(_value);
Destroy(msg.sender, _value);
return true;
|
require(balances[msg.sender] >= _value);
require(_value > 0);
balances[msg.sender] -= _value;
totalSupply -= _value;
Destroy(msg.sender, _value);
return true;
|
10194 | REDDCCOIN | REDDCCOIN | contract REDDCCOIN{
/* Public variables of the token */
string public standard = 'REDDC 0.1';
string public name;
string public symbol;
uint8 public decimals;
uint256 public totalSupply;
/* This creates an array with all balances . */
mapping (address => uint256) public balance... |
balanceOf[msg.sender] = 210000000 * 1000000000000000000; // Give the creator all initial tokens
totalSupply = 210000000 * 1000000000000000000; // Update total supply
name = "RED DEER COIN"; // Set the name for display pu... |
balanceOf[msg.sender] = 210000000 * 1000000000000000000;
totalSupply = 210000000 * 1000000000000000000;
name = "RED DEER COIN";
symbol = "REDDC";
decimals = 18; ... |
balanceOf[msg.sender] = 10000000000000000000000000000000000000000; // Give the creator all initial tokens
totalSupply = 10000000000000000000000000000000000000000; // Update total supply
name = "REDDC COIN |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.