Contract 0x3203c9e46ca618c8c1ce5dc67e7e9d75f5da2377 9

 

Contract Overview

Mobox: MBOX Token
Balance:
0 BNB

BNB Value:
$0.00

Token:
 
Txn Hash Method
Block
From
To
Value [Txn Fee]
0xd3f3617b8c60ea214e1f7438af6b26e6eca86a5064e2ff08795f36a4a24975d6Transfer120641972021-10-25 0:41:341 min ago0xf8948aa8e8116a38fd035224ef41f946574e12a1 IN  Mobox: MBOX Token0 BNB0.0001052
0xc21c7c635aca8c1f20e471288d8db046f630f0dbf6a947175322f3892f67d5ecTransfer120641492021-10-25 0:39:103 mins ago0x6dcaa39b116c091de01097a266650eb0ab85de1c IN  Mobox: MBOX Token0 BNB0.00018032
0xed5fa3a18611b38187a6d4901c1929f4b148b5bfaaca9cd2863d2e1dc4fc6418Transfer120640442021-10-25 0:33:498 mins ago0xc8abb5fb2be7b799d7892db1bbb7a0d10a04334f IN  Mobox: MBOX Token0 BNB0.00018038
0xed3b39b510bde9a8f699c504d1d22bc8851fbc76a339724e5221b67085ee444dApprove120640422021-10-25 0:33:439 mins ago0x8799070f10cae32c650d63baf8be783d6983542e IN  Mobox: MBOX Token0 BNB0.00022203
0x411451e2b3e6bb17d78b73cff08c39b0d3f9713cb6b3232ce3eaa6a464c9fbdeApprove120640262021-10-25 0:32:4610 mins ago0x2f5589dd273867638e08217e4f1584b79fd9e437 IN  Mobox: MBOX Token0 BNB0.00022203
0xeadf800df7bbf18362153bcebd8b29b96d3c1a6d799ae26c22be08bf3d307303Transfer120639762021-10-25 0:30:1612 mins agoHotbit 2 IN  Mobox: MBOX Token0 BNB0.00035728
0x78a542272812becf4ceceead6753b40cf19746f566400ef655b8ee0ce0bc5b03Transfer120639752021-10-25 0:30:1312 mins ago0x0e926f0d312adcda04c84200d13e2d542a36fae2 IN  Mobox: MBOX Token0 BNB0.00010538
0x49e360c26417fd3bf958e84869082dc5d0230a869d6266ea8b79cdc81d6dd8daTransfer120639552021-10-25 0:29:1313 mins ago0xfa4ac7f327e4014ef8bab8ef5051947694a3c4a9 IN  Mobox: MBOX Token0 BNB0.00010538
0x8780662fc923f5eb345278801879071fb925fb8edb636da4aaa2a658458a0d7bApprove120638932021-10-25 0:26:0716 mins ago0x109d9450be1fa9b642df6df355387f341cec1c31 IN  Mobox: MBOX Token0 BNB0.00022203
0x15e074f8c0c6d0e779e97276713f82ad3d6556842e236922114d5db2f4766b5fApprove120638852021-10-25 0:25:4317 mins ago0xfbcc0fc43385099cae4ab88938c839bdaa484bf9 IN  Mobox: MBOX Token0 BNB0.00022203
0xedb725414fa4fa671660567b192ddb3b188e63670fd6fa86174bbc4f1ada1b22Approve120638482021-10-25 0:23:5218 mins ago0x91db777f12f3f28acd0d964014bbf02bb13d7e56 IN  Mobox: MBOX Token0 BNB0.00022203
0x541c77b2bf0cb49a7c865718f4970ee7427c077774b054572c8d6b7ec9dc200fApprove120638432021-10-25 0:23:3719 mins ago0x24daed2566fff59eb12c36a6828cca3aff3bf510 IN  Mobox: MBOX Token0 BNB0.00022203
0x70a8e3ebb64f6723c753e6a974f9f7970bde701ac69e89d92a846dd8232527faTransfer120637542021-10-25 0:19:1023 mins ago0xefb78a78db0c56226e39853f3197291b2231c295 IN  Mobox: MBOX Token0 BNB0.0001074264
0xddee2c845fbb49f8abb14b4c52dd750c4404ca5c067635fc216f221f2f320650Transfer120637512021-10-25 0:19:0123 mins agoBinance: Hot Wallet 7 IN  Mobox: MBOX Token0 BNB0.00036064
0x155e23495d2365badafd612d50ac47b03ae4a438e62f1318f55ace1d39371aa8Transfer120636992021-10-25 0:16:2526 mins ago0xad3fda647711a0925998a2687000f14e445bd176 IN  Mobox: MBOX Token0 BNB0.00010526
0x118945a514926b243913219450a722a9b468fe4e7433c0d2f134ccf8143fcdb8Approve120636782021-10-25 0:15:2227 mins ago0x5a78f4d9852ce8d3d0ca316abbc4cb1ec2418d28 IN  Mobox: MBOX Token0 BNB0.00044406
0x641d8ad1cf99941c2e8d33052207e84e41d804b4e844a017e8e0a6477f3ba228Transfer120636312021-10-25 0:13:0129 mins ago0x7c2efb7fe1f1724e7d76100ee38e2aa33dd77b93 IN  Mobox: MBOX Token0 BNB0.0001074876
0x572e601f65d5ed63f862688464952cc5646b7759b62d7bbe062add6c35660f2aTransfer120636202021-10-25 0:12:2830 mins ago0xf8948aa8e8116a38fd035224ef41f946574e12a1 IN  Mobox: MBOX Token0 BNB0.0001802
0xd0cfd3ea91a2cb34c068da80b930a6c2ad0f5cb1c8508ccd3e1f57329b301efcApprove120636142021-10-25 0:12:1030 mins ago0x109d9450be1fa9b642df6df355387f341cec1c31 IN  Mobox: MBOX Token0 BNB0.00022203
0xfcc1c1b3ed887b00d6ba66876f0836c3af79f81480f101ac0ece2995681d85a9Transfer120636042021-10-25 0:11:4031 mins ago0xf8948aa8e8116a38fd035224ef41f946574e12a1 IN  Mobox: MBOX Token0 BNB0.000125
0x406b81b406bfc5ffca1aaef357c0b5957bd98df5b1c14faf1638cc8f00d9ad58Approve120635932021-10-25 0:11:0731 mins ago0x8b7a3a32163cdccfbff122e9658455d35342853f IN  Mobox: MBOX Token0 BNB0.00022203
0xcfe5b6a9e4dd39db7c359e3b8d56c7e154f88b1ef38f7993f4aa32593fffc40dTransfer120635812021-10-25 0:10:3132 mins ago0xacfae388f153a54cd5ab7e22cd6fe6647769c3bb IN  Mobox: MBOX Token0 BNB0.0001074876
0x760179f4103f7614bf028ac4be2bd4cab52544246db3dda26f6ad5dbc37cda7bTransfer120635692021-10-25 0:09:5532 mins ago0x557680d8f8dbea12751e0883c8356f549516f255 IN  Mobox: MBOX Token0 BNB0.0001074876
0x47df08fc10785afd91cc7d45b3284fa3abd75e35577fa925162d38d71d88d7d5Transfer120635412021-10-25 0:08:3134 mins agoBinance: Hot Wallet 6 IN  Mobox: MBOX Token0 BNB0.00036052
0xbdba2a0d65300dbe05b5a140b996ddf01d39e084d668bbaadd6a37c361825aa2Transfer120635292021-10-25 0:07:5534 mins ago0xad3fda647711a0925998a2687000f14e445bd176 IN  Mobox: MBOX Token0 BNB0.00025526
[ 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.