Token

TradeStars TSX (TSX)

ERC-20

Gaming

Sports

Trading

Overview

Max Total Supply

70,000,000 TSX

Holders

651 (0.00%)

Market

Price

$0.00 @ 0.000000 ETH

Onchain Market Cap

$116,820.90

Circulating Supply Market Cap

$32,502.00

Other Info

Token Contract (WITH 18 Decimals)

0x734c90044a0ba31b3f2e640c10dc5d3540499bfd

Filtered by Token Holder

0xF14c9dbDb31b0a18aF44Fcf97Ed12b0abfE1b92e

Balance

1,797,286.9320226 TSX

Value

$2,999.44 ( ~0.826442826595734 Eth) [2.5676%]

0xf14c9dbdb31b0a18af44fcf97ed12b0abfe1b92e

OVERVIEW

TradeStars is a fantasy sports platform powered by the Ethereum and Matic 2 blockchains. It is the first fantasy sports trading platform built on Ethereum and is based on actual statistics and market availability.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

TSX

Compiler Version

v0.8.0+commit.c7dfd78e

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-04-29
*/

// Sources flattened with hardhat v2.1.2 https://hardhat.org

// File @openzeppelin/contracts/token/ERC20/[email protected]

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}


// File @openzeppelin/contracts/utils/[email protected]



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) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}


// File @openzeppelin/contracts/token/ERC20/[email protected]



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.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of 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 {
    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 defaut value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All three 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 returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual 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
     * overloaded;
     *
     * 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 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:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, 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}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), 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}.
     *
     * Requirements:
     *
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);

        uint256 currentAllowance = _allowances[sender][_msgSender()];
        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
        _approve(sender, _msgSender(), currentAllowance - 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) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][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) {
        uint256 currentAllowance = _allowances[_msgSender()][spender];
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        _approve(_msgSender(), spender, currentAllowance - subtractedValue);

        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is 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:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        uint256 senderBalance = _balances[sender];
        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
        _balances[sender] = senderBalance - amount;
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, 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:
     *
     * - `to` 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);
    }

    /**
     * @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");
        _balances[account] = accountBalance - amount;
        _totalSupply -= amount;

        emit Transfer(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 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 to 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 { }
}


// File @openzeppelin/contracts/utils/math/[email protected]



pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
    }
}


// File @openzeppelin/contracts/utils/[email protected]



pragma solidity ^0.8.0;

/**
 * @dev Collection of functions related to array types.
 */
library Arrays {
   /**
     * @dev Searches a sorted `array` and returns the first index that contains
     * a value greater or equal to `element`. If no such index exists (i.e. all
     * values in the array are strictly less than `element`), the array length is
     * returned. Time complexity O(log n).
     *
     * `array` is expected to be sorted in ascending order, and to contain no
     * repeated elements.
     */
    function findUpperBound(uint256[] storage array, uint256 element) internal view returns (uint256) {
        if (array.length == 0) {
            return 0;
        }

        uint256 low = 0;
        uint256 high = array.length;

        while (low < high) {
            uint256 mid = Math.average(low, high);

            // Note that mid will always be strictly less than high (i.e. it will be a valid array index)
            // because Math.average rounds down (it does integer division with truncation).
            if (array[mid] > element) {
                high = mid;
            } else {
                low = mid + 1;
            }
        }

        // At this point `low` is the exclusive upper bound. We will return the inclusive upper bound.
        if (low > 0 && array[low - 1] == element) {
            return low - 1;
        } else {
            return low;
        }
    }
}


// File @openzeppelin/contracts/utils/[email protected]



pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]



pragma solidity ^0.8.0;



/**
 * @dev This contract extends an ERC20 token with a snapshot mechanism. When a snapshot is created, the balances and
 * total supply at the time are recorded for later access.
 *
 * This can be used to safely create mechanisms based on token balances such as trustless dividends or weighted voting.
 * In naive implementations it's possible to perform a "double spend" attack by reusing the same balance from different
 * accounts. By using snapshots to calculate dividends or voting power, those attacks no longer apply. It can also be
 * used to create an efficient ERC20 forking mechanism.
 *
 * Snapshots are created by the internal {_snapshot} function, which will emit the {Snapshot} event and return a
 * snapshot id. To get the total supply at the time of a snapshot, call the function {totalSupplyAt} with the snapshot
 * id. To get the balance of an account at the time of a snapshot, call the {balanceOfAt} function with the snapshot id
 * and the account address.
 *
 * ==== Gas Costs
 *
 * Snapshots are efficient. Snapshot creation is _O(1)_. Retrieval of balances or total supply from a snapshot is _O(log
 * n)_ in the number of snapshots that have been created, although _n_ for a specific account will generally be much
 * smaller since identical balances in subsequent snapshots are stored as a single entry.
 *
 * There is a constant overhead for normal ERC20 transfers due to the additional snapshot bookkeeping. This overhead is
 * only significant for the first transfer that immediately follows a snapshot for a particular account. Subsequent
 * transfers will have normal cost until the next snapshot, and so on.
 */
abstract contract ERC20Snapshot is ERC20 {
    // Inspired by Jordi Baylina's MiniMeToken to record historical balances:
    // https://github.com/Giveth/minimd/blob/ea04d950eea153a04c51fa510b068b9dded390cb/contracts/MiniMeToken.sol

    using Arrays for uint256[];
    using Counters for Counters.Counter;

    // Snapshotted values have arrays of ids and the value corresponding to that id. These could be an array of a
    // Snapshot struct, but that would impede usage of functions that work on an array.
    struct Snapshots {
        uint256[] ids;
        uint256[] values;
    }

    mapping (address => Snapshots) private _accountBalanceSnapshots;
    Snapshots private _totalSupplySnapshots;

    // Snapshot ids increase monotonically, with the first value being 1. An id of 0 is invalid.
    Counters.Counter private _currentSnapshotId;

    /**
     * @dev Emitted by {_snapshot} when a snapshot identified by `id` is created.
     */
    event Snapshot(uint256 id);

    /**
     * @dev Creates a new snapshot and returns its snapshot id.
     *
     * Emits a {Snapshot} event that contains the same id.
     *
     * {_snapshot} is `internal` and you have to decide how to expose it externally. Its usage may be restricted to a
     * set of accounts, for example using {AccessControl}, or it may be open to the public.
     *
     * [WARNING]
     * ====
     * While an open way of calling {_snapshot} is required for certain trust minimization mechanisms such as forking,
     * you must consider that it can potentially be used by attackers in two ways.
     *
     * First, it can be used to increase the cost of retrieval of values from snapshots, although it will grow
     * logarithmically thus rendering this attack ineffective in the long term. Second, it can be used to target
     * specific accounts and increase the cost of ERC20 transfers for them, in the ways specified in the Gas Costs
     * section above.
     *
     * We haven't measured the actual numbers; if this is something you're interested in please reach out to us.
     * ====
     */
    function _snapshot() internal virtual returns (uint256) {
        _currentSnapshotId.increment();

        uint256 currentId = _currentSnapshotId.current();
        emit Snapshot(currentId);
        return currentId;
    }

    /**
     * @dev Retrieves the balance of `account` at the time `snapshotId` was created.
     */
    function balanceOfAt(address account, uint256 snapshotId) public view virtual returns (uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _accountBalanceSnapshots[account]);

        return snapshotted ? value : balanceOf(account);
    }

    /**
     * @dev Retrieves the total supply at the time `snapshotId` was created.
     */
    function totalSupplyAt(uint256 snapshotId) public view virtual returns(uint256) {
        (bool snapshotted, uint256 value) = _valueAt(snapshotId, _totalSupplySnapshots);

        return snapshotted ? value : totalSupply();
    }


    // Update balance and/or total supply snapshots before the values are modified. This is implemented
    // in the _beforeTokenTransfer hook, which is executed for _mint, _burn, and _transfer operations.
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
      super._beforeTokenTransfer(from, to, amount);

      if (from == address(0)) {
        // mint
        _updateAccountSnapshot(to);
        _updateTotalSupplySnapshot();
      } else if (to == address(0)) {
        // burn
        _updateAccountSnapshot(from);
        _updateTotalSupplySnapshot();
      } else {
        // transfer
        _updateAccountSnapshot(from);
        _updateAccountSnapshot(to);
      }
    }

    function _valueAt(uint256 snapshotId, Snapshots storage snapshots)
        private view returns (bool, uint256)
    {
        require(snapshotId > 0, "ERC20Snapshot: id is 0");
        // solhint-disable-next-line max-line-length
        require(snapshotId <= _currentSnapshotId.current(), "ERC20Snapshot: nonexistent id");

        // When a valid snapshot is queried, there are three possibilities:
        //  a) The queried value was not modified after the snapshot was taken. Therefore, a snapshot entry was never
        //  created for this id, and all stored snapshot ids are smaller than the requested one. The value that corresponds
        //  to this id is the current one.
        //  b) The queried value was modified after the snapshot was taken. Therefore, there will be an entry with the
        //  requested id, and its value is the one to return.
        //  c) More snapshots were created after the requested one, and the queried value was later modified. There will be
        //  no entry for the requested id: the value that corresponds to it is that of the smallest snapshot id that is
        //  larger than the requested one.
        //
        // In summary, we need to find an element in an array, returning the index of the smallest value that is larger if
        // it is not found, unless said value doesn't exist (e.g. when all values are smaller). Arrays.findUpperBound does
        // exactly this.

        uint256 index = snapshots.ids.findUpperBound(snapshotId);

        if (index == snapshots.ids.length) {
            return (false, 0);
        } else {
            return (true, snapshots.values[index]);
        }
    }

    function _updateAccountSnapshot(address account) private {
        _updateSnapshot(_accountBalanceSnapshots[account], balanceOf(account));
    }

    function _updateTotalSupplySnapshot() private {
        _updateSnapshot(_totalSupplySnapshots, totalSupply());
    }

    function _updateSnapshot(Snapshots storage snapshots, uint256 currentValue) private {
        uint256 currentId = _currentSnapshotId.current();
        if (_lastSnapshotId(snapshots.ids) < currentId) {
            snapshots.ids.push(currentId);
            snapshots.values.push(currentValue);
        }
    }

    function _lastSnapshotId(uint256[] storage ids) private view returns (uint256) {
        if (ids.length == 0) {
            return 0;
        } else {
            return ids[ids.length - 1];
        }
    }
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]



pragma solidity ^0.8.0;


/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20Burnable is Context, ERC20 {
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        uint256 currentAllowance = allowance(account, _msgSender());
        require(currentAllowance >= amount, "ERC20: burn amount exceeds allowance");
        _approve(account, _msgSender(), currentAllowance - amount);
        _burn(account, amount);
    }
}


// File @openzeppelin/contracts/security/[email protected]



pragma solidity ^0.8.0;

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor () {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view virtual returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!paused(), "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(paused(), "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }
}


// File @openzeppelin/contracts/token/ERC20/extensions/[email protected]



pragma solidity ^0.8.0;


/**
 * @dev ERC20 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 */
abstract contract ERC20Pausable is ERC20, Pausable {
    /**
     * @dev See {ERC20-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        require(!paused(), "ERC20Pausable: token transfer while paused");
    }
}


// File @openzeppelin/contracts/utils/introspection/[email protected]



pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}


// File @openzeppelin/contracts/utils/introspection/[email protected]



pragma solidity ^0.8.0;

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}


// File @openzeppelin/contracts/access/[email protected]



pragma solidity ^0.8.0;


/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControl {
    function hasRole(bytes32 role, address account) external view returns (bool);
    function getRoleAdmin(bytes32 role) external view returns (bytes32);
    function grantRole(bytes32 role, address account) external;
    function revokeRole(bytes32 role, address account) external;
    function renounceRole(bytes32 role, address account) external;
}

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping (address => bool) members;
        bytes32 adminRole;
    }

    mapping (bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId
            || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view override returns (bool) {
        return _roles[role].members[account];
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view override returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) public virtual override {
        require(hasRole(getRoleAdmin(role), _msgSender()), "AccessControl: sender must be an admin to grant");

        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) public virtual override {
        require(hasRole(getRoleAdmin(role), _msgSender()), "AccessControl: sender must be an admin to revoke");

        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `account`.
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        require(account == _msgSender(), "AccessControl: can only renounce roles for self");

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        emit RoleAdminChanged(role, getRoleAdmin(role), adminRole);
        _roles[role].adminRole = adminRole;
    }

    function _grantRole(bytes32 role, address account) private {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    function _revokeRole(bytes32 role, address account) private {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}


// File @openzeppelin/contracts/utils/structs/[email protected]



pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;

        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}


// File @openzeppelin/contracts/access/[email protected]



pragma solidity ^0.8.0;


/**
 * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
 */
interface IAccessControlEnumerable {
    function getRoleMember(bytes32 role, uint256 index) external view returns (address);
    function getRoleMemberCount(bytes32 role) external view returns (uint256);
}

/**
 * @dev Extension of {AccessControl} that allows enumerating the members of each role.
 */
abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
    using EnumerableSet for EnumerableSet.AddressSet;

    mapping (bytes32 => EnumerableSet.AddressSet) private _roleMembers;

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControlEnumerable).interfaceId
            || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view override returns (address) {
        return _roleMembers[role].at(index);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view override returns (uint256) {
        return _roleMembers[role].length();
    }

    /**
     * @dev Overload {grantRole} to track enumerable memberships
     */
    function grantRole(bytes32 role, address account) public virtual override {
        super.grantRole(role, account);
        _roleMembers[role].add(account);
    }

    /**
     * @dev Overload {revokeRole} to track enumerable memberships
     */
    function revokeRole(bytes32 role, address account) public virtual override {
        super.revokeRole(role, account);
        _roleMembers[role].remove(account);
    }

    /**
     * @dev Overload {renounceRole} to track enumerable memberships
     */
    function renounceRole(bytes32 role, address account) public virtual override {
        super.renounceRole(role, account);
        _roleMembers[role].remove(account);
    }

    /**
     * @dev Overload {_setupRole} to track enumerable memberships
     */
    function _setupRole(bytes32 role, address account) internal virtual override {
        super._setupRole(role, account);
        _roleMembers[role].add(account);
    }
}


// File contracts/tsx/TSX.sol



pragma solidity ^0.8.0;





/**
 * @dev {TSX}:
 *  - mint/burn/pause capabilities
 *  - a minter role that allows for token minting (creation)
 *  - a pauser role that allows to stop all token transfers
 *
 * The account that deploys the contract will be granted the minter and pauser
 * roles, as well as the default admin role, which will let it grant both minter
 * and pauser roles to other accounts.
 */

contract TSX is Context, AccessControlEnumerable, ERC20Snapshot, ERC20Burnable, ERC20Pausable {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");
    bytes32 public constant SNAPSHOT_ROLE = keccak256("SNAPSHOT_ROLE");

    // Token details
    string public constant NAME = "TradeStars TSX";
    string public constant SYMBOL = "TSX";

    constructor() ERC20(NAME, SYMBOL) {
        _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());

        _setupRole(MINTER_ROLE, _msgSender());
        _setupRole(PAUSER_ROLE, _msgSender());
        _setupRole(SNAPSHOT_ROLE, _msgSender());
    }
    
    /**
     * @dev Takes a snapshop of the token at the current block. The caller must have the `SNAPSHOT_ROLE`.
     */
    function snapshot() public virtual {
        require(hasRole(SNAPSHOT_ROLE, _msgSender()), "TSX: must have snapshot role");
        _snapshot();
    }

    /**
     * @dev Mints a specific amount of tokens. The caller must have the `MINTER_ROLE`.
     * @param _to The amount of token to be minted.
     * @param _value The amount of token to be minted.
     */
    function mint(address _to, uint256 _value) public virtual {
        require(hasRole(MINTER_ROLE, _msgSender()), "TSX: must have minter role");
        _mint(_to, _value);
    }

    /**
     * @dev Pauses all token transfers. The caller must have the `PAUSER_ROLE`.
     */
    function pause() public virtual {
        require(hasRole(PAUSER_ROLE, _msgSender()), "TSX: must have pauser role");
        _pause();
    }

    /**
     * @dev Unpauses all token transfers. the caller must have the `PAUSER_ROLE`.
     */
    function unpause() public virtual {
        require(hasRole(PAUSER_ROLE, _msgSender()), "TSX: must have pauser role");
        _unpause();
    }

    function _beforeTokenTransfer(
        address from, 
        address to, 
        uint256 amount
    ) 
        internal virtual override(ERC20, ERC20Snapshot, ERC20Pausable) 
    {
        super._beforeTokenTransfer(from, to, amount);
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"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":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"id","type":"uint256"}],"name":"Snapshot","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":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NAME","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAUSER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SNAPSHOT_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SYMBOL","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","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":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"balanceOfAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","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":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"_to","type":"address"},{"internalType":"uint256","name":"_value","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"snapshot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","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":[{"internalType":"uint256","name":"snapshotId","type":"uint256"}],"name":"totalSupplyAt","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

53667:2139:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;50863:227;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5939:91;;;:::i;:::-;;;;;;;:::i;8079:169::-;;;;;;:::i;:::-;;:::i;7032:108::-;;;:::i;:::-;;;;;;;:::i;8730:422::-;;;;;;:::i;:::-;;:::i;36999:123::-;;;;;;:::i;:::-;;:::i;52234:165::-;;;;;;:::i;:::-;;:::i;:::-;;6883:84;;;:::i;:::-;;;;;;;:::i;52757:174::-;;;;;;:::i;:::-;;:::i;9561:215::-;;;;;;:::i;:::-;;:::i;55398:147::-;;;:::i;54860:179::-;;;;;;:::i;:::-;;:::i;27054:91::-;;;;;;:::i;:::-;;:::i;22663:266::-;;;;;;:::i;:::-;;:::i;28884:86::-;;;:::i;53906:66::-;;;:::i;7203:127::-;;;;;;:::i;:::-;;:::i;27464:332::-;;;;;;:::i;:::-;;:::i;55146:143::-;;;:::i;51689:145::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;36671:139::-;;;;;;:::i;:::-;;:::i;6149:95::-;;;:::i;54484:153::-;;;:::i;23033:233::-;;;;;;:::i;:::-;;:::i;35127:49::-;;;:::i;54003:46::-;;;:::i;10279:377::-;;;;;;:::i;:::-;;:::i;7543:175::-;;;;;;:::i;:::-;;:::i;52008:134::-;;;;;;:::i;:::-;;:::i;53768:62::-;;;:::i;52492:170::-;;;;;;:::i;:::-;;:::i;7781:151::-;;;;;;:::i;:::-;;:::i;53837:62::-;;;:::i;54056:37::-;;;:::i;50863:227::-;50948:4;-1:-1:-1;;;;;;50972:57:0;;-1:-1:-1;;;50972:57:0;;:110;;;51046:36;51070:11;51046:23;:36::i;:::-;50965:117;;50863:227;;;;:::o;5939:91::-;5984:13;6017:5;6010:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5939:91;:::o;8079:169::-;8162:4;8179:39;8188:12;:10;:12::i;:::-;8202:7;8211:6;8179:8;:39::i;:::-;-1:-1:-1;8236:4:0;8079:169;;;;;:::o;7032:108::-;7120:12;;7032:108;:::o;8730:422::-;8836:4;8853:36;8863:6;8871:9;8882:6;8853:9;:36::i;:::-;-1:-1:-1;;;;;8929:19:0;;8902:24;8929:19;;;:11;:19;;;;;8902:24;8949:12;:10;:12::i;:::-;-1:-1:-1;;;;;8929:33:0;-1:-1:-1;;;;;8929:33:0;;;;;;;;;;;;;8902:60;;9001:6;8981:16;:26;;8973:79;;;;-1:-1:-1;;;8973:79:0;;;;;;;:::i;:::-;;;;;;;;;9063:57;9072:6;9080:12;:10;:12::i;:::-;9094:25;9113:6;9094:16;:25;:::i;:::-;9063:8;:57::i;:::-;-1:-1:-1;9140:4:0;;8730:422;-1:-1:-1;;;;8730:422:0:o;36999:123::-;37065:7;37092:12;;;;;;;;;;:22;;;;36999:123::o;52234:165::-;52319:30;52335:4;52341:7;52319:15;:30::i;:::-;52360:18;;;;:12;:18;;;;;:31;;52383:7;52360:22;:31::i;:::-;;52234:165;;:::o;6883:84::-;6957:2;6883:84;:::o;52757:174::-;52845:33;52864:4;52870:7;52845:18;:33::i;:::-;52889:18;;;;:12;:18;;;;;:34;;52915:7;52889:25;:34::i;9561:215::-;9649:4;9666:80;9675:12;:10;:12::i;:::-;9689:7;9735:10;9698:11;:25;9710:12;:10;:12::i;:::-;-1:-1:-1;;;;;9698:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;9698:25:0;;;:34;;;;;;;;;;:47;;;;:::i;55398:147::-;55451:34;53875:24;55472:12;:10;:12::i;55451:34::-;55443:73;;;;-1:-1:-1;;;55443:73:0;;;;;;;:::i;:::-;55527:10;:8;:10::i;:::-;55398:147::o;54860:179::-;54937:34;53806:24;54958:12;:10;:12::i;54937:34::-;54929:73;;;;-1:-1:-1;;;54929:73:0;;;;;;;:::i;:::-;55013:18;55019:3;55024:6;55013:5;:18::i;:::-;54860:179;;:::o;27054:91::-;27110:27;27116:12;:10;:12::i;:::-;27130:6;27110:5;:27::i;:::-;27054:91;:::o;22663:266::-;-1:-1:-1;;;;;22827:33:0;;22750:7;22827:33;;;:24;:33;;;;;22750:7;;;;22806:55;;22815:10;;22806:8;:55::i;:::-;22770:91;;;;22881:11;:40;;22903:18;22913:7;22903:9;:18::i;:::-;22881:40;;;22895:5;22881:40;22874:47;22663:266;-1:-1:-1;;;;;22663:266:0:o;28884:86::-;28955:7;;;;28884:86;:::o;53906:66::-;53946:26;53906:66;:::o;7203:127::-;-1:-1:-1;;;;;7304:18:0;7277:7;7304:18;;;:9;:18;;;;;;;7203:127::o;27464:332::-;27541:24;27568:32;27578:7;27587:12;:10;:12::i;27568:32::-;27541:59;;27639:6;27619:16;:26;;27611:75;;;;-1:-1:-1;;;27611:75:0;;;;;;;:::i;:::-;27697:58;27706:7;27715:12;:10;:12::i;:::-;27729:25;27748:6;27729:16;:25;:::i;27697:58::-;27766:22;27772:7;27781:6;27766:5;:22::i;55146:143::-;55197:34;53875:24;55218:12;:10;:12::i;55197:34::-;55189:73;;;;-1:-1:-1;;;55189:73:0;;;;;;;:::i;:::-;55273:8;:6;:8::i;51689:145::-;51771:7;51798:18;;;:12;:18;;;;;:28;;51820:5;51798:21;:28::i;:::-;51791:35;51689:145;-1:-1:-1;;;51689:145:0:o;36671:139::-;36749:4;36773:12;;;;;;;;;;;-1:-1:-1;;;;;36773:29:0;;;;;;;;;;;;;;;36671:139::o;6149:95::-;6196:13;6229:7;6222:14;;;;;:::i;54484:153::-;54538:36;53946:26;54561:12;:10;:12::i;54538:36::-;54530:77;;;;-1:-1:-1;;;54530:77:0;;;;;;;:::i;:::-;54618:11;:9;:11::i;23033:233::-;23104:7;23125:16;23143:13;23160:43;23169:10;23181:21;23160:8;:43::i;:::-;23124:79;;;;23223:11;:35;;23245:13;:11;:13::i;:::-;23223:35;;;23237:5;23223:35;23216:42;23033:233;-1:-1:-1;;;;23033:233:0:o;35127:49::-;35172:4;35127:49;:::o;54003:46::-;;;;;;;;;;;;;;-1:-1:-1;;;54003:46:0;;;;:::o;10279:377::-;10372:4;10389:24;10416:11;:25;10428:12;:10;:12::i;:::-;-1:-1:-1;;;;;10416:25:0;;;;;;;;;;;;;;;;;-1:-1:-1;10416:25:0;;;:34;;;;;;;;;;;-1:-1:-1;10469:35:0;;;;10461:85;;;;-1:-1:-1;;;10461:85:0;;;;;;;:::i;:::-;10557:67;10566:12;:10;:12::i;:::-;10580:7;10589:34;10608:15;10589:16;:34;:::i;10557:67::-;-1:-1:-1;10644:4:0;;10279:377;-1:-1:-1;;;10279:377:0:o;7543:175::-;7629:4;7646:42;7656:12;:10;:12::i;:::-;7670:9;7681:6;7646:9;:42::i;52008:134::-;52080:7;52107:18;;;:12;:18;;;;;:27;;:25;:27::i;53768:62::-;53806:24;53768:62;:::o;52492:170::-;52578:31;52595:4;52601:7;52578:16;:31::i;7781:151::-;-1:-1:-1;;;;;7897:18:0;;;7870:7;7897:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;7781:151::o;53837:62::-;53875:24;53837:62;:::o;54056:37::-;;;;;;;;;;;;;;-1:-1:-1;;;54056:37:0;;;;:::o;39404:112::-;39483:25;39494:4;39500:7;39483:10;:25::i;46991:152::-;47061:4;47085:50;47090:3;-1:-1:-1;;;;;47110:23:0;;47085:4;:50::i;36362:217::-;36447:4;-1:-1:-1;;;;;;36471:47:0;;-1:-1:-1;;;36471:47:0;;:100;;;36535:36;36559:11;36535:23;:36::i;3536:98::-;3616:10;3536:98;:::o;13635:346::-;-1:-1:-1;;;;;13737:19:0;;13729:68;;;;-1:-1:-1;;;13729:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;13816:21:0;;13808:68;;;;-1:-1:-1;;;13808:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;13889:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;;:36;;;13941:32;;;;;13919:6;;13941:32;:::i;:::-;;;;;;;;13635:346;;;:::o;11146:604::-;-1:-1:-1;;;;;11252:20:0;;11244:70;;;;-1:-1:-1;;;11244:70:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;11333:23:0;;11325:71;;;;-1:-1:-1;;;11325:71:0;;;;;;;:::i;:::-;11409:47;11430:6;11438:9;11449:6;11409:20;:47::i;:::-;-1:-1:-1;;;;;11493:17:0;;11469:21;11493:17;;;:9;:17;;;;;;11529:23;;;;11521:74;;;;-1:-1:-1;;;11521:74:0;;;;;;;:::i;:::-;11626:22;11642:6;11626:13;:22;:::i;:::-;-1:-1:-1;;;;;11606:17:0;;;;;;;:9;:17;;;;;;:42;;;;11659:20;;;;;;;;:30;;11683:6;;11606:17;11659:30;;11683:6;;11659:30;:::i;:::-;;;;;;;;11724:9;-1:-1:-1;;;;;11707:35:0;11716:6;-1:-1:-1;;;;;11707:35:0;;11735:6;11707:35;;;;;;:::i;:::-;;;;;;;;11146:604;;;;:::o;37384:232::-;37477:41;37485:18;37498:4;37485:12;:18::i;:::-;37505:12;:10;:12::i;37477:41::-;37469:101;;;;-1:-1:-1;;;37469:101:0;;;;;;;:::i;38603:218::-;38710:12;:10;:12::i;:::-;-1:-1:-1;;;;;38699:23:0;:7;-1:-1:-1;;;;;38699:23:0;;38691:83;;;;-1:-1:-1;;;38691:83:0;;;;;;;:::i;:::-;38787:26;38799:4;38805:7;38787:11;:26::i;47319:158::-;47392:4;47416:53;47424:3;-1:-1:-1;;;;;47444:23:0;;47416:7;:53::i;29943:120::-;29487:8;:6;:8::i;:::-;29479:41;;;;-1:-1:-1;;;29479:41:0;;;;;;;:::i;:::-;30002:7:::1;:15:::0;;-1:-1:-1;;30002:15:0::1;::::0;;30033:22:::1;30042:12;:10;:12::i;:::-;30033:22;;;;;;:::i;:::-;;;;;;;;29943:120::o:0;12032:338::-;-1:-1:-1;;;;;12116:21:0;;12108:65;;;;-1:-1:-1;;;12108:65:0;;;;;;;:::i;:::-;12186:49;12215:1;12219:7;12228:6;12186:20;:49::i;:::-;12264:6;12248:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;12281:18:0;;;;;;:9;:18;;;;;:28;;12303:6;;12281:18;:28;;12303:6;;12281:28;:::i;:::-;;;;-1:-1:-1;;12325:37:0;;-1:-1:-1;;;;;12325:37:0;;;12342:1;;12325:37;;;;12355:6;;12325:37;:::i;:::-;;;;;;;;12032:338;;:::o;12703:494::-;-1:-1:-1;;;;;12787:21:0;;12779:67;;;;-1:-1:-1;;;12779:67:0;;;;;;;:::i;:::-;12859:49;12880:7;12897:1;12901:6;12859:20;:49::i;:::-;-1:-1:-1;;;;;12946:18:0;;12921:22;12946:18;;;:9;:18;;;;;;12983:24;;;;12975:71;;;;-1:-1:-1;;;12975:71:0;;;;;;;:::i;:::-;13078:23;13095:6;13078:14;:23;:::i;:::-;-1:-1:-1;;;;;13057:18:0;;;;;;:9;:18;;;;;:44;;;;13112:12;:22;;13128:6;;13057:18;13112:22;;13128:6;;13112:22;:::i;:::-;;;;-1:-1:-1;;13152:37:0;;13178:1;;-1:-1:-1;;;;;13152:37:0;;;;;;;13182:6;;13152:37;:::i;24035:1692::-;24133:4;24139:7;24185:1;24172:10;:14;24164:49;;;;-1:-1:-1;;;24164:49:0;;;;;;;:::i;:::-;24300:28;:18;:26;:28::i;:::-;24286:10;:42;;24278:84;;;;-1:-1:-1;;;24278:84:0;;;;;;;:::i;:::-;25501:13;25517:40;:9;25546:10;25517:28;:40::i;:::-;25583:20;;25501:56;;-1:-1:-1;25574:29:0;;25570:150;;;25628:5;25635:1;25620:17;;;;;;;25570:150;25678:4;25684:9;:16;;25701:5;25684:23;;;;;;-1:-1:-1;;;25684:23:0;;;;;;;;;;;;;;;;;25670:38;;;;;24035:1692;;;;;;:::o;29684:118::-;29210:8;:6;:8::i;:::-;29209:9;29201:38;;;;-1:-1:-1;;;29201:38:0;;;;;;;:::i;:::-;29744:7:::1;:14:::0;;-1:-1:-1;;29744:14:0::1;29754:4;29744:14;::::0;;29774:20:::1;29781:12;:10;:12::i;48277:158::-:0;48351:7;48402:22;48406:3;48418:5;48402:3;:22::i;22323:228::-;22370:7;22390:30;:18;:28;:30::i;:::-;22433:17;22453:28;:18;:26;:28::i;:::-;22433:48;;22497:19;22506:9;22497:19;;;;;;:::i;:::-;;;;;;;;22534:9;-1:-1:-1;22323:228:0;:::o;47816:117::-;47879:7;47906:19;47914:3;47906:7;:19::i;37861:235::-;37955:41;37963:18;37976:4;37963:12;:18::i;37955:41::-;37947:102;;;;-1:-1:-1;;;37947:102:0;;;;;;;:::i;39851:229::-;39926:22;39934:4;39940:7;39926;:22::i;:::-;39921:152;;39965:6;:12;;;;;;;;;;;-1:-1:-1;;;;;39965:29:0;;;;;;;;;:36;;-1:-1:-1;;39965:36:0;39997:4;39965:36;;;40048:12;:10;:12::i;:::-;-1:-1:-1;;;;;40021:40:0;40039:7;-1:-1:-1;;;;;40021:40:0;40033:4;40021:40;;;;;;;;;;39851:229;;:::o;42055:414::-;42118:4;42140:21;42150:3;42155:5;42140:9;:21::i;:::-;42135:327;;-1:-1:-1;42178:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;42361:18;;42339:19;;;:12;;;:19;;;;;;:40;;;;42394:11;;42135:327;-1:-1:-1;42445:5:0;42438:12;;32575:157;-1:-1:-1;;;;;;32684:40:0;;-1:-1:-1;;;32684:40:0;32575:157;;;:::o;55553:250::-;55751:44;55778:4;55784:2;55788:6;55751:26;:44::i;40088:230::-;40163:22;40171:4;40177:7;40163;:22::i;:::-;40159:152;;;40234:5;40202:12;;;;;;;;;;;-1:-1:-1;;;;;40202:29:0;;;;;;;;;:37;;-1:-1:-1;;40202:37:0;;;40286:12;:10;:12::i;:::-;-1:-1:-1;;;;;40259:40:0;40277:7;-1:-1:-1;;;;;40259:40:0;40271:4;40259:40;;;;;;;;;;40088:230;;:::o;42645:1544::-;42711:4;42850:19;;;:12;;;:19;;;;;;42886:15;;42882:1300;;43248:21;43272:14;43285:1;43272:10;:14;:::i;:::-;43321:18;;43248:38;;-1:-1:-1;43301:17:0;;43321:22;;43342:1;;43321:22;:::i;:::-;43301:42;;43588:17;43608:3;:11;;43620:9;43608:22;;;;;;-1:-1:-1;;;43608:22:0;;;;;;;;;;;;;;;;;43588:42;;43754:9;43725:3;:11;;43737:13;43725:26;;;;;;-1:-1:-1;;;43725:26:0;;;;;;;;;;;;;;;;;;:38;43857:17;:13;43873:1;43857:17;:::i;:::-;43831:23;;;;:12;;;:23;;;;;:43;43983:17;;43831:3;;43983:17;;;-1:-1:-1;;;43983:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;44078:3;:12;;:19;44091:5;44078:19;;;;;;;;;;;44071:26;;;44121:4;44114:11;;;;;;;;42882:1300;44165:5;44158:12;;;;;17901:114;17993:14;;17901:114::o;16151:918::-;16264:12;;16240:7;;16260:58;;-1:-1:-1;16305:1:0;16298:8;;16260:58;16371:12;;16330:11;;16396:424;16409:4;16403:3;:10;16396:424;;;16430:11;16444:23;16457:3;16462:4;16444:12;:23::i;:::-;16430:37;;16701:7;16688:5;16694:3;16688:10;;;;;;-1:-1:-1;;;16688:10:0;;;;;;;;;;;;;;;;;:20;16684:125;;;16736:3;16729:10;;16684:125;;;16786:7;:3;16792:1;16786:7;:::i;:::-;16780:13;;16684:125;16396:424;;;;16946:1;16940:3;:7;:36;;;;-1:-1:-1;16969:7:0;16951:5;16957:7;16963:1;16957:3;:7;:::i;:::-;16951:14;;;;;;-1:-1:-1;;;16951:14:0;;;;;;;;;;;;;;;;;:25;16940:36;16936:126;;;17000:7;17006:1;17000:3;:7;:::i;:::-;16993:14;;;;;;16936:126;-1:-1:-1;17047:3:0;-1:-1:-1;17040:10:0;;44943:204;45038:18;;45010:7;;45038:26;-1:-1:-1;45030:73:0;;;;-1:-1:-1;;;45030:73:0;;;;;;;:::i;:::-;45121:3;:11;;45133:5;45121:18;;;;;;-1:-1:-1;;;45121:18:0;;;;;;;;;;;;;;;;;45114:25;;44943:204;;;;:::o;18023:127::-;18112:19;;18130:1;18112:19;;;18023:127::o;44275:129::-;44348:4;44372:19;;;:12;;;;;:19;;;;;;:24;;;44275:129::o;30669:238::-;30778:44;30805:4;30811:2;30815:6;30778:26;:44::i;:::-;30844:8;:6;:8::i;:::-;30843:9;30835:64;;;;-1:-1:-1;;;30835:64:0;;;;;;;:::i;15350:193::-;15412:7;15533:1;15524:5;15533:1;15524;:5;:::i;:::-;15516;15520:1;15516;:5;:::i;:::-;:13;;;;:::i;:::-;15515:19;;;;:::i;:::-;15505:5;15509:1;15505;:5;:::i;:::-;15495;15499:1;15495;:5;:::i;:::-;15494:17;;;;:::i;:::-;:41;;;;:::i;23485:542::-;23592:44;23619:4;23625:2;23629:6;23592:26;:44::i;:::-;-1:-1:-1;;;;;23651:18:0;;23647:373;;23699:26;23722:2;23699:22;:26::i;:::-;23736:28;:26;:28::i;:::-;23647:373;;;-1:-1:-1;;;;;23784:16:0;;23780:240;;23830:28;23853:4;23830:22;:28::i;23780:240::-;23945:28;23968:4;23945:22;:28::i;:::-;23984:26;24007:2;25735:146;-1:-1:-1;;;;;25819:33:0;;;;;;:24;:33;;;;;25803:70;;25854:18;25844:7;25854:9;:18::i;:::-;25803:15;:70::i;25889:118::-;25946:53;25962:21;25985:13;:11;:13::i;26015:315::-;26110:17;26130:28;:18;:26;:28::i;:::-;26110:48;-1:-1:-1;26110:48:0;26173:30;26189:9;26173:15;:30::i;:::-;:42;26169:154;;;26232:29;;;;;;;;-1:-1:-1;26232:29:0;;;;;;;;;;;;;;26276:16;;;:35;;;;;;;;;;;;;;;26015:315::o;26338:212::-;26432:10;;26408:7;;26428:115;;-1:-1:-1;26471:1:0;26464:8;;26428:115;26516:10;;26512:3;;26516:14;;26529:1;;26516:14;:::i;:::-;26512:19;;;;;;-1:-1:-1;;;26512:19:0;;;;;;;;;;;;;;;;;26505:26;;;;14:175:1;84:20;;-1:-1:-1;;;;;133:31:1;;123:42;;113:2;;179:1;176;169:12;194:198;;306:2;294:9;285:7;281:23;277:32;274:2;;;327:6;319;312:22;274:2;355:31;376:9;355:31;:::i;397:274::-;;;526:2;514:9;505:7;501:23;497:32;494:2;;;547:6;539;532:22;494:2;575:31;596:9;575:31;:::i;:::-;565:41;;625:40;661:2;650:9;646:18;625:40;:::i;:::-;615:50;;484:187;;;;;:::o;676:342::-;;;;822:2;810:9;801:7;797:23;793:32;790:2;;;843:6;835;828:22;790:2;871:31;892:9;871:31;:::i;:::-;861:41;;921:40;957:2;946:9;942:18;921:40;:::i;:::-;911:50;;1008:2;997:9;993:18;980:32;970:42;;780:238;;;;;:::o;1023:266::-;;;1152:2;1140:9;1131:7;1127:23;1123:32;1120:2;;;1173:6;1165;1158:22;1120:2;1201:31;1222:9;1201:31;:::i;:::-;1191:41;1279:2;1264:18;;;;1251:32;;-1:-1:-1;;;1110:179:1:o;1294:190::-;;1406:2;1394:9;1385:7;1381:23;1377:32;1374:2;;;1427:6;1419;1412:22;1374:2;-1:-1:-1;1455:23:1;;1364:120;-1:-1:-1;1364:120:1:o;1489:266::-;;;1618:2;1606:9;1597:7;1593:23;1589:32;1586:2;;;1639:6;1631;1624:22;1586:2;1680:9;1667:23;1657:33;;1709:40;1745:2;1734:9;1730:18;1709:40;:::i;1760:258::-;;;1889:2;1877:9;1868:7;1864:23;1860:32;1857:2;;;1910:6;1902;1895:22;1857:2;-1:-1:-1;;1938:23:1;;;2008:2;1993:18;;;1980:32;;-1:-1:-1;1847:171:1:o;2023:306::-;;2134:2;2122:9;2113:7;2109:23;2105:32;2102:2;;;2155:6;2147;2140:22;2102:2;2186:23;;-1:-1:-1;;;;;;2238:32:1;;2228:43;;2218:2;;2290:6;2282;2275:22;2529:203;-1:-1:-1;;;;;2693:32:1;;;;2675:51;;2663:2;2648:18;;2630:102::o;2737:187::-;2902:14;;2895:22;2877:41;;2865:2;2850:18;;2832:92::o;2929:177::-;3075:25;;;3063:2;3048:18;;3030:76::o;3111:603::-;;3252:2;3281;3270:9;3263:21;3313:6;3307:13;3356:6;3351:2;3340:9;3336:18;3329:34;3381:4;3394:140;3408:6;3405:1;3402:13;3394:140;;;3503:14;;;3499:23;;3493:30;3469:17;;;3488:2;3465:26;3458:66;3423:10;;3394:140;;;3552:6;3549:1;3546:13;3543:2;;;3622:4;3617:2;3608:6;3597:9;3593:22;3589:31;3582:45;3543:2;-1:-1:-1;3698:2:1;3677:15;-1:-1:-1;;3673:29:1;3658:45;;;;3705:2;3654:54;;3232:482;-1:-1:-1;;;3232:482:1:o;3719:352::-;3921:2;3903:21;;;3960:2;3940:18;;;3933:30;3999;3994:2;3979:18;;3972:58;4062:2;4047:18;;3893:178::o;4076:353::-;4278:2;4260:21;;;4317:2;4297:18;;;4290:30;4356:31;4351:2;4336:18;;4329:59;4420:2;4405:18;;4250:179::o;4434:398::-;4636:2;4618:21;;;4675:2;4655:18;;;4648:30;4714:34;4709:2;4694:18;;4687:62;-1:-1:-1;;;4780:2:1;4765:18;;4758:32;4822:3;4807:19;;4608:224::o;4837:399::-;5039:2;5021:21;;;5078:2;5058:18;;;5051:30;5117:34;5112:2;5097:18;;5090:62;-1:-1:-1;;;5183:2:1;5168:18;;5161:33;5226:3;5211:19;;5011:225::o;5241:411::-;5443:2;5425:21;;;5482:2;5462:18;;;5455:30;5521:34;5516:2;5501:18;;5494:62;-1:-1:-1;;;5587:2:1;5572:18;;5565:45;5642:3;5627:19;;5415:237::o;5657:344::-;5859:2;5841:21;;;5898:2;5878:18;;;5871:30;-1:-1:-1;;;5932:2:1;5917:18;;5910:50;5992:2;5977:18;;5831:170::o;6006:398::-;6208:2;6190:21;;;6247:2;6227:18;;;6220:30;6286:34;6281:2;6266:18;;6259:62;-1:-1:-1;;;6352:2:1;6337:18;;6330:32;6394:3;6379:19;;6180:224::o;6409:398::-;6611:2;6593:21;;;6650:2;6630:18;;;6623:30;6689:34;6684:2;6669:18;;6662:62;-1:-1:-1;;;6755:2:1;6740:18;;6733:32;6797:3;6782:19;;6583:224::o;6812:350::-;7014:2;6996:21;;;7053:2;7033:18;;;7026:30;7092:28;7087:2;7072:18;;7065:56;7153:2;7138:18;;6986:176::o;7167:402::-;7369:2;7351:21;;;7408:2;7388:18;;;7381:30;7447:34;7442:2;7427:18;;7420:62;-1:-1:-1;;;7513:2:1;7498:18;;7491:36;7559:3;7544:19;;7341:228::o;7574:350::-;7776:2;7758:21;;;7815:2;7795:18;;;7788:30;7854:28;7849:2;7834:18;;7827:56;7915:2;7900:18;;7748:176::o;7929:412::-;8131:2;8113:21;;;8170:2;8150:18;;;8143:30;8209:34;8204:2;8189:18;;8182:62;-1:-1:-1;;;8275:2:1;8260:18;;8253:46;8331:3;8316:19;;8103:238::o;8346:340::-;8548:2;8530:21;;;8587:2;8567:18;;;8560:30;-1:-1:-1;;;8621:2:1;8606:18;;8599:46;8677:2;8662:18;;8520:166::o;8691:404::-;8893:2;8875:21;;;8932:2;8912:18;;;8905:30;8971:34;8966:2;8951:18;;8944:62;-1:-1:-1;;;9037:2:1;9022:18;;9015:38;9085:3;9070:19;;8865:230::o;9100:400::-;9302:2;9284:21;;;9341:2;9321:18;;;9314:30;9380:34;9375:2;9360:18;;9353:62;-1:-1:-1;;;9446:2:1;9431:18;;9424:34;9490:3;9475:19;;9274:226::o;9505:397::-;9707:2;9689:21;;;9746:2;9726:18;;;9719:30;9785:34;9780:2;9765:18;;9758:62;-1:-1:-1;;;9851:2:1;9836:18;;9829:31;9892:3;9877:19;;9679:223::o;9907:401::-;10109:2;10091:21;;;10148:2;10128:18;;;10121:30;10187:34;10182:2;10167:18;;10160:62;-1:-1:-1;;;10253:2:1;10238:18;;10231:35;10298:3;10283:19;;10081:227::o;10313:400::-;10515:2;10497:21;;;10554:2;10534:18;;;10527:30;10593:34;10588:2;10573:18;;10566:62;-1:-1:-1;;;10659:2:1;10644:18;;10637:34;10703:3;10688:19;;10487:226::o;10718:346::-;10920:2;10902:21;;;10959:2;10939:18;;;10932:30;-1:-1:-1;;;10993:2:1;10978:18;;10971:52;11055:2;11040:18;;10892:172::o;11069:401::-;11271:2;11253:21;;;11310:2;11290:18;;;11283:30;11349:34;11344:2;11329:18;;11322:62;-1:-1:-1;;;11415:2:1;11400:18;;11393:35;11460:3;11445:19;;11243:227::o;11475:411::-;11677:2;11659:21;;;11716:2;11696:18;;;11689:30;11755:34;11750:2;11735:18;;11728:62;-1:-1:-1;;;11821:2:1;11806:18;;11799:45;11876:3;11861:19;;11649:237::o;11891:355::-;12093:2;12075:21;;;12132:2;12112:18;;;12105:30;12171:33;12166:2;12151:18;;12144:61;12237:2;12222:18;;12065:181::o;12251:406::-;12453:2;12435:21;;;12492:2;12472:18;;;12465:30;12531:34;12526:2;12511:18;;12504:62;-1:-1:-1;;;12597:2:1;12582:18;;12575:40;12647:3;12632:19;;12425:232::o;12844:184::-;13016:4;13004:17;;;;12986:36;;12974:2;12959:18;;12941:87::o;13033:128::-;;13104:1;13100:6;13097:1;13094:13;13091:2;;;13110:18;;:::i;:::-;-1:-1:-1;13146:9:1;;13081:80::o;13166:120::-;;13232:1;13222:2;;13237:18;;:::i;:::-;-1:-1:-1;13271:9:1;;13212:74::o;13291:125::-;;13359:1;13356;13353:8;13350:2;;;13364:18;;:::i;:::-;-1:-1:-1;13401:9:1;;13340:76::o;13421:380::-;13506:1;13496:12;;13553:1;13543:12;;;13564:2;;13618:4;13610:6;13606:17;13596:27;;13564:2;13671;13663:6;13660:14;13640:18;13637:38;13634:2;;;13717:10;13712:3;13708:20;13705:1;13698:31;13752:4;13749:1;13742:15;13780:4;13777:1;13770:15;13634:2;;13476:325;;;:::o;13806:112::-;;13864:1;13854:2;;13869:18;;:::i;:::-;-1:-1:-1;13903:9:1;;13844:74::o;13923:127::-;13984:10;13979:3;13975:20;13972:1;13965:31;14015:4;14012:1;14005:15;14039:4;14036:1;14029:15;14055:127;14116:10;14111:3;14107:20;14104:1;14097:31;14147:4;14144:1;14137:15;14171:4;14168:1;14161:15

Swarm Source

ipfs://f77dd7f3fb8ea9051e365b0561744603c258b6a67fe12fbb73f31bc8904c8668

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