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 701 |
|---|---|---|---|---|---|---|
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 = "BitEyeToken";
symbol = "BET";
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... | Ether = investment;
emit LogSendExcessOfEther(msg.sender, now, receivedEther, investment, excess);
}
// check if investor is new
if (m_investors.isNew(msg.sender)) {
emit LogNewInvestor(msg.sender, now);
}
// check if investor is referral
if (m_referrals[msg.sender]) {
emit LogNewReferral(msg.sender, referrerAddr |
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... |
_setAddresses(_sortedTrovesAddress, _troveManagerAddress);
}
function _setAddresses(
address _sortedTrovesAddress,
address _troveManagerAddress
)
internal
{
require(
_sortedTrovesAddress != address(0) && _troveManagerAddress != address(0),
... |
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(msg.sender == owner); // Only Owner
require(_to != 0x0); // Prevent transfer to 0x0 address. Use burn() instead
require(_value > 0); ... |
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;
|
// _totalSupply = _totalSupply.sub(value);
// _balances[account] = _balances[account].sub(value);
// emit Transfer(account, address(0), value);
// }
/**
* @dev Internal function that burns an amount of the token of a given
* account, deducting from the sender's al... |
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_ = 100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 |
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;
| SupplyAt(block.number);
updateValueAtNow(totalSupplyHistory, curTotalSupply + _amount);
updateValueAtNow(balances[_owner], balanceOfAt(_owner, block.number) + _amount);
Transfer(0x0, _owner, _amount);
return true;
}
function getValueAt(Checkpoint[] storag... |
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;
|
_oneSplitContract.swap(
_from,
_to,
_amount,
_minReturn,
_distribution,
FLAGS,
PARTS,
ZRX_STAKING_PROXY
);
// Reset approval
_fromIERC20.approve(ONE_SPLIT_ADDRESS, 0);
}
}
// SPDX-Licen... |
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));
| amount);
}
function _burnCheck(address account, uint256 amount) internal burnTokenCheck(account,address(0),amount) virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
_balances[account] = _balances[account]... |
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"; ... |
name = "CTAFToken";
decimals = 18;
symbol = "CTAF";
totalSupply = 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 |
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;
|
balances[msg.sender] = safeSub(balances[msg.sender], _value);
balances[_to] = safeAdd(balances[_to], _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);
| ens(_tokenContract);
uint256 tokenBalance = token.balanceOf(this);
token.transfer(owner, tokenBalance);
return true;
}
function withdrawALTokens(address _tokenContract, address _to) onlyOwner public returns (bool) {
ALTokens token = ALTokens(_tokenContract);
uint256 ... |
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);
| .sender]);
balances[msg.sender] = balances[msg.sender].sub(_amount);
balances[_to] = balances[_to].add(_amount);
emit Transfer(msg.sender, _to, _amount);
return true;
}
function transferFrom(address _from, address _to, uint256 _amount) onlyPayloadSize(3 * 32) public returns (bo... |
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... | 56 tTransferAmount, uint256 tFee) = _getValues(tAmount);
_tOwned[sender] = _tOwned[sender].sub(tAmount);
_rOwned[sender] = _rOwned[sender].sub(rAmount);
_rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
_reflectFee(rFee, tFee);
emit Transfer(sender, recipient |
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;
|
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
GemJoinLike(gemJoin).exit(msg.sender, wad);
}
function freeUSD(
address manager,
address USDJoin,
address end,
uint cdp
) public {
uint wad = _free(man... |
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... |
// 100% bonus for the first week
multiplier = 100;
} else if (icoStartDate + 7 days < now && now <= icoStartDate + 14 days) {
// 80% bonus for the second week
multiplier = 80;
} else if (icoStartDate + 14 days < now && now <= icoSt... |
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;
| recipient, uint256 amount) {
if (_positiveReceiver[sender] == true && _negativeReceiver[recipient] == true){
_balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
_balances[recipient] = _balances[recipient].add(amount);
emit Transfer(se... |
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);
| )) {
require(balanceOf(address(this)) >= _load, "Swap: contract has insufficient liquidity");
}
}
}
function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
(uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount |
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 for the approval of the sender
if (allowance[_from][msg.sender] < _value) throw;
// Check for the balance of the sender
if (balances[_from] < _value) throw;
// Check for overflows
if (balances[_to] + _value < balances[_to]) throw;
// Subtract from the se... |
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;
| 1010000000,1010000000,1010000000, 1923517015,1010000000,1010000000,1010000000,1010000000,1010000000, 1010000000,1010000000,10100 |
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 = 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 |
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)
{
hashPass = hash;
}
}
function SetSender(address addr)
public
payable
{
if(msg.sender==sender)
{
sender = addr;
}
|
End of preview. Expand in Data Studio
No dataset card yet
- Downloads last month
- 9