Token

Polka City Asset (PCA)

ERC-721

NFT

Overview

Max Total Supply

1,425 PCA

Holders

477

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x57e9a39ae8ec404c08f88740a9e6e306f50c937f

Filtered by Token Holder

0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D

Uniswap V2: Router 2

Balance

1 PCA

0x7a250d5630b4cf539739df2c5dacb4c659f2488d

OVERVIEW

Polka City | Virtual Currency Investment Platform Polka City | A new fully autonomous contract based NFT platform that allows you to Invest in virtual assets in the form of a virtual city.

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

ERC721

Compiler Version

v0.8.1+commit.df193b15

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-02-23
*/

// SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;


interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * 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);
}
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

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

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address from, address to, uint256 tokenId) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
      * @dev Safely transfers `tokenId` token from `from` to `to`.
      *
      * Requirements:
      *
      * - `from` cannot be the zero address.
      * - `to` cannot be the zero address.
      * - `tokenId` token must exist and be owned by `from`.
      * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
      * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
      *
      * Emits a {Transfer} event.
      */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes calldata data) external;
}
interface IERC721Metadata is IERC721 {

    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}
interface IERC721Enumerable is IERC721 {

    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(address operator, address from, uint256 tokenId, bytes calldata data) external returns (bytes4);
}
abstract contract ERC165 is IERC165 {
    /**
     * @dev Mapping of interface ids to whether or not it's supported.
     */
    mapping(bytes4 => bool) private _supportedInterfaces;

    constructor () {
        // Derived contracts need only register support for their own interfaces,
        // we register support for ERC165 itself here
        _registerInterface(type(IERC165).interfaceId);
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     *
     * Time complexity O(1), guaranteed to always use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override 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 virtual {
        require(interfaceId != 0xffffffff, "ERC165: invalid interface id");
        _supportedInterfaces[interfaceId] = true;
    }
}
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on 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;
    }

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

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

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;

        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) { // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            bytes32 lastvalue = set._values[lastIndex];

            // Move the last value to the index where the value to delete is
            set._values[toDeleteIndex] = lastvalue;
            // Update the index for the moved value
            set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        require(set._values.length > index, "EnumerableSet: index out of bounds");
        return set._values[index];
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }


    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

   /**
    * @dev Returns the value stored at position `index` in the set. O(1).
    *
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }
}
library EnumerableMap {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Map type with
    // bytes32 keys and values.
    // The Map implementation uses private functions, and user-facing
    // implementations (such as Uint256ToAddressMap) are just wrappers around
    // the underlying Map.
    // This means that we can only create new EnumerableMaps for types that fit
    // in bytes32.

    struct MapEntry {
        bytes32 _key;
        bytes32 _value;
    }

    struct Map {
        // Storage of map keys and values
        MapEntry[] _entries;

        // Position of the entry defined by a key in the `entries` array, plus 1
        // because index 0 means a key is not in the map.
        mapping (bytes32 => uint256) _indexes;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function _set(Map storage map, bytes32 key, bytes32 value) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex == 0) { // Equivalent to !contains(map, key)
            map._entries.push(MapEntry({ _key: key, _value: value }));
            // The entry is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            map._indexes[key] = map._entries.length;
            return true;
        } else {
            map._entries[keyIndex - 1]._value = value;
            return false;
        }
    }

    /**
     * @dev Removes a key-value pair from a map. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function _remove(Map storage map, bytes32 key) private returns (bool) {
        // We read and store the key's index to prevent multiple reads from the same storage slot
        uint256 keyIndex = map._indexes[key];

        if (keyIndex != 0) { // Equivalent to contains(map, key)
            // To delete a key-value pair from the _entries array in O(1), we swap the entry to delete with the last one
            // in the array, and then remove the last entry (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = keyIndex - 1;
            uint256 lastIndex = map._entries.length - 1;

            // When the entry to delete is the last one, the swap operation is unnecessary. However, since this occurs
            // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.

            MapEntry storage lastEntry = map._entries[lastIndex];

            // Move the last entry to the index where the entry to delete is
            map._entries[toDeleteIndex] = lastEntry;
            // Update the index for the moved entry
            map._indexes[lastEntry._key] = toDeleteIndex + 1; // All indexes are 1-based

            // Delete the slot where the moved entry was stored
            map._entries.pop();

            // Delete the index for the deleted slot
            delete map._indexes[key];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function _contains(Map storage map, bytes32 key) private view returns (bool) {
        return map._indexes[key] != 0;
    }

    /**
     * @dev Returns the number of key-value pairs in the map. O(1).
     */
    function _length(Map storage map) private view returns (uint256) {
        return map._entries.length;
    }

   /**
    * @dev Returns the key-value pair stored at position `index` in the map. O(1).
    *
    * Note that there are no guarantees on the ordering of entries inside the
    * array, and it may change when more entries are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function _at(Map storage map, uint256 index) private view returns (bytes32, bytes32) {
        require(map._entries.length > index, "EnumerableMap: index out of bounds");

        MapEntry storage entry = map._entries[index];
        return (entry._key, entry._value);
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     */
    function _tryGet(Map storage map, bytes32 key) private view returns (bool, bytes32) {
        uint256 keyIndex = map._indexes[key];
        if (keyIndex == 0) return (false, 0); // Equivalent to contains(map, key)
        return (true, map._entries[keyIndex - 1]._value); // All indexes are 1-based
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function _get(Map storage map, bytes32 key) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, "EnumerableMap: nonexistent key"); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    /**
     * @dev Same as {_get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {_tryGet}.
     */
    function _get(Map storage map, bytes32 key, string memory errorMessage) private view returns (bytes32) {
        uint256 keyIndex = map._indexes[key];
        require(keyIndex != 0, errorMessage); // Equivalent to contains(map, key)
        return map._entries[keyIndex - 1]._value; // All indexes are 1-based
    }

    // UintToAddressMap

    struct UintToAddressMap {
        Map _inner;
    }

    /**
     * @dev Adds a key-value pair to a map, or updates the value for an existing
     * key. O(1).
     *
     * Returns true if the key was added to the map, that is if it was not
     * already present.
     */
    function set(UintToAddressMap storage map, uint256 key, address value) internal returns (bool) {
        return _set(map._inner, bytes32(key), bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the key was removed from the map, that is if it was present.
     */
    function remove(UintToAddressMap storage map, uint256 key) internal returns (bool) {
        return _remove(map._inner, bytes32(key));
    }

    /**
     * @dev Returns true if the key is in the map. O(1).
     */
    function contains(UintToAddressMap storage map, uint256 key) internal view returns (bool) {
        return _contains(map._inner, bytes32(key));
    }

    /**
     * @dev Returns the number of elements in the map. O(1).
     */
    function length(UintToAddressMap storage map) internal view returns (uint256) {
        return _length(map._inner);
    }

   /**
    * @dev Returns the element stored at position `index` in the set. O(1).
    * Note that there are no guarantees on the ordering of values inside the
    * array, and it may change when more values are added or removed.
    *
    * Requirements:
    *
    * - `index` must be strictly less than {length}.
    */
    function at(UintToAddressMap storage map, uint256 index) internal view returns (uint256, address) {
        (bytes32 key, bytes32 value) = _at(map._inner, index);
        return (uint256(key), address(uint160(uint256(value))));
    }

    /**
     * @dev Tries to returns the value associated with `key`.  O(1).
     * Does not revert if `key` is not in the map.
     *
     * _Available since v3.4._
     */
    function tryGet(UintToAddressMap storage map, uint256 key) internal view returns (bool, address) {
        (bool success, bytes32 value) = _tryGet(map._inner, bytes32(key));
        return (success, address(uint160(uint256(value))));
    }

    /**
     * @dev Returns the value associated with `key`.  O(1).
     *
     * Requirements:
     *
     * - `key` must be in the map.
     */
    function get(UintToAddressMap storage map, uint256 key) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key)))));
    }

    /**
     * @dev Same as {get}, with a custom error message when `key` is not in the map.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryGet}.
     */
    function get(UintToAddressMap storage map, uint256 key, string memory errorMessage) internal view returns (address) {
        return address(uint160(uint256(_get(map._inner, bytes32(key), errorMessage))));
    }
}
library Strings {
    /**
     * @dev Converts a `uint256` to its ASCII `string` representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        uint256 index = digits;
        temp = value;
        while (temp != 0) {
            buffer[--index] = bytes1(uint8(48 + uint256(temp % 10)));
            temp /= 10;
        }
        return string(buffer);
    }
}
library Counters {
    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 {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }
}
contract Ownable {

    address private owner;
    
    event OwnerSet(address indexed oldOwner, address indexed newOwner);
    
    modifier onlyOwner() {
        require(msg.sender == owner, "Caller is not owner");
        _;
    }

    constructor() {
        owner = msg.sender; // 'msg.sender' is sender of current call, contract deployer for a constructor
        emit OwnerSet(address(0), owner);
    }


    function changeOwner(address newOwner) public onlyOwner {
        emit OwnerSet(owner, newOwner);
        owner = newOwner;
    }

    function getOwner() external view returns (address) {
        return owner;
    }
}

contract ERC721 is ERC165, IERC721, IERC721Metadata, IERC721Enumerable, Ownable {
    using Address for address;
    using EnumerableSet for EnumerableSet.UintSet;
    using EnumerableMap for EnumerableMap.UintToAddressMap;
    using Strings for uint256;
    using Counters for Counters.Counter;

    // Map the selling contracts that can mint tokens
    mapping (address => bool) public minters;
    
    // Contract that calculates the stake profits
    address public profitsContract;
    
    // Mapping from holder address to their (enumerable) set of owned tokens
    mapping (address => EnumerableSet.UintSet) private _holderTokens;

    // Enumerable mapping from token ids to their owners
    EnumerableMap.UintToAddressMap private _tokenOwners;

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

    // Mapping from owner to operator approvals
    mapping (address => mapping (address => bool)) private _operatorApprovals;
    
    struct assetType {
        uint64 maxAmount;
        uint64 mintedAmount;
        uint128 baseValue;
    }
    
    mapping (uint256 => assetType) public assetsByType;
    
    struct assetDetail {
        uint128 value;
        uint32 lastTrade;
        uint32 lastPayment;
        uint32 typeDetail;
        uint32 customDetails;
    }
    
    mapping (uint256 => assetDetail) assetsDetails;
    address public sellingContract;
    uint256 public polkaCitizens = 0;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Base URI
    string private _baseURI;
    
    Counters.Counter private _tokenIdTracker;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor () {
        _name ="Polka City Asset";
        _symbol = "PCA";
        _baseURI = "https://polkacity.app/nftasset/";
        
        initAssets(1, 1000, 1500);
        initAssets(2, 750, 3000);
        initAssets(3, 500, 7500);
        initAssets(4, 300, 10000);
        initAssets(5, 200, 15000);
        initAssets(6, 50, 75000);
        initAssets(7, 50, 65500);
        initAssets(8, 50, 40000);
        initAssets(9, 50, 90000);
        initAssets(10, 50, 55000);
        initAssets(11, 50, 105000);
        initAssets(12, 50, 50000);
        initAssets(13, 50, 22500);
        initAssets(14, 50, 30000);
        initAssets(15, 50, 45000);
        
        // register the supported interfaces to conform to ERC721 via ERC165
        _registerInterface(type(IERC721).interfaceId);
        _registerInterface(type(IERC721Metadata).interfaceId);
        _registerInterface(type(IERC721Enumerable).interfaceId);
    }

    function initAssets(uint64 _assetType, uint64 _maxAmount, uint256 _baseValue) private {
        assetsByType[_assetType].maxAmount = _maxAmount;
        assetsByType[_assetType].mintedAmount = 0;
        assetsByType[_assetType].baseValue = uint128(_baseValue * (10 ** 18));
    }
    
    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address _owner) public view virtual override returns (uint256) {
        require(_owner != address(0), "ERC721: balance query for the zero address");
        return _holderTokens[_owner].length();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        return _tokenOwners.get(tokenId, "ERC721: owner query for nonexistent token");
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
        string memory base = baseURI();
        return string(abi.encodePacked(base, assetsDetails[tokenId].customDetails));
    }

    function baseURI() public view virtual returns (string memory) {
        return _baseURI;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address _owner, uint256 index) public view virtual override returns (uint256) {
        return _holderTokens[_owner].at(index);
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        // _tokenOwners are indexed by tokenIds, so .length() returns the number of tokenIds
        return _tokenOwners.length();
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        (uint256 tokenId, ) = _tokenOwners.at(index);
        return (tokenId);
    }
    
    function getTokenDetails(uint256 index) public view returns (uint128 lastvalue, uint32 aType, uint32 customDetails, uint32 lastTx, uint32 lastPayment) {
        return (assetsDetails[index].value, 
        assetsDetails[index].typeDetail, 
        assetsDetails[index].customDetails, 
        assetsDetails[index].lastTrade, 
        assetsDetails[index].lastPayment);
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address _owner = ERC721.ownerOf(tokenId);
        require(to != _owner, "ERC721: approval to current owner");

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

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != msg.sender, "ERC721: approve to caller");

        _operatorApprovals[msg.sender][operator] = approved;
        emit ApprovalForAll(msg.sender, operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address _owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[_owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(address from, address to, uint256 tokenId) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(msg.sender, tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory _data) public virtual override {
        require(_isApprovedOrOwner(msg.sender, tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory _data) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _tokenOwners.contains(tokenId);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address _owner = ERC721.ownerOf(tokenId);
        return (spender == _owner || getApproved(tokenId) == spender || ERC721.isApprovedForAll(_owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     d*
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(address to, uint256 tokenId, bytes memory _data) internal virtual {
        _mint(to, tokenId);
        require(_checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);

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


    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(address from, address to, uint256 tokenId) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); // internal owner
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _holderTokens[from].remove(tokenId);
        _holderTokens[to].add(tokenId);

        _tokenOwners.set(tokenId, to);
        assetsDetails[tokenId].lastTrade = uint32(block.timestamp);
        checkCitizen(to, true);
        checkCitizen(from, false);

        emit Transfer(from, to, tokenId);
    }


    function setBaseURI(string memory baseURI_) public onlyOwner {
        _baseURI = baseURI_;
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-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 bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(address from, address to, uint256 tokenId, bytes memory _data)
        private returns (bool)
    {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(msg.sender, from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver(to).onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    // solhint-disable-next-line no-inline-assembly
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    function _approve(address to, uint256 tokenId) private {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId); // internal owner
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 tokenId) internal virtual { }
    
    function checkCitizen(address _citizen, bool _addAsset) private {
        uint256 citizenBalance = _holderTokens[_citizen].length();
        if (citizenBalance > 0) {
            if (_addAsset == true && citizenBalance == 1) {
                polkaCitizens++;
            }
        } else {
            polkaCitizens--;
        }
    }
    
    function mint(address to, uint32 _assetType, uint32 _customDetails) public virtual returns (bool success) {
        require(minters[msg.sender] == true, "Not allowed");
        require(assetsByType[_assetType].maxAmount > assetsByType[_assetType].mintedAmount, "Max mintable amount reached for this asset" );
        uint256 curIndex = _tokenIdTracker.current();
        _mint(to, curIndex);
        assetsDetails[curIndex].typeDetail = _assetType;
        assetsDetails[curIndex].value = assetsByType[_assetType].baseValue;
        assetsDetails[curIndex].lastTrade = uint32(block.timestamp);
        assetsDetails[curIndex].lastPayment = uint32(block.timestamp);
        assetsDetails[curIndex].customDetails = _customDetails;
        assetsByType[_assetType].mintedAmount += 1;
        _tokenIdTracker.increment();
        checkCitizen(to, true);
        return true;
    }
    
    function setMinter(address _minterAddress, bool _canMint) public onlyOwner {
        minters[_minterAddress] = _canMint;
    }
    
    function setProfitsContract(address _contract) public onlyOwner {
        profitsContract = _contract;
    }
    
    function setPaymentDate(uint256 _asset) public {
        require(msg.sender == profitsContract);
        assetsDetails[_asset].lastPayment = uint32(block.timestamp);
    }
    
    function addAssetType(uint64 _assetId, uint64 _maxAmount, uint256 _baseValue) public onlyOwner {
        require(_maxAmount > 0 && _baseValue > 0);
        require(assetsByType[_assetId].maxAmount > 0);
        initAssets(_assetId, _maxAmount, _baseValue);
    }

    
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnerSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"uint64","name":"_assetId","type":"uint64"},{"internalType":"uint64","name":"_maxAmount","type":"uint64"},{"internalType":"uint256","name":"_baseValue","type":"uint256"}],"name":"addAssetType","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"assetsByType","outputs":[{"internalType":"uint64","name":"maxAmount","type":"uint64"},{"internalType":"uint64","name":"mintedAmount","type":"uint64"},{"internalType":"uint128","name":"baseValue","type":"uint128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"changeOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getTokenDetails","outputs":[{"internalType":"uint128","name":"lastvalue","type":"uint128"},{"internalType":"uint32","name":"aType","type":"uint32"},{"internalType":"uint32","name":"customDetails","type":"uint32"},{"internalType":"uint32","name":"lastTx","type":"uint32"},{"internalType":"uint32","name":"lastPayment","type":"uint32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint32","name":"_assetType","type":"uint32"},{"internalType":"uint32","name":"_customDetails","type":"uint32"}],"name":"mint","outputs":[{"internalType":"bool","name":"success","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minters","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"polkaCitizens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"profitsContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"sellingContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_minterAddress","type":"address"},{"internalType":"bool","name":"_canMint","type":"bool"}],"name":"setMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_asset","type":"uint256"}],"name":"setPaymentDate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_contract","type":"address"}],"name":"setProfitsContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

36678:17192:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7502:150;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40364:100;;;:::i;:::-;;;;;;;:::i;42833:221::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;42363:404::-;;;;;;:::i;:::-;;:::i;:::-;;38156:32;;;:::i;:::-;;;;;;;:::i;37825:50::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;41447:211::-;;;:::i;43719:303::-;;;;;;:::i;:::-;;:::i;53593:266::-;;;;;;:::i;:::-;;:::i;41207:164::-;;;;;;:::i;:::-;;:::i;44093:151::-;;;;;;:::i;:::-;;:::i;41735:174::-;;;;;;:::i;:::-;;:::i;49473:99::-;;;;;;:::i;:::-;;:::i;40120:177::-;;;;;;:::i;:::-;;:::i;41026:97::-;;;:::i;39834:224::-;;;;;;:::i;:::-;;:::i;52243:890::-;;;;;;:::i;:::-;;:::i;36588:83::-;;;:::i;40533:104::-;;;:::i;53407:174::-;;;;;;:::i;:::-;;:::i;43126:289::-;;;;;;:::i;:::-;;:::i;36448:132::-;;;;;;:::i;:::-;;:::i;44315:283::-;;;;;;:::i;:::-;;:::i;38119:30::-;;;:::i;53285:110::-;;;;;;:::i;:::-;;:::i;41921:380::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;:::i;40708:310::-;;;;;;:::i;:::-;;:::i;37145:30::-;;;:::i;53145:128::-;;;;;;:::i;:::-;;:::i;43486:166::-;;;;;;:::i;:::-;;:::i;37041:40::-;;;;;;:::i;:::-;;:::i;7502:150::-;-1:-1:-1;;;;;;7611:33:0;;7587:4;7611:33;;;;;;;;;;;;;7502:150;;;;:::o;40364:100::-;40418:13;40451:5;40444:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40364:100;:::o;42833:221::-;42909:7;42937:16;42945:7;42937;:16::i;:::-;42929:73;;;;-1:-1:-1;;;42929:73:0;;;;;;;:::i;:::-;;;;;;;;;-1:-1:-1;43022:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;43022:24:0;;42833:221::o;42363:404::-;42444:14;42461:23;42476:7;42461:14;:23::i;:::-;42444:40;;42509:6;-1:-1:-1;;;;;42503:12:0;:2;-1:-1:-1;;;;;42503:12:0;;;42495:58;;;;-1:-1:-1;;;42495:58:0;;;;;;;:::i;:::-;42574:10;-1:-1:-1;;;;;42574:20:0;;;;:67;;;42598:43;42622:6;42630:10;42598:23;:43::i;:::-;42566:159;;;;-1:-1:-1;;;42566:159:0;;;;;;;:::i;:::-;42738:21;42747:2;42751:7;42738:8;:21::i;:::-;42363:404;;;:::o;38156:32::-;;;;:::o;37825:50::-;;;;;;;;;;;;-1:-1:-1;;;;;37825:50:0;;;;-1:-1:-1;;;37825:50:0;;;;;;-1:-1:-1;;;37825:50:0;;-1:-1:-1;;;;;37825:50:0;;:::o;41447:211::-;41508:7;41629:21;:12;:19;:21::i;:::-;41622:28;;41447:211;:::o;43719:303::-;43880:39;43899:10;43911:7;43880:18;:39::i;:::-;43872:101;;;;-1:-1:-1;;;43872:101:0;;;;;;;:::i;:::-;43986:28;43996:4;44002:2;44006:7;43986:9;:28::i;53593:266::-;36208:5;;-1:-1:-1;;;;;36208:5:0;36194:10;:19;36186:51;;;;-1:-1:-1;;;36186:51:0;;;;;;;:::i;:::-;53720:1:::1;53707:10;-1:-1:-1::0;;;;;53707:14:0::1;;:32;;;;;53738:1;53725:10;:14;53707:32;53699:41;;;::::0;::::1;;-1:-1:-1::0;;;;;53759:22:0;;::::1;53794:1;53759:22:::0;;;:12:::1;:22;::::0;;;;:32;::::1;53751:45;;;::::0;::::1;;53807:44;53818:8;53828:10;53840;53807;:44::i;41207:164::-:0;-1:-1:-1;;;;;41332:21:0;;41305:7;41332:21;;;:13;:21;;;;;:31;;41357:5;41332:24;:31::i;:::-;41325:38;;41207:164;;;;;:::o;44093:151::-;44197:39;44214:4;44220:2;44224:7;44197:39;;;;;;;;;;;;:16;:39::i;41735:174::-;41810:7;;41852:22;:12;41868:5;41852:15;:22::i;:::-;-1:-1:-1;41830:44:0;41735:174;-1:-1:-1;;;41735:174:0:o;49473:99::-;36208:5;;-1:-1:-1;;;;;36208:5:0;36194:10;:19;36186:51;;;;-1:-1:-1;;;36186:51:0;;;;;;;:::i;:::-;49545:19;;::::1;::::0;:8:::1;::::0;:19:::1;::::0;::::1;::::0;::::1;:::i;:::-;;49473:99:::0;:::o;40120:177::-;40192:7;40219:70;40236:7;40219:70;;;;;;;;;;;;;;;;;:12;;:70;:16;:70::i;41026:97::-;41074:13;41107:8;41100:15;;;;;:::i;39834:224::-;39907:7;-1:-1:-1;;;;;39935:20:0;;39927:75;;;;-1:-1:-1;;;39927:75:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;40020:21:0;;;;;;:13;:21;;;;;:30;;:28;:30::i;52243:890::-;52376:10;52335:12;52368:19;;;:7;:19;;;;;;;;:27;;:19;:27;52360:51;;;;-1:-1:-1;;;52360:51:0;;;;;;;:::i;:::-;52467:24;;;;;;;:12;:24;;;;;:37;-1:-1:-1;;;;;;;;52467:37:0;;;;52430:34;;:74;52422:130;;;;-1:-1:-1;;;52422:130:0;;;;;;;:::i;:::-;52563:16;52582:25;:15;:23;:25::i;:::-;52563:44;;52618:19;52624:2;52628:8;52618:5;:19::i;:::-;52648:23;;;;:13;:23;;;;;;;;:47;;-1:-1:-1;;;;52648:47:0;-1:-1:-1;;;52648:47:0;;;;;;;;;;;;;;52738:24;;;:12;:24;;;;;;;:34;;-1:-1:-1;;;52738:34:0;;;;-1:-1:-1;;;;;52738:34:0;-1:-1:-1;;52706:66:0;;;;;;;-1:-1:-1;;;;52783:59:0;52826:15;52783:59;;;;;;-1:-1:-1;;;;52853:61:0;-1:-1:-1;;;52853:61:0;;;;;;;;-1:-1:-1;;;;;52925:54:0;-1:-1:-1;;;52925:54:0;;;;;;;;;;;52990:42;;-1:-1:-1;;52738:24:0;52990:37;;:42;;-1:-1:-1;;;;;52990:42:0;;-1:-1:-1;;;;;52990:42:0;;:::i;:::-;;;;;;;;-1:-1:-1;;;;;52990:42:0;;;;;-1:-1:-1;;;;;52990:42:0;;;;;;53043:27;:15;:25;:27::i;:::-;53081:22;53094:2;53098:4;53081:12;:22::i;:::-;53121:4;53114:11;;;52243:890;;;;;;:::o;36588:83::-;36658:5;;-1:-1:-1;;;;;36658:5:0;36588:83;:::o;40533:104::-;40589:13;40622:7;40615:14;;;;;:::i;53407:174::-;53487:15;;-1:-1:-1;;;;;53487:15:0;53473:10;:29;53465:38;;;;;;53514:21;;;;:13;:21;;;;;:59;;-1:-1:-1;;;;53514:59:0;-1:-1:-1;;;53557:15:0;53514:59;;;;;;53407:174::o;43126:289::-;-1:-1:-1;;;;;43229:22:0;;43241:10;43229:22;;43221:60;;;;-1:-1:-1;;;43221:60:0;;;;;;;:::i;:::-;43313:10;43294:30;;;;:18;:30;;;;;;;;-1:-1:-1;;;;;43294:40:0;;;;;;;;;;;:51;;-1:-1:-1;;43294:51:0;;;;;;;43361:46;;43294:40;;43313:10;43361:46;;;;43294:51;;43361:46;:::i;:::-;;;;;;;;43126:289;;:::o;36448:132::-;36208:5;;-1:-1:-1;;;;;36208:5:0;36194:10;:19;36186:51;;;;-1:-1:-1;;;36186:51:0;;;;;;;:::i;:::-;36529:5:::1;::::0;36520:25:::1;::::0;-1:-1:-1;;;;;36520:25:0;;::::1;::::0;36529:5:::1;::::0;36520:25:::1;::::0;36529:5:::1;::::0;36520:25:::1;36556:5;:16:::0;;-1:-1:-1;;;;;;36556:16:0::1;-1:-1:-1::0;;;;;36556:16:0;;;::::1;::::0;;;::::1;::::0;;36448:132::o;44315:283::-;44447:39;44466:10;44478:7;44447:18;:39::i;:::-;44439:101;;;;-1:-1:-1;;;44439:101:0;;;;;;;:::i;:::-;44551:39;44565:4;44571:2;44575:7;44584:5;44551:13;:39::i;:::-;44315:283;;;;:::o;38119:30::-;;;-1:-1:-1;;;;;38119:30:0;;:::o;53285:110::-;36208:5;;-1:-1:-1;;;;;36208:5:0;36194:10;:19;36186:51;;;;-1:-1:-1;;;36186:51:0;;;;;;;:::i;:::-;53360:15:::1;:27:::0;;-1:-1:-1;;;;;;53360:27:0::1;-1:-1:-1::0;;;;;53360:27:0;;;::::1;::::0;;;::::1;::::0;;53285:110::o;41921:380::-;41982:17;42091:20;;;:13;:20;;;;;:26;-1:-1:-1;;;;;42091:26:0;;;42129:31;-1:-1:-1;;;42129:31:0;;;;;-1:-1:-1;;;42172:34:0;;;;;-1:-1:-1;;;42218:30:0;;;;;-1:-1:-1;;;42260:32:0;;;;;;;41921:380::o;40708:310::-;40781:13;40815:16;40823:7;40815;:16::i;:::-;40807:76;;;;-1:-1:-1;;;40807:76:0;;;;;;;:::i;:::-;40894:18;40915:9;:7;:9::i;:::-;40972:22;;;;:13;:22;;;;;;;;;:36;40949:60;;40894:30;;-1:-1:-1;40949:60:0;;40894:30;;-1:-1:-1;;;40972:36:0;;;;;40949:60;;:::i;:::-;;;;;;;;;;;;;40935:75;;;40708:310;;;:::o;37145:30::-;;;-1:-1:-1;;;;;37145:30:0;;:::o;53145:128::-;36208:5;;-1:-1:-1;;;;;36208:5:0;36194:10;:19;36186:51;;;;-1:-1:-1;;;36186:51:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;53231:23:0;;;::::1;;::::0;;;:7:::1;:23;::::0;;;;:34;;-1:-1:-1;;53231:34:0::1;::::0;::::1;;::::0;;;::::1;::::0;;53145:128::o;43486:166::-;-1:-1:-1;;;;;43608:26:0;;;43584:4;43608:26;;;:18;:26;;;;;;;;:36;;;;;;;;;;;;;;;43486:166::o;37041:40::-;;;;;;;;;;;;;;;:::o;46065:127::-;46130:4;46154:30;:12;46176:7;46154:21;:30::i;50986:183::-;51052:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;51052:29:0;-1:-1:-1;;;;;51052:29:0;;;;;;;;:24;;51106:23;51052:24;51106:14;:23::i;:::-;-1:-1:-1;;;;;51097:46:0;;;;;;;;;;;50986:183;;:::o;32272:123::-;32341:7;32368:19;32376:3;32368:7;:19::i;46359:358::-;46452:4;46477:16;46485:7;46477;:16::i;:::-;46469:73;;;;-1:-1:-1;;;46469:73:0;;;;;;;:::i;:::-;46553:14;46570:23;46585:7;46570:14;:23::i;:::-;46553:40;;46623:6;-1:-1:-1;;;;;46612:17:0;:7;-1:-1:-1;;;;;46612:17:0;;:52;;;;46657:7;-1:-1:-1;;;;;46633:31:0;:20;46645:7;46633:11;:20::i;:::-;-1:-1:-1;;;;;46633:31:0;;46612:52;:96;;;;46668:40;46692:6;46700:7;46668:23;:40::i;:::-;46604:105;46359:358;-1:-1:-1;;;;46359:358:0:o;48726:737::-;48851:4;-1:-1:-1;;;;;48824:31:0;:23;48839:7;48824:14;:23::i;:::-;-1:-1:-1;;;;;48824:31:0;;48816:85;;;;-1:-1:-1;;;48816:85:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;48938:16:0;;48930:65;;;;-1:-1:-1;;;48930:65:0;;;;;;;:::i;:::-;49008:39;49029:4;49035:2;49039:7;49008:20;:39::i;:::-;49112:29;49129:1;49133:7;49112:8;:29::i;:::-;-1:-1:-1;;;;;49154:19:0;;;;;;:13;:19;;;;;:35;;49181:7;49154:26;:35::i;:::-;-1:-1:-1;;;;;;49200:17:0;;;;;;:13;:17;;;;;:30;;49222:7;49200:21;:30::i;:::-;-1:-1:-1;49243:29:0;:12;49260:7;49269:2;49243:16;:29::i;:::-;-1:-1:-1;49283:22:0;;;;:13;:22;;;;;:58;;-1:-1:-1;;;;49283:58:0;-1:-1:-1;;;49325:15:0;49283:58;;;;;;49352:22;49365:2;-1:-1:-1;49352:12:0;:22::i;:::-;49385:25;49398:4;49404:5;49385:12;:25::i;:::-;49447:7;49443:2;-1:-1:-1;;;;;49428:27:0;49437:4;-1:-1:-1;;;;;49428:27:0;;;;;;;;;;;48726:737;;;:::o;39482:284::-;-1:-1:-1;;;;;39579:24:0;;;;;;;:12;:24;;;;;:47;;-1:-1:-1;;39579:47:0;;;;;;;;-1:-1:-1;;39637:41:0;;;39734:23;:10;39748:8;39734:23;:::i;:::-;-1:-1:-1;;;;;39689:24:0;;;;;;;:12;:24;;;;;:69;;-1:-1:-1;;;;;39689:69:0;;;-1:-1:-1;;;39689:69:0;;;;;;;;;;-1:-1:-1;;39482:284:0:o;24894:137::-;24965:7;25000:22;25004:3;25016:5;25000:3;:22::i;32734:236::-;32814:7;;;;32874:22;32878:3;32890:5;32874:3;:22::i;:::-;32843:53;;;;-1:-1:-1;32734:236:0;-1:-1:-1;;;;;32734:236:0:o;34020:213::-;34127:7;34178:44;34183:3;34203;34209:12;34178:4;:44::i;35518:114::-;35610:14;;35518:114::o;47983:404::-;-1:-1:-1;;;;;48063:16:0;;48055:61;;;;-1:-1:-1;;;48055:61:0;;;;;;;:::i;:::-;48136:16;48144:7;48136;:16::i;:::-;48135:17;48127:58;;;;-1:-1:-1;;;48127:58:0;;;;;;;:::i;:::-;48198:45;48227:1;48231:2;48235:7;48198:20;:45::i;:::-;-1:-1:-1;;;;;48256:17:0;;;;;;:13;:17;;;;;:30;;48278:7;48256:21;:30::i;:::-;-1:-1:-1;48299:29:0;:12;48316:7;48325:2;48299:16;:29::i;:::-;-1:-1:-1;48346:33:0;;48371:7;;-1:-1:-1;;;;;48346:33:0;;;48363:1;;48346:33;;48363:1;;48346:33;47983:404;;:::o;35640:127::-;35729:19;;35747:1;35729:19;;;35640:127::o;51887:344::-;-1:-1:-1;;;;;51987:23:0;;51962:22;51987:23;;;:13;:23;;;;;:32;;:30;:32::i;:::-;51962:57;-1:-1:-1;52034:18:0;;52030:194;;52086:4;52073:17;;;;:40;;;;;52094:14;52112:1;52094:19;52073:40;52069:96;;;52134:13;:15;;;:13;:15;;;:::i;:::-;;;;;;52069:96;52030:194;;;52197:13;:15;;;:13;:15;;;:::i;:::-;;;;;;51887:344;;;:::o;45480:272::-;45594:28;45604:4;45610:2;45614:7;45594:9;:28::i;:::-;45641:48;45664:4;45670:2;45674:7;45683:5;45641:22;:48::i;:::-;45633:111;;;;-1:-1:-1;;;45633:111:0;;;;;;;:::i;32033:151::-;32117:4;32141:35;32151:3;32171;32141:9;:35::i;23981:137::-;24051:4;24075:35;24083:3;24103:5;24075:7;:35::i;23674:131::-;23741:4;23765:32;23770:3;23790:5;23765:4;:32::i;31456:185::-;31545:4;31569:64;31574:3;31594;-1:-1:-1;;;;;31608:23:0;;31569:4;:64::i;19932:204::-;20027:18;;19999:7;;20027:26;-1:-1:-1;20019:73:0;;;;-1:-1:-1;;;20019:73:0;;;;;;;:::i;:::-;20110:3;:11;;20122:5;20110:18;;;;;;-1:-1:-1;;;20110:18:0;;;;;;;;;;;;;;;;;20103:25;;19932:204;;;;:::o;29316:279::-;29420:19;;29383:7;;;;29420:27;-1:-1:-1;29412:74:0;;;;-1:-1:-1;;;29412:74:0;;;;;;;:::i;:::-;29499:22;29524:3;:12;;29537:5;29524:19;;;;;;-1:-1:-1;;;29524:19:0;;;;;;;;;;;;;;;;;;;29499:44;;29562:5;:10;;;29574:5;:12;;;29554:33;;;;;29316:279;;;;;:::o;30813:319::-;30907:7;30946:17;;;:12;;;:17;;;;;;30997:12;30982:13;30974:36;;;;-1:-1:-1;;;30974:36:0;;;;;;;;:::i;:::-;-1:-1:-1;31064:3:0;31077:12;31088:1;31077:8;:12;:::i;:::-;31064:26;;;;;;-1:-1:-1;;;31064:26:0;;;;;;;;;;;;;;;;;;;:33;;;31057:40;;;30813:319;;;;;:::o;50137:841::-;50258:4;50284:15;:2;-1:-1:-1;;;;;50284:13:0;;:15::i;:::-;50280:691;;;50320:70;;-1:-1:-1;;;50320:70:0;;-1:-1:-1;;;;;50320:36:0;;;;;:70;;50357:10;;50369:4;;50375:7;;50384:5;;50320:70;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50320:70:0;;;;;;;;-1:-1:-1;;50320:70:0;;;;;;;;;;;;:::i;:::-;;;50316:600;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;50564:13:0;;50560:341;;50607:60;;-1:-1:-1;;;50607:60:0;;;;;;;:::i;50560:341::-;50851:6;50845:13;50836:6;50832:2;50828:15;50821:38;50316:600;-1:-1:-1;;;;;;50441:55:0;-1:-1:-1;;;50441:55:0;;-1:-1:-1;50434:62:0;;50280:691;-1:-1:-1;50955:4:0;50137:841;;;;;;:::o;28631:125::-;28702:4;28726:17;;;:12;;;;;:17;;;;;;:22;;;28631:125::o;17634:1544::-;17700:4;17839:19;;;:12;;;:19;;;;;;17875:15;;17871:1300;;18237:21;18261:14;18274:1;18261:10;:14;:::i;:::-;18310:18;;18237:38;;-1:-1:-1;18290:17:0;;18310:22;;18331:1;;18310:22;:::i;:::-;18290:42;;18577:17;18597:3;:11;;18609:9;18597:22;;;;;;-1:-1:-1;;;18597:22:0;;;;;;;;;;;;;;;;;18577:42;;18743:9;18714:3;:11;;18726:13;18714:26;;;;;;-1:-1:-1;;;18714:26:0;;;;;;;;;;;;;;;;;;:38;18846:17;:13;18862:1;18846:17;:::i;:::-;18820:23;;;;:12;;;:23;;;;;:43;18972:17;;18820:3;;18972:17;;;-1:-1:-1;;;18972:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;19067:3;:12;;:19;19080:5;19067:19;;;;;;;;;;;19060:26;;;19110:4;19103:11;;;;;;;;17871:1300;19154:5;19147:12;;;;;17044:414;17107:4;17129:21;17139:3;17144:5;17129:9;:21::i;:::-;17124:327;;-1:-1:-1;17167:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;17350:18;;17328:19;;;:12;;;:19;;;;;;:40;;;;17383:11;;17124:327;-1:-1:-1;17434:5:0;17427:12;;26131:692;26207:4;26342:17;;;:12;;;:17;;;;;;26376:13;26372:444;;-1:-1:-1;;26461:38:0;;;;;;;;;;;;;;;;;;26443:57;;;;;;;;:12;:57;;;;;;;;;;;;;;;;;;;;;;;;26658:19;;26638:17;;;:12;;;:17;;;;;;;:39;26692:11;;26372:444;26772:5;26736:3;26749:12;26760:1;26749:8;:12;:::i;:::-;26736:26;;;;;;-1:-1:-1;;;26736:26:0;;;;;;;;;;;;;;;;;;;:33;;:41;;;;26799:5;26792:12;;;;;8875:422;9242:20;9281:8;;;8875:422::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:633:1;;-1:-1:-1;;;;;151:2:1;143:6;140:14;137:2;;;157:18;;:::i;:::-;232:2;226:9;200:2;286:15;;-1:-1:-1;;282:24:1;;;308:2;278:33;274:42;262:55;;;332:18;;;352:22;;;329:46;326:2;;;378:18;;:::i;:::-;418:10;414:2;407:22;447:6;438:15;;477:6;469;462:22;517:3;508:6;503:3;499:16;496:25;493:2;;;534:1;531;524:12;493:2;584:6;579:3;572:4;564:6;560:17;547:44;639:1;632:4;623:6;615;611:19;607:30;600:41;;;;90:557;;;;;:::o;652:175::-;722:20;;-1:-1:-1;;;;;771:31:1;;761:42;;751:2;;817:1;814;807:12;832:165;901:20;;961:10;950:22;;940:33;;930:2;;987:1;984;977:12;1002:173;1071:20;;-1:-1:-1;;;;;1120:30:1;;1110:41;;1100:2;;1165:1;1162;1155:12;1180:198;;1292:2;1280:9;1271:7;1267:23;1263:32;1260:2;;;1313:6;1305;1298:22;1260:2;1341:31;1362:9;1341:31;:::i;1383:274::-;;;1512:2;1500:9;1491:7;1487:23;1483:32;1480:2;;;1533:6;1525;1518:22;1480:2;1561:31;1582:9;1561:31;:::i;:::-;1551:41;;1611:40;1647:2;1636:9;1632:18;1611:40;:::i;:::-;1601:50;;1470:187;;;;;:::o;1662:342::-;;;;1808:2;1796:9;1787:7;1783:23;1779:32;1776:2;;;1829:6;1821;1814:22;1776:2;1857:31;1878:9;1857:31;:::i;:::-;1847:41;;1907:40;1943:2;1932:9;1928:18;1907:40;:::i;:::-;1897:50;;1994:2;1983:9;1979:18;1966:32;1956:42;;1766:238;;;;;:::o;2009:702::-;;;;;2181:3;2169:9;2160:7;2156:23;2152:33;2149:2;;;2203:6;2195;2188:22;2149:2;2231:31;2252:9;2231:31;:::i;:::-;2221:41;;2281:40;2317:2;2306:9;2302:18;2281:40;:::i;:::-;2271:50;;2368:2;2357:9;2353:18;2340:32;2330:42;;2423:2;2412:9;2408:18;2395:32;-1:-1:-1;;;;;2442:6:1;2439:30;2436:2;;;2487:6;2479;2472:22;2436:2;2515:22;;2568:4;2560:13;;2556:27;-1:-1:-1;2546:2:1;;2602:6;2594;2587:22;2546:2;2630:75;2697:7;2692:2;2679:16;2674:2;2670;2666:11;2630:75;:::i;:::-;2620:85;;;2139:572;;;;;;;:::o;2716:369::-;;;2842:2;2830:9;2821:7;2817:23;2813:32;2810:2;;;2863:6;2855;2848:22;2810:2;2891:31;2912:9;2891:31;:::i;:::-;2881:41;;2972:2;2961:9;2957:18;2944:32;3019:5;3012:13;3005:21;2998:5;2995:32;2985:2;;3046:6;3038;3031:22;2985:2;3074:5;3064:15;;;2800:285;;;;;:::o;3090:266::-;;;3219:2;3207:9;3198:7;3194:23;3190:32;3187:2;;;3240:6;3232;3225:22;3187:2;3268:31;3289:9;3268:31;:::i;:::-;3258:41;3346:2;3331:18;;;;3318:32;;-1:-1:-1;;;3177:179:1:o;3361:346::-;;;;3505:2;3493:9;3484:7;3480:23;3476:32;3473:2;;;3526:6;3518;3511:22;3473:2;3554:31;3575:9;3554:31;:::i;:::-;3544:41;;3604:39;3639:2;3628:9;3624:18;3604:39;:::i;:::-;3594:49;;3662:39;3697:2;3686:9;3682:18;3662:39;:::i;:::-;3652:49;;3463:244;;;;;:::o;3712:257::-;;3823:2;3811:9;3802:7;3798:23;3794:32;3791:2;;;3844:6;3836;3829:22;3791:2;3888:9;3875:23;3907:32;3933:5;3907:32;:::i;3974:261::-;;4096:2;4084:9;4075:7;4071:23;4067:32;4064:2;;;4117:6;4109;4102:22;4064:2;4154:9;4148:16;4173:32;4199:5;4173:32;:::i;4240:482::-;;4362:2;4350:9;4341:7;4337:23;4333:32;4330:2;;;4383:6;4375;4368:22;4330:2;4428:9;4415:23;-1:-1:-1;;;;;4453:6:1;4450:30;4447:2;;;4498:6;4490;4483:22;4447:2;4526:22;;4579:4;4571:13;;4567:27;-1:-1:-1;4557:2:1;;4613:6;4605;4598:22;4557:2;4641:75;4708:7;4703:2;4690:16;4685:2;4681;4677:11;4641:75;:::i;4727:190::-;;4839:2;4827:9;4818:7;4814:23;4810:32;4807:2;;;4860:6;4852;4845:22;4807:2;-1:-1:-1;4888:23:1;;4797:120;-1:-1:-1;4797:120:1:o;4922:338::-;;;;5066:2;5054:9;5045:7;5041:23;5037:32;5034:2;;;5087:6;5079;5072:22;5034:2;5115:30;5135:9;5115:30;:::i;:::-;5105:40;;5164:39;5199:2;5188:9;5184:18;5164:39;:::i;5265:259::-;;5346:5;5340:12;5373:6;5368:3;5361:19;5389:63;5445:6;5438:4;5433:3;5429:14;5422:4;5415:5;5411:16;5389:63;:::i;:::-;5506:2;5485:15;-1:-1:-1;;5481:29:1;5472:39;;;;5513:4;5468:50;;5316:208;-1:-1:-1;;5316:208:1:o;5529:404::-;;5724:6;5718:13;5740:53;5786:6;5781:3;5774:4;5766:6;5762:17;5740:53;:::i;:::-;5880:3;5858:16;;;;-1:-1:-1;;;;;;5854:43:1;5815:16;;;;5840:58;;;5925:1;5914:13;;5694:239;-1:-1:-1;;5694:239:1:o;5938:203::-;-1:-1:-1;;;;;6102:32:1;;;;6084:51;;6072:2;6057:18;;6039:102::o;6146:490::-;-1:-1:-1;;;;;6415:15:1;;;6397:34;;6467:15;;6462:2;6447:18;;6440:43;6514:2;6499:18;;6492:34;;;6562:3;6557:2;6542:18;;6535:31;;;6146:490;;6583:47;;6610:19;;6602:6;6583:47;:::i;:::-;6575:55;6349:287;-1:-1:-1;;;;;;6349:287:1:o;6641:187::-;6806:14;;6799:22;6781:41;;6769:2;6754:18;;6736:92::o;6833:221::-;;6982:2;6971:9;6964:21;7002:46;7044:2;7033:9;7029:18;7021:6;7002:46;:::i;7059:398::-;7261:2;7243:21;;;7300:2;7280:18;;;7273:30;7339:34;7334:2;7319:18;;7312:62;-1:-1:-1;;;7405:2:1;7390:18;;7383:32;7447:3;7432:19;;7233:224::o;7462:406::-;7664:2;7646:21;;;7703:2;7683:18;;;7676:30;7742:34;7737:2;7722:18;;7715:62;-1:-1:-1;;;7808:2:1;7793:18;;7786:40;7858:3;7843:19;;7636:232::o;7873:414::-;8075:2;8057:21;;;8114:2;8094:18;;;8087:30;8153:34;8148:2;8133:18;;8126:62;-1:-1:-1;;;8219:2:1;8204:18;;8197:48;8277:3;8262:19;;8047:240::o;8292:352::-;8494:2;8476:21;;;8533:2;8513:18;;;8506:30;8572;8567:2;8552:18;;8545:58;8635:2;8620:18;;8466:178::o;8649:343::-;8851:2;8833:21;;;8890:2;8870:18;;;8863:30;-1:-1:-1;;;8924:2:1;8909:18;;8902:49;8983:2;8968:18;;8823:169::o;8997:400::-;9199:2;9181:21;;;9238:2;9218:18;;;9211:30;9277:34;9272:2;9257:18;;9250:62;-1:-1:-1;;;9343:2:1;9328:18;;9321:34;9387:3;9372:19;;9171:226::o;9402:349::-;9604:2;9586:21;;;9643:2;9623:18;;;9616:30;9682:27;9677:2;9662:18;;9655:55;9742:2;9727:18;;9576:175::o;9756:408::-;9958:2;9940:21;;;9997:2;9977:18;;;9970:30;10036:34;10031:2;10016:18;;10009:62;-1:-1:-1;;;10102:2:1;10087:18;;10080:42;10154:3;10139:19;;9930:234::o;10169:420::-;10371:2;10353:21;;;10410:2;10390:18;;;10383:30;10449:34;10444:2;10429:18;;10422:62;10520:26;10515:2;10500:18;;10493:54;10579:3;10564:19;;10343:246::o;10594:406::-;10796:2;10778:21;;;10835:2;10815:18;;;10808:30;10874:34;10869:2;10854:18;;10847:62;-1:-1:-1;;;10940:2:1;10925:18;;10918:40;10990:3;10975:19;;10768:232::o;11005:398::-;11207:2;11189:21;;;11246:2;11226:18;;;11219:30;11285:34;11280:2;11265:18;;11258:62;-1:-1:-1;;;11351:2:1;11336:18;;11329:32;11393:3;11378:19;;11179:224::o;11408:356::-;11610:2;11592:21;;;11629:18;;;11622:30;11688:34;11683:2;11668:18;;11661:62;11755:2;11740:18;;11582:182::o;11769:408::-;11971:2;11953:21;;;12010:2;11990:18;;;11983:30;12049:34;12044:2;12029:18;;12022:62;-1:-1:-1;;;12115:2:1;12100:18;;12093:42;12167:3;12152:19;;11943:234::o;12182:335::-;12384:2;12366:21;;;12423:2;12403:18;;;12396:30;-1:-1:-1;;;12457:2:1;12442:18;;12435:41;12508:2;12493:18;;12356:161::o;12522:405::-;12724:2;12706:21;;;12763:2;12743:18;;;12736:30;12802:34;12797:2;12782:18;;12775:62;-1:-1:-1;;;12868:2:1;12853:18;;12846:39;12917:3;12902:19;;12696:231::o;12932:411::-;13134:2;13116:21;;;13173:2;13153:18;;;13146:30;13212:34;13207:2;13192:18;;13185:62;-1:-1:-1;;;13278:2:1;13263:18;;13256:45;13333:3;13318:19;;13106:237::o;13348:397::-;13550:2;13532:21;;;13589:2;13569:18;;;13562:30;13628:34;13623:2;13608:18;;13601:62;-1:-1:-1;;;13694:2:1;13679:18;;13672:31;13735:3;13720:19;;13522:223::o;13750:413::-;13952:2;13934:21;;;13991:2;13971:18;;;13964:30;14030:34;14025:2;14010:18;;14003:62;-1:-1:-1;;;14096:2:1;14081:18;;14074:47;14153:3;14138:19;;13924:239::o;14168:561::-;-1:-1:-1;;;;;14437:47:1;;;;14419:66;;14504:10;14550:15;;;14545:2;14530:18;;14523:43;14602:15;;;14597:2;14582:18;;14575:43;14654:15;;14649:2;14634:18;;14627:43;14707:15;14701:3;14686:19;;14679:44;14406:3;14391:19;;14373:356::o;14734:177::-;14880:25;;;14868:2;14853:18;;14835:76::o;14916:411::-;-1:-1:-1;;;;;15169:15:1;;;15151:34;;15221:15;;;;15216:2;15201:18;;15194:43;-1:-1:-1;;;;;15273:47:1;;;15268:2;15253:18;;15246:75;15102:2;15087:18;;15069:258::o;15332:128::-;;15403:1;15399:6;15396:1;15393:13;15390:2;;;15409:18;;:::i;:::-;-1:-1:-1;15445:9:1;;15380:80::o;15465:236::-;;-1:-1:-1;;;;;15577:2:1;15574:1;15570:10;15607:2;15604:1;15600:10;15638:3;15634:2;15630:12;15625:3;15622:21;15619:2;;;15646:18;;:::i;:::-;15682:13;;15512:189;-1:-1:-1;;;;15512:189:1:o;15706:168::-;;15812:1;15808;15804:6;15800:14;15797:1;15794:21;15789:1;15782:9;15775:17;15771:45;15768:2;;;15819:18;;:::i;:::-;-1:-1:-1;15859:9:1;;15758:116::o;15879:125::-;;15947:1;15944;15941:8;15938:2;;;15952:18;;:::i;:::-;-1:-1:-1;15989:9:1;;15928:76::o;16009:258::-;16081:1;16091:113;16105:6;16102:1;16099:13;16091:113;;;16181:11;;;16175:18;16162:11;;;16155:39;16127:2;16120:10;16091:113;;;16222:6;16219:1;16216:13;16213:2;;;-1:-1:-1;;16257:1:1;16239:16;;16232:27;16062:205::o;16272:136::-;;16339:5;16329:2;;16348:18;;:::i;:::-;-1:-1:-1;;;16384:18:1;;16319:89::o;16413:380::-;16498:1;16488:12;;16545:1;16535:12;;;16556:2;;16610:4;16602:6;16598:17;16588:27;;16556:2;16663;16655:6;16652:14;16632:18;16629:38;16626:2;;;16709:10;16704:3;16700:20;16697:1;16690:31;16744:4;16741:1;16734:15;16772:4;16769:1;16762:15;16626:2;;16468:325;;;:::o;16798:135::-;;-1:-1:-1;;16858:17:1;;16855:2;;;16878:18;;:::i;:::-;-1:-1:-1;16925:1:1;16914:13;;16845:88::o;16938:127::-;16999:10;16994:3;16990:20;16987:1;16980:31;17030:4;17027:1;17020:15;17054:4;17051:1;17044:15;17070:127;17131:10;17126:3;17122:20;17119:1;17112:31;17162:4;17159:1;17152:15;17186:4;17183:1;17176:15;17202:133;-1:-1:-1;;;;;;17278:32:1;;17268:43;;17258:2;;17325:1;17322;17315:12;17258:2;17248:87;:::o

Swarm Source

ipfs://54bcd47d6c9899df488d650be4b50cc6bee27c43dbf8e09eff5373316005937a

A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.

Tools & Services