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