Contract 0x4a627b324189014fa757ed7cc730b180879232d7

 

Contract Overview

MCH: Land Pool
Balance:
69.386384768786575856 Ether

EtherValue:
$132,618.20 (@ $1,911.30/ETH)

Token:
Ad
Crypto.com
Txn Hash Method
Block
From
To
Value
0xa269e0cdfdf20eba3bdfef1860e498f03bf167bf0ecd984835b7087c7568fc07Withdraw My All ...(pending)2021-06-22 13:09:248 hrs 9 mins ago0x65bf911288d5c0044e8a97b9362b8163eed316a9 IN MCH: Land Pool0 Ether(Pending)(Pending)
0x43b48615935417af658474c8111e7f4faf349f80b056410a6a306cb182830a6fWithdraw My All ...(pending)2021-06-20 4:45:342 days 16 hrs ago0xb0643c0b3027804ebc9669edcf3e8dfa8403d27b IN MCH: Land Pool0 Ether(Pending)(Pending)
0xad25ea7c5baca8411f5c392f407642a628a130e8fb6deea679c714505d954f06Withdraw My All ...126814142021-06-22 2:38:2618 hrs 40 mins ago0xb3923702e04cecd2726d0026e2154b3488e5b7e2 IN  MCH: Land Pool0 Ether0.00257880623
0xe631b78da012049d1330100211b2c08110f4bfb7dfdd9f1110a1df7a6c44d496Withdraw My All ...126684622021-06-20 2:03:062 days 19 hrs ago0xc1f89d01478f04d6c253ea2c2c958b4d85e0d5dd IN  MCH: Land Pool0 Ether0.0021709387
0xbf6cb696f9a1f4e842d74e9fdb256e2a26b616ae412ae42c5044574c9e867037Withdraw My Rewa...126684622021-06-20 2:03:062 days 19 hrs ago0xd718b31115927c7a60165423b357ba59b7e38643 IN  MCH: Land Pool0 Ether0.00046435427.1
0x096ef42ab2e79c048cc6b876fd83e4d0ef3f9617c80d3caea489845811e506ccWithdraw My All ...126681542021-06-20 0:53:302 days 20 hrs ago0x8dc9a800a12a6f0b8e0cb485213b777c296a9536 IN  MCH: Land Pool0 Ether0.00088961186.1
0x3b028cfed47e7e111efd9601df0a6e3e26d0186cba05a9967cccf15f8795e3cbWithdraw My All ...126678162021-06-19 23:43:312 days 21 hrs ago0x057dc43af6187a931e78a56b3293912a5b42e5ec IN  MCH: Land Pool0 Ether0.00168260067.1
0x757dd4190b78aa6b5a6c8c38dda376cfd413de790417b9985df22b16ca8fa8c3Withdraw My Rewa...126645562021-06-19 11:33:453 days 9 hrs ago0x2aafe1cfd4d846f17a48893c9dffc72385aacddd IN  MCH: Land Pool0 Ether0.0006540210
0xaea136cd776f812af36233e014f75d29c341f7a193fff967ee926847c1a1d1e8Withdraw My All ...126638562021-06-19 8:54:233 days 12 hrs ago0xbb93b64fe6654a3bd0ec1228cb5a193b964b3c10 IN  MCH: Land Pool0 Ether0.0005628427
0x6f03446f36af519a09a84eab516f8d68fd3bc250613528af083f7a4292c69925Withdraw My Rewa...126566782021-06-18 5:45:324 days 15 hrs ago0x3d55bec7fa149ff3d82f482492878a91155f9d6e IN  MCH: Land Pool0 Ether0.0004578147
0x08a766f87f51fee2351c17f827fff7bc8874fd403d29a410561e86d411e85441Withdraw My Rewa...126566772021-06-18 5:45:284 days 15 hrs ago0x3d55bec7fa149ff3d82f482492878a91155f9d6e IN  MCH: Land Pool0 Ether0.0004578147
0x2a6763b233a25fbb41144a69e40964d7563326a98a9527348e615aea2b23c283Withdraw My All ...126553002021-06-18 0:55:254 days 20 hrs ago0x62362b22e3040bf9c914758718ab229be6f6025f IN  MCH: Land Pool0 Ether0.00160421811
0xa0e4521523460bbad703ca10e25c3cf6df2634e9dfe9bb5494ab00653b64c541Withdraw My All ...126480612021-06-16 22:04:185 days 23 hrs ago0xa443762c3918e14edec04042da2fa114d31fe020 IN  MCH: Land Pool0 Ether0.00149995515
0xb3f367e38ab6d519dc29ff3c3a5fd1a1262cbcf0cd0d3e750af24edb846a882fWithdraw My All ...126427852021-06-16 2:14:526 days 19 hrs ago0x813074b9a3c964c51ac66b841c2577a3ce1062f6 IN  MCH: Land Pool0 Ether0.00112568414
0xc9056e94a9f02b38fb768a039609f53b73f00cd70d2e567aae7d72fcafff56d8Withdraw My All ...126390002021-06-15 12:17:067 days 9 hrs ago0x193186e8578e575a99766f1bec5950aec73e4c28 IN  MCH: Land Pool0 Ether0.0023019711
0xcd0fab3f5638e2ab3cad2f494ac367bd6c5e118b628fa0e6e3714366ef8e73feWithdraw My All ...126276522021-06-13 18:03:339 days 3 hrs ago0xccb82218c6f82a2b750cf0d65e21ae6eae14070c IN  MCH: Land Pool0 Ether0.0007708547
0xdb141b596270ceae5593700b3e9c80220ebcb938f0a24c9e0fc43824745c2402Withdraw My All ...126269862021-06-13 15:39:439 days 5 hrs ago0x94c1b1e54e27dd2fb5a11db01177c94356cacb38 IN  MCH: Land Pool0 Ether0.00241706853911.550000191
0x3eb8a9ce27a2c5d5564cf0bca608a0c3c4765deaa9336d164dc14cf7ac4fb9a3Withdraw My All ...126246572021-06-13 7:06:059 days 14 hrs ago0x5fd794a8364198cf74c6e71f7efc1754a2641f30 IN  MCH: Land Pool0 Ether0.0023898610
0x9f873c4b730b94d6ba092a3ff04a6cbb54d1ec9660a832bcf9feb5322656b1a6Withdraw My All ...126228702021-06-13 0:19:499 days 20 hrs ago0x761599064123baf63413e5c7b84e25ed64531867 IN  MCH: Land Pool0 Ether0.0009129768
0x527647f0d4311060754503d41a1171f896464204d4368b6fe855fee7ea957d28Withdraw My All ...126224592021-06-12 22:45:209 days 22 hrs ago0x59abc75b3035a0dccb9a9454296a8e92b9831c5e IN  MCH: Land Pool0 Ether0.001450897
0x13b58b6e2c6e1992fe647f7dba0c553c31b3886350b5c820581aafcbbd12a9c4Withdraw My All ...126224572021-06-12 22:45:049 days 22 hrs ago0xfa595c3f3ea63bbfb408eef222ca947f791da0bc IN  MCH: Land Pool0 Ether0.0007848547
0x4515f420db82dcdce3477b40c9103e4c35e20bd07a2b9081b6bb58766d8a8d06Withdraw My All ...126224542021-06-12 22:44:559 days 22 hrs ago0xd226691750d1592a10185de2c56569727918ab4e IN  MCH: Land Pool0 Ether0.0005628427
0x54ce68d7d9fa81c3f9125d9a8b03635acd2c60e6463c77a8ae26cf2b7cfd382eWithdraw My All ...126224532021-06-12 22:44:429 days 22 hrs ago0x0847a613acec87325bf3a16ae1229ea87674c880 IN  MCH: Land Pool0 Ether0.0010068667
0xbb9c51bb796f0d902e83a57f2514868a498b513a867cb57d15347e5fe45846daWithdraw My Rewa...126219312021-06-12 20:55:3310 days 23 mins ago0xed1cebd5ba907bc6af3734e5df8543c721b07cda IN  MCH: Land Pool0 Ether0.0005233126548.00001
0xe9b6b24b6376c1db9333963a1223724462229c08757ff4e9af4ee00910079ccbWithdraw My All ...126192142021-06-12 10:50:0110 days 10 hrs ago0xce9f8bf725e785f85354a52e3f7a6272cbe5c846 IN  MCH: Land Pool0 Ether0.0012060915
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x1d8420e2ac49c46713dac201383a9194479331c8d0a79aa56772ad5a012fe8ce126858292021-06-22 19:15:252 hrs 3 mins ago 0x32e64e75091d13c64f11db67ea94ac16951629b9 MCH: Land Pool1.5 Ether
0x49af1cfff309b9f752310ec124e21736888cf252873269d789b519605ee0d5fb126858262021-06-22 19:14:262 hrs 4 mins ago 0x32e64e75091d13c64f11db67ea94ac16951629b9 MCH: Land Pool1.5 Ether
0x3988dcdf5d3e58ef5bc09742214baa6e7e3b0e86575ef76e5720024cdc706b4a126815362021-06-22 3:09:4918 hrs 9 mins ago 0x32e64e75091d13c64f11db67ea94ac16951629b9 MCH: Land Pool0.015 Ether
0xad25ea7c5baca8411f5c392f407642a628a130e8fb6deea679c714505d954f06126814142021-06-22 2:38:2618 hrs 40 mins ago MCH: Land Pool0xb3923702e04cecd2726d0026e2154b3488e5b7e20.019096390484003277 Ether
0x38a92f8ff62d5df31fcb78e218f427fc142a561191ee19ca94d987400cd70935126764702021-06-21 8:04:261 day 13 hrs ago 0x32e64e75091d13c64f11db67ea94ac16951629b9 MCH: Land Pool0.03 Ether
0x3fba58c7f50cf425b4a7e772330daac51e247ce5bde0b69717ef6fec2582fccc126753302021-06-21 3:39:541 day 17 hrs ago 0x32e64e75091d13c64f11db67ea94ac16951629b9 MCH: Land Pool0.015 Ether
0xd7607049f6a12a72e3bf66cfb8849b9bff1908558345fb07b52adf9c3cedd5aa126743052021-06-20 23:48:001 day 21 hrs ago 0x32e64e75091d13c64f11db67ea94ac16951629b9 MCH: Land Pool0.015 Ether
0x76917851e6eed19313bddadc662e37f548756046a3f7008c876a61153093fc8a126702072021-06-20 8:36:192 days 12 hrs ago 0x32e64e75091d13c64f11db67ea94ac16951629b9 MCH: Land Pool0.03 Ether
0x089fd6d2caef443a2986562ec5b7c98faed0534fef032000e419f25a02199ac6126687212021-06-20 2:59:052 days 18 hrs ago 0x32e64e75091d13c64f11db67ea94ac16951629b9 MCH: Land Pool0.03 Ether
0xe631b78da012049d1330100211b2c08110f4bfb7dfdd9f1110a1df7a6c44d496126684622021-06-20 2:03:062 days 19 hrs ago MCH: Land Pool0xc1f89d01478f04d6c253ea2c2c958b4d85e0d5dd0.101705106480786071 Ether
0xbf6cb696f9a1f4e842d74e9fdb256e2a26b616ae412ae42c5044574c9e867037126684622021-06-20 2:03:062 days 19 hrs ago MCH: Land Pool0xd718b31115927c7a60165423b357ba59b7e386430.009986522911051212 Ether
0x096ef42ab2e79c048cc6b876fd83e4d0ef3f9617c80d3caea489845811e506cc126681542021-06-20 0:53:302 days 20 hrs ago MCH: Land Pool0x8dc9a800a12a6f0b8e0cb485213b777c296a95360.006838985261483633 Ether
0x3b028cfed47e7e111efd9601df0a6e3e26d0186cba05a9967cccf15f8795e3cb126678162021-06-19 23:43:312 days 21 hrs ago MCH: Land Pool0x057dc43af6187a931e78a56b3293912a5b42e5ec0.08144417191904184 Ether
0x757dd4190b78aa6b5a6c8c38dda376cfd413de790417b9985df22b16ca8fa8c3126645562021-06-19 11:33:453 days 9 hrs ago MCH: Land Pool0x2aafe1cfd4d846f17a48893c9dffc72385aacddd0.013969002695417788 Ether
0xaea136cd776f812af36233e014f75d29c341f7a193fff967ee926847c1a1d1e8126638562021-06-19 8:54:233 days 12 hrs ago MCH: Land Pool0xbb93b64fe6654a3bd0ec1228cb5a193b964b3c100.022979493365500603 Ether
0x5e4519cc7f40f2765b7a32769f7920a1e3724513e9c68f777d4448e7c1eeb720126585342021-06-18 12:59:094 days 8 hrs ago 0x32e64e75091d13c64f11db67ea94ac16951629b9 MCH: Land Pool0.015 Ether
0x6f03446f36af519a09a84eab516f8d68fd3bc250613528af083f7a4292c69925126566782021-06-18 5:45:324 days 15 hrs ago MCH: Land Pool0x3d55bec7fa149ff3d82f482492878a91155f9d6e0.004598965071151355 Ether
0x08a766f87f51fee2351c17f827fff7bc8874fd403d29a410561e86d411e85441126566772021-06-18 5:45:284 days 15 hrs ago MCH: Land Pool0x3d55bec7fa149ff3d82f482492878a91155f9d6e0.005496894409937886 Ether
0x2a6763b233a25fbb41144a69e40964d7563326a98a9527348e615aea2b23c283126553002021-06-18 0:55:254 days 20 hrs ago MCH: Land Pool0x62362b22e3040bf9c914758718ab229be6f6025f0.026803024409031547 Ether
0xa46dfb72623be868babd5f8b47637c4397891f0ce3d3f8243c80bbfe312a6b69126526792021-06-17 15:17:305 days 6 hrs ago 0x32e64e75091d13c64f11db67ea94ac16951629b9 MCH: Land Pool0.015 Ether
0xa0b30f1ad4f26fc7b6ae90eebd82df09fdc6ede9cc632e13ba5213a773b73eac126526332021-06-17 15:06:225 days 6 hrs ago 0x32e64e75091d13c64f11db67ea94ac16951629b9 MCH: Land Pool0.03 Ether
0x44dd3d854f05d6d38084aa7da51cfd080a063b541d3c2f86bb40e30d5a76a25f126459712021-06-16 14:14:496 days 7 hrs ago 0x32e64e75091d13c64f11db67ea94ac16951629b9 MCH: Land Pool0.015 Ether
0x3551f1c948581ce5e5e0880ba7f12c475561d27473bb9f0a619629ad3ed05591126441642021-06-16 7:30:226 days 13 hrs ago 0x32e64e75091d13c64f11db67ea94ac16951629b9 MCH: Land Pool0.015 Ether
0xb3f367e38ab6d519dc29ff3c3a5fd1a1262cbcf0cd0d3e750af24edb846a882f126427852021-06-16 2:14:526 days 19 hrs ago MCH: Land Pool0x813074b9a3c964c51ac66b841c2577a3ce1062f60.002270375161707631 Ether
0x31dbd7f25f7a7609f809e9a78be8b5c20c7dccf889da219ee43115d87fd454ed126404142021-06-15 17:32:167 days 3 hrs ago 0x32e64e75091d13c64f11db67ea94ac16951629b9 MCH: Land Pool0.03 Ether
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
MCHLandPool

Compiler Version
v0.5.4+commit.9549d8ff

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2019-02-22
*/

pragma solidity ^0.5.0;

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/utils/ReentrancyGuard.sol

/**
 * @title Helps contracts guard against reentrancy attacks.
 * @author Remco Bloemen <[email protected]π.com>, Eenae <[email protected]>
 * @dev If you mark a function `nonReentrant`, you should also
 * mark it `external`.
 */
contract ReentrancyGuard {
    /// @dev counter to allow mutex lock with only one SSTORE operation
    uint256 private _guardCounter;

    constructor () internal {
        // The counter starts at one to prevent changing it from zero to a non-zero
        // value, which is a more expensive operation.
        _guardCounter = 1;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _guardCounter += 1;
        uint256 localCounter = _guardCounter;
        _;
        require(localCounter == _guardCounter);
    }
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/math/SafeMath.sol

/**
 * @title SafeMath
 * @dev Unsigned math operations with safety checks that revert on error
 */
library SafeMath {
    /**
    * @dev Multiplies two unsigned integers, reverts on 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);

        return c;
    }

    /**
    * @dev Integer division of two unsigned integers truncating the quotient, reverts on division by zero.
    */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

    /**
    * @dev Subtracts two unsigned integers, reverts on overflow (i.e. if subtrahend is greater than minuend).
    */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a);
        uint256 c = a - b;

        return c;
    }

    /**
    * @dev Adds two unsigned integers, reverts on overflow.
    */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a);

        return c;
    }

    /**
    * @dev Divides two unsigned integers and returns the remainder (unsigned integer modulo),
    * reverts when dividing by zero.
    */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b != 0);
        return a % b;
    }
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/access/Roles.sol

/**
 * @title Roles
 * @dev Library for managing addresses assigned to a Role.
 */
library Roles {
    struct Role {
        mapping (address => bool) bearer;
    }

    /**
     * @dev give an account access to this role
     */
    function add(Role storage role, address account) internal {
        require(account != address(0));
        require(!has(role, account));

        role.bearer[account] = true;
    }

    /**
     * @dev remove an account's access to this role
     */
    function remove(Role storage role, address account) internal {
        require(account != address(0));
        require(has(role, account));

        role.bearer[account] = false;
    }

    /**
     * @dev check if an account has this role
     * @return bool
     */
    function has(Role storage role, address account) internal view returns (bool) {
        require(account != address(0));
        return role.bearer[account];
    }
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/access/roles/PauserRole.sol

contract PauserRole {
    using Roles for Roles.Role;

    event PauserAdded(address indexed account);
    event PauserRemoved(address indexed account);

    Roles.Role private _pausers;

    constructor () internal {
        _addPauser(msg.sender);
    }

    modifier onlyPauser() {
        require(isPauser(msg.sender));
        _;
    }

    function isPauser(address account) public view returns (bool) {
        return _pausers.has(account);
    }

    function addPauser(address account) public onlyPauser {
        _addPauser(account);
    }

    function renouncePauser() public {
        _removePauser(msg.sender);
    }

    function _addPauser(address account) internal {
        _pausers.add(account);
        emit PauserAdded(account);
    }

    function _removePauser(address account) internal {
        _pausers.remove(account);
        emit PauserRemoved(account);
    }
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/lifecycle/Pausable.sol

/**
 * @title Pausable
 * @dev Base contract which allows children to implement an emergency stop mechanism.
 */
contract Pausable is PauserRole {
    event Paused(address account);
    event Unpaused(address account);

    bool private _paused;

    constructor () internal {
        _paused = false;
    }

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

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     */
    modifier whenNotPaused() {
        require(!_paused);
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     */
    modifier whenPaused() {
        require(_paused);
        _;
    }

    /**
     * @dev called by the owner to pause, triggers stopped state
     */
    function pause() public onlyPauser whenNotPaused {
        _paused = true;
        emit Paused(msg.sender);
    }

    /**
     * @dev called by the owner to unpause, returns to normal state
     */
    function unpause() public onlyPauser whenPaused {
        _paused = false;
        emit Unpaused(msg.sender);
    }
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/ownership/Ownable.sol

/**
 * @title Ownable
 * @dev The Ownable contract has an owner address, and provides basic authorization control
 * functions, this simplifies the implementation of "user permissions".
 */
contract Ownable {
    address private _owner;

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

    /**
     * @dev The Ownable constructor sets the original `owner` of the contract to the sender
     * account.
     */
    constructor () internal {
        _owner = msg.sender;
        emit OwnershipTransferred(address(0), _owner);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(isOwner());
        _;
    }

    /**
     * @return true if `msg.sender` is the owner of the contract.
     */
    function isOwner() public view returns (bool) {
        return msg.sender == _owner;
    }

    /**
     * @dev Allows the current owner to relinquish control of the contract.
     * @notice Renouncing to ownership will leave the contract without an owner.
     * It will not be possible to call the functions with the `onlyOwner`
     * modifier anymore.
     */
    function renounceOwnership() public onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }

    /**
     * @dev Allows the current owner to transfer control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function transferOwnership(address newOwner) public onlyOwner {
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers control of the contract to a newOwner.
     * @param newOwner The address to transfer ownership to.
     */
    function _transferOwnership(address newOwner) internal {
        require(newOwner != address(0));
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/introspection/IERC165.sol

/**
 * @title IERC165
 * @dev https://github.com/ethereum/EIPs/blob/master/EIPS/eip-165.md
 */
interface IERC165 {
    /**
     * @notice Query if a contract implements an interface
     * @param interfaceId The interface identifier, as specified in ERC-165
     * @dev Interface identification is specified in ERC-165. This function
     * uses less than 30,000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/token/ERC721/IERC721.sol

/**
 * @title ERC721 Non-Fungible Token Standard basic interface
 * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract IERC721 is IERC165 {
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    function balanceOf(address owner) public view returns (uint256 balance);
    function ownerOf(uint256 tokenId) public view returns (address owner);

    function approve(address to, uint256 tokenId) public;
    function getApproved(uint256 tokenId) public view returns (address operator);

    function setApprovalForAll(address operator, bool _approved) public;
    function isApprovedForAll(address owner, address operator) public view returns (bool);

    function transferFrom(address from, address to, uint256 tokenId) public;
    function safeTransferFrom(address from, address to, uint256 tokenId) public;

    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/token/ERC721/IERC721Receiver.sol

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
contract IERC721Receiver {
    /**
     * @notice Handle the receipt of an NFT
     * @dev The ERC721 smart contract calls this function on the recipient
     * after a `safeTransfer`. This function MUST return the function selector,
     * otherwise the caller will revert the transaction. The selector to be
     * returned can be obtained as `this.onERC721Received.selector`. This
     * function MAY throw to revert and reject the transfer.
     * Note: the ERC721 contract address is always the message sender.
     * @param operator The address which called `safeTransferFrom` function
     * @param from The address which previously owned the token
     * @param tokenId The NFT identifier which is being transferred
     * @param data Additional data with no specified format
     * @return `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
    public returns (bytes4);
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/utils/Address.sol

/**
 * Utility library of inline functions on addresses
 */
library Address {
    /**
     * Returns whether the target address is a contract
     * @dev This function will return false if invoked during the constructor of a contract,
     * as the code is not actually created until after the constructor finishes.
     * @param account address of the account to check
     * @return whether the target address is a contract
     */
    function isContract(address account) internal view returns (bool) {
        uint256 size;
        // XXX Currently there is no better way to check if there is a contract in an address
        // than to check the size of the code at that address.
        // See https://ethereum.stackexchange.com/a/14016/36603
        // for more details about how this works.
        // TODO Check this again before the Serenity release, because all addresses will be
        // contracts then.
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/introspection/ERC165.sol

/**
 * @title ERC165
 * @author Matt Condon (@shrugs)
 * @dev Implements ERC165 using a lookup table.
 */
contract ERC165 is IERC165 {
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;
    /**
     * 0x01ffc9a7 ===
     *     bytes4(keccak256('supportsInterface(bytes4)'))
     */

    /**
     * @dev a mapping of interface id to whether or not it's supported
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    /**
     * @dev A contract implementing SupportsInterfaceWithLookup
     * implement ERC165 itself
     */
    constructor () internal {
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    /**
     * @dev implement supportsInterface(bytes4) using a lookup table
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev internal method for registering an interface
     */
    function _registerInterface(bytes4 interfaceId) internal {
        require(interfaceId != 0xffffffff);
        _supportedInterfaces[interfaceId] = true;
    }
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/token/ERC721/ERC721.sol

/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract ERC721 is ERC165, IERC721 {
    using SafeMath for uint256;
    using Address for address;

    // Equals to `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
    // which can be also obtained as `IERC721Receiver(0).onERC721Received.selector`
    bytes4 private constant _ERC721_RECEIVED = 0x150b7a02;

    // Mapping from token ID to owner
    mapping (uint256 => address) private _tokenOwner;

    // Mapping from token ID to approved address
    mapping (uint256 => address) private _tokenApprovals;

    // Mapping from owner to number of owned token
    mapping (address => uint256) private _ownedTokensCount;

    // Mapping from owner to operator approvals
    mapping (address => mapping (address => bool)) private _operatorApprovals;

    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;
    /*
     * 0x80ac58cd ===
     *     bytes4(keccak256('balanceOf(address)')) ^
     *     bytes4(keccak256('ownerOf(uint256)')) ^
     *     bytes4(keccak256('approve(address,uint256)')) ^
     *     bytes4(keccak256('getApproved(uint256)')) ^
     *     bytes4(keccak256('setApprovalForAll(address,bool)')) ^
     *     bytes4(keccak256('isApprovedForAll(address,address)')) ^
     *     bytes4(keccak256('transferFrom(address,address,uint256)')) ^
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256)')) ^
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)'))
     */

    constructor () public {
        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721);
    }

    /**
     * @dev Gets the balance of the specified address
     * @param owner address to query the balance of
     * @return uint256 representing the amount owned by the passed address
     */
    function balanceOf(address owner) public view returns (uint256) {
        require(owner != address(0));
        return _ownedTokensCount[owner];
    }

    /**
     * @dev Gets the owner of the specified token ID
     * @param tokenId uint256 ID of the token to query the owner of
     * @return owner address currently marked as the owner of the given token ID
     */
    function ownerOf(uint256 tokenId) public view returns (address) {
        address owner = _tokenOwner[tokenId];
        require(owner != address(0));
        return owner;
    }

    /**
     * @dev Approves another address to transfer the given token ID
     * The zero address indicates there is no approved address.
     * There can only be one approved address per token at a given time.
     * Can only be called by the token owner or an approved operator.
     * @param to address to be approved for the given token ID
     * @param tokenId uint256 ID of the token to be approved
     */
    function approve(address to, uint256 tokenId) public {
        address owner = ownerOf(tokenId);
        require(to != owner);
        require(msg.sender == owner || isApprovedForAll(owner, msg.sender));

        _tokenApprovals[tokenId] = to;
        emit Approval(owner, to, tokenId);
    }

    /**
     * @dev Gets the approved address for a token ID, or zero if no address set
     * Reverts if the token ID does not exist.
     * @param tokenId uint256 ID of the token to query the approval of
     * @return address currently approved for the given token ID
     */
    function getApproved(uint256 tokenId) public view returns (address) {
        require(_exists(tokenId));
        return _tokenApprovals[tokenId];
    }

    /**
     * @dev Sets or unsets the approval of a given operator
     * An operator is allowed to transfer all tokens of the sender on their behalf
     * @param to operator address to set the approval
     * @param approved representing the status of the approval to be set
     */
    function setApprovalForAll(address to, bool approved) public {
        require(to != msg.sender);
        _operatorApprovals[msg.sender][to] = approved;
        emit ApprovalForAll(msg.sender, to, approved);
    }

    /**
     * @dev Tells whether an operator is approved by a given owner
     * @param owner owner address which you want to query the approval of
     * @param operator operator address which you want to query the approval of
     * @return bool whether the given operator is approved by the given owner
     */
    function isApprovedForAll(address owner, address operator) public view returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev Transfers the ownership of a given token ID to another address
     * Usage of this method is discouraged, use `safeTransferFrom` whenever possible
     * Requires the msg sender to be the owner, approved, or operator
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
    */
    function transferFrom(address from, address to, uint256 tokenId) public {
        require(_isApprovedOrOwner(msg.sender, tokenId));

        _transferFrom(from, to, tokenId);
    }

    /**
     * @dev Safely transfers the ownership of a given token ID to another address
     * If the target address is a contract, it must implement `onERC721Received`,
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     *
     * Requires the msg sender to be the owner, approved, or operator
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
    */
    function safeTransferFrom(address from, address to, uint256 tokenId) public {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev Safely transfers the ownership of a given token ID to another address
     * If the target address is a contract, it must implement `onERC721Received`,
     * which is called upon a safe transfer, and return the magic value
     * `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`; otherwise,
     * the transfer is reverted.
     * Requires the msg sender to be the owner, approved, or operator
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes data to send along with a safe transfer check
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public {
        transferFrom(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data));
    }

    /**
     * @dev Returns whether the specified token exists
     * @param tokenId uint256 ID of the token to query the existence of
     * @return whether the token exists
     */
    function _exists(uint256 tokenId) internal view returns (bool) {
        address owner = _tokenOwner[tokenId];
        return owner != address(0);
    }

    /**
     * @dev Returns whether the given spender can transfer a given token ID
     * @param spender address of the spender to query
     * @param tokenId uint256 ID of the token to be transferred
     * @return bool whether the msg.sender is approved for the given token ID,
     *    is an operator of the owner, or is the owner of the token
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view returns (bool) {
        address owner = ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Internal function to mint a new token
     * Reverts if the given token ID already exists
     * @param to The address that will own the minted token
     * @param tokenId uint256 ID of the token to be minted
     */
    function _mint(address to, uint256 tokenId) internal {
        require(to != address(0));
        require(!_exists(tokenId));

        _tokenOwner[tokenId] = to;
        _ownedTokensCount[to] = _ownedTokensCount[to].add(1);

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Internal function to burn a specific token
     * Reverts if the token does not exist
     * Deprecated, use _burn(uint256) instead.
     * @param owner owner of the token to burn
     * @param tokenId uint256 ID of the token being burned
     */
    function _burn(address owner, uint256 tokenId) internal {
        require(ownerOf(tokenId) == owner);

        _clearApproval(tokenId);

        _ownedTokensCount[owner] = _ownedTokensCount[owner].sub(1);
        _tokenOwner[tokenId] = address(0);

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Internal function to burn a specific token
     * Reverts if the token does not exist
     * @param tokenId uint256 ID of the token being burned
     */
    function _burn(uint256 tokenId) internal {
        _burn(ownerOf(tokenId), tokenId);
    }

    /**
     * @dev Internal function to transfer ownership of a given token ID to another address.
     * As opposed to transferFrom, this imposes no restrictions on msg.sender.
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
    */
    function _transferFrom(address from, address to, uint256 tokenId) internal {
        require(ownerOf(tokenId) == from);
        require(to != address(0));

        _clearApproval(tokenId);

        _ownedTokensCount[from] = _ownedTokensCount[from].sub(1);
        _ownedTokensCount[to] = _ownedTokensCount[to].add(1);

        _tokenOwner[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Internal function to invoke `onERC721Received` on a target address
     * The call is not executed if the target address is not a contract
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
        internal returns (bool)
    {
        if (!to.isContract()) {
            return true;
        }

        bytes4 retval = IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data);
        return (retval == _ERC721_RECEIVED);
    }

    /**
     * @dev Private function to clear current approval of a given token ID
     * @param tokenId uint256 ID of the token to be transferred
     */
    function _clearApproval(uint256 tokenId) private {
        if (_tokenApprovals[tokenId] != address(0)) {
            _tokenApprovals[tokenId] = address(0);
        }
    }
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/access/roles/MinterRole.sol

contract MinterRole {
    using Roles for Roles.Role;

    event MinterAdded(address indexed account);
    event MinterRemoved(address indexed account);

    Roles.Role private _minters;

    constructor () internal {
        _addMinter(msg.sender);
    }

    modifier onlyMinter() {
        require(isMinter(msg.sender));
        _;
    }

    function isMinter(address account) public view returns (bool) {
        return _minters.has(account);
    }

    function addMinter(address account) public onlyMinter {
        _addMinter(account);
    }

    function renounceMinter() public {
        _removeMinter(msg.sender);
    }

    function _addMinter(address account) internal {
        _minters.add(account);
        emit MinterAdded(account);
    }

    function _removeMinter(address account) internal {
        _minters.remove(account);
        emit MinterRemoved(account);
    }
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/token/ERC721/ERC721Mintable.sol

/**
 * @title ERC721Mintable
 * @dev ERC721 minting logic
 */
contract ERC721Mintable is ERC721, MinterRole {
    /**
     * @dev Function to mint tokens
     * @param to The address that will receive the minted tokens.
     * @param tokenId The token id to mint.
     * @return A boolean that indicates if the operation was successful.
     */
    function mint(address to, uint256 tokenId) public onlyMinter returns (bool) {
        _mint(to, tokenId);
        return true;
    }
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/token/ERC721/ERC721Pausable.sol

/**
 * @title ERC721 Non-Fungible Pausable token
 * @dev ERC721 modified with pausable transfers.
 **/
contract ERC721Pausable is ERC721, Pausable {
    function approve(address to, uint256 tokenId) public whenNotPaused {
        super.approve(to, tokenId);
    }

    function setApprovalForAll(address to, bool approved) public whenNotPaused {
        super.setApprovalForAll(to, approved);
    }

    function transferFrom(address from, address to, uint256 tokenId) public whenNotPaused {
        super.transferFrom(from, to, tokenId);
    }
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/token/ERC721/IERC721Enumerable.sol

/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract IERC721Enumerable is IERC721 {
    function totalSupply() public view returns (uint256);
    function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256 tokenId);

    function tokenByIndex(uint256 index) public view returns (uint256);
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/token/ERC721/ERC721Enumerable.sol

/**
 * @title ERC-721 Non-Fungible Token with optional enumeration extension logic
 * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract ERC721Enumerable is ERC165, ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => uint256[]) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

    bytes4 private constant _INTERFACE_ID_ERC721_ENUMERABLE = 0x780e9d63;
    /**
     * 0x780e9d63 ===
     *     bytes4(keccak256('totalSupply()')) ^
     *     bytes4(keccak256('tokenOfOwnerByIndex(address,uint256)')) ^
     *     bytes4(keccak256('tokenByIndex(uint256)'))
     */

    /**
     * @dev Constructor function
     */
    constructor () public {
        // register the supported interface to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721_ENUMERABLE);
    }

    /**
     * @dev Gets the token ID at a given index of the tokens list of the requested owner
     * @param owner address owning the tokens list to be accessed
     * @param index uint256 representing the index to be accessed of the requested tokens list
     * @return uint256 token ID at the given index of the tokens list owned by the requested address
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view returns (uint256) {
        require(index < balanceOf(owner));
        return _ownedTokens[owner][index];
    }

    /**
     * @dev Gets the total amount of tokens stored by the contract
     * @return uint256 representing the total amount of tokens
     */
    function totalSupply() public view returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev Gets the token ID at a given index of all the tokens in this contract
     * Reverts if the index is greater or equal to the total number of tokens
     * @param index uint256 representing the index to be accessed of the tokens list
     * @return uint256 token ID at the given index of the tokens list
     */
    function tokenByIndex(uint256 index) public view returns (uint256) {
        require(index < totalSupply());
        return _allTokens[index];
    }

    /**
     * @dev Internal function to transfer ownership of a given token ID to another address.
     * As opposed to transferFrom, this imposes no restrictions on msg.sender.
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the token to be transferred
    */
    function _transferFrom(address from, address to, uint256 tokenId) internal {
        super._transferFrom(from, to, tokenId);

        _removeTokenFromOwnerEnumeration(from, tokenId);

        _addTokenToOwnerEnumeration(to, tokenId);
    }

    /**
     * @dev Internal function to mint a new token
     * Reverts if the given token ID already exists
     * @param to address the beneficiary that will own the minted token
     * @param tokenId uint256 ID of the token to be minted
     */
    function _mint(address to, uint256 tokenId) internal {
        super._mint(to, tokenId);

        _addTokenToOwnerEnumeration(to, tokenId);

        _addTokenToAllTokensEnumeration(tokenId);
    }

    /**
     * @dev Internal function to burn a specific token
     * Reverts if the token does not exist
     * Deprecated, use _burn(uint256) instead
     * @param owner owner of the token to burn
     * @param tokenId uint256 ID of the token being burned
     */
    function _burn(address owner, uint256 tokenId) internal {
        super._burn(owner, tokenId);

        _removeTokenFromOwnerEnumeration(owner, tokenId);
        // Since tokenId will be deleted, we can clear its slot in _ownedTokensIndex to trigger a gas refund
        _ownedTokensIndex[tokenId] = 0;

        _removeTokenFromAllTokensEnumeration(tokenId);
    }

    /**
     * @dev Gets the list of token IDs of the requested owner
     * @param owner address owning the tokens
     * @return uint256[] List of token IDs owned by the requested address
     */
    function _tokensOfOwner(address owner) internal view returns (uint256[] storage) {
        return _ownedTokens[owner];
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        _ownedTokensIndex[tokenId] = _ownedTokens[to].length;
        _ownedTokens[to].push(tokenId);
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the _ownedTokensIndex mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _ownedTokens[from].length.sub(1);
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        _ownedTokens[from].length--;

        // Note that _ownedTokensIndex[tokenId] hasn't been cleared: it still points to the old slot (now occcupied by
        // lasTokenId, or just over the end of the array if the token was the last one).
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length.sub(1);
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        _allTokens.length--;
        _allTokensIndex[tokenId] = 0;
    }
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/token/ERC721/IERC721Metadata.sol

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract IERC721Metadata is IERC721 {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/token/ERC721/ERC721Metadata.sol

contract ERC721Metadata is ERC165, ERC721, IERC721Metadata {
    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Optional mapping for token URIs
    mapping(uint256 => string) private _tokenURIs;

    bytes4 private constant _INTERFACE_ID_ERC721_METADATA = 0x5b5e139f;
    /**
     * 0x5b5e139f ===
     *     bytes4(keccak256('name()')) ^
     *     bytes4(keccak256('symbol()')) ^
     *     bytes4(keccak256('tokenURI(uint256)'))
     */

    /**
     * @dev Constructor function
     */
    constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;

        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(_INTERFACE_ID_ERC721_METADATA);
    }

    /**
     * @dev Gets the token name
     * @return string representing the token name
     */
    function name() external view returns (string memory) {
        return _name;
    }

    /**
     * @dev Gets the token symbol
     * @return string representing the token symbol
     */
    function symbol() external view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns an URI for a given token ID
     * Throws if the token ID does not exist. May return an empty string.
     * @param tokenId uint256 ID of the token to query
     */
    function tokenURI(uint256 tokenId) external view returns (string memory) {
        require(_exists(tokenId));
        return _tokenURIs[tokenId];
    }

    /**
     * @dev Internal function to set the token URI for a given token
     * Reverts if the token ID does not exist
     * @param tokenId uint256 ID of the token to set its URI
     * @param uri string URI to assign
     */
    function _setTokenURI(uint256 tokenId, string memory uri) internal {
        require(_exists(tokenId));
        _tokenURIs[tokenId] = uri;
    }

    /**
     * @dev Internal function to burn a specific token
     * Reverts if the token does not exist
     * Deprecated, use _burn(uint256) instead
     * @param owner owner of the token to burn
     * @param tokenId uint256 ID of the token being burned by the msg.sender
     */
    function _burn(address owner, uint256 tokenId) internal {
        super._burn(owner, tokenId);

        // Clear metadata (if any)
        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }
    }
}

// File: contracts/lib/github.com/OpenZeppelin/openzeppelin-solidity-2.1.2/contracts/token/ERC721/ERC721FUll.sol

/**
 * @title Full ERC721 Token
 * This implementation includes all the required and some optional functionality of the ERC721 standard
 * Moreover, it includes approve all functionality using operator terminology
 * @dev see https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md
 */
contract ERC721Full is ERC721, ERC721Enumerable, ERC721Metadata {
    constructor (string memory name, string memory symbol) public ERC721Metadata(name, symbol) {
        // solhint-disable-previous-line no-empty-blocks
    }
}

// File: contracts/LandSectorAsset.sol

/* solhint-disable indent*/
pragma solidity 0.5.4;





contract LandSectorAsset is ERC721Full, ERC721Mintable, ERC721Pausable {


  uint256 public constant SHARE_RATE_DECIMAL = 10**18;

  uint16 public constant LEGENDARY_RARITY = 5;
  uint16 public constant EPIC_RARITY = 4;
  uint16 public constant RARE_RARITY = 3;
  uint16 public constant UNCOMMON_RARITY = 2;
  uint16 public constant COMMON_RARITY = 1;

  uint16 public constant NO_LAND = 0;

  string public tokenURIPrefix = "https://www.mycryptoheroes.net/metadata/land/";

  mapping(uint16 => uint256) private landTypeToTotalVolume;
  mapping(uint16 => uint256) private landTypeToSectorSupplyLimit;
  mapping(uint16 => mapping(uint16 => uint256)) private landTypeAndRarityToSectorSupply;
  mapping(uint16 => uint256[]) private landTypeToLandSectorList;
  mapping(uint16 => uint256) private landTypeToLandSectorIndex;
  mapping(uint16 => mapping(uint16 => uint256)) private landTypeAndRarityToLandSectorCount;
  mapping(uint16 => uint256) private rarityToSectorVolume;

  event MintEvent(
    address indexed assetOwner,
    uint256 tokenId,
    uint256 at,
    bytes32 indexed eventHash
  );

  constructor() public ERC721Full("MyCryptoHeroes:Land", "MCHL") {
    rarityToSectorVolume[5] = 100;
    rarityToSectorVolume[4] = 20;
    rarityToSectorVolume[3] = 5;
    rarityToSectorVolume[2] = 2;
    rarityToSectorVolume[1] = 1;
    landTypeToTotalVolume[NO_LAND] = 0;
  }

  function setSupplyAndSector(
    uint16 _landType,
    uint256 _totalVolume,
    uint256 _sectorSupplyLimit,
    uint256 legendarySupply,
    uint256 epicSupply,
    uint256 rareSupply,
    uint256 uncommonSupply,
    uint256 commonSupply
  ) external onlyMinter {
    require(_landType != 0, "landType 0 is noland");
    require(_totalVolume != 0, "totalVolume must not be 0");
    require(getMintedSectorCount(_landType) == 0, "This LandType already exists");
    require(
      legendarySupply.mul(rarityToSectorVolume[LEGENDARY_RARITY])
      .add(epicSupply.mul(rarityToSectorVolume[EPIC_RARITY]))
      .add(rareSupply.mul(rarityToSectorVolume[RARE_RARITY]))
      .add(uncommonSupply.mul(rarityToSectorVolume[UNCOMMON_RARITY]))
      .add(commonSupply.mul(rarityToSectorVolume[COMMON_RARITY]))
      == _totalVolume
    );
    require(
      legendarySupply
      .add(epicSupply)
      .add(rareSupply)
      .add(uncommonSupply)
      .add(commonSupply)
      == _sectorSupplyLimit
    );
    landTypeToTotalVolume[_landType] = _totalVolume;
    landTypeToSectorSupplyLimit[_landType] = _sectorSupplyLimit;
    landTypeAndRarityToSectorSupply[_landType][LEGENDARY_RARITY] = legendarySupply;
    landTypeAndRarityToSectorSupply[_landType][EPIC_RARITY] = epicSupply;
    landTypeAndRarityToSectorSupply[_landType][RARE_RARITY] = rareSupply;
    landTypeAndRarityToSectorSupply[_landType][UNCOMMON_RARITY] = uncommonSupply;
    landTypeAndRarityToSectorSupply[_landType][COMMON_RARITY] = commonSupply;
  }

  function setTokenURIPrefix(string calldata _tokenURIPrefix) external onlyMinter {
    tokenURIPrefix = _tokenURIPrefix;
  }

  function isAlreadyMinted(uint256 _tokenId) public view returns (bool) {
    return _exists(_tokenId);
  }

  function isValidLandSector(uint256 _tokenId) public view returns (bool) {
    uint16 rarity = getRarity(_tokenId);
    if (!(rarityToSectorVolume[rarity] > 0)) {
      return false;
    }
    uint16 landType = getLandType(_tokenId);
    if (!(landTypeToTotalVolume[landType] > 0)) {
      return false;
    }
    uint256 serial = _tokenId % 10000;
    if (serial > landTypeAndRarityToSectorSupply[landType][rarity]) {
      return false;
    }
    return true;
  }

  function getTotalVolume(uint16 _landType) public view returns (uint256) {
    return landTypeToTotalVolume[_landType];
  }

  function getSectorSupplyLimit(uint16 _landType) public view returns (uint256) {
    return landTypeToSectorSupplyLimit[_landType];
  }

  function getLandType(uint256 _landSector) public view returns (uint16) {
    uint16 _landType = uint16((_landSector.div(10000)) % 1000);
    return _landType;
  }

  function getRarity(uint256 _landSector) public view returns (uint16) {
    return uint16(_landSector.div(10**7));
  }

  function getMintedSectorCount(uint16 _landType) public view returns (uint256) {
    return landTypeToLandSectorIndex[_landType];
  }

  function getMintedSectorCountByRarity(uint16 _landType, uint16 _rarity) public view returns (uint256) {
    return landTypeAndRarityToLandSectorCount[_landType][_rarity];
  }

  function getSectorSupplyByRarity(uint16 _landType, uint16 _rarity) public view returns (uint256) {
    return landTypeAndRarityToSectorSupply[_landType][_rarity];
  }

  function getMintedSectorList(uint16 _landType) public view returns (uint256[] memory) {
    return landTypeToLandSectorList[_landType];
  }

  function getSectorVolumeByRarity(uint16 _rarity) public view returns (uint256) {
    return rarityToSectorVolume[_rarity];
  }

  function getShareRateWithDecimal(uint256 _landSector) public view returns (uint256, uint256) {
    return (
      getSectorVolumeByRarity(getRarity(_landSector))
        .mul(SHARE_RATE_DECIMAL)
        .div(getTotalVolume(getLandType(_landSector))),
      SHARE_RATE_DECIMAL
    );
  }

  function mintLandSector(address _owner, uint256 _landSector, bytes32 _eventHash) public onlyMinter {
    require(!isAlreadyMinted(_landSector));
    require(isValidLandSector(_landSector));
    uint16 _landType = getLandType(_landSector);
    require(landTypeToLandSectorIndex[_landType] < landTypeToSectorSupplyLimit[_landType]);
    uint16 rarity = getRarity(_landSector);
    require(landTypeAndRarityToLandSectorCount[_landType][rarity] < landTypeAndRarityToSectorSupply[_landType][rarity], "supply over");
    _mint(_owner, _landSector);
    landTypeToLandSectorList[_landType].push(_landSector);
    landTypeToLandSectorIndex[_landType]++;
    landTypeAndRarityToLandSectorCount[_landType][rarity]++;

    emit MintEvent(
      _owner,
      _landSector,
      block.timestamp,
      _eventHash
    );
  }

  function tokenURI(uint256 tokenId) public view returns (string memory) {
    bytes32 tokenIdBytes;
    if (tokenId == 0) {
      tokenIdBytes = "0";
    } else {
      uint256 value = tokenId;
      while (value > 0) {
        tokenIdBytes = bytes32(uint256(tokenIdBytes) / (2 ** 8));
        tokenIdBytes |= bytes32(((value % 10) + 48) * 2 ** (8 * 31));
        value /= 10;
      }
    }

    bytes memory prefixBytes = bytes(tokenURIPrefix);
    bytes memory tokenURIBytes = new bytes(prefixBytes.length + tokenIdBytes.length);

    uint8 i;
    uint8 index = 0;

    for (i = 0; i < prefixBytes.length; i++) {
      tokenURIBytes[index] = prefixBytes[i];
      index++;
    }

    for (i = 0; i < tokenIdBytes.length; i++) {
      tokenURIBytes[index] = tokenIdBytes[i];
      index++;
    }

    return string(tokenURIBytes);
  }
}
/* solhint-enable indent*/

// File: contracts/MCHLandPool.sol

/* solhint-disable indent*/
pragma solidity 0.5.4;







contract MCHLandPool is Ownable, Pausable, ReentrancyGuard {
  using SafeMath for uint256;


  LandSectorAsset public landSectorAsset;

  mapping(uint16 => uint256) private landTypeToTotalAmount;
  mapping(uint256 => uint256) private landSectorToWithdrawnAmount;
  mapping(address => bool) private allowedAddresses;

  event EthAddedToPool(
    uint16 indexed landType,
    address txSender,
    address indexed purchaseBy,
    uint256 value,
    uint256 at
  );

  event WithdrawEther(
    uint256 indexed landSector,
    address indexed lord,
    uint256 value,
    uint256 at
  );

  event AllowedAddressSet(
    address allowedAddress,
    bool allowedStatus
  );

  constructor(address _landSectorAssetAddress) public {
    landSectorAsset = LandSectorAsset(_landSectorAssetAddress);
  }

  function setLandSectorAssetAddress(address _landSectorAssetAddress) external onlyOwner() {
    landSectorAsset = LandSectorAsset(_landSectorAssetAddress);
  }

  function setAllowedAddress(address _address, bool desired) external onlyOwner() {
    allowedAddresses[_address] = desired;
    emit AllowedAddressSet(
      _address,
      desired
    );
  }

  function addEthToLandPool(uint16 _landType, address _purchaseBy) external payable whenNotPaused() nonReentrant() {
    require(landSectorAsset.getTotalVolume(_landType) > 0);
    require(allowedAddresses[msg.sender]);
    landTypeToTotalAmount[_landType] += msg.value;

    emit EthAddedToPool(
      _landType,
      msg.sender,
      _purchaseBy,
      msg.value,
      block.timestamp
    );
  }

  function withdrawMyAllRewards() external whenNotPaused() nonReentrant() {
    require(getWithdrawableBalance(msg.sender) > 0);

    uint256 withdrawValue;
    uint256 balance = landSectorAsset.balanceOf(msg.sender);
    
    for (uint256 i=balance; i > 0; i--) {
      uint256 landSector = landSectorAsset.tokenOfOwnerByIndex(msg.sender, i-1);
      uint256 tmpAmount = getLandSectorWithdrawableBalance(landSector);
      withdrawValue += tmpAmount;
      landSectorToWithdrawnAmount[landSector] += tmpAmount;

      emit WithdrawEther(
        landSector,
        msg.sender,
        tmpAmount,
        block.timestamp
      );
    }
    msg.sender.transfer(withdrawValue);
  }

  function withdrawMyReward(uint256 _landSector) external whenNotPaused() nonReentrant() {
    require(landSectorAsset.ownerOf(_landSector) == msg.sender);
    uint256 withdrawableAmount = getLandSectorWithdrawableBalance(_landSector);
    require(withdrawableAmount > 0);

    landSectorToWithdrawnAmount[_landSector] += withdrawableAmount;
    msg.sender.transfer(withdrawableAmount);

    emit WithdrawEther(
      _landSector,
      msg.sender,
      withdrawableAmount,
      block.timestamp
    );
  }

  function getAllowedAddress(address _address) public view returns (bool) {
    return allowedAddresses[_address];
  }

  function getTotalEthBackAmountPerLandType(uint16 _landType) public view returns (uint256) {
    return landTypeToTotalAmount[_landType];
  }

  function getLandSectorWithdrawnAmount(uint256 _landSector) public view returns (uint256) {
    return landSectorToWithdrawnAmount[_landSector];
  }

  function getLandSectorWithdrawableBalance(uint256 _landSector) public view returns (uint256) {
    require(landSectorAsset.isValidLandSector(_landSector));
    uint16 _landType = landSectorAsset.getLandType(_landSector);
    (uint256 shareRate, uint256 decimal) = landSectorAsset.getShareRateWithDecimal(_landSector);
    uint256 maxAmount = landTypeToTotalAmount[_landType]
      .mul(shareRate)
      .div(decimal);
    return maxAmount.sub(landSectorToWithdrawnAmount[_landSector]);
  }

  function getWithdrawableBalance(address _lordAddress) public view returns (uint256) {
    uint256 balance = landSectorAsset.balanceOf(_lordAddress);
    uint256 withdrawableAmount;

    for (uint256 i=balance; i > 0; i--) {
      uint256 landSector = landSectorAsset.tokenOfOwnerByIndex(_lordAddress, i-1);
      withdrawableAmount += getLandSectorWithdrawableBalance(landSector);
    }

    return withdrawableAmount;
  }
}
/* solhint-enable indent*/

Contract Security Audit

Contract ABI

[{"constant":true,"inputs":[{"name":"_landSector","type":"uint256"}],"name":"getLandSectorWithdrawableBalance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_landSectorAssetAddress","type":"address"}],"name":"setLandSectorAssetAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"unpause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"account","type":"address"}],"name":"isPauser","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_landSector","type":"uint256"}],"name":"withdrawMyReward","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[],"name":"paused","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"renouncePauser","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"renounceOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[],"name":"withdrawMyAllRewards","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"account","type":"address"}],"name":"addPauser","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_lordAddress","type":"address"}],"name":"getWithdrawableBalance","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[],"name":"pause","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":true,"inputs":[{"name":"_landSector","type":"uint256"}],"name":"getLandSectorWithdrawnAmount","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"owner","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"isOwner","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_address","type":"address"}],"name":"getAllowedAddress","outputs":[{"name":"","type":"bool"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[{"name":"_landType","type":"uint16"}],"name":"getTotalEthBackAmountPerLandType","outputs":[{"name":"","type":"uint256"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"landSectorAsset","outputs":[{"name":"","type":"address"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"name":"_landType","type":"uint16"},{"name":"_purchaseBy","type":"address"}],"name":"addEthToLandPool","outputs":[],"payable":true,"stateMutability":"payable","type":"function"},{"constant":false,"inputs":[{"name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"name":"_address","type":"address"},{"name":"desired","type":"bool"}],"name":"setAllowedAddress","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"inputs":[{"name":"_landSectorAssetAddress","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"name":"landType","type":"uint16"},{"indexed":false,"name":"txSender","type":"address"},{"indexed":true,"name":"purchaseBy","type":"address"},{"indexed":false,"name":"value","type":"uint256"},{"indexed":false,"name":"at","type":"uint256"}],"name":"EthAddedToPool","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"landSector","type":"uint256"},{"indexed":true,"name":"lord","type":"address"},{"indexed":false,"name":"value","type":"uint256"},{"indexed":false,"name":"at","type":"uint256"}],"name":"WithdrawEther","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"allowedAddress","type":"address"},{"indexed":false,"name":"allowedStatus","type":"bool"}],"name":"AllowedAddressSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"account","type":"address"}],"name":"PauserAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"account","type":"address"}],"name":"PauserRemoved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"name":"previousOwner","type":"address"},{"indexed":true,"name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

00000000000000000000000075a640661b78021e4b1a58577e4831c7edb571af

-----Decoded View---------------
Arg [0] : _landSectorAssetAddress (address): 0x75a640661b78021e4b1a58577e4831c7edb571af

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000075a640661b78021e4b1a58577e4831c7edb571af


Swarm Source

bzzr://ed578d491686832c37fbabcb20acb75adaef32d83d203e8e53c917e3f9f9ba93
Block Transaction Difficulty Gas Used Reward
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.