Token

Tiger Queen (TQUEEN)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-20

Overview

Max Total Supply

100,000,000,000,000 TQUEEN

Holders

321

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x77a13ccd9b3983ee24513f0845c8deffc1874e12

Filtered by Token Holder

0xfC7330c83b68D88869652F09C3e3d9e0D15a1433

Balance

0.604175723265193224 TQUEEN

Value

$0.00

0xfc7330c83b68d88869652f09c3e3d9e0d15a1433

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

TigerQueen

Compiler Version

v0.8.19+commit.7dd6d404

Optimization Enabled:

Yes with 20000 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-06-02
*/

// File: @uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router01.sol

pragma solidity >=0.6.2;

interface IUniswapV2Router01 {
    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 removeLiquidity(
        address tokenA,
        address tokenB,
        uint liquidity,
        uint amountAMin,
        uint amountBMin,
        address to,
        uint deadline
    ) external returns (uint amountA, uint amountB);
    function removeLiquidityETH(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountToken, uint amountETH);
    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 removeLiquidityETHWithPermit(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountToken, uint amountETH);
    function swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapTokensForExactTokens(
        uint amountOut,
        uint amountInMax,
        address[] calldata path,
        address to,
        uint deadline
    ) external returns (uint[] memory amounts);
    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);
    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
        external
        returns (uint[] memory amounts);
    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
        external
        payable
        returns (uint[] memory amounts);

    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
}

// File: @uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol

pragma solidity >=0.6.2;


interface IUniswapV2Router02 is IUniswapV2Router01 {
    function removeLiquidityETHSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external returns (uint amountETH);
    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
        address token,
        uint liquidity,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline,
        bool approveMax, uint8 v, bytes32 r, bytes32 s
    ) external returns (uint amountETH);

    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;
}

// File: @uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol

pragma solidity >=0.5.0;

interface IUniswapV2Factory {
    event PairCreated(address indexed token0, address indexed token1, address pair, uint);

    function feeTo() external view returns (address);
    function feeToSetter() external view returns (address);

    function getPair(address tokenA, address tokenB) external view returns (address pair);
    function allPairs(uint) external view returns (address pair);
    function allPairsLength() external view returns (uint);

    function createPair(address tokenA, address tokenB) external returns (address pair);

    function setFeeTo(address) external;
    function setFeeToSetter(address) external;
}

// File: @uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol

pragma solidity >=0.5.0;

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

// File: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain `call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
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() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

    /**
     * @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 {
        _transferOwnership(address(0));
    }

    /**
     * @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 {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

    /**
     * @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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
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);
}

// File: @openzeppelin/contracts/token/ERC20/ERC20.sol


// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
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;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the default value returned by this function, unless
     * it's overridden.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}

// File: TigerQueen.sol


pragma solidity ^0.8.0;









// Set token name
contract TigerQueen is ERC20, Ownable {
    using Address for address payable;

    // Events
    event HandleTaxes (
        uint256 tokens,
        uint256 treasuryEth
    );
    event TradingEnabled (uint blockNumber);
    event NewDexPair (address pair);
    event AdmiralAckbar (
        address unsuspectingFool,
        uint256 numberOfShips
    );

    // Uniswap
    IUniswapV2Router02 public uniswapV2Router;
    mapping(address => bool) public dexPair;

    // System Operation
    bool private tradingEnabled;
    bool private isSystemSwapping; // Many contracts simply call it "swapping"

    // Taxes
    uint256 public buyTax;
    uint256 public sellTax;
    uint256 public penaltyTax;
    bool public handleBalance; // Automatically liquidate/distribute taxes
    uint256 public minTokensToLiquidate; // Liquidation will not process below this token balance
    uint256 public liquidityPercentage; // Percentage of taxes added to liquidity

    // Wallets
    address public treasuryWallet;

    // Black/whitelists
    mapping(address => bool) public exemptFee;
    mapping(address => uint256) public purchaseRegistry; // Tracks accounts receiving tokens for frontrun protection
    BotRegistry botRegistry;
    bool private frontrunProtection = true; // Auto blacklists frontrunning bots. On by default
    uint256 public minTxBlocks; // Minimum blocks between purchase/sell transactions

    // Define all settings in the constructor
    constructor(address treasuryAddr) ERC20("Tiger Queen", "TQUEEN") {
        // Mint tokens to deployer
        _mint(msg.sender, 100000000000000 * 10 ** decimals());

        // Initialize uniswap router
        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);

        // Use uniswap factory to deploy/set the token pair
        address _uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
            .createPair(address(this), _uniswapV2Router.WETH());
        uniswapV2Router = _uniswapV2Router;
        _updateDexPairs(_uniswapV2Pair, true);
        // Provides "infinite" approval of this token to the uniswap router for fee liquidation
        // See approveExternal() if additional approvals are required
        _approve(address(this), address(uniswapV2Router), 2**255);

        // Set Taxes
        buyTax=10;
        sellTax=10;
        penaltyTax=99; // Don't revent on malicious bots, just charge them exorbitant fees
        handleBalance=true;
        minTokensToLiquidate = 100000000000 * 10 ** decimals();
        liquidityPercentage = 0;
        minTxBlocks = 4;

        // Set wallets
        treasuryWallet = treasuryAddr;

        // Tax exemptions
        exemptFee[address(this)] = true;
        exemptFee[msg.sender] = true;
        exemptFee[treasuryWallet] = true;
        
    }

    // onlyOwner SETTERS //
    // Enable trading. Cannot be used to disable trading
    function enableTrading() external onlyOwner {
        require(!tradingEnabled, "Trading is already enabled");
        tradingEnabled = true;
        emit TradingEnabled(block.number);
    }

    /** Amount in percentage. ie 1 = 1% */
    function updateBuyTax(uint256 amount) external onlyOwner {
        require(amount <= 100, "100% Max");
        buyTax = amount;
    }
    
    /** Amount in percentage. ie 1 = 1% */
    function updateSellTax(uint256 amount) external onlyOwner {
        require(amount <= 100, "100% Max");
        sellTax = amount;
    }
   
    /** Amount in percentage. ie 1 = 1% */
    function updatePenaltyTax(uint256 amount) external onlyOwner {
        require(amount <= 100, "100% Max");
        penaltyTax = amount;
    }
    // Enable/disable auto balance handling
    function updateHandleBalance(bool status) external onlyOwner {
        require(handleBalance != status, "Status already set");
        handleBalance = status;
    }
    // Update minimum liquidation threshhold
    function updateMinTokensToLiquidate(uint256 amount) external onlyOwner {
        minTokensToLiquidate = amount;
    }
    // Update liquidity percentage 
    function updateLiquidityPercentage(uint256 percent) external onlyOwner {
        require(percent <= 100, "Weight must be less than 100");
        liquidityPercentage = percent;
    }
   
    // Designate a new treasury address
    function updateTreasuryWallet(address wallet) external onlyOwner {
        require(wallet != address(this), "Fee Address cannot be Contract Address");
        require(wallet != address(0), "Fee Address cannot be zero address");
        treasuryWallet = wallet;
    }

     // Update dex Pairs 
    function updateDexPairs(address addr, bool state) external onlyOwner {
        _updateDexPairs(addr, state);
    }
    function _updateDexPairs(address addr, bool state) internal {
        dexPair[addr] = state;
        if (state)
            emit NewDexPair (addr);
    }

    // Update exempt fee addresses
    function updateExemptFee(address addr, bool state) external onlyOwner {
        exemptFee[addr] = state;
    }
    function bulkExemptFee(address[] memory accounts, bool state) external onlyOwner {
        for (uint256 i = 0; i < accounts.length; i++) {
            exemptFee[accounts[i]] = state;
        }
    }

    // Enable/disable auto balance handling
    function updateFrontrunProtection(bool status) external onlyOwner {
        require(frontrunProtection != status, "Protection already set");
        frontrunProtection = status;
    }
    // Update minimum blocks between purchase/sell transactions
    function updateMinTxBlocks(uint256 blocks) external onlyOwner {
        require(blocks < 75, "Longer periods aren't really frontunning, are they?");
        minTxBlocks = blocks;
    }
    // Define the bot registry
    function setBotRegistry(address addr) external onlyOwner {
        botRegistry = BotRegistry(addr); // Can be changed to other a different registry later
    }
    // END SETTERS //

    
    // FUNCTIONS 

    function _transfer(
        address sender,
        address recipient,
        uint256 amount
    ) internal override {
        // require(tradingEnabled || exemptFee[sender], "Slow down turbo!"); // Prevent trading when not enabled
        require(amount > 0, "Why is it so HEAVY???");
        
        uint256 feePercent; // Logic below determines the percent paid as the fee

        // Catch snipers. Note: This will catch *any* non-exempted buys until trading is enabled. Beware collateral damage
        // Used for stealth launches and to auto blacklist bots that try to snipe before a token is live
        if ( !tradingEnabled ) { // Skip this block once trading is enabled
            if (!exemptFee[recipient] && !dexPair[recipient]) {
                _registerBot(recipient); // Blacklists account receiving tokens (commonly a MEV treasury contract)
                _registerBot(tx.origin); // Blacklists operator (common with MEV bots)
            }
        }

        // Logic to auto blacklist frontrunning bots
        // If an account receives, and sends tokens in a short window
        // then we assume they are a bot and add them to the naughtyList
        // Note: If the bot requires a minAmountOut (uniswap) the tx will revert
        // and no naughtyList will be saved. Only catches panic sellers.
        if ( frontrunProtection ) {
            // Adds token recipient/holder to purchase registry
            if (!exemptFee[recipient] && !dexPair[recipient])
                purchaseRegistry[recipient] = block.number;
            if (!exemptFee[sender] && !dexPair[sender]) {
                // If this sender has received tokens within the minTxBlocks period
                if (block.number - purchaseRegistry[sender] < minTxBlocks) {
                    _registerBot(sender); // Blacklists account sending tokens (commonly a MEV treasury contract)
                    _registerBot(tx.origin); // Blacklists operator (common with MEV bots)
                }
            }
        }

        //set fee to zero if exempted
        if (exemptFee[sender] || exemptFee[recipient])
            feePercent = 0;
        // Don't let bots dump their tokens
        else if (isRegistered(sender)) {
            feePercent = penaltyTax;
            emit AdmiralAckbar(sender, amount);
        }

        // Tokens are moving into a registered dexPair, this is a SELL
        else if (dexPair[recipient]) {
            if (isRegistered(tx.origin)) { // Don't let bot *operators* sell tokens from contracts
                feePercent = penaltyTax;
                emit AdmiralAckbar(tx.origin, amount);
            } else 
                feePercent = sellTax;

            // Delegate tax/fee handling to a separate function
            _handleTaxes(); // Tax liquidation frontruns this sell. THAT'S WHAT YOU GET
        } 
        // If tokens are coming from a registered dexPair, it's a BUY!
        else if (dexPair[sender])
            feePercent = buyTax;

        // Logic above sets feePercent for taxable events
        if ( feePercent == 0 ) // If there are no fees, simply....transfer the tokens, save gas
            super._transfer(sender, recipient, amount);
        else {
            uint256 feeAmount = amount * feePercent / 100;
            super._transfer(sender, address(this), feeAmount); // Collect taxes in contract
            super._transfer(sender, recipient, amount - feeAmount); // Complete transfer minus fee
        } 
    }

    // Manually handle taxes
    function handleTaxes() external {
        _handleTaxes();
    }
    // Handle all tax logic here
    // This logic can vary project to project. Ideally make all customization here.
    function _handleTaxes() private {
        // If this wasn't a sell, we aren't handling balances, or we are already swapping, exit
        if (!handleBalance || isSystemSwapping)
            return;
        isSystemSwapping = true; // Prevents recursion
        uint256 tokenBalance = balanceOf(address(this));
        // If the balance is too low, don't waste gas
        if (tokenBalance < minTokensToLiquidate)
            return;
        // Of the percentage of tokens used for liquidity, we will hold half.
        if (liquidityPercentage > 0 ) {
            uint256 tokensForLiquidity = liquidityPercentage * tokenBalance / 200; // Weighted balance as percentage
            // Liquidate entire balance, minus half for liquidity
            _swapTokensForEth(tokenBalance-tokensForLiquidity);
            // Add liquidity with remaining tokens
            // Note: Slippage skews this slightly and will take a bit more ETH
            if (tokensForLiquidity > 0)
                _addLiquidity(tokensForLiquidity, address(this).balance);
        } else {
            _swapTokensForEth(tokenBalance);
        }
        // Send whatever ETH remains to the treasury
        uint256 treasuryEth = address(this).balance;
        payable(treasuryWallet).transfer(treasuryEth);
        emit HandleTaxes(tokenBalance, treasuryEth);
        isSystemSwapping = false; // End recursion protection
    }

    // Returns true if the address is listed on the bot registry
    function isRegistered(address addr) internal view returns (bool) {
        if (address(botRegistry) != address(0)) { // We have defined the address
            return botRegistry.botRegistry(addr);
        } else
            return false; // If we haven't defined it, nobody is a bot!
    }
    // Adds a bot to the registry. Accounts can be removed directly from the registry if needed
    function _registerBot(address addr) internal {
        if (address(botRegistry) != address(0)) { // We have defined the address
            // This contract must be a manager on the registry otherwise this will fail
            botRegistry.updateBotRegistry(addr, true);
        }
    }
    // END USER FUNCTIONS

    // UNISWAP FUNCTIONS

    // This should never be needed. But in case the router ever runs out of an approval
    function approveExternal(address externalContract, uint256 amount) external onlyOwner {
        _approve(address(this), externalContract, amount);
    }
    // Liquidate tokens into ETH. Note: Introduces price slippage, skewing other math
    function _swapTokensForEth(uint256 tokenAmount) private {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = uniswapV2Router.WETH();
        // Pre-approved in constructor to save gas. Re-enable if needed
        // _approve(address(this), address(uniswapV2Router), tokenAmount);
        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0, // We're not worrying about frontrunning. 
            path,
            address(this),
            block.timestamp
        );

    }

    // Adds token and ETH into LP, sending LP tokens to contract owner
    // NOTE: Uniswap **Requires** balanced amounts, extra amounts are left in the contract
    // Due to the nature of slippage, the "half" commonly seen in swapAndLiquify results in
    // more tokens left in the contract. Since we're collecting tokens as taxes this is
    // a non-issue, but most developers are ignorant of this, and IF they notice, have no
    // clue why the amounts are off.
    function _addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
        // Skip approve, handled in constructor
        // _approve(address(this), address(uniswapV2Router), tokenAmount);

        uniswapV2Router.addLiquidityETH{value: ethAmount}(
            address(this),
            tokenAmount,
            0,
            0,
            owner(), // Send LP tokens to owner
            block.timestamp
        );
    }

    // END UNISWAP FUNCTIONS

    // ADMIN TOOLS
    /** Emergency withdraw for ETH left in contract **/
    function rescueNative(uint256 amount) external onlyOwner {
        payable(owner()).transfer(amount);
    }

    /** Emergency withdraw for tokens left in contract **/
    function claimToken(address tokenAddress, uint256 amount) external onlyOwner {
        IERC20(tokenAddress).transfer(owner(), amount);
    }
    // Trying to be highly efficient, but no yul/assembly because it's harder to read
    function airdrop(address[] calldata recipients, uint256[] calldata amounts) external onlyOwner {
        uint256 totalRecipients = recipients.length; // Number of recipients passed
        require(totalRecipients == amounts.length, "Number of recipients and amounts don't match!");

        unchecked { // As long as we don't pass more that 2**256-1 recipients in this won't overflow...
            for (uint256 i = 0; i < totalRecipients;) {
                // Uses raw transfer from the owner to the recipient. No tax/bot/logic involved
                super._transfer(msg.sender, recipients[i], amounts[i]);
                ++i;
            }
        }
    }
    // END ADMIN TOOLS

    // fallbacks
    receive() external payable {}
}


/// Contract to manage malicious/unwanted bot list. Sharable between multiple contracts.
/// Used to restrict functionality of bad actors. Snipers, frontrunners, generally bad people.
contract BotRegistry {
    /// Global Vars
    address public owner;

    /// Address Mappings
    mapping(address => bool) public botRegistry; // List of bots. Any contract can read this, only managers can write
    mapping(address => bool) private managers; // List of addresses that can update the registry

    /// Modifiers
    modifier onlyOwner {
        require(msg.sender == owner, "Address is not the owner");
        _;
    }
    modifier onlyManager {
        require(managers[msg.sender], "Address is not a list manager");
        _;
    }

    constructor() {
        owner = msg.sender;
        managers[msg.sender] = true;
    }

    /// Functions

    /// List Management
    function updateBotRegistry(address addr, bool status) onlyManager external {
        botRegistry[addr] = status;
    }
    function bulkUpdateBotRegistry(address[] memory accounts, bool status) external onlyManager {
        uint256 numAccounts = accounts.length;
        unchecked { // Reduces gas
            for (uint256 i = 0; i < numAccounts;) {
                botRegistry[accounts[i]] = status;
                ++i;
            }
        }
    }
    /// Add/remove managers
    function updateManagers(address addr, bool status) onlyOwner external {
        managers[addr] = status;
    }
    function transferOwnership(address addr) public onlyOwner {
        owner = addr; // Set to any address, 0x0 for revoking
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"treasuryAddr","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"unsuspectingFool","type":"address"},{"indexed":false,"internalType":"uint256","name":"numberOfShips","type":"uint256"}],"name":"AdmiralAckbar","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokens","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"treasuryEth","type":"uint256"}],"name":"HandleTaxes","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"pair","type":"address"}],"name":"NewDexPair","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"TradingEnabled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address[]","name":"recipients","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"airdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"externalContract","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approveExternal","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"},{"internalType":"bool","name":"state","type":"bool"}],"name":"bulkExemptFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"buyTax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"claimToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"dexPair","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"enableTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"exemptFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"handleBalance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"handleTaxes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"liquidityPercentage","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minTokensToLiquidate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minTxBlocks","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"penaltyTax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"purchaseRegistry","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"rescueNative","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sellTax","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"setBotRegistry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"treasuryWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"updateBuyTax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"updateDexPairs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"},{"internalType":"bool","name":"state","type":"bool"}],"name":"updateExemptFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"status","type":"bool"}],"name":"updateFrontrunProtection","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"status","type":"bool"}],"name":"updateHandleBalance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"percent","type":"uint256"}],"name":"updateLiquidityPercentage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"updateMinTokensToLiquidate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"blocks","type":"uint256"}],"name":"updateMinTxBlocks","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"updatePenaltyTax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"updateSellTax","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"wallet","type":"address"}],"name":"updateTreasuryWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000c23d371f60ac74375cc4e2c0d17d1cc51942aaad

-----Decoded View---------------
Arg [0] : treasuryAddr (address): 0xC23d371F60Ac74375cc4E2C0D17d1CC51942AAad

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000c23d371f60ac74375cc4e2c0d17d1cc51942aaad

Deployed Bytecode Sourcemap

38241:15294:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39148:34;;;;;;;;;;;;;;;;;;;160:25:1;;;148:2;133:18;39148:34:0;;;;;;;;42985:116;;;;;;;;;;-1:-1:-1;42985:116:0;;;;;:::i;:::-;;:::i;:::-;;27157:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;29517:201::-;;;;;;;;;;-1:-1:-1;29517:201:0;;;;;:::i;:::-;;:::i;:::-;;;2234:14:1;;2227:22;2209:41;;2197:2;2182:18;29517:201:0;2069:187:1;39605:26:0;;;;;;;;;;;;;;;;39360:51;;;;;;;;;;-1:-1:-1;39360:51:0;;;;;:::i;:::-;;;;;;;;;;;;;;43426:202;;;;;;;;;;-1:-1:-1;43426:202:0;;;;;:::i;:::-;;:::i;41674:138::-;;;;;;;;;;-1:-1:-1;41674:138:0;;;;;:::i;:::-;;:::i;42062:167::-;;;;;;;;;;-1:-1:-1;42062:167:0;;;;;:::i;:::-;;:::i;38633:41::-;;;;;;;;;;-1:-1:-1;38633:41:0;;;;;;;;;;;4590:42:1;4578:55;;;4560:74;;4548:2;4533:18;38633:41:0;4388:252:1;52546:142:0;;;;;;;;;;-1:-1:-1;52546:142:0;;;;;:::i;:::-;;:::i;28286:108::-;;;;;;;;;;-1:-1:-1;28374:12:0;;28286:108;;44163:161;;;;;;;;;;-1:-1:-1;44163:161:0;;;;;:::i;:::-;;:::i;30298:261::-;;;;;;;;;;-1:-1:-1;30298:261:0;;;;;:::i;:::-;;:::i;43681:186::-;;;;;;;;;;-1:-1:-1;43681:186:0;;;;;:::i;:::-;;:::i;28128:93::-;;;;;;;;;;-1:-1:-1;28128:93:0;;28211:2;5248:36:1;;5236:2;5221:18;28128:93:0;5106:184:1;43308:112:0;;;;;;;;;;-1:-1:-1;43308:112:0;;;;;:::i;:::-;;:::i;30968:238::-;;;;;;;;;;-1:-1:-1;30968:238:0;;;;;:::i;:::-;;:::i;41482:136::-;;;;;;;;;;-1:-1:-1;41482:136:0;;;;;:::i;:::-;;:::i;52369:109::-;;;;;;;;;;-1:-1:-1;52369:109:0;;;;;:::i;:::-;;:::i;42443:185::-;;;;;;;;;;-1:-1:-1;42443:185:0;;;;;:::i;:::-;;:::i;39249:29::-;;;;;;;;;;-1:-1:-1;39249:29:0;;;;;;;;38884:21;;;;;;;;;;;;;;;;38973:25;;;;;;;;;;-1:-1:-1;38973:25:0;;;;;;;;52781:672;;;;;;;;;;-1:-1:-1;52781:672:0;;;;;:::i;:::-;;:::i;28457:127::-;;;;;;;;;;-1:-1:-1;28457:127:0;;;;;:::i;:::-;28558:18;;28531:7;28558:18;;;;;;;;;;;;28457:127;20578:103;;;;;;;;;;;;;:::i;42680:270::-;;;;;;;;;;-1:-1:-1;42680:270:0;;;;;:::i;:::-;;:::i;41237:193::-;;;;;;;;;;;;;:::i;19930:87::-;;;;;;;;;;-1:-1:-1;20003:6:0;;;;19930:87;;27376:104;;;;;;;;;;;;;:::i;41867:144::-;;;;;;;;;;-1:-1:-1;41867:144:0;;;;;:::i;:::-;;:::i;31709:436::-;;;;;;;;;;-1:-1:-1;31709:436:0;;;;;:::i;:::-;;:::i;38681:39::-;;;;;;;;;;-1:-1:-1;38681:39:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;28790:193;;;;;;;;;;-1:-1:-1;28790:193:0;;;;;:::i;:::-;;:::i;47961:65::-;;;;;;;;;;;;;:::i;43938:187::-;;;;;;;;;;-1:-1:-1;43938:187:0;;;;;:::i;:::-;;:::i;39312:41::-;;;;;;;;;;-1:-1:-1;39312:41:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;38912:22;;;;;;;;;;;;;;;;50487:154;;;;;;;;;;-1:-1:-1;50487:154:0;;;;;:::i;:::-;;:::i;29046:151::-;;;;;;;;;;-1:-1:-1;29046:151:0;;;;;:::i;:::-;29162:18;;;;29135:7;29162:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;29046:151;42281:119;;;;;;;;;;-1:-1:-1;42281:119:0;;;;;:::i;:::-;;:::i;20836:201::-;;;;;;;;;;-1:-1:-1;20836:201:0;;;;;:::i;:::-;;:::i;38941:25::-;;;;;;;;;;;;;;;;39049:35;;;;;;;;;;;;;;;;42985:116;19816:13;:11;:13::i;:::-;43065:28:::1;43081:4;43087:5;43065:15;:28::i;:::-;42985:116:::0;;:::o;27157:100::-;27211:13;27244:5;27237:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27157:100;:::o;29517:201::-;29600:4;18561:10;29656:32;18561:10;29672:7;29681:6;29656:8;:32::i;:::-;29706:4;29699:11;;;29517:201;;;;;:::o;43426:202::-;19816:13;:11;:13::i;:::-;43523:9:::1;43518:103;43542:8;:15;43538:1;:19;43518:103;;;43604:5;43579:9;:22;43589:8;43598:1;43589:11;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;43579:22:::1;;::::0;;;::::1;::::0;;;;;;-1:-1:-1;43579:22:0;:30;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;43559:3;::::1;::::0;::::1;:::i;:::-;;;;43518:103;;;;43426:202:::0;;:::o;41674:138::-;19816:13;:11;:13::i;:::-;41761:3:::1;41751:6;:13;;41743:34;;;::::0;::::1;::::0;;8291:2:1;41743:34:0::1;::::0;::::1;8273:21:1::0;8330:1;8310:18;;;8303:29;8368:10;8348:18;;;8341:38;8396:18;;41743:34:0::1;;;;;;;;;41788:7;:16:::0;41674:138::o;42062:167::-;19816:13;:11;:13::i;:::-;42142::::1;::::0;:23;::::1;;:13;::::0;;::::1;:23;;::::0;42134:54:::1;;;::::0;::::1;::::0;;8627:2:1;42134:54:0::1;::::0;::::1;8609:21:1::0;8666:2;8646:18;;;8639:30;8705:20;8685:18;;;8678:48;8743:18;;42134:54:0::1;8425:342:1::0;42134:54:0::1;42199:13;:22:::0;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;42062:167::o;52546:142::-;19816:13;:11;:13::i;:::-;52641:12:::1;52634:29;;;52664:7;20003:6:::0;;;;;19930:87;52664:7:::1;52634:46;::::0;;::::1;::::0;;;;;;8976:42:1;8964:55;;;52634:46:0::1;::::0;::::1;8946:74:1::0;9036:18;;;9029:34;;;8919:18;;52634:46:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;44163:161::-:0;19816:13;:11;:13::i;:::-;44231:11:::1;:31:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;44163:161::o;30298:261::-;30395:4;18561:10;30453:38;30469:4;18561:10;30484:6;30453:15;:38::i;:::-;30502:27;30512:4;30518:2;30522:6;30502:9;:27::i;:::-;-1:-1:-1;30547:4:0;;30298:261;-1:-1:-1;;;;30298:261:0:o;43681:186::-;19816:13;:11;:13::i;:::-;43788:6:::1;43766:28;;:18;;;;;;;;;;;:28;;::::0;43758:63:::1;;;::::0;::::1;::::0;;9526:2:1;43758:63:0::1;::::0;::::1;9508:21:1::0;9565:2;9545:18;;;9538:30;9604:24;9584:18;;;9577:52;9646:18;;43758:63:0::1;9324:346:1::0;43758:63:0::1;43832:18;:27:::0;;;::::1;;::::0;::::1;::::0;;;::::1;::::0;;;::::1;::::0;;43681:186::o;43308:112::-;19816:13;:11;:13::i;:::-;43389:15:::1;::::0;;;::::1;;::::0;;;:9:::1;:15;::::0;;;;:23;;;::::1;::::0;::::1;;::::0;;;::::1;::::0;;43308:112::o;30968:238::-;18561:10;31056:4;29162:18;;;:11;:18;;;;;;;;;:27;;;;;;;;;;31056:4;;18561:10;31112:64;;18561:10;;29162:27;;31137:38;;31165:10;;31137:38;:::i;:::-;31112:8;:64::i;41482:136::-;19816:13;:11;:13::i;:::-;41568:3:::1;41558:6;:13;;41550:34;;;::::0;::::1;::::0;;8291:2:1;41550:34:0::1;::::0;::::1;8273:21:1::0;8330:1;8310:18;;;8303:29;8368:10;8348:18;;;8341:38;8396:18;;41550:34:0::1;8089:331:1::0;41550:34:0::1;41595:6;:15:::0;41482:136::o;52369:109::-;19816:13;:11;:13::i;:::-;20003:6;;52437:33:::1;::::0;20003:6;;;;;52437:33;::::1;;;::::0;52463:6;;52437:33:::1;::::0;;;52463:6;20003;52437:33;::::1;;;;;;;;;;;;;::::0;::::1;;;;42443:185:::0;19816:13;:11;:13::i;:::-;42544:3:::1;42533:7;:14;;42525:55;;;::::0;::::1;::::0;;10007:2:1;42525:55:0::1;::::0;::::1;9989:21:1::0;10046:2;10026:18;;;10019:30;10085;10065:18;;;10058:58;10133:18;;42525:55:0::1;9805:352:1::0;42525:55:0::1;42591:19;:29:::0;42443:185::o;52781:672::-;19816:13;:11;:13::i;:::-;52913:10;52980:33;;::::1;52972:91;;;::::0;::::1;::::0;;10364:2:1;52972:91:0::1;::::0;::::1;10346:21:1::0;10403:2;10383:18;;;10376:30;10442:34;10422:18;;;10415:62;10513:15;10493:18;;;10486:43;10546:19;;52972:91:0::1;10162:409:1::0;52972:91:0::1;53190:9;53185:250;53209:15;53205:1;:19;53185:250;;;53343:54;53359:10;53371;;53382:1;53371:13;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;53386:7;;53394:1;53386:10;;;;;;;:::i;:::-;;;;;;;53343:15;:54::i;:::-;53416:3;;53185:250;;;;52876:577;52781:672:::0;;;;:::o;20578:103::-;19816:13;:11;:13::i;:::-;20643:30:::1;20670:1;20643:18;:30::i;:::-;20578:103::o:0;42680:270::-;19816:13;:11;:13::i;:::-;42782:4:::1;42764:23;::::0;::::1;::::0;42756:74:::1;;;::::0;::::1;::::0;;10778:2:1;42756:74:0::1;::::0;::::1;10760:21:1::0;10817:2;10797:18;;;10790:30;10856:34;10836:18;;;10829:62;10927:8;10907:18;;;10900:36;10953:19;;42756:74:0::1;10576:402:1::0;42756:74:0::1;42849:20;::::0;::::1;42841:67;;;::::0;::::1;::::0;;11185:2:1;42841:67:0::1;::::0;::::1;11167:21:1::0;11224:2;11204:18;;;11197:30;11263:34;11243:18;;;11236:62;11334:4;11314:18;;;11307:32;11356:19;;42841:67:0::1;10983:398:1::0;42841:67:0::1;42919:14;:23:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;42680:270::o;41237:193::-;19816:13;:11;:13::i;:::-;41301:14:::1;::::0;::::1;;41300:15;41292:54;;;::::0;::::1;::::0;;11588:2:1;41292:54:0::1;::::0;::::1;11570:21:1::0;11627:2;11607:18;;;11600:30;11666:28;11646:18;;;11639:56;11712:18;;41292:54:0::1;11386:350:1::0;41292:54:0::1;41357:14;:21:::0;;;::::1;41374:4;41357:21;::::0;;41394:28:::1;::::0;::::1;::::0;::::1;::::0;41409:12:::1;160:25:1::0;;148:2;133:18;;14:177;41394:28:0::1;;;;;;;;41237:193::o:0;27376:104::-;27432:13;27465:7;27458:14;;;;;:::i;41867:144::-;19816:13;:11;:13::i;:::-;41957:3:::1;41947:6;:13;;41939:34;;;::::0;::::1;::::0;;8291:2:1;41939:34:0::1;::::0;::::1;8273:21:1::0;8330:1;8310:18;;;8303:29;8368:10;8348:18;;;8341:38;8396:18;;41939:34:0::1;8089:331:1::0;41939:34:0::1;41984:10;:19:::0;41867:144::o;31709:436::-;18561:10;31802:4;29162:18;;;:11;:18;;;;;;;;;:27;;;;;;;;;;31802:4;;18561:10;31949:15;31929:16;:35;;31921:85;;;;;;;11943:2:1;31921:85:0;;;11925:21:1;11982:2;11962:18;;;11955:30;12021:34;12001:18;;;11994:62;12092:7;12072:18;;;12065:35;12117:19;;31921:85:0;11741:401:1;31921:85:0;32042:60;32051:5;32058:7;32086:15;32067:16;:34;32042:8;:60::i;28790:193::-;28869:4;18561:10;28925:28;18561:10;28942:2;28946:6;28925:9;:28::i;47961:65::-;48004:14;:12;:14::i;43938:187::-;19816:13;:11;:13::i;:::-;44028:2:::1;44019:6;:11;44011:75;;;::::0;::::1;::::0;;12349:2:1;44011:75:0::1;::::0;::::1;12331:21:1::0;12388:2;12368:18;;;12361:30;12427:34;12407:18;;;12400:62;12498:21;12478:18;;;12471:49;12537:19;;44011:75:0::1;12147:415:1::0;44011:75:0::1;44097:11;:20:::0;43938:187::o;50487:154::-;19816:13;:11;:13::i;:::-;50584:49:::1;50601:4;50608:16;50626:6;50584:8;:49::i;42281:119::-:0;19816:13;:11;:13::i;:::-;42363:20:::1;:29:::0;42281:119::o;20836:201::-;19816:13;:11;:13::i;:::-;20925:22:::1;::::0;::::1;20917:73;;;::::0;::::1;::::0;;12769:2:1;20917:73:0::1;::::0;::::1;12751:21:1::0;12808:2;12788:18;;;12781:30;12847:34;12827:18;;;12820:62;12918:8;12898:18;;;12891:36;12944:19;;20917:73:0::1;12567:402:1::0;20917:73:0::1;21001:28;21020:8;21001:18;:28::i;:::-;20836:201:::0;:::o;20095:132::-;20003:6;;20159:23;20003:6;18561:10;20159:23;20151:68;;;;;;;13176:2:1;20151:68:0;;;13158:21:1;;;13195:18;;;13188:30;13254:34;13234:18;;;13227:62;13306:18;;20151:68:0;12974:356:1;43107:157:0;43178:13;;;;;;;:7;:13;;;;;:21;;;;;;;;;;;;;;;43210:46;;43239:17;;4590:42:1;4578:55;;4560:74;;43239:17:0;;4548:2:1;4533:18;43239:17:0;;;;;;;43107:157;;:::o;35702:346::-;35804:19;;;35796:68;;;;;;;13537:2:1;35796:68:0;;;13519:21:1;13576:2;13556:18;;;13549:30;13615:34;13595:18;;;13588:62;13686:6;13666:18;;;13659:34;13710:19;;35796:68:0;13335:400:1;35796:68:0;35883:21;;;35875:68;;;;;;;13942:2:1;35875:68:0;;;13924:21:1;13981:2;13961:18;;;13954:30;14020:34;14000:18;;;13993:62;14091:4;14071:18;;;14064:32;14113:19;;35875:68:0;13740:398:1;35875:68:0;35956:18;;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;36008:32;;160:25:1;;;36008:32:0;;133:18:1;36008:32:0;;;;;;;35702:346;;;:::o;36339:419::-;29162:18;;;;36440:24;29162:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;36527:17;36507:37;;36503:248;;36589:6;36569:16;:26;;36561:68;;;;;;;14345:2:1;36561:68:0;;;14327:21:1;14384:2;14364:18;;;14357:30;14423:31;14403:18;;;14396:59;14472:18;;36561:68:0;14143:353:1;36561:68:0;36673:51;36682:5;36689:7;36717:6;36698:16;:25;36673:8;:51::i;:::-;36429:329;36339:419;;;:::o;44382:3541::-;44646:1;44637:6;:10;44629:44;;;;;;;14703:2:1;44629:44:0;;;14685:21:1;14742:2;14722:18;;;14715:30;14781:23;14761:18;;;14754:51;14822:18;;44629:44:0;14501:345:1;44629:44:0;45015:14;;44694:18;;45015:14;;45009:362;;45095:20;;;;;;;:9;:20;;;;;;;;45094:21;:44;;;;-1:-1:-1;45120:18:0;;;;;;;:7;:18;;;;;;;;45119:19;45094:44;45090:270;;;45159:23;45172:9;45159:12;:23::i;:::-;45275;45288:9;45275:12;:23::i;:::-;45743:18;;;;;;;45738:690;;;45849:20;;;;;;;:9;:20;;;;;;;;45848:21;:44;;;;-1:-1:-1;45874:18:0;;;;;;;:7;:18;;;;;;;;45873:19;45848:44;45844:109;;;45911:27;;;;;;;:16;:27;;;;;45941:12;45911:42;;45844:109;45973:17;;;;;;;:9;:17;;;;;;;;45972:18;:38;;;;-1:-1:-1;45995:15:0;;;;;;;:7;:15;;;;;;;;45994:16;45972:38;45968:449;;;46162:11;;46135:24;;;;;;;:16;:24;;;;;;46120:39;;:12;:39;:::i;:::-;:53;46116:286;;;46198:20;46211:6;46198:12;:20::i;:::-;46313:23;46326:9;46313:12;:23::i;:::-;46483:17;;;;;;;:9;:17;;;;;;;;;:41;;-1:-1:-1;46504:20:0;;;;;;;:9;:20;;;;;;;;46483:41;46479:940;;;-1:-1:-1;46552:1:0;46479:940;;;46618:20;46631:6;46618:12;:20::i;:::-;46614:805;;;-1:-1:-1;46668:10:0;;46698:29;;;8976:42:1;8964:55;;8946:74;;9051:2;9036:18;;9029:34;;;46698:29:0;;8919:18:1;46698:29:0;;;;;;;46614:805;;;46832:18;;;;;;;:7;:18;;;;;;;;46828:591;;;46871:23;46884:9;46871:12;:23::i;:::-;46867:243;;;-1:-1:-1;46984:10:0;;47018:32;;;47032:9;8946:74:1;;9051:2;9036:18;;9029:34;;;47018:32:0;;8919:18:1;47018:32:0;;;;;;;46867:243;;;-1:-1:-1;47103:7:0;;46867:243;47192:14;:12;:14::i;:::-;46828:591;;;47370:15;;;;;;;:7;:15;;;;;;;;47366:53;;;-1:-1:-1;47413:6:0;;47366:53;47496:10;47510:1;47496:15;47491:424;;47592:42;47608:6;47616:9;47627:6;47592:15;:42::i;:::-;47491:424;;;47665:17;47707:3;47685:19;47694:10;47685:6;:19;:::i;:::-;:25;;;;:::i;:::-;47665:45;;47725:49;47741:6;47757:4;47764:9;47725:15;:49::i;:::-;47818:54;47834:6;47842:9;47853:18;47862:9;47853:6;:18;:::i;:::-;47818:15;:54::i;:::-;47650:265;44504:3419;44382:3541;;;:::o;32615:806::-;32712:18;;;32704:68;;;;;;;15638:2:1;32704:68:0;;;15620:21:1;15677:2;15657:18;;;15650:30;15716:34;15696:18;;;15689:62;15787:7;15767:18;;;15760:35;15812:19;;32704:68:0;15436:401:1;32704:68:0;32791:16;;;32783:64;;;;;;;16044:2:1;32783:64:0;;;16026:21:1;16083:2;16063:18;;;16056:30;16122:34;16102:18;;;16095:62;16193:5;16173:18;;;16166:33;16216:19;;32783:64:0;15842:399:1;32783:64:0;32933:15;;;32911:19;32933:15;;;;;;;;;;;32967:21;;;;32959:72;;;;;;;16448:2:1;32959:72:0;;;16430:21:1;16487:2;16467:18;;;16460:30;16526:34;16506:18;;;16499:62;16597:8;16577:18;;;16570:36;16623:19;;32959:72:0;16246:402:1;32959:72:0;33067:15;;;;:9;:15;;;;;;;;;;;33085:20;;;33067:38;;33285:13;;;;;;;;;;:23;;;;;;33337:26;;160:25:1;;;33285:13:0;;33337:26;;133:18:1;33337:26:0;;;;;;;33376:37;43426:202;21197:191;21290:6;;;;21307:17;;;;;;;;;;;21340:40;;21290:6;;;21307:17;21290:6;;21340:40;;21271:16;;21340:40;21260:128;21197:191;:::o;48151:1421::-;48296:13;;;;48295:14;;:34;;-1:-1:-1;48313:16:0;;;;;;;48295:34;48291:60;;;48151:1421::o;48291:60::-;48361:16;:23;;;;;;;;48458:4;-1:-1:-1;28558:18:0;;;;;;;;;;;48417:47;;48549:20;;48534:12;:35;48530:61;;;48584:7;48151:1421::o;48530:61::-;48684:19;;:23;48680:604;;48725:26;48791:3;48776:12;48754:19;;:34;;;;:::i;:::-;:40;;;;:::i;:::-;48725:69;-1:-1:-1;48910:50:0;48928:31;48725:69;48928:12;:31;:::i;:::-;48910:17;:50::i;:::-;49111:22;;49107:101;;49152:56;49166:18;49186:21;49152:13;:56::i;:::-;48710:510;48680:604;;;49241:31;49259:12;49241:17;:31::i;:::-;49410:14;;49402:45;;49370:21;;49410:14;;;49402:45;;;;;49370:21;;49348:19;49402:45;49348:19;49402:45;49370:21;49410:14;49402:45;;;;;;;;;;;;;;;;;;;;-1:-1:-1;49463:38:0;;;16827:25:1;;;16883:2;16868:18;;16861:34;;;49463:38:0;;16800:18:1;49463:38:0;;;;;;;-1:-1:-1;;49512:16:0;:24;;;;;;48151:1421::o;50044:291::-;50112:11;;50104:34;50112:11;50104:34;50100:228;;50275:11;;:41;;;;;:11;17092:55:1;;;50275:41:0;;;17074:74:1;50275:11:0;17164:18:1;;;17157:50;50275:11:0;;;;:29;;17047:18:1;;50275:41:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49646:295;49734:11;;49705:4;;49726:34;49734:11;49726:34;49722:165;;49815:11;;:29;;;;;:11;4578:55:1;;;49815:29:0;;;4560:74:1;49815:11:0;;;;:23;;4533:18:1;;49815:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;49722:165::-;-1:-1:-1;49882:5:0;;49646:295;-1:-1:-1;49646:295:0:o;49722:165::-;49646:295;;;:::o;50734:593::-;50825:16;;;50839:1;50825:16;;;;;;;;50801:21;;50825:16;;;;;;;;;;-1:-1:-1;50825:16:0;50801:40;;50870:4;50852;50857:1;50852:7;;;;;;;;:::i;:::-;:23;;;;:7;;;;;;;;;;:23;;;;50896:15;;:22;;;;;;;;:15;;;;;:20;;:22;;;;;50852:7;;50896:22;;;;;:15;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;50886:4;50891:1;50886:7;;;;;;;;:::i;:::-;:32;;;;:7;;;;;;;;;:32;51078:15;;:239;;;;;:15;;;:66;;:239;;51159:11;;51078:15;;51244:4;;51271;;51291:15;;51078:239;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51810:442;52019:15;;;;:31;52058:9;52091:4;52111:11;52019:15;;52169:7;20003:6;;;;;19930:87;52169:7;52019:225;;;;;;;;;;18818:42:1;18887:15;;;52019:225:0;;;18869:34:1;18919:18;;;18912:34;;;;18962:18;;;18955:34;;;;19005:18;;;18998:34;19069:15;;;19048:19;;;19041:44;52218:15:0;19101:19:1;;;19094:35;18780:19;;52019:225:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;196:154:1:-;282:42;275:5;271:54;264:5;261:65;251:93;;340:1;337;330:12;355:134;423:20;;452:31;423:20;452:31;:::i;494:118::-;580:5;573:13;566:21;559:5;556:32;546:60;;602:1;599;592:12;617:128;682:20;;711:28;682:20;711:28;:::i;750:382::-;815:6;823;876:2;864:9;855:7;851:23;847:32;844:52;;;892:1;889;882:12;844:52;931:9;918:23;950:31;975:5;950:31;:::i;:::-;1000:5;-1:-1:-1;1057:2:1;1042:18;;1029:32;1070:30;1029:32;1070:30;:::i;:::-;1119:7;1109:17;;;750:382;;;;;:::o;1137:607::-;1249:4;1278:2;1307;1296:9;1289:21;1339:6;1333:13;1382:6;1377:2;1366:9;1362:18;1355:34;1407:1;1417:140;1431:6;1428:1;1425:13;1417:140;;;1526:14;;;1522:23;;1516:30;1492:17;;;1511:2;1488:26;1481:66;1446:10;;1417:140;;;1421:3;1606:1;1601:2;1592:6;1581:9;1577:22;1573:31;1566:42;1735:2;1665:66;1660:2;1652:6;1648:15;1644:88;1633:9;1629:104;1625:113;1617:121;;;;1137:607;;;;:::o;1749:315::-;1817:6;1825;1878:2;1866:9;1857:7;1853:23;1849:32;1846:52;;;1894:1;1891;1884:12;1846:52;1933:9;1920:23;1952:31;1977:5;1952:31;:::i;:::-;2002:5;2054:2;2039:18;;;;2026:32;;-1:-1:-1;;;1749:315:1:o;2261:247::-;2320:6;2373:2;2361:9;2352:7;2348:23;2344:32;2341:52;;;2389:1;2386;2379:12;2341:52;2428:9;2415:23;2447:31;2472:5;2447:31;:::i;:::-;2497:5;2261:247;-1:-1:-1;;;2261:247:1:o;2513:184::-;2565:77;2562:1;2555:88;2662:4;2659:1;2652:15;2686:4;2683:1;2676:15;2702:1250;2792:6;2800;2853:2;2841:9;2832:7;2828:23;2824:32;2821:52;;;2869:1;2866;2859:12;2821:52;2909:9;2896:23;2938:18;2979:2;2971:6;2968:14;2965:34;;;2995:1;2992;2985:12;2965:34;3033:6;3022:9;3018:22;3008:32;;3078:7;3071:4;3067:2;3063:13;3059:27;3049:55;;3100:1;3097;3090:12;3049:55;3136:2;3123:16;3158:4;3181:2;3177;3174:10;3171:36;;;3187:18;;:::i;:::-;3233:2;3230:1;3226:10;3265:2;3259:9;3324:66;3319:2;3315;3311:11;3307:84;3299:6;3295:97;3442:6;3430:10;3427:22;3422:2;3410:10;3407:18;3404:46;3401:72;;;3453:18;;:::i;:::-;3489:2;3482:22;3539:18;;;3573:15;;;;-1:-1:-1;3615:11:1;;;3611:20;;;3643:19;;;3640:39;;;3675:1;3672;3665:12;3640:39;3699:11;;;;3719:148;3735:6;3730:3;3727:15;3719:148;;;3801:23;3820:3;3801:23;:::i;:::-;3789:36;;3752:12;;;;3845;;;;3719:148;;;3886:6;-1:-1:-1;3911:35:1;;-1:-1:-1;3927:18:1;;;3911:35;:::i;:::-;3901:45;;;;;;2702:1250;;;;;:::o;3957:180::-;4016:6;4069:2;4057:9;4048:7;4044:23;4040:32;4037:52;;;4085:1;4082;4075:12;4037:52;-1:-1:-1;4108:23:1;;3957:180;-1:-1:-1;3957:180:1:o;4142:241::-;4198:6;4251:2;4239:9;4230:7;4226:23;4222:32;4219:52;;;4267:1;4264;4257:12;4219:52;4306:9;4293:23;4325:28;4347:5;4325:28;:::i;4645:456::-;4722:6;4730;4738;4791:2;4779:9;4770:7;4766:23;4762:32;4759:52;;;4807:1;4804;4797:12;4759:52;4846:9;4833:23;4865:31;4890:5;4865:31;:::i;:::-;4915:5;-1:-1:-1;4972:2:1;4957:18;;4944:32;4985:33;4944:32;4985:33;:::i;:::-;4645:456;;5037:7;;-1:-1:-1;;;5091:2:1;5076:18;;;;5063:32;;4645:456::o;5526:367::-;5589:8;5599:6;5653:3;5646:4;5638:6;5634:17;5630:27;5620:55;;5671:1;5668;5661:12;5620:55;-1:-1:-1;5694:20:1;;5737:18;5726:30;;5723:50;;;5769:1;5766;5759:12;5723:50;5806:4;5798:6;5794:17;5782:29;;5866:3;5859:4;5849:6;5846:1;5842:14;5834:6;5830:27;5826:38;5823:47;5820:67;;;5883:1;5880;5873:12;5820:67;5526:367;;;;;:::o;5898:773::-;6020:6;6028;6036;6044;6097:2;6085:9;6076:7;6072:23;6068:32;6065:52;;;6113:1;6110;6103:12;6065:52;6153:9;6140:23;6182:18;6223:2;6215:6;6212:14;6209:34;;;6239:1;6236;6229:12;6209:34;6278:70;6340:7;6331:6;6320:9;6316:22;6278:70;:::i;:::-;6367:8;;-1:-1:-1;6252:96:1;-1:-1:-1;6455:2:1;6440:18;;6427:32;;-1:-1:-1;6471:16:1;;;6468:36;;;6500:1;6497;6490:12;6468:36;;6539:72;6603:7;6592:8;6581:9;6577:24;6539:72;:::i;:::-;5898:773;;;;-1:-1:-1;6630:8:1;-1:-1:-1;;;;5898:773:1:o;6676:388::-;6744:6;6752;6805:2;6793:9;6784:7;6780:23;6776:32;6773:52;;;6821:1;6818;6811:12;6773:52;6860:9;6847:23;6879:31;6904:5;6879:31;:::i;:::-;6929:5;-1:-1:-1;6986:2:1;6971:18;;6958:32;6999:33;6958:32;6999:33;:::i;7069:437::-;7148:1;7144:12;;;;7191;;;7212:61;;7266:4;7258:6;7254:17;7244:27;;7212:61;7319:2;7311:6;7308:14;7288:18;7285:38;7282:218;;7356:77;7353:1;7346:88;7457:4;7454:1;7447:15;7485:4;7482:1;7475:15;7282:218;;7069:437;;;:::o;7511:184::-;7563:77;7560:1;7553:88;7660:4;7657:1;7650:15;7684:4;7681:1;7674:15;7700:184;7752:77;7749:1;7742:88;7849:4;7846:1;7839:15;7873:4;7870:1;7863:15;7889:195;7928:3;7959:66;7952:5;7949:77;7946:103;;8029:18;;:::i;:::-;-1:-1:-1;8076:1:1;8065:13;;7889:195::o;9074:245::-;9141:6;9194:2;9182:9;9173:7;9169:23;9165:32;9162:52;;;9210:1;9207;9200:12;9162:52;9242:9;9236:16;9261:28;9283:5;9261:28;:::i;9675:125::-;9740:9;;;9761:10;;;9758:36;;;9774:18;;:::i;14851:128::-;14918:9;;;14939:11;;;14936:37;;;14953:18;;:::i;14984:168::-;15057:9;;;15088;;15105:15;;;15099:22;;15085:37;15075:71;;15126:18;;:::i;15157:274::-;15197:1;15223;15213:189;;15258:77;15255:1;15248:88;15359:4;15356:1;15349:15;15387:4;15384:1;15377:15;15213:189;-1:-1:-1;15416:9:1;;15157:274::o;17218:251::-;17288:6;17341:2;17329:9;17320:7;17316:23;17312:32;17309:52;;;17357:1;17354;17347:12;17309:52;17389:9;17383:16;17408:31;17433:5;17408:31;:::i;17474:1026::-;17736:4;17784:3;17773:9;17769:19;17815:6;17804:9;17797:25;17841:2;17879:6;17874:2;17863:9;17859:18;17852:34;17922:3;17917:2;17906:9;17902:18;17895:31;17946:6;17981;17975:13;18012:6;18004;17997:22;18050:3;18039:9;18035:19;18028:26;;18089:2;18081:6;18077:15;18063:29;;18110:1;18120:218;18134:6;18131:1;18128:13;18120:218;;;18199:13;;18214:42;18195:62;18183:75;;18313:15;;;;18278:12;;;;18156:1;18149:9;18120:218;;;-1:-1:-1;;18406:42:1;18394:55;;;;18389:2;18374:18;;18367:83;-1:-1:-1;;;18481:3:1;18466:19;18459:35;18355:3;17474:1026;-1:-1:-1;;;17474:1026:1:o;19140:306::-;19228:6;19236;19244;19297:2;19285:9;19276:7;19272:23;19268:32;19265:52;;;19313:1;19310;19303:12;19265:52;19342:9;19336:16;19326:26;;19392:2;19381:9;19377:18;19371:25;19361:35;;19436:2;19425:9;19421:18;19415:25;19405:35;;19140:306;;;;;:::o

Swarm Source

ipfs://68336ccf253564f3214f6b9055e75e6621bf01e01a593be5df40b986e0c4b44c

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services