Contract 0x3203c9e46ca618c8c1ce5dc67e7e9d75f5da2377

 
 
Txn Hash
Block
From
To
Value [Txn Fee]
0x8c608e5a63563d2255189e9db307bf5f9b13aea99f258c528d87a40f1477b69394153162021-07-23 18:24:262 mins ago0xa4d1ab22f24c3a83ada9e6ad4bc1afbbeff199ac IN  Mobox: MBOX Token0 BNB0.00022203
0x1bf8173d746369e1a55d65cece9c3e68a5be8b0ac3280eb0f039ddc96b6bf03794152892021-07-23 18:23:053 mins ago0xd25c23bf3070bdc2dde478e668a38501162b695f IN  Mobox: MBOX Token0 BNB0.00022203
0x6df8b6f2ab63689c77f05325402dca26455785a7046486c22301393e214937f194152742021-07-23 18:22:204 mins ago0xfdce632c910d3526f62bb5151ff25d5376a37372 IN  Mobox: MBOX Token0 BNB0.00018026
0xfbdc3666c6823df4407af2df76fac518cd57b4173520b5e89f23bd39c50d449794152732021-07-23 18:22:174 mins ago0x9f36bb0045f27b89515bbac0603f4ea956a6f48f IN  Mobox: MBOX Token0 BNB0.00022203
0xe7314b970f322feef65f0e6826cff5e8b93b5579856bd5d932f3d3b0ab4901ea94152632021-07-23 18:21:474 mins ago0xbfa4ec46c01209c0a3458b3d57bd6c997265e053 IN  Mobox: MBOX Token0 BNB0.00022203
0x858d145b2fa46fc0be99baca2f10e52449a78426b691f36e2d42541ad32b441194152542021-07-23 18:21:205 mins ago0xeeb46bd3d100540af674a3ab4104ed40b0ce607a IN  Mobox: MBOX Token0 BNB0.0001802
0x9ca3e7401fe075d199dcecfcd39c62490b08ef1927abc9b2278b6618ee5e667394152342021-07-23 18:20:206 mins ago0xfdce632c910d3526f62bb5151ff25d5376a37372 IN  Mobox: MBOX Token0 BNB0.0002552
0x46a1a3d32889a05314b89ee38ef668df18f107ff4c951b2efa596906a0db83fc94152162021-07-23 18:19:267 mins ago0x3b3e104cafd8a75c81e4931504340ab5253039e1 IN  Mobox: MBOX Token0 BNB0.00022203
0x188f34ebd72a4cfaf1f5843d36cfe48a705adcddc86569c4fe003b6de29699a994151912021-07-23 18:18:118 mins ago0x93d83a73aa80254fabe7bc4dff355f9f95f43b1e IN  Mobox: MBOX Token0 BNB0.00022203
0xff80e1dd2b18638e0acebf9e5af6c4c56edcda6dc313fe21e98996563647dfb194151072021-07-23 18:13:5812 mins ago0x0f4ba19cb9a810a9163d6544b354973abf6e38b7 IN  Mobox: MBOX Token0 BNB0.00010538
0xd2cee8597eebd22ab9cd7504368a4e8a4e2aa07438ab82a2b65f39c7818eb91794150902021-07-23 18:13:0713 mins ago0x59cd33b689ec0450c0e766cf6265cc2d8337810f IN  Mobox: MBOX Token0 BNB0.00025538
0xd7c166e56493a5a24bbdd966b37813fe6f8197f553f34314c7d28400ae7ebd0f94150882021-07-23 18:13:0113 mins ago0xdb4fbcf6970786c4cf02699074d4afe64523d259 IN  Mobox: MBOX Token0 BNB0.00022203
0x9f4fd0a347e5d4d6d0d7b7bc31f2b282fe31a15c449d701f9a7edf4044338fb694150642021-07-23 18:11:4914 mins ago0x7de54f5e65cbe35d473d694dca43b612530120fe IN  Mobox: MBOX Token0 BNB0.0002552
0x8b6bcc560a5502922170fd08673659b87eaae1f9d4e5ad62d9de9a4fba9e5f1794150582021-07-23 18:11:3114 mins ago0x5a5892ef48f24ad8cba60a5d02c8b8337c2b8ef4 IN  Mobox: MBOX Token0 BNB0.00022203
0x8b5f6dd7f0729f2f1753f5062cfbf4ad0868f2988e4bef70a280bf9ab111bf8194150382021-07-23 18:10:3115 mins ago0x8fa0dfa1de362b4b5bd1ad388b35be66df1ee26d IN  Mobox: MBOX Token0 BNB0.00044406
0xcb983bee9f930e660d5ed36f8f8d413073330da135e2df66d1bb1713d830b19294150212021-07-23 18:09:4016 mins ago0x59cd33b689ec0450c0e766cf6265cc2d8337810f IN  Mobox: MBOX Token0 BNB0.00013784
0x7b7f152fe1325379b24243e426aa9eadfaee8609751b26166e5ff94b733ab50d94149922021-07-23 18:08:1318 mins ago0xdb4fbcf6970786c4cf02699074d4afe64523d259 IN  Mobox: MBOX Token0 BNB0.00022203
0x4026411fde26d7985086dc26e4edf06c9c50aaafca04a36e7a8bb72138a6343494149782021-07-23 18:07:3118 mins ago0x5a36b26c268fd503e2d1095c034a5fe9da753ab2 IN  Mobox: MBOX Token0 BNB0.00013784
0xed9bfd22ffbed0447c4612bd52760d8ebfc348938cc37b0301a0d5ce0b91b5d694149542021-07-23 18:06:1020 mins ago0x6ae154a3567f5f7a40b42cc6a0fd576ef2c2b04f IN  Mobox: MBOX Token0 BNB0.00025526
0x42154515895bbdb93f575bf21a2cc28b618a6b4253cc3754b70e45a9b31a342794149312021-07-23 18:04:4721 mins ago0x6ae154a3567f5f7a40b42cc6a0fd576ef2c2b04f IN  Mobox: MBOX Token0 BNB0.00015
0x247f47d205eed3db2e87260e51d2c7c45f6504a5079c79273f333995e31c51c294149242021-07-23 18:04:2422 mins ago0x843ac4bb8fb731a5ebfd523fcc9eb2c9e0bd05a6 IN  Mobox: MBOX Token0 BNB0.00022203
0x676c5fed95b4b95e9008c5cfd8255b8597f8163b4cf9ee9ba7231848a80eea1094149132021-07-23 18:03:4822 mins ago0x1cb65985f5b52f192560774cf44cb5f30d5d1dd8 IN  Mobox: MBOX Token0 BNB0.00022203
0x89acf23e4ff7b5e5c0f39b859df7ff3627477f687df4c69880b73c070625edb594149042021-07-23 18:03:1423 mins ago0x8fa0dfa1de362b4b5bd1ad388b35be66df1ee26d IN  Mobox: MBOX Token0 BNB0.00044406
0xe4a8c7649ac74f47159ac529df697ea3580e0aae78d51ba6383cda49cce5fae494148712021-07-23 18:01:0425 mins ago0xad3629c8570a121765f8a05bfc3a7d0e5b270fdb IN  Mobox: MBOX Token0 BNB0.0002552
0xd677d13f78f36943f53a547c2fbf501cd1f471fd39ff06d72dfa8452f24d26a894148252021-07-23 17:58:4127 mins ago0xa6e85c3dd52d4534d105fd1614b0af024262a871 IN  Mobox: MBOX Token0 BNB0.00022203
[ Download CSV Export 

OVERVIEW

MOBOX platform combines DeFi and Gaming NFT, creating a gaming ecosystem.

Parent Txn Hash Block From To Value
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
MoboxToken

Compiler Version
v0.6.12+commit.27d51765

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity Multiple files format)

File 1 of 7: MoboxToken.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.6;

import "./SafeMath.sol";
import "./ERC20.sol";
import "./Ownable.sol";

contract MoboxToken is ERC20, Ownable {
    using SafeMath for uint256;

    /**
     * The time interval from each 'mint' to the 'Mobox mining pool' is not less than 365 days
     */
    uint256 public constant  MINT_INTERVAL = 365 days;

    /**
     * All of the minted 'Mbox' will be moved to the mainPool.
     */
    address public mainPool;

    /**
     * The unixtimestamp for the last mint.
     */
    uint256 public lastestMinting;

    /**
     * All of the minted 'Mbox' burned in the corresponding mining pool if the released amount is not used up in the current year 
     * 
     */
    uint256[6] public maxMintOfYears;

    /**
     * The number of times 'mint' has been executed
     */
    uint256 public yearMint = 0;

    constructor() 
        public 
        ERC20("Mobox", "MBOX", 18) 
    {
        uint256 decimal = 10 ** uint256(decimals);
        /**
        * There will distribute 400,000,000 Mbox in year 1
        *                       225,000,000 Mbox in year 2
        *                       175,000,000 Mbox in year 3
        *                       125,000,000 Mbox in year 4
        *                       75,000,000  Mbox in year 5
        *  In the future, up to 50,000,000 Mbox can be released each year
        */
        maxMintOfYears[0] = 400000000 * decimal;
        maxMintOfYears[1] = 225000000 * decimal;
        maxMintOfYears[2] = 175000000 * decimal;
        maxMintOfYears[3] = 125000000 * decimal;
        maxMintOfYears[4] = 75000000 * decimal;
        maxMintOfYears[5] = 50000000 * decimal;
    }

    /**
     * The unixtimestamp of 'mint' can be executed next time
     */
    function nextMinting() public view returns(uint256) {
        return lastestMinting + MINT_INTERVAL;
    }

    /** 
     * Set the target mining pool contract for minting
     */
    function setMainPool(address pool_) external onlyOwner {
        require(pool_ != address(0));
        mainPool = pool_;
    }

    /**
     * Distribute MBOX to the main mining pool according to the MBOX limit that can be released every year
     */
    function mint(address dest_) external {
        require(msg.sender == mainPool, "invalid minter");
        require(lastestMinting.add(MINT_INTERVAL) < block.timestamp, "minting not allowed yet");

        uint256 amountThisYear = yearMint < 5 ? maxMintOfYears[yearMint] : maxMintOfYears[5];
        yearMint += 1;
        lastestMinting = block.timestamp;

        _mint(dest_, amountThisYear); 
    }

    function burn(uint256 amount_) external { 
        _burn(msg.sender, amount_);
    }

    function burnFrom(address from_, uint256 amount_) external {
        require(from_ != address(0), "burn from zero");
        
        _approve(from_, msg.sender, _allowances[from_][msg.sender].sub(amount_));
        _burn(from_, amount_);
    }
}

File 2 of 7: Address.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.6;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
        // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
        // for accounts without code, i.e. `keccak256('')`
        bytes32 codehash;
        bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
        // solhint-disable-next-line no-inline-assembly
        assembly { codehash := extcodehash(account) }
        return (codehash != accountHash && codehash != 0x0);
    }

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

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }
}

File 3 of 7: Context.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.6;

/*
 * @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 GSN 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 payable) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes memory) {
        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

File 4 of 7: ERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.6;

import "./SafeMath.sol";
import "./IERC20.sol";
import "./Context.sol";

contract ERC20 is IERC20, Context {
    using SafeMath for uint256;

    mapping (address => uint256) internal _balances;
    mapping (address => mapping (address => uint256)) internal _allowances;

    uint256 internal _totalSupply;

    /**
     * @dev Returns the name of the token.
     */
    string public name;

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    string public 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 {_setupDecimals} is
     * called.
     *
     * 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}.
     */
    uint8  public decimals;

    /**
     * @dev Sets the values for {_name} and {_symbol}, {_decimals}
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory _name, string memory _symbol, uint8 _decimals) public {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;
    }

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

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

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

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address _owner, address _spender) external view override returns (uint256) {
        return _allowances[_owner][_spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `_spender` cannot be the zero address.
     */
    function approve(address _spender, uint256 _amount) external 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:
     *
     * - `_from` and `_to` cannot be the zero address.
     * - `_from` must have a balance of at least `_amount`.
     * - the caller must have allowance for `_from`'s tokens of at least
     * `_amount`.
     */
    function transferFrom(address _from, address _to, uint256 _amount) external override returns (bool) {
        require(_from != address(0) && _to != address(0));

        _approve(_from, _msgSender(), _allowances[_from][_msgSender()].sub(_amount));
        _transfer(_from, _to, _amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `_spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `_spender` cannot be the zero address.
     */
    function increaseAllowance(address _spender, uint256 _addVal) external returns (bool) {
        require(_spender != address(0), "approve to 0");

        _approve(_msgSender(), _spender, _allowances[_msgSender()][_spender].add(_addVal));
        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 _subVal) external returns (bool) {
        require(_spender != address(0), "approve to 0");

        _approve(_msgSender(), _spender, _allowances[_msgSender()][_spender].sub(_subVal));
        return true;
    }

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

        _balances[_from] = _balances[_from].sub(_amount);
        _balances[_to] = _balances[_to].add(_amount);
        emit Transfer(_from, _to, _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 {
        require(_owner != address(0), "approve from 0");
        require(_spender != address(0), "approve to 0");

        _allowances[_owner][_spender] = _amount;
        emit Approval(_owner, _spender, _amount);
    }

    /** @dev Creates `_amount` tokens and assigns them to `_to`, 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 _to, uint256 _amount) internal {
        require(_to != address(0), "mint to 0");

        _totalSupply = _totalSupply.add(_amount);
        _balances[_to] = _balances[_to].add(_amount);
        emit Transfer(address(0), _to, _amount);
    }

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

        _balances[_from] = _balances[_from].sub(_amount);
        _totalSupply = _totalSupply.sub(_amount);
        emit Transfer(_from, address(0), _amount);
    }
}

File 5 of 7: IERC20.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.6;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 * From https://github.com/OpenZeppelin/openzeppelin-contracts
 */
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 6 of 7: Ownable.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.6;

import "./Context.sol";

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() internal {
        _owner = _msgSender();
        emit OwnershipTransferred(address(0), _owner);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_msgSender() == _owner, "not owner");
        _;
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public {
        require(newOwner != address(0), "newOwner invalid");
        if (_owner != address(0)) {
            require(_msgSender() == _owner, "not owner");
        }
        
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

File 7 of 7: SafeMath.sol
// SPDX-License-Identifier: MIT

pragma solidity ^0.6.6;

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

        return c;
    }

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

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, "SafeMath: division by zero");
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

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

library SafeMathExt {
    function add128(uint128 a, uint128 b) internal pure returns (uint128) {
        uint128 c = a + b;
        require(c >= a, "uint128: addition overflow");

        return c;
    }

    function sub128(uint128 a, uint128 b) internal pure returns (uint128) {
        require(b <= a, "uint128: subtraction overflow");
        uint128 c = a - b;

        return c;
    }

    function add64(uint64 a, uint64 b) internal pure returns (uint64) {
        uint64 c = a + b;
        require(c >= a, "uint64: addition overflow");

        return c;
    }

    function sub64(uint64 a, uint64 b) internal pure returns (uint64) {
        require(b <= a, "uint64: subtraction overflow");
        uint64 c = a - b;

        return c;
    }

    function safe128(uint256 a) internal pure returns(uint128) {
        require(a < 0x0100000000000000000000000000000000, "uint128: number overflow");
        return uint128(a);
    }

    function safe64(uint256 a) internal pure returns(uint64) {
        require(a < 0x010000000000000000, "uint64: number overflow");
        return uint64(a);
    }

    function safe32(uint256 a) internal pure returns(uint32) {
        require(a < 0x0100000000, "uint32: number overflow");
        return uint32(a);
    }

    function safe16(uint256 a) internal pure returns(uint16) {
        require(a < 0x010000, "uint32: number overflow");
        return uint16(a);
    }
}

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

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":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","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":[],"name":"MINT_INTERVAL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"_owner","type":"address"}],"name":"balanceOf","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":"from_","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":"_subVal","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_spender","type":"address"},{"internalType":"uint256","name":"_addVal","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"lastestMinting","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mainPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"maxMintOfYears","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"dest_","type":"address"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"nextMinting","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pool_","type":"address"}],"name":"setMainPool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_from","type":"address"},{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"yearMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

60806040526000600e553480156200001657600080fd5b50604080518082018252600581526409adec4def60db1b60208083019182528351808501909452600484526309a849eb60e31b90840152815191929160129162000064916003919062000144565b5081516200007a90600490602085019062000144565b506005805460ff191660ff92909216919091179055506200009c905062000140565b60058054610100600160a81b0319166101006001600160a01b03938416810291909117918290556040519104909116906000907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a360055460ff16600a90810a6317d784008102600855630d693a408102600955630a6e49c0810290915563077359408102600b5563047868c08102600c556302faf08002600d55620001e0565b3390565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f106200018757805160ff1916838001178555620001b7565b82800160010185558215620001b7579182015b82811115620001b75782518255916020019190600101906200019a565b50620001c5929150620001c9565b5090565b5b80821115620001c55760008155600101620001ca565b61103f80620001f06000396000f3fe608060405234801561001057600080fd5b506004361061014d5760003560e01c806370a08231116100c3578063a5a302d31161007c578063a5a302d3146103eb578063a9059cbb146103f3578063b4eddb811461041f578063dd62ed3e14610427578063df557bc014610455578063f2fde38b1461045d5761014d565b806370a082311461033957806379cc67901461035f57806384e7e3d31461038b5780638da5cb5b1461039357806395d89b41146103b7578063a457c2d7146103bf5761014d565b806329dbecb11161011557806329dbecb114610267578063313ce5671461028f578063376fcb6d146102ad57806339509351146102ca57806342966c68146102f65780636a627842146103135761014d565b806306fdde0314610152578063095ea7b3146101cf5780630de5d1d91461020f57806318160ddd1461022957806323b872dd14610231575b600080fd5b61015a610483565b6040805160208082528351818301528351919283929083019185019080838360005b8381101561019457818101518382015260200161017c565b50505050905090810190601f1680156101c15780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6101fb600480360360408110156101e557600080fd5b506001600160a01b038135169060200135610511565b604080519115158252519081900360200190f35b61021761052e565b60408051918252519081900360200190f35b610217610534565b6101fb6004803603606081101561024757600080fd5b506001600160a01b0381358116916020810135909116906040013561053a565b61028d6004803603602081101561027d57600080fd5b50356001600160a01b03166105d2565b005b610297610667565b6040805160ff9092168252519081900360200190f35b610217600480360360208110156102c357600080fd5b5035610670565b6101fb600480360360408110156102e057600080fd5b506001600160a01b038135169060200135610684565b61028d6004803603602081101561030c57600080fd5b503561071c565b61028d6004803603602081101561032957600080fd5b50356001600160a01b0316610729565b6102176004803603602081101561034f57600080fd5b50356001600160a01b0316610821565b61028d6004803603604081101561037557600080fd5b506001600160a01b03813516906020013561083c565b6102176108c7565b61039b6108cf565b604080516001600160a01b039092168252519081900360200190f35b61015a6108e3565b6101fb600480360360408110156103d557600080fd5b506001600160a01b03813516906020013561093e565b61039b6109d6565b6101fb6004803603604081101561040957600080fd5b506001600160a01b0381351690602001356109e5565b6102176109f9565b6102176004803603604081101561043d57600080fd5b506001600160a01b0381358116916020013516610a05565b610217610a30565b61028d6004803603602081101561047357600080fd5b50356001600160a01b0316610a36565b6003805460408051602060026001851615610100026000190190941693909304601f810184900484028201840190925281815292918301828280156105095780601f106104de57610100808354040283529160200191610509565b820191906000526020600020905b8154815290600101906020018083116104ec57829003601f168201915b505050505081565b600061052561051e610b61565b8484610b65565b50600192915050565b60075481565b60025490565b60006001600160a01b0384161580159061055c57506001600160a01b03831615155b61056557600080fd5b6105bd84610571610b61565b6001600160a01b03871660009081526001602052604081206105b891879190610598610b61565b6001600160a01b0316815260208101919091526040016000205490610c5d565b610b65565b6105c8848484610cba565b5060019392505050565b60055461010090046001600160a01b03166105eb610b61565b6001600160a01b031614610632576040805162461bcd60e51b81526020600482015260096024820152683737ba1037bbb732b960b91b604482015290519081900360640190fd5b6001600160a01b03811661064557600080fd5b600680546001600160a01b0319166001600160a01b0392909216919091179055565b60055460ff1681565b6008816006811061067d57fe5b0154905081565b60006001600160a01b0383166106d0576040805162461bcd60e51b815260206004820152600c60248201526b0617070726f766520746f20360a41b604482015290519081900360640190fd5b6105256106db610b61565b846105b885600160006106ec610b61565b6001600160a01b03908116825260208083019390935260409182016000908120918c168152925290205490610dfe565b6107263382610e5f565b50565b6006546001600160a01b03163314610779576040805162461bcd60e51b815260206004820152600e60248201526d34b73b30b634b21036b4b73a32b960911b604482015290519081900360640190fd5b600754429061078c906301e13380610dfe565b106107de576040805162461bcd60e51b815260206004820152601760248201527f6d696e74696e67206e6f7420616c6c6f77656420796574000000000000000000604482015290519081900360640190fd5b60006005600e54106107f257600d54610804565b6008600e546006811061080157fe5b01545b600e8054600101905542600755905061081d8282610f39565b5050565b6001600160a01b031660009081526020819052604090205490565b6001600160a01b038216610888576040805162461bcd60e51b815260206004820152600e60248201526d6275726e2066726f6d207a65726f60901b604482015290519081900360640190fd5b6001600160a01b0382166000908152600160209081526040808320338085529252909120546108bd9184916105b89085610c5d565b61081d8282610e5f565b6301e1338081565b60055461010090046001600160a01b031690565b6004805460408051602060026001851615610100026000190190941693909304601f810184900484028201840190925281815292918301828280156105095780601f106104de57610100808354040283529160200191610509565b60006001600160a01b03831661098a576040805162461bcd60e51b815260206004820152600c60248201526b0617070726f766520746f20360a41b604482015290519081900360640190fd5b610525610995610b61565b846105b885600160006109a6610b61565b6001600160a01b03908116825260208083019390935260409182016000908120918c168152925290205490610c5d565b6006546001600160a01b031681565b60006105256109f2610b61565b8484610cba565b6007546301e133800190565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b600e5481565b6001600160a01b038116610a84576040805162461bcd60e51b815260206004820152601060248201526f1b995dd3dddb995c881a5b9d985b1a5960821b604482015290519081900360640190fd5b60055461010090046001600160a01b031615610afa5760055461010090046001600160a01b0316610ab3610b61565b6001600160a01b031614610afa576040805162461bcd60e51b81526020600482015260096024820152683737ba1037bbb732b960b91b604482015290519081900360640190fd5b6005546040516001600160a01b0380841692610100900416907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a3600580546001600160a01b0390921661010002610100600160a81b0319909216919091179055565b3390565b6001600160a01b038316610bb1576040805162461bcd60e51b815260206004820152600e60248201526d0617070726f76652066726f6d20360941b604482015290519081900360640190fd5b6001600160a01b038216610bfb576040805162461bcd60e51b815260206004820152600c60248201526b0617070726f766520746f20360a41b604482015290519081900360640190fd5b6001600160a01b03808416600081815260016020908152604080832094871680845294825291829020859055815185815291517f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259281900390910190a3505050565b600082821115610cb4576040805162461bcd60e51b815260206004820152601e60248201527f536166654d6174683a207375627472616374696f6e206f766572666c6f770000604482015290519081900360640190fd5b50900390565b6001600160a01b038316610d07576040805162461bcd60e51b815260206004820152600f60248201526e07472616e736665722066726f6d203608c1b604482015290519081900360640190fd5b6001600160a01b038216610d52576040805162461bcd60e51b815260206004820152600d60248201526c07472616e7366657220746f203609c1b604482015290519081900360640190fd5b6001600160a01b038316600090815260208190526040902054610d759082610c5d565b6001600160a01b038085166000908152602081905260408082209390935590841681522054610da49082610dfe565b6001600160a01b038084166000818152602081815260409182902094909455805185815290519193928716927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef92918290030190a3505050565b600082820183811015610e58576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b9392505050565b6001600160a01b038216610ea8576040805162461bcd60e51b815260206004820152600b60248201526a06275726e2066726f6d20360ac1b604482015290519081900360640190fd5b6001600160a01b038216600090815260208190526040902054610ecb9082610c5d565b6001600160a01b038316600090815260208190526040902055600254610ef19082610c5d565b6002556040805182815290516000916001600160a01b038516917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9181900360200190a35050565b6001600160a01b038216610f80576040805162461bcd60e51b815260206004820152600960248201526806d696e7420746f20360bc1b604482015290519081900360640190fd5b600254610f8d9082610dfe565b6002556001600160a01b038216600090815260208190526040902054610fb39082610dfe565b6001600160a01b0383166000818152602081815260408083209490945583518581529351929391927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9281900390910190a3505056fea26469706673582212200c8dd20a2a6e154810f3d15349e82dc8b796e3ff80f40eb831b679a3a053e10764736f6c634300060c0033

Deployed ByteCode Sourcemap

138:2912:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;448:18:2;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2801:167;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;2801:167:2;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;567:29:4;;;:::i;:::-;;;;;;;;;;;;;;;;1791:101:2;;;:::i;3441:320::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;3441:320:2;;;;;;;;;;;;;;;;;:::i;2023:129:4:-;;;;;;;;;;;;;;;;-1:-1:-1;2023:129:4;-1:-1:-1;;;;;2023:129:4;;:::i;:::-;;1245:22:2;;;:::i;:::-;;;;;;;;;;;;;;;;;;;764:32:4;;;;;;;;;;;;;;;;-1:-1:-1;764:32:4;;:::i;4172:269:2:-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;4172:269:2;;;;;;;;:::i;2704:86:4:-;;;;;;;;;;;;;;;;-1:-1:-1;2704:86:4;;:::i;2286:410::-;;;;;;;;;;;;;;;;-1:-1:-1;2286:410:4;-1:-1:-1;;;;;2286:410:4;;:::i;1955:119:2:-;;;;;;;;;;;;;;;;-1:-1:-1;1955:119:2;-1:-1:-1;;;;;1955:119:2;;:::i;2798:249:4:-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;2798:249:4;;;;;;;;:::i;332:49::-;;;:::i;1062:79:5:-;;;:::i;:::-;;;;-1:-1:-1;;;;;1062:79:5;;;;;;;;;;;;;;586:20:2;;;:::i;4947:269::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;4947:269:2;;;;;;;;:::i;472:23:4:-;;;:::i;2282:159:2:-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;2282:159:2;;;;;;;;:::i;1832:108:4:-;;;:::i;2504:149:2:-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;2504:149:2;;;;;;;;;;:::i;876:27:4:-;;;:::i;1485:321:5:-;;;;;;;;;;;;;;;;-1:-1:-1;1485:321:5;-1:-1:-1;;;;;1485:321:5;;:::i;448:18:2:-;;;;;;;;;;;;;;;-1:-1:-1;;448:18:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2801:167::-;2880:4;2897:41;2906:12;:10;:12::i;:::-;2920:8;2930:7;2897:8;:41::i;:::-;-1:-1:-1;2956:4:2;2801:167;;;;:::o;567:29:4:-;;;;:::o;1791:101:2:-;1872:12;;1791:101;:::o;3441:320::-;3535:4;-1:-1:-1;;;;;3560:19:2;;;;;;:40;;-1:-1:-1;;;;;;3583:17:2;;;;3560:40;3552:49;;;;;;3614:76;3623:5;3630:12;:10;:12::i;:::-;-1:-1:-1;;;;;3644:18:2;;;;;;:11;:18;;;;;:45;;3681:7;;3644:18;3663:12;:10;:12::i;:::-;-1:-1:-1;;;;;3644:32:2;;;;;;;;;;;;-1:-1:-1;3644:32:2;;;:36;:45::i;:::-;3614:8;:76::i;:::-;3701:30;3711:5;3718:3;3723:7;3701:9;:30::i;:::-;-1:-1:-1;3749:4:2;3441:320;;;;;:::o;2023:129:4:-;1290:6:5;;;;;-1:-1:-1;;;;;1290:6:5;1274:12;:10;:12::i;:::-;-1:-1:-1;;;;;1274:22:5;;1266:44;;;;;-1:-1:-1;;;1266:44:5;;;;;;;;;;;;-1:-1:-1;;;1266:44:5;;;;;;;;;;;;;;;-1:-1:-1;;;;;2097:19:4;::::1;2089:28;;;::::0;::::1;;2128:8;:16:::0;;-1:-1:-1;;;;;;2128:16:4::1;-1:-1:-1::0;;;;;2128:16:4;;;::::1;::::0;;;::::1;::::0;;2023:129::o;1245:22:2:-;;;;;;:::o;764:32:4:-;;;;;;;;;;;;;-1:-1:-1;764:32:4;:::o;4172:269:2:-;4252:4;-1:-1:-1;;;;;4277:22:2;;4269:47;;;;;-1:-1:-1;;;4269:47:2;;;;;;;;;;;;-1:-1:-1;;;4269:47:2;;;;;;;;;;;;;;;4329:82;4338:12;:10;:12::i;:::-;4352:8;4362:48;4402:7;4362:11;:25;4374:12;:10;:12::i;:::-;-1:-1:-1;;;;;4362:25:2;;;;;;;;;;;;;;;;;-1:-1:-1;4362:25:2;;;:35;;;;;;;;;;;:39;:48::i;2704:86:4:-;2756:26;2762:10;2774:7;2756:5;:26::i;:::-;2704:86;:::o;2286:410::-;2357:8;;-1:-1:-1;;;;;2357:8:4;2343:10;:22;2335:49;;;;;-1:-1:-1;;;2335:49:4;;;;;;;;;;;;-1:-1:-1;;;2335:49:4;;;;;;;;;;;;;;;2403:14;;2439:15;;2403:33;;373:8;2403:18;:33::i;:::-;:51;2395:87;;;;;-1:-1:-1;;;2395:87:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;2495:22;2531:1;2520:8;;:12;:59;;2562:17;;2520:59;;;2535:14;2550:8;;2535:24;;;;;;;;;2520:59;2590:8;:13;;2602:1;2590:13;;;2631:15;2614:14;:32;2495:84;-1:-1:-1;2659:28:4;2665:5;2495:84;2659:5;:28::i;:::-;2286:410;;:::o;1955:119:2:-;-1:-1:-1;;;;;2049:17:2;2022:7;2049:17;;;;;;;;;;;;1955:119::o;2798:249:4:-;-1:-1:-1;;;;;2876:19:4;;2868:46;;;;;-1:-1:-1;;;2868:46:4;;;;;;;;;;;;-1:-1:-1;;;2868:46:4;;;;;;;;;;;;;;;-1:-1:-1;;;;;2963:18:4;;;;;;:11;:18;;;;;;;;2951:10;2963:30;;;;;;;;;2935:72;;2944:5;;2963:43;;2998:7;2963:34;:43::i;2935:72::-;3018:21;3024:5;3031:7;3018:5;:21::i;332:49::-;373:8;332:49;:::o;1062:79:5:-;1127:6;;;;;-1:-1:-1;;;;;1127:6:5;;1062:79::o;586:20:2:-;;;;;;;;;;;;;;;-1:-1:-1;;586:20:2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4947:269;5027:4;-1:-1:-1;;;;;5052:22:2;;5044:47;;;;;-1:-1:-1;;;5044:47:2;;;;;;;;;;;;-1:-1:-1;;;5044:47:2;;;;;;;;;;;;;;;5104:82;5113:12;:10;:12::i;:::-;5127:8;5137:48;5177:7;5137:11;:25;5149:12;:10;:12::i;:::-;-1:-1:-1;;;;;5137:25:2;;;;;;;;;;;;;;;;;-1:-1:-1;5137:25:2;;;:35;;;;;;;;;;;:39;:48::i;472:23:4:-;;;-1:-1:-1;;;;;472:23:4;;:::o;2282:159:2:-;2357:4;2374:37;2384:12;:10;:12::i;:::-;2398:3;2403:7;2374:9;:37::i;1832:108:4:-;1902:14;;373:8;1902:30;1832:108;:::o;2504:149:2:-;-1:-1:-1;;;;;2616:19:2;;;2589:7;2616:19;;;:11;:19;;;;;;;;:29;;;;;;;;;;;;;2504:149::o;876:27:4:-;;;;:::o;1485:321:5:-;-1:-1:-1;;;;;1556:22:5;;1548:51;;;;;-1:-1:-1;;;1548:51:5;;;;;;;;;;;;-1:-1:-1;;;1548:51:5;;;;;;;;;;;;;;;1614:6;;;;;-1:-1:-1;;;;;1614:6:5;:20;1610:97;;1675:6;;;;;-1:-1:-1;;;;;1675:6:5;1659:12;:10;:12::i;:::-;-1:-1:-1;;;;;1659:22:5;;1651:44;;;;;-1:-1:-1;;;1651:44:5;;;;;;;;;;;;-1:-1:-1;;;1651:44:5;;;;;;;;;;;;;;;1753:6;;1732:38;;-1:-1:-1;;;;;1732:38:5;;;;1753:6;;;;;1732:38;;;;;1781:6;:17;;-1:-1:-1;;;;;1781:17:5;;;;;-1:-1:-1;;;;;;1781:17:5;;;;;;;;;1485:321::o;605:106:1:-;693:10;605:106;:::o;6489:305:2:-;-1:-1:-1;;;;;6586:20:2;;6578:47;;;;;-1:-1:-1;;;6578:47:2;;;;;;;;;;;;-1:-1:-1;;;6578:47:2;;;;;;;;;;;;;;;-1:-1:-1;;;;;6644:22:2;;6636:47;;;;;-1:-1:-1;;;6636:47:2;;;;;;;;;;;;-1:-1:-1;;;6636:47:2;;;;;;;;;;;;;;;-1:-1:-1;;;;;6696:19:2;;;;;;;:11;:19;;;;;;;;:29;;;;;;;;;;;;;:39;;;6751:35;;;;;;;;;;;;;;;;;6489:305;;;:::o;773:184:6:-;831:7;864:1;859;:6;;851:49;;;;;-1:-1:-1;;;851:49:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;923:5:6;;;773:184::o;5693:354:2:-;-1:-1:-1;;;;;5785:19:2;;5777:47;;;;;-1:-1:-1;;;5777:47:2;;;;;;;;;;;;-1:-1:-1;;;5777:47:2;;;;;;;;;;;;;;;-1:-1:-1;;;;;5843:17:2;;5835:43;;;;;-1:-1:-1;;;5835:43:2;;;;;;;;;;;;-1:-1:-1;;;5835:43:2;;;;;;;;;;;;;;;-1:-1:-1;;;;;5910:16:2;;:9;:16;;;;;;;;;;;:29;;5931:7;5910:20;:29::i;:::-;-1:-1:-1;;;;;5891:16:2;;;:9;:16;;;;;;;;;;;:48;;;;5967:14;;;;;;;:27;;5986:7;5967:18;:27::i;:::-;-1:-1:-1;;;;;5950:14:2;;;:9;:14;;;;;;;;;;;;:44;;;;6010:29;;;;;;;5950:14;;6010:29;;;;;;;;;;;;;5693:354;;;:::o;317:181:6:-;375:7;407:5;;;431:6;;;;423:46;;;;;-1:-1:-1;;;423:46:6;;;;;;;;;;;;;;;;;;;;;;;;;;;;489:1;317:181;-1:-1:-1;;;317:181:6:o;7672:282:2:-;-1:-1:-1;;;;;7747:19:2;;7739:43;;;;;-1:-1:-1;;;7739:43:2;;;;;;;;;;;;-1:-1:-1;;;7739:43:2;;;;;;;;;;;;;;;-1:-1:-1;;;;;7814:16:2;;:9;:16;;;;;;;;;;;:29;;7835:7;7814:20;:29::i;:::-;-1:-1:-1;;;;;7795:16:2;;:9;:16;;;;;;;;;;:48;7869:12;;:25;;7886:7;7869:16;:25::i;:::-;7854:12;:40;7910:36;;;;;;;;7934:1;;-1:-1:-1;;;;;7910:36:2;;;;;;;;;;;;7672:282;;:::o;7073:270::-;-1:-1:-1;;;;;7146:17:2;;7138:39;;;;;-1:-1:-1;;;7138:39:2;;;;;;;;;;;;-1:-1:-1;;;7138:39:2;;;;;;;;;;;;;;;7205:12;;:25;;7222:7;7205:16;:25::i;:::-;7190:12;:40;-1:-1:-1;;;;;7258:14:2;;:9;:14;;;;;;;;;;;:27;;7277:7;7258:18;:27::i;:::-;-1:-1:-1;;;;;7241:14:2;;:9;:14;;;;;;;;;;;:44;;;;7301:34;;;;;;;7241:14;;:9;;7301:34;;;;;;;;;;7073:270;;:::o

Swarm Source

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