Contract 0x3203c9e46ca618c8c1ce5dc67e7e9d75f5da2377 9

 

Contract Overview

Mobox: MBOX Token
Balance:
0 BNB

BNB Value:
$0.00
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xf98e21442a6016e89bad5a94dd0576807c4892165fb9e17647f2642aa8aab263Transfer111346172021-09-22 11:06:2147 secs ago0xb8c674487c7f67bb055e34256c50209b1018ae43 IN  Mobox: MBOX Token0 BNB0.0002552
0x9421358601c7eb2feb51e35ad27e02d2ba8a3588e8a0e5d0604920e88e0d60f1Approve111346162021-09-22 11:06:1850 secs ago0x3d2f4b158cb077d6d970adf4fbe957b8e882536f IN  Mobox: MBOX Token0 BNB0.00022203
0x1af0c8a340e2f6a6d57e244394c0bf0c3f9c07a10fbcf08e68d168309b699f00Transfer111346152021-09-22 11:06:1553 secs ago0xc4f088a3e61e729365b062ca7be2605474ed43d7 IN  Mobox: MBOX Token0 BNB0.0002552
0x64cde56812241d6ee84c71870109ab2e709b4940f4343def851ffc36a2f7974eTransfer111346142021-09-22 11:06:1256 secs ago0x5c22774f3bf06a9e4b989399aa76490fb083857d IN  Mobox: MBOX Token0 BNB0.0001802
0xbe9e1cf9e90633ddf8f85160052b265cb230abb95cad5e50de93d73f85cc8eabApprove111346142021-09-22 11:06:1256 secs ago0xf1b2d905aaed9cffb5e63cd990c7895244ae3755 IN  Mobox: MBOX Token0 BNB0.0002264706
0x03a3b03e2f44027cb2b04a009eed0e231d818b6b8653063cc7afaa50446afdbcTransfer111346132021-09-22 11:06:0959 secs agoBinance: Hot Wallet 6 IN  Mobox: MBOX Token0 BNB0.00036064
0x8f8bc65b0ec9da341a2e375456788e129fe99cabc036fa95fb7deb766db83411Transfer111346032021-09-22 11:05:391 min ago0x1c36b797e6baa25b966ba8b20426954d8fe95e07 IN  Mobox: MBOX Token0 BNB0.000260304
0x9cfd99aaf11a98c049d03443f688c7d4497199d0ecebafecb1e72955c6df621cTransfer111346032021-09-22 11:05:391 min agoBinance: Hot Wallet 7 IN  Mobox: MBOX Token0 BNB0.00036052
0x4e654d38c388aa447806393309552a1ae7363a9038b40ae6d52128951bef477eTransfer111345982021-09-22 11:05:241 min ago0x8aac9379ecaa7e543aa00eab47f38cd306195ebb IN  Mobox: MBOX Token0 BNB0.0001839264
0x009bc850adeb25a8a835b0a9f895cd29a8369aaf6a92431856137703cbd6f0c8Transfer111345972021-09-22 11:05:211 min ago0x5c22774f3bf06a9e4b989399aa76490fb083857d IN  Mobox: MBOX Token0 BNB0.0001802
0xcd6d253ab7a74a4d7494f96edf069bd20574f039207a98eec981d27ac1a875c7Transfer111345892021-09-22 11:04:572 mins ago0xf23dcce5e3828cab24a339d6b77c752d568d8720 IN  Mobox: MBOX Token0 BNB0.0001052
0x2e1a085d53e22098cd506f13501ec5b4302c478cdfe8d2bf5eca274df9d4a88dApprove111345872021-09-22 11:04:512 mins ago0x1f474f0ef21280226f449278bd27ca5884502fe8 IN  Mobox: MBOX Token0 BNB0.00022203
0x3d1809e573b707cd17776af7b1cad957fbcaf16dd74557b0855c9fcc779cb0e4Approve111345862021-09-22 11:04:482 mins ago0x0b79651650b1b2affec007878c2eb78468102e3a IN  Mobox: MBOX Token0 BNB0.0002264706
0x99c3f8055855b3e40bdcc664f04ae80e91ced76adadaab00681665df03cd725fTransfer111345862021-09-22 11:04:482 mins ago0xc39200225276242ab15b04b40c052af4d634e0e7 IN  Mobox: MBOX Token0 BNB0.0001839876
0x95be2b37eb56520aa92359572a1b7e8339da0f320648eabc855e572cea07441fApprove111345802021-09-22 11:04:252 mins ago0x94c08b91ee1f41d926b1bce21c7af1396ab55036 IN  Mobox: MBOX Token0 BNB0.00022203
0xbe2e5c2923f743a7dae4e234f6a0587de79df3a2ef711ed4834d3c2cb74c6f9dApprove111345772021-09-22 11:04:142 mins ago0x57631909c1b73cbc1856708b20c97c67a1c722f0 IN  Mobox: MBOX Token0 BNB0.00022203
0xb5a20e87f17800f91c1b3b9eb726c1b71c1661fee9122482de1a03de1a78521dTransfer111345742021-09-22 11:04:033 mins ago0x1c36b797e6baa25b966ba8b20426954d8fe95e07 IN  Mobox: MBOX Token0 BNB0.000260304
0x39954c5dfd637d2b939dbf8ebee8d033be835631dee84b2966d1316c1529260bTransfer111345712021-09-22 11:03:543 mins ago0x5c22774f3bf06a9e4b989399aa76490fb083857d IN  Mobox: MBOX Token0 BNB0.0001802
0x938edb6e77a5fd97eb288df5d71bdbbaee3d4530dc0938397f47eecc46077b4cTransfer111345592021-09-22 11:03:173 mins ago0xb7a8c783e937ef871a377ea9dd336fd0949d4ddb IN  Mobox: MBOX Token0 BNB0.0001802
0xd1a86a5c38815c992727fa619442f5702e74791c34db4e289bb201e0854c86eeApprove111345552021-09-22 11:03:054 mins ago0x5ea120779bc005a5a583ba56211bde560ca67e8c IN  Mobox: MBOX Token0 BNB0.00022203
0x2cb67175210af9cf3358cde42c1ddb00b98317c5fd37c16b60ae49f1b6341f5eTransfer111345512021-09-22 11:02:534 mins ago0xb8c674487c7f67bb055e34256c50209b1018ae43 IN  Mobox: MBOX Token0 BNB0.0002552
0x54abc8c59d59fa126e771187a62ba2539fff94312e7c9c781c5293cf4eb1867aTransfer111345502021-09-22 11:02:504 mins ago0x5c22774f3bf06a9e4b989399aa76490fb083857d IN  Mobox: MBOX Token0 BNB0.0001802
0x1d8de4f0310afedafd1559c715e1355b3f2a35e52f54164a16ad8a6539b208d9Transfer111345462021-09-22 11:02:384 mins ago0xd2537d002e6e9821c4d8489c7a9099b150a05d55 IN  Mobox: MBOX Token0 BNB0.00018026
0x1ebc23e9f7f0f926978902fd3cd305c1468b4aba4eada0b30a3d02715da35d22Transfer111345452021-09-22 11:02:354 mins ago0x538f3d4237c04a2becaf45ff59320b69edd1518c IN  Mobox: MBOX Token0 BNB0.00010532
0x92b11e44649258f8f7523d0b7ccdec90c22aae34b8e20e4bcc813f245925b773Transfer111345432021-09-22 11:02:294 mins ago0xb7a8c783e937ef871a377ea9dd336fd0949d4ddb IN  Mobox: MBOX Token0 BNB0.0001802
[ 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 Security Audit

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"}]

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

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.