Contract 0x84214215904cDEbA9044ECf95F3eBF009185AAf4

Contract Overview

Balance:
0 Ether
Txn Hash
Method
Block
From
To
Value
0x370356e1d8e5a93f12ac1e7f23e254fa28dfcf3af2305111ebe55197e4b20c29Claim101425762022-02-10 9:02:16146 days 10 hrs ago0x725b239fc80194ffe10af8a584bccf234bf340fa IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00030738 2.08407696
0x919af9dd615e082d06a9a4ae374ed429de87f7871caf011b068032e3fd4e069bClaim101414892022-02-09 22:14:14146 days 21 hrs ago0x122278a06753d5af91383848b13cf136f9c6f721 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00014748 1.00000269
0xd39dd935427e90ae68123070f73d2b0e28971a2bc5cf50fa69a4040069ee2adfClaim101403982022-02-09 17:41:19147 days 2 hrs ago0x509564020e30b6c1b8f55f1a1d40cc074e05e505 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00080765 4.76003439
0x1cd8d6ce7b772e8a5c5a744a1f93687994427603c8ab4ffb70ee39bc1631db7eClaim100731472022-01-29 1:19:25158 days 18 hrs ago0x63d5c30a7c7b7c8b7f1db6c2ff3c8735f698cbbc IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00013036 1
0xdfc3bd4022134c459dc9312a50932f01ec99e3261fd3e301898e4d4ff8da2c8eClaim99541422022-01-08 6:53:41179 days 13 hrs ago0xf09df4e35e8fdb6f1f706b506ef32d329ad5b0e1 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00019301 1
0x8bceac62289a9b1f695c3ac18f964d8d15f15ae0e194d6280e8ca63e825e58d8Claim99541332022-01-08 6:51:26179 days 13 hrs ago0xf09df4e35e8fdb6f1f706b506ef32d329ad5b0e1 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00004661 1
0x95079dad1d7761144f76819169abb9565180222670b07cdde49550be025cca54Claim98955232021-12-28 21:43:59189 days 22 hrs ago0xc9d3087201bd5e907ed3e40cac0384128cb8fd1f IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00017524 1
0x8a688d8074c446733eac8ed39d18bc495694e0fd5a3c37da6c1c9b5411714119Claim98620972021-12-23 2:24:53195 days 17 hrs ago0x63d5c30a7c7b7c8b7f1db6c2ff3c8735f698cbbc IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00014748 1
0xfb92a36a9f5948957445d849c36baa0bfe4aaba8948010d79828f83ddd1f16f4Claim98381482021-12-18 22:35:56199 days 21 hrs ago0x26535a5217d09a0bf214df0df54a751dbc70c99a IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00017527 1
0xa813ae2f4bf19e79d38528173aeab088e29593d3de1720e7771c2295e7205679Claim98137922021-12-14 14:27:26204 days 5 hrs ago0x5d95d386d3806cf63b8ff889cb9fb25433f76462 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.0012472 9.56789127
0x47bdd4d23b7171a8ac70460a979793481d88cedc14210482cfb2e5a0d0112d8dClaim98137912021-12-14 14:27:11204 days 5 hrs ago0x5d95d386d3806cf63b8ff889cb9fb25433f76462 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00126663 9.71693524
0x3c6a034d731ba2ccb8c4987288c920ac3bb6fc61e0403a741f430892152dac82Claim98137912021-12-14 14:27:11204 days 5 hrs ago0x5d95d386d3806cf63b8ff889cb9fb25433f76462 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00126663 9.71693524
0xd6864b1efec2b710ec0a4cbadde2f5ff48460cca836b7d617a7f958cdd415e8fClaim98137902021-12-14 14:26:56204 days 5 hrs ago0x5d95d386d3806cf63b8ff889cb9fb25433f76462 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.0014653 9.93826529
0x812ff33932da71f3934a52cffb5c9a3486b9ab2881519a3325715b2d38b47573Claim98137832021-12-14 14:25:11204 days 5 hrs ago0x666574cadedeb4a0f282ff0c2b3588617e29e6a0 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00140766 10.7988484
0xe55769b37ed748a02d302cd4fbe42b327d47639a29fb8be53d0e7292db5ed5a4Claim98137822021-12-14 14:24:56204 days 5 hrs ago0x666574cadedeb4a0f282ff0c2b3588617e29e6a0 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00153652 11.78740081
0x15dacd1c3625f9f7cff4eb68748f3b21c48477016baa79cde2371e6925d9eaebClaim98137822021-12-14 14:24:56204 days 5 hrs ago0x666574cadedeb4a0f282ff0c2b3588617e29e6a0 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00153652 11.78740081
0xeb93aa98b529ac82bd607d94853d5666aa19900d5d446b20b315b83f7c5d43adClaim98137822021-12-14 14:24:56204 days 5 hrs ago0x666574cadedeb4a0f282ff0c2b3588617e29e6a0 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00153652 11.78740081
0x0e01a08beb265718d67e0650405fa3149c8996021a4b5245ba4e04dfb4586172Claim98137692021-12-14 14:21:41204 days 5 hrs ago0x1f1709dc4469c56cfaf99c28114f6d35cb013b38 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00143389 11.00107749
0x42715d2011252a945f577ba373ed564550a78c9b0e3006a7c73ecd5ac201ce7dClaim98137682021-12-14 14:21:26204 days 5 hrs ago0x1f1709dc4469c56cfaf99c28114f6d35cb013b38 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00146735 11.25782933
0x004d5c7276a6da3cee441326062ebc62a11179017175720b614de91e7818f759Claim98137682021-12-14 14:21:26204 days 5 hrs ago0x1f1709dc4469c56cfaf99c28114f6d35cb013b38 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00146735 11.25782933
0x0f9c8835a1c08c8ddf2fc9d15ab63825ebd10c49ab26c6612dc3ea7ea2cec46cClaim98137672021-12-14 14:21:11204 days 5 hrs ago0x1f1709dc4469c56cfaf99c28114f6d35cb013b38 IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00170003 11.53025124
0xda93b60a57db668ac249742f8e1382e006c723b15c0aa99bdfc2d7f0cd41aab8Claim98137622021-12-14 14:19:56204 days 5 hrs ago0xbdc0fd1e0c9911e061cfe264369a1463927d99dc IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00172713 13.25089362
0x6087292445cbac38facc99e6e6351f4c196a5709e127660ba309015433addac9Claim98137582021-12-14 14:18:56204 days 5 hrs ago0xbdc0fd1e0c9911e061cfe264369a1463927d99dc IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00186588 14.31538012
0x9fc566e8f26b91ef15c24d8fe07d10a9263998014ea33bba0f929ec09fb14cfdClaim98137572021-12-14 14:18:41204 days 5 hrs ago0xbdc0fd1e0c9911e061cfe264369a1463927d99dc IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00197808 15.17620185
0x8d8cefb0ad45f36c4c4cc73eeff0b2538177835497055c0331f0982f0b03d8d9Claim98137562021-12-14 14:18:26204 days 5 hrs ago0xbdc0fd1e0c9911e061cfe264369a1463927d99dc IN  0x84214215904cdeba9044ecf95f3ebf009185aaf40 Ether0.00201648 15.47082451
[ Download CSV Export 
Latest 25 internal transaction
Parent Txn Hash Block From To Value
0x370356e1d8e5a93f12ac1e7f23e254fa28dfcf3af2305111ebe55197e4b20c29101425762022-02-10 9:02:16146 days 10 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x919af9dd615e082d06a9a4ae374ed429de87f7871caf011b068032e3fd4e069b101414892022-02-09 22:14:14146 days 21 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0xd39dd935427e90ae68123070f73d2b0e28971a2bc5cf50fa69a4040069ee2adf101403982022-02-09 17:41:19147 days 2 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x1cd8d6ce7b772e8a5c5a744a1f93687994427603c8ab4ffb70ee39bc1631db7e100731472022-01-29 1:19:25158 days 18 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0xdfc3bd4022134c459dc9312a50932f01ec99e3261fd3e301898e4d4ff8da2c8e99541422022-01-08 6:53:41179 days 13 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x8bceac62289a9b1f695c3ac18f964d8d15f15ae0e194d6280e8ca63e825e58d899541332022-01-08 6:51:26179 days 13 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x95079dad1d7761144f76819169abb9565180222670b07cdde49550be025cca5498955232021-12-28 21:43:59189 days 22 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x8a688d8074c446733eac8ed39d18bc495694e0fd5a3c37da6c1c9b541171411998620972021-12-23 2:24:53195 days 17 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0xfb92a36a9f5948957445d849c36baa0bfe4aaba8948010d79828f83ddd1f16f498381482021-12-18 22:35:56199 days 21 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0xa813ae2f4bf19e79d38528173aeab088e29593d3de1720e7771c2295e720567998137922021-12-14 14:27:26204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x47bdd4d23b7171a8ac70460a979793481d88cedc14210482cfb2e5a0d0112d8d98137912021-12-14 14:27:11204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x3c6a034d731ba2ccb8c4987288c920ac3bb6fc61e0403a741f430892152dac8298137912021-12-14 14:27:11204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0xd6864b1efec2b710ec0a4cbadde2f5ff48460cca836b7d617a7f958cdd415e8f98137902021-12-14 14:26:56204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x812ff33932da71f3934a52cffb5c9a3486b9ab2881519a3325715b2d38b4757398137832021-12-14 14:25:11204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0xe55769b37ed748a02d302cd4fbe42b327d47639a29fb8be53d0e7292db5ed5a498137822021-12-14 14:24:56204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x15dacd1c3625f9f7cff4eb68748f3b21c48477016baa79cde2371e6925d9eaeb98137822021-12-14 14:24:56204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0xeb93aa98b529ac82bd607d94853d5666aa19900d5d446b20b315b83f7c5d43ad98137822021-12-14 14:24:56204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x0e01a08beb265718d67e0650405fa3149c8996021a4b5245ba4e04dfb458617298137692021-12-14 14:21:41204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x42715d2011252a945f577ba373ed564550a78c9b0e3006a7c73ecd5ac201ce7d98137682021-12-14 14:21:26204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x004d5c7276a6da3cee441326062ebc62a11179017175720b614de91e7818f75998137682021-12-14 14:21:26204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x0f9c8835a1c08c8ddf2fc9d15ab63825ebd10c49ab26c6612dc3ea7ea2cec46c98137672021-12-14 14:21:11204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0xda93b60a57db668ac249742f8e1382e006c723b15c0aa99bdfc2d7f0cd41aab898137622021-12-14 14:19:56204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x6087292445cbac38facc99e6e6351f4c196a5709e127660ba309015433addac998137582021-12-14 14:18:56204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x9fc566e8f26b91ef15c24d8fe07d10a9263998014ea33bba0f929ec09fb14cfd98137572021-12-14 14:18:41204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
0x8d8cefb0ad45f36c4c4cc73eeff0b2538177835497055c0331f0982f0b03d8d998137562021-12-14 14:18:26204 days 5 hrs ago 0x84214215904cdeba9044ecf95f3ebf009185aaf4 0x51765307aeb3df2e647014a2c501d5324212467c0 Ether
[ Download CSV Export 
Loading

Contract Source Code Verified (Exact Match)

Contract Name:
FreeMinter

Compiler Version
v0.5.12+commit.7709ece9

Optimization Enabled:
No with 200 runs

Other Settings:
default evmVersion, None license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2020-12-08
*/

pragma solidity 0.5.12;
pragma experimental ABIEncoderV2;


contract IResolver {
    /**
     * @dev Reset all domain records and set new ones
     * @param keys New record keys
     * @param values New record values
     * @param tokenId ERC-721 token id of the domain
     */
    function reconfigure(string[] memory keys, string[] memory values, uint256 tokenId) public;

    /**
    * @dev Set all domain records for newly minted domain
    * @param keys New record keys
    * @param values New record values
    * @param tokenId ERC-721 token id of the domain
    */
    function preconfigure(string[] memory keys, string[] memory values, uint256 tokenId) public;

    /**
     * @dev Set or update domain records
     * @param keys New record keys
     * @param values New record values
     * @param tokenId ERC-721 token id of the domain
     */
    function setMany(string[] memory keys, string[] memory values, uint256 tokenId) public;

    /**
     * @dev Function to set record.
     * @param key The key set the value of.
     * @param value The value to set key to.
     * @param tokenId ERC-721 token id to set.
     */
    function set(string calldata key, string calldata value, uint256 tokenId) external;

    /**
     * @dev Function to reset all existing records on a domain.
     * @param tokenId ERC-721 token id to set.
     */
    function reset(uint256 tokenId) external;
}

interface IRegistryReader {
    function name() external view returns (string memory);
    function symbol() external view returns (string memory);
    function tokenURI(uint256 tokenId) external view returns (string memory);

    /**
     * @dev Returns whether the given spender can transfer a given token ID. Registry related function.
     * @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) external view returns (bool);

    /**
     * @dev Gets the resolver of the specified token ID. Registry related function.
     * @param tokenId uint256 ID of the token to query the resolver of
     * @return address currently marked as the resolver of the given token ID
     */
    function resolverOf(uint256 tokenId) external view returns (address);

    /**
     * @dev Provides child token (subdomain) of provided tokenId. Registry related function.
     * @param tokenId uint256 ID of the token
     * @param label label of subdomain (for `aaa.bbb.crypto` it will be `aaa`)
     */
    function childIdOf(uint256 tokenId, string calldata label) external view returns (uint256);

    /**
     * @dev Controller related function.
     * @return bool whether the account is a controller
     */
    function isController(address account) external view returns (bool);

    /**
     * @dev Returns the number of NFTs in `owner`'s account. ERC721 related function.
     */
    function balanceOf(address owner) external view returns (uint256);

    /**
     * @dev Returns the owner of the NFT specified by `tokenId`. ERC721 related function.
     */
    function ownerOf(uint256 tokenId) external view returns (address);
    
    /**
     * @dev ERC721 related function.
     */
    function getApproved(uint256 tokenId) external view returns (address);
    
    /**
     * @dev ERC721 related function.
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
     * @dev Registry related function.
     * @return root hash.
     */
    function root() external view returns (uint256);
}

/**
 * @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(!has(role, account), "Roles: account already has role");
        role.bearer[account] = true;
    }

    /**
     * @dev Remove an account's access to this role.
     */
    function remove(Role storage role, address account) internal {
        require(has(role, account), "Roles: account does not have role");
        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), "Roles: account is the zero address");
        return role.bearer[account];
    }
}

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), "MinterRole: caller does not have the Minter role");
        _;
    }

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

interface IMintingController {

    /**
     * @dev Minter function that mints a Second Level Domain (SLD).
     * @param to address to mint the new SLD to.
     * @param label SLD label to mint.
     */
    function mintSLD(address to, string calldata label) external;

    /**
     * @dev Minter function that safely mints a Second Level Domain (SLD).
     * Implements a ERC721Reciever check unlike mintSLD.
     * @param to address to mint the new SLD to.
     * @param label SLD label to mint.
     */
    function safeMintSLD(address to, string calldata label) external;

    /**
     * @dev Minter function that safely mints a Second Level Domain (SLD).
     * Implements a ERC721Reciever check unlike mintSLD.
     * @param to address to mint the new SLD to.
     * @param label SLD label to mint.
     * @param _data bytes data to send along with a safe transfer check
     */
    function safeMintSLD(address to, string calldata label, bytes calldata _data) external;

}

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * [EIP](https://eips.ethereum.org/EIPS/eip-165).
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others (`ERC165Checker`).
 *
 * For an implementation, see `ERC165`.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * [EIP section](https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified)
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
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);

    /**
     * @dev Returns the number of NFTs in `owner`'s account.
     */
    function balanceOf(address owner) public view returns (uint256 balance);

    /**
     * @dev Returns the owner of the NFT specified by `tokenId`.
     */
    function ownerOf(uint256 tokenId) public view returns (address owner);

    /**
     * @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
     * another (`to`).
     *
     * 
     *
     * Requirements:
     * - `from`, `to` cannot be zero.
     * - `tokenId` must be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this
     * NFT by either `approve` or `setApproveForAll`.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public;
    /**
     * @dev Transfers a specific NFT (`tokenId`) from one account (`from`) to
     * another (`to`).
     *
     * Requirements:
     * - If the caller is not `from`, it must be approved to move this NFT by
     * either `approve` or `setApproveForAll`.
     */
    function transferFrom(address from, address to, uint256 tokenId) public;
    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 safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public;
}

/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
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);
}

contract IRegistry is IERC721Metadata {

    event NewURI(uint256 indexed tokenId, string uri);

    event NewURIPrefix(string prefix);

    event Resolve(uint256 indexed tokenId, address indexed to);

    event Sync(address indexed resolver, uint256 indexed updateId, uint256 indexed tokenId);

    /**
     * @dev Controlled function to set the token URI Prefix for all tokens.
     * @param prefix string URI to assign
     */
    function controlledSetTokenURIPrefix(string calldata prefix) external;

    /**
     * @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) external view returns (bool);

    /**
     * @dev Mints a new a child token.
     * Calculates child token ID using a namehash function.
     * Requires the msg.sender to be the owner, approved, or operator of tokenId.
     * Requires the token not exist.
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 ID of the parent token
     * @param label subdomain label of the child token ID
     */
    function mintChild(address to, uint256 tokenId, string calldata label) external;

    /**
     * @dev Controlled function to mint a given token ID.
     * Requires the msg.sender to be controller.
     * Requires the token ID to not exist.
     * @param to address the given token ID will be minted to
     * @param label string that is a subdomain
     * @param tokenId uint256 ID of the parent token
     */
    function controlledMintChild(address to, uint256 tokenId, string calldata label) external;

    /**
     * @dev Transfers the ownership of a child token ID to another address.
     * Calculates child token ID using a namehash function.
     * Requires the msg.sender to be the owner, approved, or operator of tokenId.
     * Requires the token already exist.
     * @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 label subdomain label of the child token ID
     */
    function transferFromChild(address from, address to, uint256 tokenId, string calldata label) external;

    /**
     * @dev Controlled function to transfers the ownership of a token ID to
     * another address.
     * Requires the msg.sender to be controller.
     * Requires the token already exist.
     * @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 controlledTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Safely transfers the ownership of a child token ID to another address.
     * Calculates child token ID using a namehash function.
     * Implements a ERC721Reciever check unlike transferFromChild.
     * Requires the msg.sender to be the owner, approved, or operator of tokenId.
     * Requires the token already exist.
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 parent ID of the token to be transferred
     * @param label subdomain label of the child token ID
     * @param _data bytes data to send along with a safe transfer check
     */
    function safeTransferFromChild(address from, address to, uint256 tokenId, string calldata label, bytes calldata _data) external;

    /// Shorthand for calling the above ^^^ safeTransferFromChild function with an empty _data parameter. Similar to ERC721.safeTransferFrom.
    function safeTransferFromChild(address from, address to, uint256 tokenId, string calldata label) external;

    /**
     * @dev Controlled frunction to safely transfers the ownership of a token ID
     * to another address.
     * Implements a ERC721Reciever check unlike controlledSafeTransferFrom.
     * Requires the msg.sender to be controller.
     * Requires the token already exist.
     * @param from current owner of the token
     * @param to address to receive the ownership of the given token ID
     * @param tokenId uint256 parent ID of the token to be transferred
     * @param _data bytes data to send along with a safe transfer check
     */
    function controlledSafeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data) external;

    /**
     * @dev Burns a child token ID.
     * Calculates child token ID using a namehash function.
     * Requires the msg.sender to be the owner, approved, or operator of tokenId.
     * Requires the token already exist.
     * @param tokenId uint256 ID of the token to be transferred
     * @param label subdomain label of the child token ID
     */
    function burnChild(uint256 tokenId, string calldata label) external;

    /**
     * @dev Controlled function to burn a given token ID.
     * Requires the msg.sender to be controller.
     * Requires the token already exist.
     * @param tokenId uint256 ID of the token to be burned
     */
    function controlledBurn(uint256 tokenId) external;

    /**
     * @dev Sets the resolver of a given token ID to another address.
     * Requires the msg.sender to be the owner, approved, or operator.
     * @param to address the given token ID will resolve to
     * @param tokenId uint256 ID of the token to be transferred
     */
    function resolveTo(address to, uint256 tokenId) external;

    /**
     * @dev Gets the resolver of the specified token ID.
     * @param tokenId uint256 ID of the token to query the resolver of
     * @return address currently marked as the resolver of the given token ID
     */
    function resolverOf(uint256 tokenId) external view returns (address);

    /**
     * @dev Controlled function to sets the resolver of a given token ID.
     * Requires the msg.sender to be controller.
     * @param to address the given token ID will resolve to
     * @param tokenId uint256 ID of the token to be transferred
     */
    function controlledResolveTo(address to, uint256 tokenId) external;

    /**
     * @dev Provides child token (subdomain) of provided tokenId.
     * @param tokenId uint256 ID of the token
     * @param label label of subdomain (for `aaa.bbb.crypto` it will be `aaa`)
     */
    function childIdOf(uint256 tokenId, string calldata label) external pure returns (uint256);

    /**
     * @dev Transfer domain ownership without resetting domain records.
     * @param to address of new domain owner
     * @param tokenId uint256 ID of the token to be transferred
     */
    function setOwner(address to, uint256 tokenId) external;
}

/**
 * @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 `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes memory data)
    public returns (bytes4);
}

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
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-contracts/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;
    }
}

/**
 * @dev Collection of functions related to the address type,
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * This test is non-exhaustive, and there may be false-negatives: during the
     * execution of a contract's constructor, its address will be reported as
     * not containing a contract.
     *
     * > It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }
}

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented or decremented by one. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 * Since it is not possible to overflow a 256 bit integer with increments of one, `increment` can skip the SafeMath
 * overflow check, thereby saving gas. This does assume however correct usage, in that the underlying `_value` is never
 * directly accessed.
 */
library Counters {
    using SafeMath for uint256;

    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        counter._value += 1;
    }

    function decrement(Counter storage counter) internal {
        counter._value = counter._value.sub(1);
    }
}

/**
 * @dev Implementation of the `IERC165` interface.
 *
 * Contracts may inherit from this and call `_registerInterface` to declare
 * their support of an interface.
 */
contract ERC165 is IERC165 {
    /*
     * bytes4(keccak256('supportsInterface(bytes4)')) == 0x01ffc9a7
     */
    bytes4 private constant _INTERFACE_ID_ERC165 = 0x01ffc9a7;

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

    constructor () internal {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(_INTERFACE_ID_ERC165);
    }

    /**
     * @dev See `IERC165.supportsInterface`.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool) {
        return _supportedInterfaces[interfaceId];
    }

    /**
     * @dev Registers the contract as an implementer of the interface defined by
     * `interfaceId`. Support of the actual ERC165 interface is automatic and
     * registering its interface id is not required.
     *
     * See `IERC165.supportsInterface`.
     *
     * Requirements:
     *
     * - `interfaceId` cannot be the ERC165 invalid interface (`0xffffffff`).
     */
    function _registerInterface(bytes4 interfaceId) internal {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}

/**
 * @title ERC721 Non-Fungible Token Standard basic implementation
 * @dev see https://eips.ethereum.org/EIPS/eip-721
 */
contract ERC721 is ERC165, IERC721 {
    using SafeMath for uint256;
    using Address for address;
    using Counters for Counters.Counter;

    // 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 => Counters.Counter) private _ownedTokensCount;

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

    /*
     *     bytes4(keccak256('balanceOf(address)')) == 0x70a08231
     *     bytes4(keccak256('ownerOf(uint256)')) == 0x6352211e
     *     bytes4(keccak256('approve(address,uint256)')) == 0x095ea7b3
     *     bytes4(keccak256('getApproved(uint256)')) == 0x081812fc
     *     bytes4(keccak256('setApprovalForAll(address,bool)')) == 0xa22cb465
     *     bytes4(keccak256('isApprovedForAll(address,address)')) == 0xe985e9c
     *     bytes4(keccak256('transferFrom(address,address,uint256)')) == 0x23b872dd
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256)')) == 0x42842e0e
     *     bytes4(keccak256('safeTransferFrom(address,address,uint256,bytes)')) == 0xb88d4fde
     *
     *     => 0x70a08231 ^ 0x6352211e ^ 0x095ea7b3 ^ 0x081812fc ^
     *        0xa22cb465 ^ 0xe985e9c ^ 0x23b872dd ^ 0x42842e0e ^ 0xb88d4fde == 0x80ac58cd
     */
    bytes4 private constant _INTERFACE_ID_ERC721 = 0x80ac58cd;

    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), "ERC721: balance query for the zero address");

        return _ownedTokensCount[owner].current();
    }

    /**
     * @dev Gets the owner of the specified token ID.
     * @param tokenId uint256 ID of the token to query the owner of
     * @return 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), "ERC721: owner query for nonexistent token");

        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, "ERC721: approval to current owner");

        require(msg.sender == owner || isApprovedForAll(owner, msg.sender),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _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), "ERC721: approved query for nonexistent token");

        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, "ERC721: approve to caller");

        _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 {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(msg.sender, tokenId), "ERC721: transfer caller is not owner nor approved");

        _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), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether the specified token exists.
     * @param tokenId uint256 ID of the token to query the existence of
     * @return bool 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) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        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), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _tokenOwner[tokenId] = to;
        _ownedTokensCount[to].increment();

        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, "ERC721: burn of token that is not own");

        _clearApproval(tokenId);

        _ownedTokensCount[owner].decrement();
        _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, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _clearApproval(tokenId);

        _ownedTokensCount[from].decrement();
        _ownedTokensCount[to].increment();

        _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.
     *
     * This function is deprecated.
     * @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 bool 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);
        }
    }
}

/**
 * @title ERC721 Burnable Token
 * @dev ERC721 Token that can be irreversibly burned (destroyed).
 */
contract ERC721Burnable is ERC721 {
    /**
     * @dev Burns a specific ERC721 token.
     * @param tokenId uint256 id of the ERC721 token to be burned.
     */
    function burn(uint256 tokenId) public {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(msg.sender, tokenId), "ERC721Burnable: caller is not owner nor approved");
        _burn(tokenId);
    }
}

// solium-disable error-reason
/**
 * @title ControllerRole
 * @dev An Controller role defined using the Open Zeppelin Role system.
 */
contract ControllerRole {

    using Roles for Roles.Role;

    // NOTE: Commented out standard Role events to save gas.
    // event ControllerAdded(address indexed account);
    // event ControllerRemoved(address indexed account);

    Roles.Role private _controllers;

    constructor () public {
        _addController(msg.sender);
    }

    modifier onlyController() {
        require(isController(msg.sender));
        _;
    }

    function isController(address account) public view returns (bool) {
        return _controllers.has(account);
    }

    function addController(address account) public onlyController {
        _addController(account);
    }

    function renounceController() public {
        _removeController(msg.sender);
    }

    function _addController(address account) internal {
        _controllers.add(account);
        // emit ControllerAdded(account);
    }

    function _removeController(address account) internal {
        _controllers.remove(account);
        // emit ControllerRemoved(account);
    }

}

// solium-disable no-empty-blocks,error-reason
/**
 * @title Registry
 * @dev An ERC721 Token see https://eips.ethereum.org/EIPS/eip-721. With
 * additional functions so other trusted contracts to interact with the tokens.
 */
contract Registry is IRegistry, ControllerRole, ERC721Burnable {

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

    string internal _prefix;

    // Mapping from token ID to resolver address
    mapping (uint256 => address) internal _tokenResolvers;

    // uint256(keccak256(abi.encodePacked(uint256(0x0), keccak256(abi.encodePacked("crypto")))))
    uint256 private constant _CRYPTO_HASH =
        0x0f4a10a4f46c288cea365fcf45cccf0e9d901b945b9829ccdb54c10dc3cb7a6f;

    modifier onlyApprovedOrOwner(uint256 tokenId) {
        require(_isApprovedOrOwner(msg.sender, tokenId));
        _;
    }

    constructor () public {
        _mint(address(0xdead), _CRYPTO_HASH);
        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(0x5b5e139f); // ERC721 Metadata Interface
        _tokenURIs[root()] = "crypto";
        emit NewURI(root(), "crypto");
    }

    /// ERC721 Metadata extension

    function name() external view returns (string memory) {
        return ".crypto";
    }

    function symbol() external view returns (string memory) {
        return "UD";
    }

    function tokenURI(uint256 tokenId) external view returns (string memory) {
        require(_exists(tokenId));
        return string(abi.encodePacked(_prefix, _tokenURIs[tokenId]));
    }

    function controlledSetTokenURIPrefix(string calldata prefix) external onlyController {
        _prefix = prefix;
        emit NewURIPrefix(prefix);
    }

    /// Ownership

    function isApprovedOrOwner(address spender, uint256 tokenId) external view returns (bool) {
        return _isApprovedOrOwner(spender, tokenId);
    }

    /// Registry Constants

    function root() public pure returns (uint256) {
        return _CRYPTO_HASH;
    }

    function childIdOf(uint256 tokenId, string calldata label) external pure returns (uint256) {
        return _childId(tokenId, label);
    }

    /// Minting

    function mintChild(address to, uint256 tokenId, string calldata label) external onlyApprovedOrOwner(tokenId) {
        _mintChild(to, tokenId, label);
    }

    function controlledMintChild(address to, uint256 tokenId, string calldata label) external onlyController {
        _mintChild(to, tokenId, label);
    }

    function safeMintChild(address to, uint256 tokenId, string calldata label) external onlyApprovedOrOwner(tokenId) {
        _safeMintChild(to, tokenId, label, "");
    }

    function safeMintChild(address to, uint256 tokenId, string calldata label, bytes calldata _data)
        external
        onlyApprovedOrOwner(tokenId)
    {
        _safeMintChild(to, tokenId, label, _data);
    }

    function controlledSafeMintChild(address to, uint256 tokenId, string calldata label, bytes calldata _data)
        external
        onlyController
    {
        _safeMintChild(to, tokenId, label, _data);
    }

    /// Transfering

    function setOwner(address to, uint256 tokenId) external onlyApprovedOrOwner(tokenId)  {
        super._transferFrom(ownerOf(tokenId), to, tokenId);
    }

    function transferFromChild(address from, address to, uint256 tokenId, string calldata label)
        external
        onlyApprovedOrOwner(tokenId)
    {
        _transferFrom(from, to, _childId(tokenId, label));
    }

    function controlledTransferFrom(address from, address to, uint256 tokenId) external onlyController {
        _transferFrom(from, to, tokenId);
    }

    function safeTransferFromChild(
        address from,
        address to,
        uint256 tokenId,
        string memory label,
        bytes memory _data
    ) public onlyApprovedOrOwner(tokenId) {
        uint256 childId = _childId(tokenId, label);
        _transferFrom(from, to, childId);
        require(_checkOnERC721Received(from, to, childId, _data));
    }

    function safeTransferFromChild(address from, address to, uint256 tokenId, string calldata label) external {
        safeTransferFromChild(from, to, tokenId, label, "");
    }

    function controlledSafeTransferFrom(address from, address to, uint256 tokenId, bytes calldata _data)
        external
        onlyController
    {
        _transferFrom(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data));
    }

    /// Burning

    function burnChild(uint256 tokenId, string calldata label) external onlyApprovedOrOwner(tokenId) {
        _burn(_childId(tokenId, label));
    }

    function controlledBurn(uint256 tokenId) external onlyController {
        _burn(tokenId);
    }

    /// Resolution

    function resolverOf(uint256 tokenId) external view returns (address) {
        address resolver = _tokenResolvers[tokenId];
        require(resolver != address(0));
        return resolver;
    }

    function resolveTo(address to, uint256 tokenId) external onlyApprovedOrOwner(tokenId) {
        _resolveTo(to, tokenId);
    }

    function controlledResolveTo(address to, uint256 tokenId) external onlyController {
        _resolveTo(to, tokenId);
    }

    function sync(uint256 tokenId, uint256 updateId) external {
        require(_tokenResolvers[tokenId] == msg.sender);
        emit Sync(msg.sender, updateId, tokenId);
    }

    /// Internal

    function _childId(uint256 tokenId, string memory label) internal pure returns (uint256) {
        require(bytes(label).length != 0);
        return uint256(keccak256(abi.encodePacked(tokenId, keccak256(abi.encodePacked(label)))));
    }

    function _mintChild(address to, uint256 tokenId, string memory label) internal {
        uint256 childId = _childId(tokenId, label);
        _mint(to, childId);

        require(bytes(label).length != 0);
        require(_exists(childId));

        bytes memory domain = abi.encodePacked(label, ".", _tokenURIs[tokenId]);

        _tokenURIs[childId] = string(domain);
        emit NewURI(childId, string(domain));
    }

    function _safeMintChild(address to, uint256 tokenId, string memory label, bytes memory _data) internal {
        _mintChild(to, tokenId, label);
        require(_checkOnERC721Received(address(0), to, _childId(tokenId, label), _data));
    }

    function _transferFrom(address from, address to, uint256 tokenId) internal {
        super._transferFrom(from, to, tokenId);
        // Clear resolver (if any)
        if (_tokenResolvers[tokenId] != address(0x0)) {
            delete _tokenResolvers[tokenId];
        }
    }

    function _burn(uint256 tokenId) internal {
        super._burn(tokenId);
        // Clear resolver (if any)
        if (_tokenResolvers[tokenId] != address(0x0)) {
            delete _tokenResolvers[tokenId];
        }
        // Clear metadata (if any)
        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }
    }

    function _resolveTo(address to, uint256 tokenId) internal {
        require(_exists(tokenId));
        emit Resolve(tokenId, to);
        _tokenResolvers[tokenId] = to;
    }

}

/**
 * @title MintingController
 * @dev Defines the functions for distribution of Second Level Domains (SLD)s.
 */
contract MintingController is IMintingController, MinterRole {

    Registry internal _registry;

    constructor (Registry registry) public {
        _registry = registry;
    }

    function registry() external view returns (address) {
        return address(_registry);
    }

    function mintSLD(address to, string memory label) public onlyMinter {
        _registry.controlledMintChild(to, _registry.root(), label);
    }

    function safeMintSLD(address to, string calldata label) external {
        safeMintSLD(to, label, "");
    }

    function safeMintSLD(address to, string memory label, bytes memory _data) public onlyMinter {
        _registry.controlledSafeMintChild(to, _registry.root(), label, _data);
    }

    function mintSLDWithResolver(address to, string memory label, address resolver) public onlyMinter {
        _registry.controlledMintChild(to, _registry.root(), label);
        _registry.controlledResolveTo(resolver, _registry.childIdOf(_registry.root(), label));
    }

    function safeMintSLDWithResolver(address to, string calldata label, address resolver) external {
        safeMintSLD(to, label, "");
        _registry.controlledResolveTo(resolver, _registry.childIdOf(_registry.root(), label));
    }

    function safeMintSLDWithResolver(address to, string calldata label, address resolver, bytes calldata _data) external {
        safeMintSLD(to, label, _data);
        _registry.controlledResolveTo(resolver, _registry.childIdOf(_registry.root(), label));
    }

}

contract FreeMinter {
    string public constant NAME = 'Unstoppable Free Domains Minter';
    string public constant VERSION = '0.1.0';
    string private constant DOMAIN_NAME_PREFIX = 'udtestdev-';

    MintingController private _mintingController;
    IResolver private _resolver;
    IRegistryReader private _registry;

    constructor(MintingController mintingController, IResolver resolver, IRegistryReader registry) public {
        _mintingController = mintingController;
        _resolver = resolver;
        _registry = registry;
    }

    function claim(string calldata label) external {
        mintSLD(label, msg.sender);
    }

    function claimTo(string calldata label, address receiver) external {
        mintSLD(label, receiver);
    }

    function claimToWithRecords(string calldata label, address receiver, string[] calldata keys, string[] calldata values) external {
        string memory labelWithPrefix = mintSLD(label, receiver);
        if (keys.length == 0) {
            return;
        }
        uint256 tokenId = _registry.childIdOf(_registry.root(), labelWithPrefix);
        _resolver.preconfigure(keys, values, tokenId);
    }

    function mintSLD(string memory label, address receiver) private returns (string memory) {
        string memory labelWithPrefix = string(abi.encodePacked(DOMAIN_NAME_PREFIX, label));
        _mintingController.mintSLDWithResolver(receiver, labelWithPrefix, address(_resolver));

        return labelWithPrefix;
    }
}

Contract ABI

[{"inputs":[{"internalType":"contract MintingController","name":"mintingController","type":"address"},{"internalType":"contract IResolver","name":"resolver","type":"address"},{"internalType":"contract IRegistryReader","name":"registry","type":"address"}],"payable":false,"stateMutability":"nonpayable","type":"constructor"},{"constant":true,"inputs":[],"name":"NAME","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":true,"inputs":[],"name":"VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"payable":false,"stateMutability":"view","type":"function"},{"constant":false,"inputs":[{"internalType":"string","name":"label","type":"string"}],"name":"claim","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"string","name":"label","type":"string"},{"internalType":"address","name":"receiver","type":"address"}],"name":"claimTo","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"},{"constant":false,"inputs":[{"internalType":"string","name":"label","type":"string"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"string[]","name":"keys","type":"string[]"},{"internalType":"string[]","name":"values","type":"string[]"}],"name":"claimToWithRecords","outputs":[],"payable":false,"stateMutability":"nonpayable","type":"function"}]

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

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

00000000000000000000000051765307aeb3df2e647014a2c501d5324212467c00000000000000000000000095ae1515367aa64c462c71e87157771165b1287a000000000000000000000000aad76bea7cfec82927239415bb18d2e93518ecbb

-----Decoded View---------------
Arg [0] : mintingController (address): 0x51765307aeb3df2e647014a2c501d5324212467c
Arg [1] : resolver (address): 0x95ae1515367aa64c462c71e87157771165b1287a
Arg [2] : registry (address): 0xaad76bea7cfec82927239415bb18d2e93518ecbb

-----Encoded View---------------
3 Constructor Arguments found :
Arg [0] : 00000000000000000000000051765307aeb3df2e647014a2c501d5324212467c
Arg [1] : 00000000000000000000000095ae1515367aa64c462c71e87157771165b1287a
Arg [2] : 000000000000000000000000aad76bea7cfec82927239415bb18d2e93518ecbb


Deployed ByteCode Sourcemap

49128:1523:0:-;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;49128:1523:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49912:407;;;;;;;;;;;;;;;;:::i;:::-;;49155:63;;;:::i;:::-;;;;;;;;;;;;;;;;49794:110;;;;;;;;;;;;;;;;:::i;:::-;;49694:92;;;;;;;;;;;;;;;;:::i;:::-;;49225:40;;;:::i;:::-;;;;;;;;;;;;;;;;49912:407;50051:29;50083:24;50091:5;;50083:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;50083:24:0;;;;;;50098:8;50083:7;:24::i;:::-;50051:56;;50137:1;50122:4;;:11;;:16;50118:55;;;50155:7;;;50118:55;50183:15;50201:9;;;;;;;;;;;:19;;;50221:9;;;;;;;;;;;:14;;;:16;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50221:16:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50221:16:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;50221:16:0;;;;;;;;;50239:15;50201:54;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50201:54:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50201:54:0;;;;;;;101:4:-1;97:9;90:4;84;80:15;76:31;69:5;65:43;126:6;120:4;113:20;0:138;50201:54:0;;;;;;;;;50183:72;;50266:9;;;;;;;;;;;:22;;;50289:4;;50295:6;;50303:7;50266:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50266:45:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50266:45:0;;;;49912:407;;;;;;;;;;:::o;49155:63::-;;;;;;;;;;;;;;;;;;;:::o;49794:110::-;49872:24;49880:5;;49872:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;49872:24:0;;;;;;49887:8;49872:7;:24::i;:::-;;49794:110;;;:::o;49694:92::-;49752:26;49760:5;;49752:26;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;30:3:-1;22:6;14;1:33;99:1;93:3;85:6;81:16;74:27;137:4;133:9;126:4;121:3;117:14;113:30;106:37;;169:3;161:6;157:16;147:26;;49752::0;;;;;;49767:10;49752:7;:26::i;:::-;;49694:92;;:::o;49225:40::-;;;;;;;;;;;;;;;;;;;:::o;50327:321::-;50400:13;50426:29;50482:18;;;;;;;;;;;;;;;;;50502:5;50465:43;;;;;;;;;;;;;49:4:-1;39:7;30;26:21;22:32;13:7;6:49;50465:43:0;;;50426:83;;50520:18;;;;;;;;;;;:38;;;50559:8;50569:15;50594:9;;;;;;;;;;;50520:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8:9:-1;5:2;;;30:1;27;20:12;5:2;50520:85:0;;;;8:9:-1;5:2;;;45:16;42:1;39;24:38;77:16;74:1;67:27;5:2;50520:85:0;;;;50625:15;50618:22;;;50327:321;;;;:::o;5:130:-1:-;;85:6;72:20;63:29;;97:33;124:5;97:33;;;57:78;;;;;159:360;;;297:3;290:4;282:6;278:17;274:27;264:2;;315:1;312;305:12;264:2;348:6;335:20;325:30;;375:18;367:6;364:30;361:2;;;407:1;404;397:12;361:2;441:4;433:6;429:17;417:29;;492:3;484:4;476:6;472:17;462:8;458:32;455:41;452:2;;;509:1;506;499:12;452:2;257:262;;;;;;542:336;;;657:3;650:4;642:6;638:17;634:27;624:2;;675:1;672;665:12;624:2;708:6;695:20;685:30;;735:18;727:6;724:30;721:2;;;767:1;764;757:12;721:2;801:4;793:6;789:17;777:29;;851:3;844;836:6;832:16;822:8;818:31;815:40;812:2;;;868:1;865;858:12;812:2;617:261;;;;;;886:134;;970:6;964:13;955:22;;982:33;1009:5;982:33;;;949:71;;;;;1027:367;;;1151:2;1139:9;1130:7;1126:23;1122:32;1119:2;;;1167:1;1164;1157:12;1119:2;1230:1;1219:9;1215:17;1202:31;1253:18;1245:6;1242:30;1239:2;;;1285:1;1282;1275:12;1239:2;1313:65;1370:7;1361:6;1350:9;1346:22;1313:65;;;1303:75;;;;1181:203;1113:281;;;;;;1401:492;;;;1542:2;1530:9;1521:7;1517:23;1513:32;1510:2;;;1558:1;1555;1548:12;1510:2;1621:1;1610:9;1606:17;1593:31;1644:18;1636:6;1633:30;1630:2;;;1676:1;1673;1666:12;1630:2;1704:65;1761:7;1752:6;1741:9;1737:22;1704:65;;;1694:75;;;;1572:203;1806:2;1824:53;1869:7;1860:6;1849:9;1845:22;1824:53;;;1814:63;;1785:98;1504:389;;;;;;1900:1087;;;;;;;;2161:3;2149:9;2140:7;2136:23;2132:33;2129:2;;;2178:1;2175;2168:12;2129:2;2241:1;2230:9;2226:17;2213:31;2264:18;2256:6;2253:30;2250:2;;;2296:1;2293;2286:12;2250:2;2324:65;2381:7;2372:6;2361:9;2357:22;2324:65;;;2314:75;;;;2192:203;2426:2;2444:53;2489:7;2480:6;2469:9;2465:22;2444:53;;;2434:63;;2405:98;2562:2;2551:9;2547:18;2534:32;2586:18;2578:6;2575:30;2572:2;;;2618:1;2615;2608:12;2572:2;2646:88;2726:7;2717:6;2706:9;2702:22;2646:88;;;2636:98;;;;2513:227;2799:2;2788:9;2784:18;2771:32;2823:18;2815:6;2812:30;2809:2;;;2855:1;2852;2845:12;2809:2;2883:88;2963:7;2954:6;2943:9;2939:22;2883:88;;;2873:98;;;;2750:227;2123:864;;;;;;;;;;;2994:263;;3109:2;3097:9;3088:7;3084:23;3080:32;3077:2;;;3125:1;3122;3115:12;3077:2;3160:1;3177:64;3233:7;3224:6;3213:9;3209:22;3177:64;;;3167:74;;3139:108;3071:186;;;;;3265:201;;3388:72;3456:3;3448:6;3440;3388:72;;;3374:86;;3367:99;;;;;;3474:113;3557:24;3575:5;3557:24;;;3552:3;3545:37;3539:48;;;3623:911;;3791:92;3876:6;3871:3;3791:92;;;3784:99;;3906:3;3948:4;3940:6;3936:17;3931:3;3927:27;3975:66;4035:5;3975:66;;;4061:7;4089:1;4074:421;4099:6;4096:1;4093:13;4074:421;;;4161:9;4155:4;4151:20;4146:3;4139:33;4215:50;4258:6;4249:7;4215:50;;;4280:93;4368:4;4353:13;4338;4280:93;;;4272:101;;4390:70;4453:6;4390:70;;;4380:80;;4483:4;4478:3;4474:14;4467:21;;4131:364;;4121:1;4118;4114:9;4109:14;;4074:421;;;4078:14;4508:4;4501:11;;4525:3;4518:10;;3771:763;;;;;;;;;;4567:276;;4669:61;4723:6;4718:3;4669:61;;;4662:68;;4742:43;4778:6;4773:3;4766:5;4742:43;;;4807:29;4829:6;4807:29;;;4802:3;4798:39;4791:46;;4655:188;;;;;;4851:347;;4963:39;4996:5;4963:39;;;5014:71;5078:6;5073:3;5014:71;;;5007:78;;5090:52;5135:6;5130:3;5123:4;5116:5;5112:16;5090:52;;;5163:29;5185:6;5163:29;;;5158:3;5154:39;5147:46;;4943:255;;;;;;5205:360;;5335:39;5368:5;5335:39;;;5386:89;5468:6;5463:3;5386:89;;;5379:96;;5480:52;5525:6;5520:3;5513:4;5506:5;5502:16;5480:52;;;5553:6;5548:3;5544:16;5537:23;;5315:250;;;;;;5572:339;;5680:35;5709:5;5680:35;;;5727:71;5791:6;5786:3;5727:71;;;5720:78;;5803:52;5848:6;5843:3;5836:4;5829:5;5825:16;5803:52;;;5876:29;5898:6;5876:29;;;5871:3;5867:39;5860:46;;5660:251;;;;;;5918:352;;6044:35;6073:5;6044:35;;;6091:89;6173:6;6168:3;6091:89;;;6084:96;;6185:52;6230:6;6225:3;6218:4;6211:5;6207:16;6185:52;;;6258:6;6253:3;6249:16;6242:23;;6024:246;;;;;;6277:113;6360:24;6378:5;6360:24;;;6355:3;6348:37;6342:48;;;6397:419;;6587:91;6674:3;6665:6;6587:91;;;6580:98;;6696:95;6787:3;6778:6;6696:95;;;6689:102;;6808:3;6801:10;;6568:248;;;;;;6823:523;;7017:2;7006:9;7002:18;6994:26;;7031:71;7099:1;7088:9;7084:17;7075:6;7031:71;;;7150:9;7144:4;7140:20;7135:2;7124:9;7120:18;7113:48;7175:78;7248:4;7239:6;7175:78;;;7167:86;;7264:72;7332:2;7321:9;7317:18;7308:6;7264:72;;;6988:358;;;;;;;7353:827;;7675:2;7664:9;7660:18;7652:26;;7725:9;7719:4;7715:20;7711:1;7700:9;7696:17;7689:47;7750:132;7877:4;7868:6;7860;7750:132;;;7742:140;;7930:9;7924:4;7920:20;7915:2;7904:9;7900:18;7893:48;7955:132;8082:4;8073:6;8065;7955:132;;;7947:140;;8098:72;8166:2;8155:9;8151:18;8142:6;8098:72;;;7646:534;;;;;;;;;8187:293;;8321:2;8310:9;8306:18;8298:26;;8371:9;8365:4;8361:20;8357:1;8346:9;8342:17;8335:47;8396:74;8465:4;8456:6;8396:74;;;8388:82;;8292:188;;;;;8487:412;;8653:2;8642:9;8638:18;8630:26;;8667:71;8735:1;8724:9;8720:17;8711:6;8667:71;;;8786:9;8780:4;8776:20;8771:2;8760:9;8756:18;8749:48;8811:78;8884:4;8875:6;8811:78;;;8803:86;;8624:275;;;;;;8906:126;;9002:3;8994:11;;8988:44;;;;9039:118;;9129:5;9123:12;9113:22;;9094:63;;;;9164:122;;9258:5;9252:12;9242:22;;9223:63;;;;9293:118;;9401:4;9396:3;9392:14;9384:22;;9378:33;;;;9419:184;;9555:6;9550:3;9543:19;9592:4;9587:3;9583:14;9568:29;;9536:67;;;;;9612:153;;9717:6;9712:3;9705:19;9754:4;9749:3;9745:14;9730:29;;9698:67;;;;;9774:163;;9889:6;9884:3;9877:19;9926:4;9921:3;9917:14;9902:29;;9870:67;;;;;9946:145;;10082:3;10067:18;;10060:31;;;;;10100:497;;;10221:3;10208:17;10310:1;10304:4;10300:12;10289:8;10273:14;10269:29;10265:48;10245:18;10241:73;10231:2;;10328:1;10325;10318:12;10231:2;10371:8;10351:18;10347:33;10338:42;;10415:5;10402:19;10392:29;;10447:4;10440:5;10436:16;10427:25;;10472:18;10464:6;10461:30;10458:2;;;10504:1;10501;10494:12;10458:2;10563:3;10555:6;10551:16;10535:14;10531:37;10521:8;10517:52;10514:2;;;10582:1;10579;10572:12;10514:2;10175:422;;;;;;;10605:91;;10667:24;10685:5;10667:24;;;10656:35;;10650:46;;;;10703:121;;10776:42;10769:5;10765:54;10754:65;;10748:76;;;;10831:72;;10893:5;10882:16;;10876:27;;;;10911:145;10992:6;10987:3;10982;10969:30;11048:1;11039:6;11034:3;11030:16;11023:27;10962:94;;;;11065:268;11130:1;11137:101;11151:6;11148:1;11145:13;11137:101;;;11227:1;11222:3;11218:11;11212:18;11208:1;11203:3;11199:11;11192:39;11173:2;11170:1;11166:10;11161:15;;11137:101;;;11253:6;11250:1;11247:13;11244:2;;;11318:1;11309:6;11304:3;11300:16;11293:27;11244:2;11114:219;;;;;11341:97;;11429:2;11425:7;11420:2;11413:5;11409:14;11405:28;11395:38;;11389:49;;;;11446:117;11515:24;11533:5;11515:24;;;11508:5;11505:35;11495:2;;11554:1;11551;11544:12;11495:2;11489:74;;11570:117;11639:24;11657:5;11639:24;;;11632:5;11629:35;11619:2;;11678:1;11675;11668:12;11619:2;11613:74;

Swarm Source

bzzr://ba515582b0b8e3c3bac710d03898ff3bb9883d1bce437669cd5c0c081f5025e8
Block Transaction Difficulty Gas Used Reward
Block Uncle Number Difficulty Gas Used Reward
Loading

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.