Contract 0x722c4ce1b280eea949fee0096140852deaef6bbd

Txn Hash Method
Block
From
To
Value [Txn Fee]
0x68938d9d10c7d3266569c238359b72e9316b7ed2c4e7cb863d9b3a8f50db5c8eTransfer141001352022-04-30 16:39:19271 days 4 hrs ago0xdd027531890eb9c6b5b9cdff779e688bb0ef0212 IN  0x722c4ce1b280eea949fee0096140852deaef6bbd0 AVAX0.00175410669938.318515836
0x46c98e0d7914dafe8cb261df22ee282a1cf2b43b6e9e378cde49f858fd0dd9a2Transfer141000822022-04-30 16:37:29271 days 4 hrs ago0xdd027531890eb9c6b5b9cdff779e688bb0ef0212 IN  0x722c4ce1b280eea949fee0096140852deaef6bbd0 AVAX0.00244824830138.951972081
0x7ecf60b19d654fa55fff731c33ebe10603dc7250cad59bc5f52e33bd5646c6f5Transfer136259922022-04-19 13:58:54282 days 7 hrs ago0x2300655255e80eab7b73dab3a41dd5b263bbdd03 IN  0x722c4ce1b280eea949fee0096140852deaef6bbd0 AVAX0.006152581499 97.832395164
0xdc3409c0c21cc2b67f2c6a70c25ba7ea972663c1e48b66729e75f145e4088bdeTransfer134629332022-04-15 19:10:18286 days 2 hrs ago0xebde459b6bd72b3577a05a4dddc7f729cab0b45f IN  0x722c4ce1b280eea949fee0096140852deaef6bbd0 AVAX0.0024879955354.350340361
0x164b0d783d0e63f7c65be42e3b8da98f26fae41543f15766c5a2d570594ad2e3Transfer133720682022-04-13 16:22:12288 days 4 hrs ago0xfa6e48965242b48fddf8fb7f5b4e0455eb6e42c4 IN  0x722c4ce1b280eea949fee0096140852deaef6bbd0 AVAX0.004342374883 94.85931545
0x095536ce39314131f3a5d8b78010fb9f999ef9aa78d65c6bc505fc5baab04857Transfer130282952022-04-05 15:01:40296 days 6 hrs ago0x15b09bcce3028d02df64bb9b6c5da05bf77013e1 IN  0x722c4ce1b280eea949fee0096140852deaef6bbd0 AVAX0.006414999239 102.024575592
0x7c96fba55b9260830ef3d8346808678c9ceb1b8f74b8d1c43d0e0fcb57c0d967Transfer129917742022-04-04 17:36:32297 days 3 hrs ago0xcf33beefd51e8eb2b7443be609a32f3b84acf5b5 IN  0x722c4ce1b280eea949fee0096140852deaef6bbd0 AVAX0.003691870005 80.649015999
0xdd265eb049a78327e3be483480a4e0f2ba80ae0bbe7bd10ce82a1ddc07e641fdTransfer128525132022-04-01 10:25:53300 days 10 hrs ago0xc2b0ec214244fd6867f86359fd93cab5f01e9008 IN  0x722c4ce1b280eea949fee0096140852deaef6bbd0 AVAX0.001286011867 28.11446521
0xd7949a10082800521d7662fc33ce60d8030a8ea848e958fef54aba3b5af65748Transfer128394302022-04-01 3:01:37300 days 18 hrs ago0xe04c96b970e7b7b6c2a96431179fcb8f09d03038 IN  0x722c4ce1b280eea949fee0096140852deaef6bbd0 AVAX0.006251206927 99.493982617
0x89ac4bc149f8dcb5e6c9502e1338e6567a0e5daba8c3800d746a4c0a53514a63Transfer128212122022-03-31 16:47:41301 days 4 hrs ago0xae9b2e1b0452d43c072f75d5cc13a1c005a18d5d IN  0x722c4ce1b280eea949fee0096140852deaef6bbd0 AVAX0.004697512779 102.668898441
0xc8936e7246b4be88ff385c0577b02887831d816279d74d0d9df72570a6284b1bTransfer128177592022-03-31 14:51:03301 days 6 hrs ago0xa27c31b1cb47f31c91027551ad74e585d020bf09 IN  0x722c4ce1b280eea949fee0096140852deaef6bbd0 AVAX0.00611313193 133.643739459
0x98d0c2c438a294995af8e7328f5d4f03f7bb95f4518eb29ecd7ce5ca8105d0090x60806040127308902022-03-29 13:51:20303 days 7 hrs ago0x77bc5bac6d3590a41e475684c85693aa1f31b244 IN  Create: TokenS4200 AVAX0.10429418309 82.548576643
[ Download CSV Export 
Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
TokenS420

Compiler Version
v0.8.9+commit.e5eed63a

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at snowtrace.io on 2022-03-30
*/

pragma solidity 0.8.9;

// SPDX-License-Identifier: MIT

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

/**
 * @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 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 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:
     *
     * - `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");
        unchecked {
            _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");
        unchecked {
            _approve(_msgSender(), 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:
     *
     * - `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");
        unchecked {
            _balances[sender] = senderBalance - amount;
        }
        _balances[recipient] += amount;

        emit Transfer(sender, recipient, amount);

        _afterTokenTransfer(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:
     *
     * - `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 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 {}
}

/**
 *  @title  DAO Manager Interface
 *
 *  @author 420 DAO Team
 *
 *  @notice Interface of `DaoManager` to be used commonly by multiple other smart contracts.
 *  @notice This interface includes function to get these global properties of the DAO:
 *          - Admin address of the DAO
 *          - Current day
 *          - New tokens emission termination
 *          - Migration status
 */
interface IDaoManager {
    /**
     *  @notice Get the the admin address of the DAO.
     */
    function admin() external view returns (address);

    /**
     *  @notice Get the current day of the DAO.
     */
    function day() external view returns (uint256);

    /**
     *  @notice Check if the DAO has stopped emitting new tokens.
     *
     *  @dev    Once the total supply of Token 420 surpasses the maximum cap, the DAO will stop minting or emitting any
     *          new tokens. Thenceforth, users won't be able to deposit or receive staking rewards anymore.
     */
    function emissionTerminated() external view returns (bool);

    /**
     *  @dev    In order to migrate the DAO system, two stages must be taking place sequentially:
     *          1. Admin switches the DAO state from normal to preparative. The entire community can notice it is the
     *          last day running on the current system as the function `isGoingToMigrate()` will be returning true.
     *          2. When that last auction is ended, the DAO state will be switched from preparative to migrated and the
     *          current system will be frozen permanently. Every method on the old DAO will be blocked and replaced by
     *          new ones on a new DAO with one exception which is the function `withdraw()` of `AuctionManager` can
     *          still be called by users to collect the remaining tokens from ended auctions.
     */

    /**
     *  @notice Check if the DAO is preparing for migration.
     */
    function isGoingToMigrate() external view returns (bool);

    /**
     *  @notice Check if the migration has been done and DAO is blocked permanently.
     */
    function isBlockedForMigration() external view returns (bool);

}

/// @title Contains 512-bit math functions
/// @notice Facilitates multiplication and division that can have overflow of an intermediate value without any loss of precision
/// @dev Handles "phantom overflow" i.e., allows multiplication and division where an intermediate value overflows 256 bits
library MulDiv {
    /// @notice Calculates floor(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
    /// @param a The multiplicand
    /// @param b The multiplier
    /// @param denominator The divisor
    /// @return result The 256-bit result
    /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv
    function mulDiv(
        uint256 a,
        uint256 b,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = a * b
            // Compute the product mod 2**256 and mod 2**256 - 1
            // then use the Chinese Remainder Theorem to reconstruct
            // the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2**256 + prod0
            uint256 prod0; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(a, b, not(0))
                prod0 := mul(a, b)
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division
            if (prod1 == 0) {
                require(denominator > 0);
                assembly {
                    result := div(prod0, denominator)
                }
                return result;
            }

            // Make sure the result is less than 2**256.
            // Also prevents denominator == 0
            require(denominator > prod1);

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0]
            // Compute remainder using mulmod
            uint256 remainder;
            assembly {
                remainder := mulmod(a, b, denominator)
            }
            // Subtract 256 bit number from 512 bit number
            assembly {
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator
            // Compute largest power of two divisor of denominator.
            // Always >= 1.
            uint256 twos = (~denominator + 1) & denominator;
            // Divide denominator by power of two
            assembly {
                denominator := div(denominator, twos)
            }

            // Divide [prod1 prod0] by the factors of two
            assembly {
                prod0 := div(prod0, twos)
            }
            // Shift in bits from prod1 into prod0. For this we need
            // to flip `twos` such that it is 2**256 / twos.
            // If twos is zero, then it becomes one
            assembly {
                twos := add(div(sub(0, twos), twos), 1)
            }
            prod0 |= prod1 * twos;

            // Invert denominator mod 2**256
            // Now that denominator is an odd number, it has an inverse
            // modulo 2**256 such that denominator * inv = 1 mod 2**256.
            // Compute the inverse by starting with a seed that is correct
            // correct for four bits. That is, denominator * inv = 1 mod 2**4
            uint256 inv = (3 * denominator) ^ 2;
            // Now use Newton-Raphson iteration to improve the precision.
            // Thanks to Hensel's lifting lemma, this also works in modular
            // arithmetic, doubling the correct bits in each step.
            inv *= 2 - denominator * inv; // inverse mod 2**8
            inv *= 2 - denominator * inv; // inverse mod 2**16
            inv *= 2 - denominator * inv; // inverse mod 2**32
            inv *= 2 - denominator * inv; // inverse mod 2**64
            inv *= 2 - denominator * inv; // inverse mod 2**128
            inv *= 2 - denominator * inv; // inverse mod 2**256

            // Because the division is now exact we can divide by multiplying
            // with the modular inverse of denominator. This will give us the
            // correct result modulo 2**256. Since the preconditions guarantee
            // that the outcome is less than 2**256, this is the final result.
            // We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inv;
        }
        return result;
    }

    /// @notice Calculates ceil(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
    /// @param a The multiplicand
    /// @param b The multiplier
    /// @param denominator The divisor
    /// @return result The 256-bit result
    function mulDivRoundingUp(
        uint256 a,
        uint256 b,
        uint256 denominator
    ) internal pure returns (uint256 result) {
        result = mulDiv(a, b, denominator);
        if (mulmod(a, b, denominator) > 0) {
            require(result < type(uint256).max);
            result++;
        }
    }
}

/**
 *  @title  Fixed
 *
 *  @author 420 DAO Team
 *
 *  @notice This struct displays a unsigned fixed-point decimal number.
 */
struct Fixed {
    /**
     *  @dev    The property `value` has 256 bits whose 128 first bits contain the integer part and 128 last bits contain
     *          the fractional part. In other words, `value` will be the truncation of the original decimal times 2^128.
     *  @dev    Its integer part can't also be greater than 2^128.
     */
    uint256 value;
}

/**
 *  @title  Fixed Math
 *
 *  @author 420 DAO Team
 *
 *  @notice This library provides basic operators of `Fixed` utilizing the library `MulDiv`.
 *
 *  @dev    Any of these function can cause revert if the result exceeds `Fixed` boundary.
 */
library FixedMath {
    /**
     *  @notice Quotient of `Fixed`.
     *
     *  @dev    Q = 2^128.
     */
    uint256 private constant Q = 0x100000000000000000000000000000000;

    /**
     *  @notice Get number 1 as `Fixed`.
     *
     *  @dev    Its `value` is equal to `Q`.
     */
    function one() internal pure returns (Fixed memory) {
        return Fixed(Q);
    }

    /**
     *  @notice Get `Fixed` instance of an `uint256`.
     */
    function intToFixed(uint256 _x) internal pure returns (Fixed memory) {
        return Fixed(_x * Q);
    }

    /**
     *  @notice Get truncated value from a `Fixed`.
     */
    function fixedToInt(Fixed memory _x) internal pure returns (uint256) {
        return _x.value / Q;
    }

    /**
     *  @notice Comparison
     *
     *  @dev    Comparison  Result
     *          x < y       -1
     *          x = y       0
     *          x > y       1
     */
    function compare(Fixed memory _x, Fixed memory _y) internal pure returns (int256) {
        if (_x.value < _y.value) return -1;
        if (_x.value > _y.value) return 1;
        return 0;
    }

    /**
     *  @notice Addition
     */
    function add(Fixed memory _a, Fixed memory _b) internal pure returns (Fixed memory) {
        return Fixed(_a.value + _b.value);
    }

    /**
     *  @notice Subtraction
     */
    function subtract(Fixed memory _a, Fixed memory _b) internal pure returns (Fixed memory) {
        return Fixed(_a.value - _b.value);
    }

    /**
     *  @notice Multiplication
     */
    function multiply(Fixed memory _a, Fixed memory _b) internal pure returns (Fixed memory) {
        return Fixed(MulDiv.mulDiv(_a.value, _b.value, Q));
    }

    function multiply(Fixed memory _a, uint256 _b) internal pure returns (Fixed memory) {
        return Fixed(_a.value * _b);
    }

    function multiply(uint256 _a, Fixed memory _b) internal pure returns (Fixed memory) {
        return Fixed(_a * _b.value);
    }

    function multiplyTruncating(Fixed memory _a, uint256 _b) internal pure returns (uint256) {
        return MulDiv.mulDiv(_a.value, _b, Q);
    }

    function multiplyTruncating(uint256 _a, Fixed memory _b) internal pure returns (uint256) {
        return MulDiv.mulDiv(_a, _b.value, Q);
    }

    /**
     *  @notice Division
     */
    function divide(Fixed memory _a, Fixed memory _b) internal pure returns (Fixed memory) {
        require(_b.value != 0, "FixedMath: Division by zero.");
        return Fixed(MulDiv.mulDiv(_a.value, Q, _b.value));
    }

    function divide(uint256 _a, uint256 _b) internal pure returns (Fixed memory) {
        require(_b != 0, "FixedMath: Division by zero.");
        return Fixed(MulDiv.mulDiv(_a, Q, _b));
    }

    function divide(Fixed memory _a, uint256 _b) internal pure returns (Fixed memory) {
        require(_b != 0, "FixedMath: Division by zero.");
        return Fixed(_a.value / _b);
    }
}

/**
 *  @title  Staking Pool Interface
 *
 *  @author 420 DAO Team
 *
 *  @notice Interface of `StakingPool` to be used in `TokenS420`.
 *  @notice This interface includes functions:
 *          - Get the address of the DAO manager
 *          - Convert between discount factors and staking tokens
 *          - Transfer all token 420 to a new Staking Pool in case of migration
 */
interface IStakingPool {
    /**
     *  @notice Get the address of the DAO Manager.
     */
    function daoAddress() external view returns (address);

    /**
     *  @notice Convert an token amount to the corresponding amount of discount factor.
     */
    function tokenToDiscountFactor(uint256 _token) external view returns (Fixed memory);

    /**
     *  @notice Convert an amount of discount factor to the corresponding token amount.
     */
    function discountFactorToToken(Fixed memory _discountFactor) external view returns (uint256);

    /**
     *  @notice Transfer all token 420 belongs to the current Staking Pool to a new one in case of migration.
     */
    function upgradeTo(address _newAddress) external;
}

/**
 *  @title  Constant
 *
 *  @author 420 DAO Team
 *
 *  @notice This library provides most of constants used in smart contracts among the project.
 */
library Constant {
    /**
     *  @notice Refer to how divisible one token 420 or s420 can be.
     */
    uint8   internal constant TOKEN_DECIMALS = 18;
    uint256 internal constant TOKEN_SCALE = 10**TOKEN_DECIMALS;

    /**
     *  @notice Once total supply surpassed this threshold, auction will stop permanently.
     *          The threshold is 420 million tokens.
     */
    uint256 internal constant TOKEN_MAX_SUPPLY_THRESHOLD = 420000000 * TOKEN_SCALE;

    /**
     *  @notice Cash come to the Treasury are split as following:
     *          - Asset Fund:     50%
     *          - Insurance Fund: 30%
     *          - Operation Fund: 20%
     */
    uint256 internal constant TREASURY_PERCENTAGE_ASSET     = 50;
    uint256 internal constant TREASURY_PERCENTAGE_INSURANCE = 30;

    /**
     *  @notice Tokens come to the Mirror Pool are split as following:
     *          - Development & Marketing: 30%
     *          - Early Supporters:        10%
     *          - Reservation:             60%
     */
    uint256 internal constant MIRROR_PERCENTAGE_EARLY_SUPPORTERS = 10;
    uint256 internal constant MIRROR_PERCENTAGE_RESERVATION      = 60;

    /**
     *  @notice Formula of the staking fee: (1 - i / 787) * 42%
     */
    uint256 internal constant STAKING_FEE_CONVERGENCE_DAY = 787;
    uint256 internal constant STAKING_FEE_BASE_PERCENTAGE = 42;

    /**
     *  @notice Formula of the soft floor price in auctions: 2 * A / Q / 80%
     *          80% is sum of asset fund percentage and insurance fund percentage in the Treasury.
     */
    uint256 internal constant AUCTION_SOFT_FLOOR_PRICE_COEFFICIENT = 200;

    /**
     *  @notice The maximum tokens sold and the maximum cash a member of the whitelist can pay to buy during the
     *          whitelist campaign.
     */
    uint256 public constant WHITELIST_TOKEN_AMOUNT = 50000;
    uint256 public constant WHITELIST_MAX_CASH = 500;
}

/**
 *  @title  Double Halving
 *
 *  @author 420 DAO Team
 *
 *  @notice This library defines the mechanism of each token inflation phase of the DAO. There are 5 phases. The first
 *          phase lasts 420 days, emits at most 100,000 tokens in each auction and rewards at most 220,000 tokens (not
 *          including fee) for stakeholders each day. The next 3 phases sequentially remains half in duration, auction
 *          emission and staking reward, compared to each previous one. The fifth phase has the same auction emission
 *          and staking reward as the fourth but lasts as long as the total supply has never surpassed the maximum
 *          threshold.
 *  @notice Despite having a difference in staking fee, the fourth phase and the fifth phases can be considered the same
 *          for the implementation here.
 */
library DoubleHalving {
    /**
     *  @notice The last date of each phase.
     *          Phase   Duration    Last date
     *          1       420         420
     *          2       210         630
     *          3       105         735
     */
    uint256 internal constant PHASE_1 =  420;
    uint256 internal constant PHASE_2 =  630;
    uint256 internal constant PHASE_3 =  735;

    /**
     *  @notice The maximum token amount emitted to each auction.
     */
    uint256 internal constant AUCTION_EMISSION_1 = 100000;
    uint256 internal constant AUCTION_EMISSION_2 =  50000;
    uint256 internal constant AUCTION_EMISSION_3 =  25000;
    uint256 internal constant AUCTION_EMISSION_4 =  12500;

    /**
     *  @notice The maximum amount of staking reward each day.
     */
    uint256 internal constant STAKING_REWARD_1 = 220000;
    uint256 internal constant STAKING_REWARD_2 = 110000;
    uint256 internal constant STAKING_REWARD_3 =  55000;
    uint256 internal constant STAKING_REWARD_4 =  27000;

    /**
     *  @notice Get the maximum auction emission and the staking reward of a certain day.
     *          Type: tuple(int, int)
     *          Usage: DaoManager
     *
     *          Name    Meaning
     *  @param  _day    The day to query with
     */
    function tokenInflationOf(uint256 _day) internal pure returns (uint256, uint256) {
        if (_day <= PHASE_1) return (AUCTION_EMISSION_1 * Constant.TOKEN_SCALE, STAKING_REWARD_1 * Constant.TOKEN_SCALE);
        if (_day <= PHASE_2) return (AUCTION_EMISSION_2 * Constant.TOKEN_SCALE, STAKING_REWARD_2 * Constant.TOKEN_SCALE);
        if (_day <= PHASE_3) return (AUCTION_EMISSION_3 * Constant.TOKEN_SCALE, STAKING_REWARD_3 * Constant.TOKEN_SCALE);
        return (AUCTION_EMISSION_4 * Constant.TOKEN_SCALE, STAKING_REWARD_4 * Constant.TOKEN_SCALE);
    }
}

/**
 *  @title  Formula
 *
 *  @author 420 DAO Team
 *
 *  @notice Each function of this library is the implementation of a featured mathematical formula used in the system.
 */
library Formula {
    using FixedMath for Fixed;
    using FixedMath for uint256;

    /**
     *  @notice Calculate the truncated value of a certain portion of an integer amount.
     *          Formula:    truncate(x / y * a)
     *          Type:       int
     *          Usage:      AuctionManager, MirrorPool, TreasuryManager
     *
     *  @dev    The proportion (x / y) must be less than or equal to 1.
     *
     *          Name    Symbol  Type    Meaning
     *  @param  _x      x       int     Numerator of the proportion
     *  @param  _y      y       int     Denominator of the proportion
     *  @param  _a      a       int     Whole amount
     */
    function portion(uint256 _x, uint256 _y, uint256 _a) internal pure returns (uint256 res) {
        require(_x <= _y, "Formula: The proportion must be less than or equal to 1.");
        Fixed memory proportion = _x.divide(_y);
        res = _a.multiplyTruncating(proportion);
    }

    /**
     *  @notice Calculate the staking fee rate of a certain day before the fee converges and becomes unchangeable.
     *          Formula:    (1 - i / 787) * 42%
     *          Type:       dec
     *          Usage:      StakingPool
     *
     *  @dev    The day (i) must be less than or equal to the convergent day.
     *  @dev    Constant: STAKING_FEE_CONVERGENCE_DAY = 787
     *  @dev    Constant: STAKING_FEE_BASE_PERCENTAGE = 42
     *
     *          Name    Symbol  Type    Meaning
     *  @param  _day    i       int     integer Day to calculate fee
     */
    function earlyFeeRate(uint256 _day) internal pure returns (Fixed memory res) {
        require(
            _day <= Constant.STAKING_FEE_CONVERGENCE_DAY,
            "Formula: The day is greater than the convergent day."
        );
        // (1 - i / 787) * 42% = (787 - i) * 42 / 78700
        res = FixedMath.divide(
            (Constant.STAKING_FEE_CONVERGENCE_DAY - _day) * Constant.STAKING_FEE_BASE_PERCENTAGE,
            Constant.STAKING_FEE_CONVERGENCE_DAY * 100
        );
    }

    /**
     *  @notice Calculate the accumulated interest rate in the staking pool when an amount of staking reward is emitted.
     *          Formula:    P * (1 + r / a)
     *          Type:       dec
     *          Usage:      StakingPool
     *
     *          Name                    Symbol  Type    Meaning
     *  @param  _productOfInterestRate  P       dec     Accumulated interest rate in the staking pool
     *  @param  _reward                 r       int     Staking reward
     *  @param  _totalCapital           a       int     Total staked capital
     */
    function newProductOfInterestRate(
        Fixed memory _productOfInterestRate,
        uint256 _reward,
        uint256 _totalCapital
    ) internal pure returns (Fixed memory res) {
        Fixed memory interestRate = FixedMath.one().add(_reward.divide(_totalCapital));
        res = _productOfInterestRate.multiply(interestRate);
    }

    /**
     *  @notice Calculate the minimum price of token that the auction must surpass to emit maximum token of the day.
     *          Formula:    2 * A / Q / 80%
     *          Type:       int
     *          Usage:      StakingPool
     *
     *  @dev    Constant: AUCTION_SOFT_FLOOR_PRICE_COEFFICIENT = 200
     *  @dev    Constant: TREASURY_PERCENTAGE_ASSET = 50
     *  @dev    Constant: TREASURY_PERCENTAGE_INSURANCE = 30
     *
     *          Name            Symbol  Type    Meaning
     *  @param  _communityAsset A       int     Total value of the asset fund and the insurance fund in the treasury
     *  @param  _totalSupply    Q       int     Total circulating supply of the token
     */
    function softFloorPrice(
        uint256 _communityAsset,
        uint256 _totalSupply
    ) internal pure returns (Fixed memory res) {
        if (_totalSupply == 0) return Fixed(0);
        // 2 * A / Q / 80% = (200 * A) / (80 * Q)
        res = FixedMath.divide(
            Constant.AUCTION_SOFT_FLOOR_PRICE_COEFFICIENT * _communityAsset,
            (Constant.TREASURY_PERCENTAGE_ASSET + Constant.TREASURY_PERCENTAGE_INSURANCE) * _totalSupply
        );
    }
}

/**
 *  @title  Permission
 *
 *  @author 420 DAO Team
 *
 *  @notice This abstract contract provides a modifier to restrict the permission of functions.
 */
abstract contract Permission {
    modifier permittedTo(address _account) {
        require(msg.sender == _account, "Permission: Unauthorized.");
        _;
    }
}

/**
 *  @title  Token S420
 *
 *  @author 420 DAO Team
 *
 *  @notice Token 420 is fully conformed to the ERC-20 with the remarkable feature of globally inflating the balance of
 *          each token owner.
 *          The token is integrated with the Staking Pool as well as the whole 420 DAO system.
 *
 *  @dev    This contract derives from the implementation of ERC-20 of OpenZeppelin.
 */
contract TokenS420 is ERC20, Permission {
    IStakingPool public pStaking;

    /**
     *  @notice The significant intrinsic value of each address represents its stake in the whole circulating supply of
     *          the token. The distribution of token balances among addresses are proportional to their discount
     *          factors. The ratio between the discount factor and the real balance is the accumulated of the interest
     *          rate from the Staking Pool.
     */
    mapping(address => Fixed) public discountFactors;

    /**
     *  @notice Total minted discount factor.
     */
    Fixed public totalDiscountFactor;

    event StakingPoolRegistration(address indexed account);
    event StakingPoolUpgrade(address indexed oldAddress, address indexed newAddress);
    event DiscountFactorTransfer(address indexed from, address indexed to, Fixed value);
    event DiscountFactorMint(address indexed account, Fixed value);
    event DiscountFactorBurn(address indexed account, Fixed value);

    /**
     *  @dev    Apply the constructor of the superclass contract `ERC20`.
     *          Name:     "Stake s420"
     *          Symbol:   "s420"
     */
    constructor() ERC20("Stake s420", "s420") {}

    /**
     *  @notice Register a DAO Manager for some restricted function.
     *
     *  @dev    This can only be called once.
     */
    function registerStakingPool() external {
        require(address(pStaking) == address(0), "TokenS420: Staking Pool has already been registered.");
        pStaking = IStakingPool(msg.sender);
        emit StakingPoolRegistration(address(pStaking));
    }

    /**
     *  @notice Migrate to a new DAO Manager.
     *
     *  @dev    Only the DAO admin can call this function.
     *
     *          Name            Meaning
     *  @param  _newStakingPool Address of the new Staking Pool
     */
    function upgradeStakingPool(IStakingPool _newStakingPool) external {
        IDaoManager dao = IDaoManager(pStaking.daoAddress());
        require(msg.sender == dao.admin(), "Permission: Unauthorized.");
        require(dao.isBlockedForMigration(), "TokenS420: DAO is not ready for migration.");
        address oldAddress = address(pStaking);
        address newAddress = address(_newStakingPool);
        pStaking.upgradeTo(newAddress);
        pStaking = _newStakingPool;
        emit StakingPoolUpgrade(oldAddress, newAddress);
    }

    /**
     *  @dev    ERC-20: `decimals()`
     */
    function decimals() public pure override returns (uint8) {
        return Constant.TOKEN_DECIMALS;
    }

    /**
     *  @dev    ERC-20: `totalSupply()`
     *  @dev    The result is calculated from `totalDiscountFactor`.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return pStaking.discountFactorToToken(totalDiscountFactor);
    }

    /**
     *  @dev    ERC-20: `balanceOf(address)`
     *  @dev    The result is calculated from `discountFactors`.
     */
    function balanceOf(address _account) public view override returns (uint256) {
        return pStaking.discountFactorToToken(discountFactors[_account]);
    }

    /**
     *  @dev    ERC-20: `transfer(address, uint256)`
     *  @dev    This function actually transfers the `discountFactors`.
     */
    function transfer(address _recipient, uint256 _amount) public override returns (bool) {
        Fixed memory discountFactor = pStaking.tokenToDiscountFactor(_amount);
        _transfer(msg.sender, _recipient, discountFactor);
        emit Transfer(msg.sender, _recipient, _amount);

        return true;
    }

    /**
     *  @dev    ERC-20: `transferFrom(address, address, uint256)`
     *  @dev    This function actually transfers the `discountFactors`.
     */
    function transferFrom(
        address _sender,
        address _recipient,
        uint256 _amount
    ) public override returns (bool) {
        uint256 currentAllowance = allowance(_sender, _recipient);
        require(currentAllowance >= _amount, "TokenS420: Transfer amount exceeds allowance.");

        // Already check overflow
        unchecked {
            _approve(_sender, msg.sender, currentAllowance - _amount);
        }

        Fixed memory discountFactor = pStaking.tokenToDiscountFactor(_amount);
        _transfer(_sender, _recipient, discountFactor);

        emit Transfer(_sender, _recipient, _amount);

        return true;
    }

    /**
     *  @notice Transfer discount factor from an address to another.
     *
     *          Name            Meaning
     *  @param  _sender         Sending address
     *  @param  _recipient      Receiving address
     *  @param  _discountFactor Transfer discount factor value
     */
    function _transfer(
        address _sender,
        address _recipient,
        Fixed memory _discountFactor
    ) internal {
        require(_sender != address(0), "TokenS420: Transfer from the zero address.");
        require(_recipient != address(0), "TokenS420: Transfer to the zero address.");

        Fixed memory senderDiscountFactor = discountFactors[_sender];
        require(
            FixedMath.compare(senderDiscountFactor, _discountFactor) > -1,
            "TokenS420: Transfer amount exceeds balance."
        );

        discountFactors[_sender] = FixedMath.subtract(discountFactors[_sender], _discountFactor);
        discountFactors[_recipient] = FixedMath.add(discountFactors[_recipient], _discountFactor);

        emit DiscountFactorTransfer(_sender, _recipient, _discountFactor);
    }

    /**
     *  @notice Mint discount factor to an account.
     *
     *  @dev    Only the Staking Pool can call this function.
     *
     *          Name            Meaning
     *  @param  _account        Address of the account that needs to mint token
     *  @param  _discountFactor Discount factor value to mint
     */
    function mintDiscountFactor(address _account, Fixed memory _discountFactor) public permittedTo(address(pStaking)) {
        require(_account != address(0), "TokenS420: Mint to the zero address");

        discountFactors[_account] = FixedMath.add(discountFactors[_account], _discountFactor);
        totalDiscountFactor = FixedMath.add(totalDiscountFactor, _discountFactor);

        emit DiscountFactorMint(_account, _discountFactor);
    }

    /**
     *  @notice Burn discount factor from an account.
     *
     *  @dev    Only the Staking Pool can call this function.
     *
     *          Name            Meaning
     *  @param  _account        Address of the account that needs to burn token
     *  @param  _discountFactor Discount factor value to to burn
     */
    function burnDiscountFactor(address _account, Fixed memory _discountFactor) public permittedTo(address(pStaking)) {
        require(_account != address(0), "TokenS420: Burn from the zero address.");

        Fixed memory accountDiscountFactor = discountFactors[_account];
        require(
            FixedMath.compare(accountDiscountFactor, _discountFactor) > -1,
            "TokenS420: Transfer amount exceeds balance."
        );

        discountFactors[_account] = FixedMath.subtract(discountFactors[_account], _discountFactor);
        totalDiscountFactor = FixedMath.subtract(totalDiscountFactor, _discountFactor);

        emit DiscountFactorBurn(_account, _discountFactor);
    }
}

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":true,"internalType":"address","name":"account","type":"address"},{"components":[{"internalType":"uint256","name":"value","type":"uint256"}],"indexed":false,"internalType":"struct Fixed","name":"value","type":"tuple"}],"name":"DiscountFactorBurn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"components":[{"internalType":"uint256","name":"value","type":"uint256"}],"indexed":false,"internalType":"struct Fixed","name":"value","type":"tuple"}],"name":"DiscountFactorMint","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"components":[{"internalType":"uint256","name":"value","type":"uint256"}],"indexed":false,"internalType":"struct Fixed","name":"value","type":"tuple"}],"name":"DiscountFactorTransfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"}],"name":"StakingPoolRegistration","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldAddress","type":"address"},{"indexed":true,"internalType":"address","name":"newAddress","type":"address"}],"name":"StakingPoolUpgrade","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"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"},{"components":[{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct Fixed","name":"_discountFactor","type":"tuple"}],"name":"burnDiscountFactor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"discountFactors","outputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"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":"_account","type":"address"},{"components":[{"internalType":"uint256","name":"value","type":"uint256"}],"internalType":"struct Fixed","name":"_discountFactor","type":"tuple"}],"name":"mintDiscountFactor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pStaking","outputs":[{"internalType":"contract IStakingPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"registerStakingPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalDiscountFactor","outputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","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":[{"internalType":"contract IStakingPool","name":"_newStakingPool","type":"address"}],"name":"upgradeStakingPool","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Deployed ByteCode Sourcemap

38741:7505:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40146:259;;;:::i;:::-;;6086:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;8253:169;;;;;;:::i;:::-;;:::i;:::-;;;1237:14:1;;1230:22;1212:41;;1200:2;1185:18;8253:169:0;1072:187:1;41513:147:0;;;:::i;:::-;;;1410:25:1;;;1398:2;1383:18;41513:147:0;1264:177:1;42591:673:0;;;;;;:::i;:::-;;:::i;41270:106::-;;;29030:2;2049:36:1;;2037:2;2022:18;41270:106:0;1907:184:1;40660:546:0;;;;;;:::i;:::-;;:::i;9805:215::-;;;;;;:::i;:::-;;:::i;45541:702::-;;;;;;:::i;:::-;;:::i;39243:48::-;;;;;;:::i;:::-;;;;;;;;;;;;;;41798:159;;;;;;:::i;:::-;;:::i;38788:28::-;;;;;-1:-1:-1;;;;;38788:28:0;;;;;;-1:-1:-1;;;;;3645:32:1;;;3627:51;;3615:2;3600:18;38788:28:0;3460:224:1;6305:104:0;;;:::i;10523:413::-;;;;;;:::i;:::-;;:::i;42110:315::-;;;;;;:::i;:::-;;:::i;44745:448::-;;;;;;:::i;:::-;;:::i;39365:32::-;;;;;;;7955:151;;;;;;:::i;:::-;-1:-1:-1;;;;;8071:18:0;;;8044:7;8071:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;7955:151;40146:259;40213:8;;-1:-1:-1;;;;;40213:8:0;40205:31;40197:96;;;;-1:-1:-1;;;40197:96:0;;4284:2:1;40197:96:0;;;4266:21:1;4323:2;4303:18;;;4296:30;4362:34;4342:18;;;4335:62;-1:-1:-1;;;4413:18:1;;;4406:50;4473:19;;40197:96:0;;;;;;;;;40304:8;:35;;-1:-1:-1;;;;;;40304:35:0;40328:10;40304:35;;;;;;40355:42;;;;40304:8;;40355:42;40146:259::o;6086:100::-;6140:13;6173:5;6166:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6086:100;:::o;8253:169::-;8336:4;8353:39;3974:10;8376:7;8385:6;8353:8;:39::i;:::-;-1:-1:-1;8410:4:0;8253:169;;;;;:::o;41513:147::-;41601:8;;:51;;-1:-1:-1;;;41601:51:0;;41632:19;5093:13:1;41601:51:0;;;5075:32:1;41574:7:0;;-1:-1:-1;;;;;41601:8:0;;:30;;5048:18:1;;41601:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41594:58;;41513:147;:::o;42591:673::-;-1:-1:-1;;;;;8071:18:0;;;42726:4;8071:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;42839:7;42819:16;:27;;42811:85;;;;-1:-1:-1;;;42811:85:0;;5509:2:1;42811:85:0;;;5491:21:1;5548:2;5528:18;;;5521:30;5587:34;5567:18;;;5560:62;-1:-1:-1;;;5638:18:1;;;5631:43;5691:19;;42811:85:0;5307:409:1;42811:85:0;42969:57;42978:7;42987:10;43018:7;42999:16;:26;42969:8;:57::i;:::-;43080:8;;:39;;-1:-1:-1;;;43080:39:0;;;;;1410:25:1;;;43050:27:0;;-1:-1:-1;;;;;43080:8:0;;:30;;1383:18:1;;43080:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;43050:69;;43130:46;43140:7;43149:10;43161:14;43130:9;:46::i;:::-;43212:10;-1:-1:-1;;;;;43194:38:0;43203:7;-1:-1:-1;;;;;43194:38:0;;43224:7;43194:38;;;;1410:25:1;;1398:2;1383:18;;1264:177;43194:38:0;;;;;;;;-1:-1:-1;43252:4:0;;42591:673;-1:-1:-1;;;;;42591:673:0:o;40660:546::-;40768:8;;:21;;;-1:-1:-1;;;40768:21:0;;;;40738:15;;-1:-1:-1;;;;;40768:8:0;;:19;;:21;;;;;;;;;;;;;;:8;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;40738:52;;40823:3;-1:-1:-1;;;;;40823:9:0;;:11;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;40809:25:0;:10;-1:-1:-1;;;;;40809:25:0;;40801:63;;;;-1:-1:-1;;;40801:63:0;;;;;;;:::i;:::-;40883:3;-1:-1:-1;;;;;40883:25:0;;:27;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;40875:82;;;;-1:-1:-1;;;40875:82:0;;7094:2:1;40875:82:0;;;7076:21:1;7133:2;7113:18;;;7106:30;7172:34;7152:18;;;7145:62;-1:-1:-1;;;7223:18:1;;;7216:40;7273:19;;40875:82:0;6892:406:1;40875:82:0;40997:8;;41073:30;;-1:-1:-1;;;41073:30:0;;-1:-1:-1;;;;;3645:32:1;;;41073:30:0;;;3627:51:1;40997:8:0;;;;41046:15;;40997:8;;41073:18;;3600::1;;41073:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;41114:8:0;:26;;-1:-1:-1;;;;;;41114:26:0;-1:-1:-1;;;;;41114:26:0;;;;;;;;;;41156:42;;;;;;-1:-1:-1;41156:42:0;;;;-1:-1:-1;41156:42:0;;-1:-1:-1;;41156:42:0;40727:479;;;40660:546;:::o;9805:215::-;3974:10;9893:4;9942:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;9942:34:0;;;;;;;;;;9893:4;;9910:80;;9933:7;;9942:47;;9979:10;;9942:47;:::i;:::-;9910:8;:80::i;45541:702::-;45644:8;;-1:-1:-1;;;;;45644:8:0;38256:10;:22;;38248:60;;;;-1:-1:-1;;;38248:60:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;45674:22:0;::::1;45666:73;;;::::0;-1:-1:-1;;;45666:73:0;;7978:2:1;45666:73:0::1;::::0;::::1;7960:21:1::0;8017:2;7997:18;;;7990:30;8056:34;8036:18;;;8029:62;-1:-1:-1;;;8107:18:1;;;8100:36;8153:19;;45666:73:0::1;7776:402:1::0;45666:73:0::1;-1:-1:-1::0;;;;;45789:25:0;::::1;45752:34;45789:25:::0;;;:15:::1;:25;::::0;;;;;;;;45752:62;;;;::::1;::::0;;;;;;;-1:-1:-1;;45847:57:0::1;45752:62:::0;45888:15;45847:17:::1;:57::i;:::-;:62;45825:155;;;;-1:-1:-1::0;;;45825:155:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;46040:25:0;::::1;;::::0;;;:15:::1;:25;::::0;;;;;;;;46021:62;;;;::::1;::::0;;;;;;;::::1;::::0;46067:15;46021:18:::1;:62::i;:::-;-1:-1:-1::0;;;;;45993:25:0;::::1;;::::0;;;:15:::1;:25;::::0;;;;;;;;:90;;;;;46116:56;;;;::::1;::::0;;46135:19:::1;46116:56:::0;;;::::1;::::0;46156:15;46116:18:::1;:56::i;:::-;46094:78:::0;:19:::1;:78:::0;46190:45:::1;::::0;8803:13:1;;8785:32;;-1:-1:-1;;;;;46190:45:0;::::1;::::0;::::1;::::0;8773:2:1;8758:18;46190:45:0::1;;;;;;;45655:588;45541:702:::0;;;:::o;41798:159::-;41892:8;;-1:-1:-1;;;;;41923:25:0;;;41865:7;41923:25;;;:15;:25;;;;;;41892:57;;-1:-1:-1;;;41892:57:0;;5093:13:1;;41892:57:0;;;5075:32:1;41865:7:0;;41892:8;;;;;:30;;5048:18:1;;41892:57:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;6305:104::-;6361:13;6394:7;6387:14;;;;;:::i;10523:413::-;3974:10;10616:4;10660:25;;;:11;:25;;;;;;;;-1:-1:-1;;;;;10660:34:0;;;;;;;;;;10713:35;;;;10705:85;;;;-1:-1:-1;;;10705:85:0;;9030:2:1;10705:85:0;;;9012:21:1;9069:2;9049:18;;;9042:30;9108:34;9088:18;;;9081:62;-1:-1:-1;;;9159:18:1;;;9152:35;9204:19;;10705:85:0;8828:401:1;10705:85:0;10826:67;3974:10;10849:7;10877:15;10858:16;:34;10826:8;:67::i;:::-;-1:-1:-1;10924:4:0;;10523:413;-1:-1:-1;;;10523:413:0:o;42110:315::-;42237:8;;:39;;-1:-1:-1;;;42237:39:0;;;;;1410:25:1;;;42190:4:0;;;;-1:-1:-1;;;;;42237:8:0;;;;:30;;1383:18:1;;42237:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42207:69;;42287:49;42297:10;42309;42321:14;42287:9;:49::i;:::-;42352:41;;1410:25:1;;;-1:-1:-1;;;;;42352:41:0;;;42361:10;;42352:41;;1398:2:1;1383:18;42352:41:0;;;;;;;-1:-1:-1;42413:4:0;;42110:315;-1:-1:-1;;;42110:315:0:o;44745:448::-;44848:8;;-1:-1:-1;;;;;44848:8:0;38256:10;:22;;38248:60;;;;-1:-1:-1;;;38248:60:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;44878:22:0;::::1;44870:70;;;::::0;-1:-1:-1;;;44870:70:0;;9436:2:1;44870:70:0::1;::::0;::::1;9418:21:1::0;9475:2;9455:18;;;9448:30;9514:34;9494:18;;;9487:62;-1:-1:-1;;;9565:18:1;;;9558:33;9608:19;;44870:70:0::1;9234:399:1::0;44870:70:0::1;-1:-1:-1::0;;;;;44995:25:0;::::1;;::::0;;;:15:::1;:25;::::0;;;;;;;;44981:57;;;;::::1;::::0;;;;;;;::::1;::::0;45022:15;44981:13:::1;:57::i;:::-;-1:-1:-1::0;;;;;44953:25:0;::::1;;::::0;;;:15:::1;:25;::::0;;;;;;;;:85;;;;;45071:51;;;;::::1;::::0;;45085:19:::1;45071:51:::0;;;::::1;::::0;45106:15;45071:13:::1;:51::i;:::-;45049:73:::0;:19:::1;:73:::0;45140:45:::1;::::0;8803:13:1;;8785:32;;-1:-1:-1;;;;;45140:45:0;::::1;::::0;::::1;::::0;8773:2:1;8758:18;45140:45:0::1;;;;;;;44745:448:::0;;;:::o;14207:380::-;-1:-1:-1;;;;;14343:19:0;;14335:68;;;;-1:-1:-1;;;14335:68:0;;9840:2:1;14335:68:0;;;9822:21:1;9879:2;9859:18;;;9852:30;9918:34;9898:18;;;9891:62;-1:-1:-1;;;9969:18:1;;;9962:34;10013:19;;14335:68:0;9638:400:1;14335:68:0;-1:-1:-1;;;;;14422:21:0;;14414:68;;;;-1:-1:-1;;;14414:68:0;;10245:2:1;14414:68:0;;;10227:21:1;10284:2;10264:18;;;10257:30;10323:34;10303:18;;;10296:62;-1:-1:-1;;;10374:18:1;;;10367:32;10416:19;;14414:68:0;10043:398:1;14414:68:0;-1:-1:-1;;;;;14495:18:0;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;14547:32;;1410:25:1;;;14547:32:0;;1383:18:1;14547:32:0;;;;;;;14207:380;;;:::o;43573:829::-;-1:-1:-1;;;;;43721:21:0;;43713:76;;;;-1:-1:-1;;;43713:76:0;;10648:2:1;43713:76:0;;;10630:21:1;10687:2;10667:18;;;10660:30;10726:34;10706:18;;;10699:62;-1:-1:-1;;;10777:18:1;;;10770:40;10827:19;;43713:76:0;10446:406:1;43713:76:0;-1:-1:-1;;;;;43808:24:0;;43800:77;;;;-1:-1:-1;;;43800:77:0;;11059:2:1;43800:77:0;;;11041:21:1;11098:2;11078:18;;;11071:30;11137:34;11117:18;;;11110:62;-1:-1:-1;;;11188:18:1;;;11181:38;11236:19;;43800:77:0;10857:404:1;43800:77:0;-1:-1:-1;;;;;43926:24:0;;43890:33;43926:24;;;:15;:24;;;;;;;;;43890:60;;;;;;;;;;;;-1:-1:-1;;43983:56:0;43890:60;44023:15;43983:17;:56::i;:::-;:61;43961:154;;;;-1:-1:-1;;;43961:154:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;44174:24:0;;;;;;:15;:24;;;;;;;;;44155:61;;;;;;;;;;;;;;44200:15;44155:18;:61::i;:::-;-1:-1:-1;;;;;44128:24:0;;;;;;;:15;:24;;;;;;;;:88;;;;;44271:27;;;;;;;;44257:59;;;;;;;;;;;;;;44300:15;44257:13;:59::i;:::-;-1:-1:-1;;;;;44227:27:0;;;;;;;:15;:27;;;;;;;:89;;;;;44334:60;;;;;;;;;;44378:15;8803:13:1;8785:32;;8773:2;8758:18;;8595:228;44334:60:0;;;;;;;;43702:700;43573:829;;;:::o;25509:198::-;25617:8;;25606;;25583:6;;-1:-1:-1;25602:34:0;;;-1:-1:-1;;;25627:9:0;;25602:34;25662:8;;25651;;:19;25647:33;;;-1:-1:-1;25679:1:0;25672:8;;25647:33;-1:-1:-1;25698:1:0;25509:198;;;;:::o;25950:141::-;-1:-1:-1;;;;;;;;;;;;26057:26:0;;;;;;;;;26074:8;;26063;;26057:26;;26063:19;;;:::i;:::-;26057:26;;26050:33;25950:141;-1:-1:-1;;;25950:141:0:o;25759:136::-;-1:-1:-1;;;;;;;;;;;;25861:26:0;;;;;;;;;25878:8;;25867;;25861:26;;25867:19;;;:::i;14:597: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;;;452:6;449:1;446:13;443:91;;;522:1;517:2;508:6;497:9;493:22;489:31;482:42;443:91;-1:-1:-1;595:2:1;574:15;-1:-1:-1;;570:29:1;555:45;;;;602:2;551:54;;14:597;-1:-1:-1;;;14:597:1:o;616:131::-;-1:-1:-1;;;;;691:31:1;;681:42;;671:70;;737:1;734;727:12;671:70;616:131;:::o;752:315::-;820:6;828;881:2;869:9;860:7;856:23;852:32;849:52;;;897:1;894;887:12;849:52;936:9;923:23;955:31;980:5;955:31;:::i;:::-;1005:5;1057:2;1042:18;;;;1029:32;;-1:-1:-1;;;752:315:1:o;1446:456::-;1523:6;1531;1539;1592:2;1580:9;1571:7;1567:23;1563:32;1560:52;;;1608:1;1605;1598:12;1560:52;1647:9;1634:23;1666:31;1691:5;1666:31;:::i;:::-;1716:5;-1:-1:-1;1773:2:1;1758:18;;1745:32;1786:33;1745:32;1786:33;:::i;:::-;1446:456;;1838:7;;-1:-1:-1;;;1892:2:1;1877:18;;;;1864:32;;1446:456::o;2096:268::-;2176:6;2229:2;2217:9;2208:7;2204:23;2200:32;2197:52;;;2245:1;2242;2235:12;2197:52;2284:9;2271:23;2303:31;2328:5;2303:31;:::i;:::-;2353:5;2096:268;-1:-1:-1;;;2096:268:1:o;2369:343::-;2436:2;2430:9;2478:2;2466:15;;2511:18;2496:34;;2532:22;;;2493:62;2490:185;;;2597:10;2592:3;2588:20;2585:1;2578:31;2632:4;2629:1;2622:15;2660:4;2657:1;2650:15;2490:185;2691:2;2684:22;2369:343;:::o;2717:486::-;2807:6;2815;2859:9;2850:7;2846:23;2889:2;2885;2881:11;2878:31;;;2905:1;2902;2895:12;2878:31;2944:9;2931:23;2963:31;2988:5;2963:31;:::i;:::-;3013:5;-1:-1:-1;3052:2:1;-1:-1:-1;;3034:16:1;;3030:25;3027:45;;;3068:1;3065;3058:12;3027:45;;3096:17;;:::i;:::-;3166:2;3151:18;;;;3138:32;3122:49;;-1:-1:-1;2717:486:1;3129:7;;-1:-1:-1;2717:486:1:o;3689:388::-;3757:6;3765;3818:2;3806:9;3797:7;3793:23;3789:32;3786:52;;;3834:1;3831;3824:12;3786:52;3873:9;3860:23;3892:31;3917:5;3892:31;:::i;:::-;3942:5;-1:-1:-1;3999:2:1;3984:18;;3971:32;4012:33;3971:32;4012:33;:::i;:::-;4064:7;4054:17;;;3689:388;;;;;:::o;4503:380::-;4582:1;4578:12;;;;4625;;;4646:61;;4700:4;4692:6;4688:17;4678:27;;4646:61;4753:2;4745:6;4742:14;4722:18;4719:38;4716:161;;;4799:10;4794:3;4790:20;4787:1;4780:31;4834:4;4831:1;4824:15;4862:4;4859:1;4852:15;4716:161;;4503:380;;;:::o;5118:184::-;5188:6;5241:2;5229:9;5220:7;5216:23;5212:32;5209:52;;;5257:1;5254;5247:12;5209:52;-1:-1:-1;5280:16:1;;5118:184;-1:-1:-1;5118:184:1:o;5721:274::-;5813:6;5866:2;5854:9;5845:7;5841:23;5837:32;5834:52;;;5882:1;5879;5872:12;5834:52;5908:17;;:::i;:::-;5948:16;;5934:31;;-1:-1:-1;5941:5:1;5721:274;-1:-1:-1;5721:274:1:o;6000:251::-;6070:6;6123:2;6111:9;6102:7;6098:23;6094:32;6091:52;;;6139:1;6136;6129:12;6091:52;6171:9;6165:16;6190:31;6215:5;6190:31;:::i;6256:349::-;6458:2;6440:21;;;6497:2;6477:18;;;6470:30;6536:27;6531:2;6516:18;;6509:55;6596:2;6581:18;;6256:349::o;6610:277::-;6677:6;6730:2;6718:9;6709:7;6705:23;6701:32;6698:52;;;6746:1;6743;6736:12;6698:52;6778:9;6772:16;6831:5;6824:13;6817:21;6810:5;6807:32;6797:60;;6853:1;6850;6843:12;7511:127;7572:10;7567:3;7563:20;7560:1;7553:31;7603:4;7600:1;7593:15;7627:4;7624:1;7617:15;7643:128;7683:3;7714:1;7710:6;7707:1;7704:13;7701:39;;;7720:18;;:::i;:::-;-1:-1:-1;7756:9:1;;7643:128::o;8183:407::-;8385:2;8367:21;;;8424:2;8404:18;;;8397:30;8463:34;8458:2;8443:18;;8436:62;-1:-1:-1;;;8529:2:1;8514:18;;8507:41;8580:3;8565:19;;8183:407::o;11266:125::-;11306:4;11334:1;11331;11328:8;11325:34;;;11339:18;;:::i;:::-;-1:-1:-1;11376:9:1;;11266:125::o

Swarm Source

ipfs://3463098fb364dcfaf1d9ccb094ab65782edf5e0b0a06a2f3afb0a36836b71a95
Block Transaction Gas Used Reward
Age Block Fee Address BC Fee Address Voting Power Jailed Incoming
Block Uncle Number Difficulty Gas Used Reward
Loading
Make sure to use the "Vote Down" button for any spammy posts, and the "Vote Up" for interesting conversations.