Token

Ethereum Dex (ETX)

ERC-20

Overview

Max Total Supply

21,000,000 ETX

Holders

4,242

Market

Onchain Market Cap

$0.00

Circulating Supply Market Cap

Other Info

Token Contract (WITH 18 Decimals)

0x2a69219523a3c3372b26de059352302a30efe982

Filtered by Token Holder

0x70611A3cABE9Ae5C1eF80c711C056337D69fDC99

Balance

0 ETX

Value

$0.00

0x70611a3cabe9ae5c1ef80c711c056337d69fdc99

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

EtxToken

Compiler Version

v0.8.18+commit.87f61d96

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, None license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2023-07-24
*/

//SPDX-License-Identifier: Unlicensed
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;
    }
}

/**
 * @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 Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        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);
    }
}


/**
 * @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);
}

/**
 * @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);
}

/**
 * @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.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * 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}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * 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 value {ERC20} uses, unless this function is
     * 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 `sender` to `recipient`.
     *
     * 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;
        }
        _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;
        _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;
        }
        _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 {}
}

/**
 * @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 functionCall(target, data, "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");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason 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 {
            // 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

library SafeMathInt {
    function mul(int256 a, int256 b) internal pure returns (int256) {
        // Prevent overflow when multiplying INT256_MIN with -1
        // https://github.com/RequestNetwork/requestNetwork/issues/43
        require(!(a == - 2**255 && b == -1) && !(b == - 2**255 && a == -1));

        int256 c = a * b;
        require((b == 0) || (c / b == a));
        return c;
    }

    function div(int256 a, int256 b) internal pure returns (int256) {
        // Prevent overflow when dividing INT256_MIN by -1
        // https://github.com/RequestNetwork/requestNetwork/issues/43
        require(!(a == - 2**255 && b == -1) && (b > 0));

        return a / b;
    }

    function sub(int256 a, int256 b) internal pure returns (int256) {
        require((b >= 0 && a - b <= a) || (b < 0 && a - b > a));

        return a - b;
    }

    function add(int256 a, int256 b) internal pure returns (int256) {
        int256 c = a + b;
        require((b >= 0 && c >= a) || (b < 0 && c < a));
        return c;
    }

    function toUint256Safe(int256 a) internal pure returns (uint256) {
        require(a >= 0);
        return uint256(a);
    }
}

interface IPancakeFactory {
    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;
}

interface IPancakePair {
    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 (uint256);
    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;
}

interface IPancakeRouter01 {
    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);
}

interface IPancakeRouter02 is IPancakeRouter01 {
    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;
}

interface IFundDistribute {
   function notifyReward(address account, uint256 amount) external;
}

contract EtxToken is ERC20, Ownable {
    using SafeMath for uint256;
    using Address for address;

    IPancakeRouter02 public pancakeRouter;
    address public pancakePair;

    address[] internal fundsAddress;
    address public buyBackAddress;


    uint256 internal fee = 20;
    uint256 buyBackFee = 500;
    uint256 fundFee = 500;

    uint256 public swapTokensAtAmount = 280 * 10 ** 18;

     /****************/
    bool public tradingEnabled = true;   
    bool public swappingEnabled = true;  
    bool private swapping;

    // exlcude from fees and max transaction amount
    mapping (address => bool) private _isExcludedFromFees;

    event UpdateTradingStatus(bool status);
    event UpdateSwappingStatus(bool status);
    event SetSwapTokensAtAmount(uint256 OldAmount, uint256 NewAmount);
    event UpdatePancakeRouter(address indexed newAddress, address indexed oldAddress);
    event ExcludeMultipleAccountsFromFees(address[] accounts, bool isExcluded);
    event StartSwapTokensForEth(uint256 tokenAmountToBeSwapped);
    event FinishSwapTokensForEth(uint256 ethAmountSwapped);

    constructor( 
        address _managerAddress
    ) ERC20("Ethereum Dex", "ETX") {
        updatePancakeRouter(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);  // geoli
        

        _isExcludedFromFees[owner()] = true;
        _isExcludedFromFees[_managerAddress] = true;
        _isExcludedFromFees[address(this)] = true;    

        _mint(_managerAddress, 21000000 * 10 ** 18);
    }

    function updatePancakeRouter(address newAddress) public onlyOwner {
        require(newAddress != address(pancakeRouter), "ETXToken: The router already has that address");
        emit UpdatePancakeRouter(newAddress, address(pancakeRouter));
        pancakeRouter = IPancakeRouter02(newAddress);
        address _pancakePair = IPancakeFactory(pancakeRouter.factory())
        .createPair(address(this), pancakeRouter.WETH());
        pancakePair = _pancakePair;

        _isExcludedFromFees[newAddress] = true;
    }

    function setFee(uint _fee, uint _buyBackFee, uint _fundFee) external onlyOwner {
        fee = _fee;
        buyBackFee = _buyBackFee;
        fundFee = _fundFee;
    }

    function setFundAddress(address[] memory _fundsAddress) external onlyOwner {
        fundsAddress = _fundsAddress;
    }

    function setBuyBackAddress(address _buyBackAddress) external onlyOwner {
        buyBackAddress = _buyBackAddress;
    }

    function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
        for(uint256 i = 0; i < accounts.length; i++) {
            _isExcludedFromFees[accounts[i]] = excluded;
        }
        emit ExcludeMultipleAccountsFromFees(accounts, excluded);
    }

    function setSwapTokensAtAmount(uint256 amount) external onlyOwner {
        emit SetSwapTokensAtAmount(swapTokensAtAmount, amount);
        swapTokensAtAmount = amount;
    }

    function setTradingIsEnabled(bool status) external onlyOwner {
        tradingEnabled = status;
        emit UpdateTradingStatus(status);
    }

    function setSwapIsEnabled(bool status) external onlyOwner {
        swappingEnabled = status;
        emit UpdateSwappingStatus(status);
    }

    function isExcludedFromFees(address account) public view returns(bool) {
        return _isExcludedFromFees[account];
    }

    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");

        if(amount == 0) {
            super._transfer(from, to, 0);
            return;
        }

        bool canSwap =  balanceOf(address(this)) >= swapTokensAtAmount;
        if(
            tradingEnabled &&
            canSwap &&
            !swapping &&
            swappingEnabled &&
            to == pancakePair
        ) {
            swapping = true;
            swapAndDistribute(swapTokensAtAmount);
            swapping = false;
        }

        bool takeFee = false;
        if(!_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
            takeFee = true;
        }
        if(takeFee && (to == pancakePair || from == pancakePair)) {
             uint256 totalFees = amount.mul(fee).div(1000);
            amount = amount.sub(totalFees);
            super._transfer(from, address(this), totalFees);
        }
        super._transfer(from, to, amount);
    }

    function swapAndDistribute(uint256 amount) private {
        uint256 buyBackfundAmount = amount.mul(fundFee).div(1000);
        uint256 fundAmount = amount.sub(buyBackfundAmount);
        swapTokensForEth(buyBackfundAmount,buyBackAddress);

        uint256 fundsCount = fundsAddress.length;
        uint256 perMarketAmount = fundAmount.div(fundsCount);
       
        for(uint8 i = 0; i < fundsCount; i++) {
            if(fundsAddress[i] != address(0) && perMarketAmount > 0) {
                super._transfer(address(this), fundsAddress[i], perMarketAmount);
            }
        }        
    }

    function swapTokensForEth(uint256 tokenAmount, address receiveAddress) private {
        emit StartSwapTokensForEth(tokenAmount);
        // generate the pancake pair path of token -> weth
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = pancakeRouter.WETH();

        _approve(address(this), address(pancakeRouter), tokenAmount);

        // make the swap
        pancakeRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tokenAmount,
            0, // accept any amount of ETH
            path,
            receiveAddress,
            block.timestamp
        );
        emit FinishSwapTokensForEth(address(this).balance);
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"_managerAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"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":"address[]","name":"accounts","type":"address[]"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeMultipleAccountsFromFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"ethAmountSwapped","type":"uint256"}],"name":"FinishSwapTokensForEth","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":"OldAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"NewAmount","type":"uint256"}],"name":"SetSwapTokensAtAmount","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tokenAmountToBeSwapped","type":"uint256"}],"name":"StartSwapTokensForEth","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"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"newAddress","type":"address"},{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"}],"name":"UpdatePancakeRouter","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"UpdateSwappingStatus","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bool","name":"status","type":"bool"}],"name":"UpdateTradingStatus","type":"event"},{"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":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buyBackAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":"accounts","type":"address[]"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"excludeMultipleAccountsFromFees","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":[{"internalType":"address","name":"account","type":"address"}],"name":"isExcludedFromFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"pancakePair","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pancakeRouter","outputs":[{"internalType":"contract IPancakeRouter02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_buyBackAddress","type":"address"}],"name":"setBuyBackAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fee","type":"uint256"},{"internalType":"uint256","name":"_buyBackFee","type":"uint256"},{"internalType":"uint256","name":"_fundFee","type":"uint256"}],"name":"setFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_fundsAddress","type":"address[]"}],"name":"setFundAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"status","type":"bool"}],"name":"setSwapIsEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"setSwapTokensAtAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"status","type":"bool"}],"name":"setTradingIsEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapTokensAtAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swappingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":[],"name":"tradingEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":[{"internalType":"address","name":"newAddress","type":"address"}],"name":"updatePancakeRouter","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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)

000000000000000000000000dc1aaa785cde1dbf9996bb01ca86949d9862262c

-----Decoded View---------------
Arg [0] : _managerAddress (address): 0xDC1AaA785CDE1dbf9996bB01cA86949D9862262C

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

Deployed Bytecode Sourcemap

43524:5986:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8448:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;10799:201;;;;;;:::i;:::-;;:::i;:::-;;;1327:14:1;;1320:22;1302:41;;1290:2;1275:18;10799:201:0;1162:187:1;9568:108:0;9656:12;;9568:108;;;1500:25:1;;;1488:2;1473:18;9568:108:0;1354:177:1;11580:295:0;;;;;;:::i;:::-;;:::i;9410:93::-;;;9493:2;2139:36:1;;2127:2;2112:18;9410:93:0;1997:184:1;12284:238:0;;;;;;:::i;:::-;;:::i;46689:145::-;;;;;;:::i;:::-;;:::i;:::-;;43968:33;;;;;;;;;46842:125;;;;;;:::i;:::-;-1:-1:-1;;;;;46931:28:0;46907:4;46931:28;;;:19;:28;;;;;;;;;46842:125;45600:172;;;;;;:::i;:::-;;:::i;9739:127::-;;;;;;:::i;:::-;-1:-1:-1;;;;;9840:18:0;9813:7;9840:18;;;;;;;;;;;;9739:127;2390:103;;;:::i;43751:29::-;;;;;-1:-1:-1;;;;;43751:29:0;;;;;;-1:-1:-1;;;;;3273:32:1;;;3255:51;;3243:2;3228:18;43751:29:0;3109:203:1;1739:87:0;1812:6;;-1:-1:-1;;;;;1812:6:0;1739:87;;8667:104;;;:::i;45780:122::-;;;;;;:::i;:::-;;:::i;13025:436::-;;;;;;:::i;:::-;;:::i;10072:193::-;;;;;;:::i;:::-;;:::i;45910:122::-;;;;;;:::i;:::-;;:::i;44011:34::-;;;;;;;;;;;;46350:177;;;;;;:::i;:::-;;:::i;43678:26::-;;;;;-1:-1:-1;;;;;43678:26:0;;;43634:37;;;;;-1:-1:-1;;;;;43634:37:0;;;46040:302;;;;;;:::i;:::-;;:::i;45067:525::-;;;;;;:::i;:::-;;:::i;10328:151::-;;;;;;:::i;:::-;;:::i;46535:146::-;;;;;;:::i;:::-;;:::i;43884:50::-;;;;;;2648:201;;;;;;:::i;:::-;;:::i;8448:100::-;8502:13;8535:5;8528:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8448:100;:::o;10799:201::-;10882:4;686:10;10938:32;686:10;10954:7;10963:6;10938:8;:32::i;:::-;10988:4;10981:11;;;10799:201;;;;;:::o;11580:295::-;11711:4;686:10;11769:38;11785:4;686:10;11800:6;11769:15;:38::i;:::-;11818:27;11828:4;11834:2;11838:6;11818:9;:27::i;:::-;-1:-1:-1;11863:4:0;;11580:295;-1:-1:-1;;;;11580:295:0:o;12284:238::-;12372:4;686:10;12428:64;686:10;12444:7;12481:10;12453:25;686:10;12444:7;12453:9;:25::i;:::-;:38;;;;:::i;:::-;12428:8;:64::i;46689:145::-;1812:6;;-1:-1:-1;;;;;1812:6:0;686:10;1959:23;1951:68;;;;-1:-1:-1;;;1951:68:0;;;;;;;:::i;:::-;;;;;;;;;46758:15:::1;:24:::0;;;::::1;;;;-1:-1:-1::0;;46758:24:0;;::::1;;::::0;;46798:28:::1;::::0;::::1;::::0;::::1;::::0;46776:6;1327:14:1;1320:22;1302:41;;1290:2;1275:18;;1162:187;46798:28:0::1;;;;;;;;46689:145:::0;:::o;45600:172::-;1812:6;;-1:-1:-1;;;;;1812:6:0;686:10;1959:23;1951:68;;;;-1:-1:-1;;;1951:68:0;;;;;;;:::i;:::-;45690:3:::1;:10:::0;;;;45711::::1;:24:::0;45746:7:::1;:18:::0;45600:172::o;2390:103::-;1812:6;;-1:-1:-1;;;;;1812:6:0;686:10;1959:23;1951:68;;;;-1:-1:-1;;;1951:68:0;;;;;;;:::i;:::-;2455:30:::1;2482:1;2455:18;:30::i;:::-;2390:103::o:0;8667:104::-;8723:13;8756:7;8749:14;;;;;:::i;45780:122::-;1812:6;;-1:-1:-1;;;;;1812:6:0;686:10;1959:23;1951:68;;;;-1:-1:-1;;;1951:68:0;;;;;;;:::i;:::-;45866:28;;::::1;::::0;:12:::1;::::0;:28:::1;::::0;::::1;::::0;::::1;:::i;:::-;;45780:122:::0;:::o;13025:436::-;13118:4;686:10;13118:4;13201:25;686:10;13218:7;13201:9;:25::i;:::-;13174:52;;13265:15;13245:16;:35;;13237:85;;;;-1:-1:-1;;;13237:85:0;;7290:2:1;13237:85:0;;;7272:21:1;7329:2;7309:18;;;7302:30;7368:34;7348:18;;;7341:62;-1:-1:-1;;;7419:18:1;;;7412:35;7464:19;;13237:85:0;7088:401:1;13237:85:0;13358:60;13367:5;13374:7;13402:15;13383:16;:34;13358:8;:60::i;10072:193::-;10151:4;686:10;10207:28;686:10;10224:2;10228:6;10207:9;:28::i;45910:122::-;1812:6;;-1:-1:-1;;;;;1812:6:0;686:10;1959:23;1951:68;;;;-1:-1:-1;;;1951:68:0;;;;;;;:::i;:::-;45992:14:::1;:32:::0;;-1:-1:-1;;;;;;45992:32:0::1;-1:-1:-1::0;;;;;45992:32:0;;;::::1;::::0;;;::::1;::::0;;45910:122::o;46350:177::-;1812:6;;-1:-1:-1;;;;;1812:6:0;686:10;1959:23;1951:68;;;;-1:-1:-1;;;1951:68:0;;;;;;;:::i;:::-;46454:18:::1;::::0;46432:49:::1;::::0;;7668:25:1;;;7724:2;7709:18;;7702:34;;;46432:49:0::1;::::0;7641:18:1;46432:49:0::1;;;;;;;46492:18;:27:::0;46350:177::o;46040:302::-;1812:6;;-1:-1:-1;;;;;1812:6:0;686:10;1959:23;1951:68;;;;-1:-1:-1;;;1951:68:0;;;;;;;:::i;:::-;46157:9:::1;46153:115;46172:19:::0;;::::1;46153:115;;;46248:8;46213:19;:32;46233:8;;46242:1;46233:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;46213:32:0::1;::::0;;::::1;::::0;::::1;::::0;;;;;;-1:-1:-1;46213:32:0;:43;;-1:-1:-1;;46213:43:0::1;::::0;::::1;;::::0;;;::::1;::::0;;46193:3;::::1;::::0;::::1;:::i;:::-;;;;46153:115;;;;46283:51;46315:8;;46325;46283:51;;;;;;;;:::i;:::-;;;;;;;;46040:302:::0;;;:::o;45067:525::-;1812:6;;-1:-1:-1;;;;;1812:6:0;686:10;1959:23;1951:68;;;;-1:-1:-1;;;1951:68:0;;;;;;;:::i;:::-;45174:13:::1;::::0;-1:-1:-1;;;;;45174:13:0;;::::1;45152:36:::0;;::::1;::::0;45144:94:::1;;;::::0;-1:-1:-1;;;45144:94:0;;9020:2:1;45144:94:0::1;::::0;::::1;9002:21:1::0;9059:2;9039:18;;;9032:30;9098:34;9078:18;;;9071:62;-1:-1:-1;;;9149:18:1;;;9142:43;9202:19;;45144:94:0::1;8818:409:1::0;45144:94:0::1;45294:13;::::0;45254:55:::1;::::0;-1:-1:-1;;;;;45294:13:0;;::::1;::::0;45254:55;::::1;::::0;::::1;::::0;45294:13:::1;::::0;45254:55:::1;45320:13;:44:::0;;-1:-1:-1;;;;;;45320:44:0::1;-1:-1:-1::0;;;;;45320:44:0;::::1;::::0;;::::1;::::0;;;45414:23:::1;::::0;;-1:-1:-1;;;45414:23:0;;;;-1:-1:-1;;45320:44:0;45414:21:::1;::::0;:23:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;45320:44;45414:23:::1;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;45398:61:0::1;;45468:4;45475:13;;;;;;;;;-1:-1:-1::0;;;;;45475:13:0::1;-1:-1:-1::0;;;;;45475:18:0::1;;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;45398:98;::::0;-1:-1:-1;;;;;;45398:98:0::1;::::0;;;;;;-1:-1:-1;;;;;9718:15:1;;;45398:98:0::1;::::0;::::1;9700:34:1::0;9770:15;;9750:18;;;9743:43;9635:18;;45398:98:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;45507:11;:26:::0;;-1:-1:-1;;;;;;45507:26:0::1;-1:-1:-1::0;;;;;45507:26:0;;::::1;;::::0;;45546:31;;;::::1;-1:-1:-1::0;45546:31:0;;;:19:::1;:31;::::0;;;;:38;;-1:-1:-1;;45546:38:0::1;-1:-1:-1::0;45546:38:0::1;::::0;;-1:-1:-1;45067:525:0:o;10328:151::-;-1:-1:-1;;;;;10444:18:0;;;10417:7;10444:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;10328:151::o;46535:146::-;1812:6;;-1:-1:-1;;;;;1812:6:0;686:10;1959:23;1951:68;;;;-1:-1:-1;;;1951:68:0;;;;;;;:::i;:::-;46607:14:::1;:23:::0;;-1:-1:-1;;46607:23:0::1;::::0;::::1;;::::0;;::::1;::::0;;;46646:27:::1;::::0;1302:41:1;;;46646:27:0::1;::::0;1290:2:1;1275:18;46646:27:0::1;1162:187:1::0;2648:201:0;1812:6;;-1:-1:-1;;;;;1812:6:0;686:10;1959:23;1951:68;;;;-1:-1:-1;;;1951:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;2737:22:0;::::1;2729:73;;;::::0;-1:-1:-1;;;2729:73:0;;9999:2:1;2729:73:0::1;::::0;::::1;9981:21:1::0;10038:2;10018:18;;;10011:30;10077:34;10057:18;;;10050:62;-1:-1:-1;;;10128:18:1;;;10121:36;10174:19;;2729:73:0::1;9797:402:1::0;2729:73:0::1;2813:28;2832:8;2813:18;:28::i;:::-;2648:201:::0;:::o;16659:380::-;-1:-1:-1;;;;;16795:19:0;;16787:68;;;;-1:-1:-1;;;16787:68:0;;10406:2:1;16787:68:0;;;10388:21:1;10445:2;10425:18;;;10418:30;10484:34;10464:18;;;10457:62;-1:-1:-1;;;10535:18:1;;;10528:34;10579:19;;16787:68:0;10204:400:1;16787:68:0;-1:-1:-1;;;;;16874:21:0;;16866:68;;;;-1:-1:-1;;;16866:68:0;;10811:2:1;16866:68:0;;;10793:21:1;10850:2;10830:18;;;10823:30;10889:34;10869:18;;;10862:62;-1:-1:-1;;;10940:18:1;;;10933:32;10982:19;;16866:68:0;10609:398:1;16866:68:0;-1:-1:-1;;;;;16947:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;16999:32;;1500:25:1;;;16999:32:0;;1473:18:1;16999:32:0;;;;;;;16659:380;;;:::o;17330:453::-;17465:24;17492:25;17502:5;17509:7;17492:9;:25::i;:::-;17465:52;;-1:-1:-1;;17532:16:0;:37;17528:248;;17614:6;17594:16;:26;;17586:68;;;;-1:-1:-1;;;17586:68:0;;11214:2:1;17586:68:0;;;11196:21:1;11253:2;11233:18;;;11226:30;11292:31;11272:18;;;11265:59;11341:18;;17586:68:0;11012:353:1;17586:68:0;17698:51;17707:5;17714:7;17742:6;17723:16;:25;17698:8;:51::i;:::-;17454:329;17330:453;;;:::o;46975:1183::-;-1:-1:-1;;;;;47107:18:0;;47099:68;;;;-1:-1:-1;;;47099:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;47186:16:0;;47178:64;;;;-1:-1:-1;;;47178:64:0;;;;;;;:::i;:::-;47258:6;47268:1;47258:11;47255:92;;47286:28;47302:4;47308:2;47312:1;47286:15;:28::i;:::-;46975:1183;;;:::o;47255:92::-;47403:18;;47393:4;47359:12;9840:18;;;;;;;;;;;47449:14;;-1:-1:-1;;47375:46:0;;47449:14;;:38;;;;;47480:7;47449:38;:64;;;;-1:-1:-1;47505:8:0;;;;;;;47504:9;47449:64;:96;;;;-1:-1:-1;47530:15:0;;;;;;;47449:96;:130;;;;-1:-1:-1;47568:11:0;;-1:-1:-1;;;;;47562:17:0;;;47568:11;;47562:17;47449:130;47432:284;;;47606:8;:15;;-1:-1:-1;;47606:15:0;;;;;47654:18;;47636:37;;:17;:37::i;:::-;47688:8;:16;;-1:-1:-1;;47688:16:0;;;47432:284;-1:-1:-1;;;;;47763:25:0;;47728:12;47763:25;;;:19;:25;;;;;;;;47762:26;:54;;;;-1:-1:-1;;;;;;47793:23:0;;;;;;:19;:23;;;;;;;;47792:24;47762:54;47759:100;;;-1:-1:-1;47843:4:0;47759:100;47872:7;:53;;;;-1:-1:-1;47890:11:0;;-1:-1:-1;;;;;47884:17:0;;;47890:11;;47884:17;;:40;;-1:-1:-1;47913:11:0;;-1:-1:-1;;;;;47905:19:0;;;47913:11;;47905:19;47884:40;47869:238;;;47943:17;47963:25;47983:4;47963:15;47974:3;;47963:6;:10;;:15;;;;:::i;:::-;:19;;:25::i;:::-;47943:45;-1:-1:-1;48012:21:0;:6;47943:45;48012:10;:21::i;:::-;48003:30;;48048:47;48064:4;48078;48085:9;48048:15;:47::i;:::-;47927:180;47869:238;48117:33;48133:4;48139:2;48143:6;48117:15;:33::i;:::-;47088:1070;;46975:1183;;;:::o;3009:191::-;3102:6;;;-1:-1:-1;;;;;3119:17:0;;;-1:-1:-1;;;;;;3119:17:0;;;;;;;3152:40;;3102:6;;;3119:17;3102:6;;3152:40;;3083:16;;3152:40;3072:128;3009:191;:::o;13940:671::-;-1:-1:-1;;;;;14071:18:0;;14063:68;;;;-1:-1:-1;;;14063:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;14150:16:0;;14142:64;;;;-1:-1:-1;;;14142:64:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;14292:15:0;;14270:19;14292:15;;;;;;;;;;;14326:21;;;;14318:72;;;;-1:-1:-1;;;14318:72:0;;12382:2:1;14318:72:0;;;12364:21:1;12421:2;12401:18;;;12394:30;12460:34;12440:18;;;12433:62;-1:-1:-1;;;12511:18:1;;;12504:36;12557:19;;14318:72:0;12180:402:1;14318:72:0;-1:-1:-1;;;;;14426:15:0;;;:9;:15;;;;;;;;;;;14444:20;;;14426:38;;14486:13;;;;;;;;:23;;14458:6;;14426:9;14486:23;;14458:6;;14486:23;:::i;:::-;;;;;;;;14542:2;-1:-1:-1;;;;;14527:26:0;14536:4;-1:-1:-1;;;;;14527:26:0;;14546:6;14527:26;;;;1500:25:1;;1488:2;1473:18;;1354:177;14527:26:0;;;;;;;;14566:37;46975:1183;48166:612;48228:25;48256:29;48280:4;48256:19;48267:7;;48256:6;:10;;:19;;;;:::i;:29::-;48228:57;-1:-1:-1;48296:18:0;48317:29;:6;48228:57;48317:10;:29::i;:::-;48392:14;;48296:50;;-1:-1:-1;48357:50:0;;48374:17;;-1:-1:-1;;;;;48392:14:0;48357:16;:50::i;:::-;48441:12;:19;48420:18;48497:26;:10;48441:19;48497:14;:26::i;:::-;48471:52;;48547:7;48543:220;48564:10;48560:1;:14;;;48543:220;;;48626:1;-1:-1:-1;;;;;48599:29:0;:12;48612:1;48599:15;;;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;48599:15:0;:29;;;;:52;;;48650:1;48632:15;:19;48599:52;48596:156;;;48672:64;48696:4;48703:12;48716:1;48703:15;;;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;48703:15:0;48720;48672;:64::i;:::-;48576:3;;;;:::i;:::-;;;;48543:220;;;;48217:561;;;;48166:612;:::o;30883:98::-;30941:7;30968:5;30972:1;30968;:5;:::i;:::-;30961:12;30883:98;-1:-1:-1;;;30883:98:0:o;31282:::-;31340:7;31367:5;31371:1;31367;:5;:::i;30526:98::-;30584:7;30611:5;30615:1;30611;:5;:::i;48786:719::-;48881:34;;1500:25:1;;;48881:34:0;;1488:2:1;1473:18;48881:34:0;;;;;;;49010:16;;;49024:1;49010:16;;;;;;;;48986:21;;49010:16;;;;;;;;;;-1:-1:-1;49010:16:0;48986:40;;49055:4;49037;49042:1;49037:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;49037:23:0;;;:7;;;;;;;;;;:23;;;;49081:13;;:20;;;-1:-1:-1;;;49081:20:0;;;;:13;;;;;:18;;:20;;;;;49037:7;;49081:20;;;;;:13;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49071:4;49076:1;49071:7;;;;;;;;:::i;:::-;-1:-1:-1;;;;;49071:30:0;;;:7;;;;;;;;;:30;49146:13;;49114:60;;49131:4;;49146:13;49162:11;49114:8;:60::i;:::-;49213:13;;:223;;-1:-1:-1;;;49213:223:0;;-1:-1:-1;;;;;49213:13:0;;;;:64;;:223;;49292:11;;49213:13;;49362:4;;49381:14;;49410:15;;49213:223;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49452:45;49475:21;49452:45;;;;1500:25:1;;1488:2;1473:18;;1354:177;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:548:1;126:4;155:2;184;173:9;166:21;216:6;210:13;259:6;254:2;243:9;239:18;232:34;284:1;294:140;308:6;305:1;302:13;294:140;;;403:14;;;399:23;;393:30;369:17;;;388:2;365:26;358:66;323:10;;294:140;;;298:3;483:1;478:2;469:6;458:9;454:22;450:31;443:42;553:2;546;542:7;537:2;529:6;525:15;521:29;510:9;506:45;502:54;494:62;;;;14:548;;;;:::o;567:131::-;-1:-1:-1;;;;;642:31:1;;632:42;;622:70;;688:1;685;678:12;703:134;771:20;;800:31;771:20;800:31;:::i;:::-;703:134;;;:::o;842:315::-;910:6;918;971:2;959:9;950:7;946:23;942:32;939:52;;;987:1;984;977:12;939:52;1026:9;1013:23;1045:31;1070:5;1045:31;:::i;:::-;1095:5;1147:2;1132:18;;;;1119:32;;-1:-1:-1;;;842:315:1:o;1536:456::-;1613:6;1621;1629;1682:2;1670:9;1661:7;1657:23;1653:32;1650:52;;;1698:1;1695;1688:12;1650:52;1737:9;1724:23;1756:31;1781:5;1756:31;:::i;:::-;1806:5;-1:-1:-1;1863:2:1;1848:18;;1835:32;1876:33;1835:32;1876:33;:::i;:::-;1536:456;;1928:7;;-1:-1:-1;;;1982:2:1;1967:18;;;;1954:32;;1536:456::o;2186:160::-;2251:20;;2307:13;;2300:21;2290:32;;2280:60;;2336:1;2333;2326:12;2351:180;2407:6;2460:2;2448:9;2439:7;2435:23;2431:32;2428:52;;;2476:1;2473;2466:12;2428:52;2499:26;2515:9;2499:26;:::i;2536:247::-;2595:6;2648:2;2636:9;2627:7;2623:23;2619:32;2616:52;;;2664:1;2661;2654:12;2616:52;2703:9;2690:23;2722:31;2747:5;2722:31;:::i;2788:316::-;2865:6;2873;2881;2934:2;2922:9;2913:7;2909:23;2905:32;2902:52;;;2950:1;2947;2940:12;2902:52;-1:-1:-1;;2973:23:1;;;3043:2;3028:18;;3015:32;;-1:-1:-1;3094:2:1;3079:18;;;3066:32;;2788:316;-1:-1:-1;2788:316:1:o;3317:127::-;3378:10;3373:3;3369:20;3366:1;3359:31;3409:4;3406:1;3399:15;3433:4;3430:1;3423:15;3449:1121;3533:6;3564:2;3607;3595:9;3586:7;3582:23;3578:32;3575:52;;;3623:1;3620;3613:12;3575:52;3663:9;3650:23;3692:18;3733:2;3725:6;3722:14;3719:34;;;3749:1;3746;3739:12;3719:34;3787:6;3776:9;3772:22;3762:32;;3832:7;3825:4;3821:2;3817:13;3813:27;3803:55;;3854:1;3851;3844:12;3803:55;3890:2;3877:16;3912:2;3908;3905:10;3902:36;;;3918:18;;:::i;:::-;3964:2;3961:1;3957:10;3996:2;3990:9;4059:2;4055:7;4050:2;4046;4042:11;4038:25;4030:6;4026:38;4114:6;4102:10;4099:22;4094:2;4082:10;4079:18;4076:46;4073:72;;;4125:18;;:::i;:::-;4161:2;4154:22;4211:18;;;4245:15;;;;-1:-1:-1;4287:11:1;;;4283:20;;;4315:19;;;4312:39;;;4347:1;4344;4337:12;4312:39;4371:11;;;;4391:148;4407:6;4402:3;4399:15;4391:148;;;4473:23;4492:3;4473:23;:::i;:::-;4461:36;;4424:12;;;;4517;;;;4391:148;;;4558:6;3449:1121;-1:-1:-1;;;;;;;;3449:1121:1:o;4575:180::-;4634:6;4687:2;4675:9;4666:7;4662:23;4658:32;4655:52;;;4703:1;4700;4693:12;4655:52;-1:-1:-1;4726:23:1;;4575:180;-1:-1:-1;4575:180:1:o;4993:689::-;5085:6;5093;5101;5154:2;5142:9;5133:7;5129:23;5125:32;5122:52;;;5170:1;5167;5160:12;5122:52;5210:9;5197:23;5239:18;5280:2;5272:6;5269:14;5266:34;;;5296:1;5293;5286:12;5266:34;5334:6;5323:9;5319:22;5309:32;;5379:7;5372:4;5368:2;5364:13;5360:27;5350:55;;5401:1;5398;5391:12;5350:55;5441:2;5428:16;5467:2;5459:6;5456:14;5453:34;;;5483:1;5480;5473:12;5453:34;5538:7;5531:4;5521:6;5518:1;5514:14;5510:2;5506:23;5502:34;5499:47;5496:67;;;5559:1;5556;5549:12;5496:67;5590:4;5582:13;;;;-1:-1:-1;5614:6:1;-1:-1:-1;5639:37:1;;5655:20;;;-1:-1:-1;5639:37:1;:::i;:::-;5629:47;;4993:689;;;;;:::o;5687:388::-;5755:6;5763;5816:2;5804:9;5795:7;5791:23;5787:32;5784:52;;;5832:1;5829;5822:12;5784:52;5871:9;5858:23;5890:31;5915:5;5890:31;:::i;:::-;5940:5;-1:-1:-1;5997:2:1;5982:18;;5969:32;6010:33;5969:32;6010:33;:::i;:::-;6062:7;6052:17;;;5687:388;;;;;:::o;6080:380::-;6159:1;6155:12;;;;6202;;;6223:61;;6277:4;6269:6;6265:17;6255:27;;6223:61;6330:2;6322:6;6319:14;6299:18;6296:38;6293:161;;6376:10;6371:3;6367:20;6364:1;6357:31;6411:4;6408:1;6401:15;6439:4;6436:1;6429:15;6293:161;;6080:380;;;:::o;6465:127::-;6526:10;6521:3;6517:20;6514:1;6507:31;6557:4;6554:1;6547:15;6581:4;6578:1;6571:15;6597:125;6662:9;;;6683:10;;;6680:36;;;6696:18;;:::i;6727:356::-;6929:2;6911:21;;;6948:18;;;6941:30;7007:34;7002:2;6987:18;;6980:62;7074:2;7059:18;;6727:356::o;7747:127::-;7808:10;7803:3;7799:20;7796:1;7789:31;7839:4;7836:1;7829:15;7863:4;7860:1;7853:15;7879:135;7918:3;7939:17;;;7936:43;;7959:18;;:::i;:::-;-1:-1:-1;8006:1:1;7995:13;;7879:135::o;8019:794::-;8241:2;8253:21;;;8226:18;;8309:22;;;8193:4;8388:6;8362:2;8347:18;;8193:4;8422:304;8436:6;8433:1;8430:13;8422:304;;;8511:6;8498:20;8531:31;8556:5;8531:31;:::i;:::-;-1:-1:-1;;;;;8587:31:1;8575:44;;8642:4;8701:15;;;;8666:12;;;;8615:1;8451:9;8422:304;;;8426:3;8743;8735:11;;;;8798:6;8791:14;8784:22;8777:4;8766:9;8762:20;8755:52;8019:794;;;;;;:::o;9232:251::-;9302:6;9355:2;9343:9;9334:7;9330:23;9326:32;9323:52;;;9371:1;9368;9361:12;9323:52;9403:9;9397:16;9422:31;9447:5;9422:31;:::i;11370:401::-;11572:2;11554:21;;;11611:2;11591:18;;;11584:30;11650:34;11645:2;11630:18;;11623:62;-1:-1:-1;;;11716:2:1;11701:18;;11694:35;11761:3;11746:19;;11370:401::o;11776:399::-;11978:2;11960:21;;;12017:2;11997:18;;;11990:30;12056:34;12051:2;12036:18;;12029:62;-1:-1:-1;;;12122:2:1;12107:18;;12100:33;12165:3;12150:19;;11776:399::o;12587:175::-;12624:3;12668:4;12661:5;12657:16;12697:4;12688:7;12685:17;12682:43;;12705:18;;:::i;:::-;12754:1;12741:15;;12587:175;-1:-1:-1;;12587:175:1:o;12767:168::-;12840:9;;;12871;;12888:15;;;12882:22;;12868:37;12858:71;;12909:18;;:::i;12940:217::-;12980:1;13006;12996:132;;13050:10;13045:3;13041:20;13038:1;13031:31;13085:4;13082:1;13075:15;13113:4;13110:1;13103:15;12996:132;-1:-1:-1;13142:9:1;;12940:217::o;13162:128::-;13229:9;;;13250:11;;;13247:37;;;13264:18;;:::i;13295:980::-;13557:4;13605:3;13594:9;13590:19;13636:6;13625:9;13618:25;13662:2;13700:6;13695:2;13684:9;13680:18;13673:34;13743:3;13738:2;13727:9;13723:18;13716:31;13767:6;13802;13796:13;13833:6;13825;13818:22;13871:3;13860:9;13856:19;13849:26;;13910:2;13902:6;13898:15;13884:29;;13931:1;13941:195;13955:6;13952:1;13949:13;13941:195;;;14020:13;;-1:-1:-1;;;;;14016:39:1;14004:52;;14111:15;;;;14076:12;;;;14052:1;13970:9;13941:195;;;-1:-1:-1;;;;;;;14192:32:1;;;;14187:2;14172:18;;14165:60;-1:-1:-1;;;14256:3:1;14241:19;14234:35;14153:3;13295:980;-1:-1:-1;;;13295:980:1:o

Swarm Source

ipfs://28c523f3d85b68450a34f50e783104fa362ac502bc487143c8762724ffde5bc7

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