@paimaexample/evm-contracts 0.3.0

package/src/contracts/token/IInverseAppProjected1155.sol

@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {IInverseProjected1155} from "./IInverseProjected1155.sol";
+
+/// @dev A Paima Inverse Projection ERC1155 token where initialization is handled by the app-layer.
+/// A standard ERC1155 that can be freely minted and stores an unique `<minter, userTokenId>` pair (used in `tokenURI`) when minted.
+interface IInverseAppProjected1155 is IInverseProjected1155 {
+    /// @dev Emitted when `value` amount of globally-enforced `tokenId` in combination with an unique `<minter, userTokenId>` pair is minted.
+    event Minted(
+        uint256 indexed tokenId,
+        address indexed minter,
+        uint256 indexed userTokenId,
+        uint256 value
+    );
+
+    /// @notice Returns the last nonce used (or 0 if the user has never minted)
+    /// @dev Useful if you need to either needs to
+    ///      1. Check if the nonce matches the expected value, or if more NFTs need to be minted
+    ///      2. Use a nonce algorithm where the next nonce depends on the current nonce
+    function currentNonce(address user) external view returns (uint256);
+
+    /// @dev Mints `value` of a new token to the transaction sender.
+    /// Increases the `currentTokenId`.
+    /// Reverts if transaction sender is a smart contract that does not implement IERC1155Receiver-onERC1155Received.
+    /// Emits the `Minted` event.
+    /// @param value the amount of tokens to mint.
+    /// @param data additional data to pass to the receiver contract.
+    /// @param verificationData any additional data to verify the validity of the mint
+    /// @return id of the minted token.
+    function mint(
+        uint256 value,
+        bytes memory data,
+        bytes memory verificationData
+    ) external returns (uint256);
+
+    /// @dev This works identically to the other function with an extra data parameter,
+    ///      except this function just sets data to "".
+    function mint(uint256 value, bytes memory data) external returns (uint256);
+}

package/src/contracts/token/IInverseAppProjectedNft.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {IInverseProjectedNft} from "./IInverseProjectedNft.sol";
+
+/// @dev A Paima Inverse Projection NFT where initialization is handled by the app-layer.
+/// A standard ERC721 that can be freely minted and stores an unique `<minter, userTokenId>` pair (used in tokenURI) when minted.
+/// See PRC3 for more.
+interface IInverseAppProjectedNft is IInverseProjectedNft {
+    /// @dev Emitted when the globally-enforced tokenId in combination with an unique `<minter, userTokenId>` pair is minted.
+    event Minted(uint256 indexed tokenId, address indexed minter, uint256 indexed userTokenId);
+
+    /// @dev Mints a new token to address `_to`
+    /// Increases the `totalSupply` and `currentTokenId`.
+    /// Reverts if `_to` is a zero address or if it refers to smart contract but does not implement IERC721Receiver-onERC721Received.
+    /// Emits the `Minted` event.
+    /// @param _to where to send the NFT to
+    /// @param _verificationData any additional data to verify the validity of the mint
+    /// @param _data any additional data to pass to the receiver contract
+    /// @return id of the minted token
+    function mint(
+        address _to,
+        bytes memory _verificationData,
+        bytes memory _data
+    ) external returns (uint256);
+
+    /// @dev Shorthand function that calls the `mint` function with empty `_data`.
+    function mint(address _to, bytes memory _verificationData) external returns (uint256);
+
+    /// @dev Shorthand function that calls the `mint` function with empty `_verificationData` and empty `_data`.
+    function mint(address _to) external returns (uint256);
+
+    /// @notice Returns the last nonce used (or 0 if the user has never minted)
+    /// @dev Useful if you need to either needs to
+    ///      1. Check if the nonce matches the expected value, or if more NFTs need to be minted
+    ///      2. Use a nonce algorithm where the next nonce depends on the current nonce
+    function currentNonce(address seller) external view returns (uint256);
+}

package/src/contracts/token/IInverseBaseProjected1155.sol

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {IInverseProjected1155} from "./IInverseProjected1155.sol";
+
+/// @dev A Paima Inverse Projection ERC1155 token where initialization is handled by the base-layer.
+/// A standard ERC1155 that accepts calldata in the mint function for any initialization data needed in a Paima dApp.
+interface IInverseBaseProjected1155 is IInverseProjected1155 {
+    /// @dev Emitted when `value` amount of globally-enforced `tokenId` is minted, with `initialData` provided in the `mint` function parameters.
+    event Minted(uint256 indexed tokenId, uint256 value, string initialData);
+
+    /// @dev Mints `value` of a new token to transaction sender, passing `initialData` to be emitted in the event.
+    /// Increases the `currentTokenId`.
+    /// Reverts if transaction sender is a smart contract that does not implement IERC1155Receiver-onERC1155Received.
+    /// Emits the `Minted` event.
+    /// @param value the amount of tokens to mint.
+    /// @param data additional data to pass to the receiver contract.
+    /// @param initialData data that is emitted in the `Minted` event.
+    /// @return id of the minted token.
+    function mint(
+        uint256 value,
+        bytes memory data,
+        string calldata initialData
+    ) external returns (uint256);
+}

package/src/contracts/token/IInverseBaseProjectedNft.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {IInverseProjectedNft} from "./IInverseProjectedNft.sol";
+
+/// @dev A Paima Inverse Projection NFT where initialization is handled by the base-layer.
+/// A standard ERC721 that accepts calldata in the mint function for any initialization data needed in a Paima dApp.
+/// See PRC3 for more.
+interface IInverseBaseProjectedNft is IInverseProjectedNft {
+    /// @dev Emitted when the globally-enforced tokenId is minted, with `initialData` provided in the `mint` function parameters.
+    event Minted(uint256 indexed tokenId, string initialData);
+
+    /// @dev Mints a new token to address `_to`, passing `initialData` to be emitted in the event.
+    /// Increases the `totalSupply` and `currentTokenId`.
+    /// Reverts if `_to` is a zero address or if it refers to smart contract but does not implement IERC721Receiver-onERC721Received.
+    /// Emits the `Minted` event.
+    /// @param _to where to send the NFT to
+    /// @param initialData data that is emitted in the `Minted` event
+    /// @param data any additional data to pass to the receiver contract
+    /// @return id of the minted token
+    function mint(
+        address _to,
+        string calldata initialData,
+        bytes memory data
+    ) external returns (uint256);
+
+    /// @dev Shorthand function that calls the `mint` function with empty `data`.
+    function mint(address _to, string calldata initialData) external returns (uint256);
+}

package/src/contracts/token/IInverseProjected1155.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {IERC1155MetadataURI} from "@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol";
+import {IERC4906Agnostic} from "./IERC4906Agnostic.sol";
+import {IUri} from "./IUri.sol";
+
+/// @dev A standard ERC1155 that can be burned and has a special uri function accepting a custom base URI.
+interface IInverseProjected1155 is IERC1155MetadataURI, IERC4906Agnostic {
+    /// @dev Emitted when `baseExtension` is updated from `oldBaseExtension` to `newBaseExtension`.
+    event SetBaseExtension(string oldBaseExtension, string newBaseExtension);
+
+    /// @dev Emitted when `baseUri` is updated from `oldUri` to `newUri`.
+    event SetBaseURI(string oldUri, string newUri);
+
+    /// @dev Burns `value` amount of token of ID `id` from transaction sender.
+    /// Reverts if transaction sender's balance of `id` is less than `value`.
+    function burn(uint256 id, uint256 value) external;
+
+    /// @dev Burns batch of `values` amounts of tokens of IDs `ids` from transaction sender.
+    /// Reverts if transaction sender's balance of any `id` is less than `value`.
+    function burnBatch(uint256[] memory ids, uint256[] memory values) external;
+
+    /// @dev Sets `_URI` as the `baseURI`.
+    /// Callable only by the contract owner.
+    /// Emits the `SetBaseURI` event.
+    function setBaseURI(string memory _URI) external;
+
+    /// @dev Sets `_newBaseExtension` as the `baseExtension`.
+    /// Callable only by the contract owner.
+    function setBaseExtension(string memory _newBaseExtension) external;
+
+    /// @dev Returns the token URI of specified `id` using a custom base URI.
+    function uri(uint256 id, string memory customBaseUri) external view returns (string memory);
+
+    /// @dev Returns the token URI of specified `id` using a call to contract implementing `IUri`.
+    function uri(uint256 id, IUri customUriInterface) external view returns (string memory);
+}

package/src/contracts/token/IInverseProjectedNft.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {IERC721Metadata} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
+import {IERC4906} from "@openzeppelin/contracts/interfaces/IERC4906.sol";
+import {ITokenUri} from "./ITokenUri.sol";
+
+/// @dev A standard ERC721 that can be burned and has a special tokenURI function accepting a custom base URI.
+/// See PRC3 for more.
+interface IInverseProjectedNft is IERC4906, IERC721Metadata {
+    /// @dev Emitted when `baseExtension` is updated from `oldBaseExtension` to `newBaseExtension`.
+    event SetBaseExtension(string oldBaseExtension, string newBaseExtension);
+
+    /// @dev Emitted when `baseUri` is updated from `oldUri` to `newUri`.
+    event SetBaseURI(string oldUri, string newUri);
+
+    /// @dev Burns token of ID `_tokenId`. Callable only by the owner of the specified token.
+    /// Reverts if `_tokenId` is not existing.
+    function burn(uint256 _tokenId) external;
+
+    /// @dev Sets `_URI` as the `baseURI` of the NFT.
+    /// Callable only by the contract owner.
+    /// Emits the `SetBaseURI` event.
+    function setBaseURI(string memory _URI) external;
+
+    /// @dev Sets `_newBaseExtension` as the `baseExtension` of the NFT.
+    /// Callable only by the contract owner.
+    function setBaseExtension(string memory _newBaseExtension) external;
+
+    /// @dev Returns the token URI of specified `tokenId` using a custom base URI.
+    function tokenURI(
+        uint256 tokenId,
+        string memory customBaseUri
+    ) external view returns (string memory);
+
+    /// @dev Returns the token URI of specified `tokenId` using a call to contract implementing `ITokenUri`.
+    function tokenURI(
+        uint256 tokenId,
+        ITokenUri customUriInterface
+    ) external view returns (string memory);
+}

package/src/contracts/token/ITokenUri.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+/// @dev An interface exposing the `tokenURI` function from IERC721Metadata.
+interface ITokenUri {
+    /**
+     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
+     */
+    function tokenURI(uint256 tokenId) external view returns (string memory);
+}

package/src/contracts/token/IUri.sol

@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+/// @dev An interface exposing the `uri` function from IERC1155MetadataURI.
+interface IUri {
+    /**
+     * @dev Returns the URI for token type `id`.
+     *
+     * If the `\{id\}` substring is present in the URI, it must be replaced by
+     * clients with the actual token type ID.
+     */
+    function uri(uint256 id) external view returns (string memory);
+}

package/src/contracts/token/InverseAppProjected1155.sol

@@ -0,0 +1,218 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+import {ERC1155} from "@openzeppelin/contracts/token/ERC1155/ERC1155.sol";
+import {IERC1155MetadataURI} from "@openzeppelin/contracts/token/ERC1155/extensions/IERC1155MetadataURI.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IInverseProjected1155} from "./IInverseProjected1155.sol";
+import {IInverseAppProjected1155} from "./IInverseAppProjected1155.sol";
+import {IUri} from "./IUri.sol";
+
+struct MintEntry {
+    address minter;
+    uint256 userTokenId;
+}
+
+/// @dev A Paima Inverse Projection ERC1155 token where initialization is handled by the app-layer.
+/// A standard ERC1155 that can be freely minted and stores an unique `<minter, userTokenId>` pair (used in `tokenURI`) when minted.
+contract InverseAppProjected1155 is IInverseAppProjected1155, ERC1155, Ownable {
+    using Strings for uint256;
+
+    string public name;
+    string public symbol;
+
+    mapping(uint256 id => MintEntry) public tokenToMint;
+    mapping(address minter => uint256) public mintCount;
+    mapping(uint256 id => uint256) private _initialSupply;
+    mapping(uint256 id => uint256) private _totalSupply;
+
+    /// @dev The token ID that will be minted when calling the `mint` function.
+    uint256 public currentTokenId;
+    /// @dev Base URI that is used in the `uri` function to form the start of the token URI.
+    string public baseURI;
+    /// @dev Base extension that is used in the `uri` function to form the end of the token URI.
+    string public baseExtension;
+
+    /// @dev Sets the token's `_name`, `_symbol`, and transfers ownership to `_owner`.
+    /// Also sets `currentTokenId` to 1.
+    constructor(
+        string memory _name,
+        string memory _symbol,
+        address _owner
+    ) ERC1155("") Ownable(_owner) {
+        name = _name;
+        symbol = _symbol;
+        currentTokenId = 1;
+        baseExtension = ".json";
+    }
+
+    /// @dev Returns true if this contract implements the interface defined by `interfaceId`. See EIP165.
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view virtual override(IERC165, ERC1155) returns (bool) {
+        return
+            interfaceId == type(IInverseProjected1155).interfaceId ||
+            interfaceId == type(IInverseAppProjected1155).interfaceId ||
+            super.supportsInterface(interfaceId);
+    }
+
+    function currentNonce(address user) public view virtual returns (uint256) {
+        return mintCount[user];
+    }
+
+    function validateMint(address, bytes memory) internal virtual returns (bool) {
+        // Base contract allows any mint
+        // Replace this with any custom verification logic
+        return true;
+    }
+
+    /// @dev Returns the amount of token with ID `id` that had been initially minted.
+    function initialSupply(uint256 id) public view virtual returns (uint256) {
+        return _initialSupply[id];
+    }
+
+    /// @dev Returns the total amount of tokens with ID `id` that currently exists.
+    function totalSupply(uint256 id) public view virtual returns (uint256) {
+        return _totalSupply[id];
+    }
+
+    /// @dev Mints `value` of a new token to the transaction sender.
+    /// Increases the `currentTokenId`.
+    /// Reverts if transaction sender is a smart contract that does not implement IERC1155Receiver-onERC1155Received.
+    /// Emits the `Minted` event.
+    /// @param value the amount of tokens to mint.
+    /// @param data additional data to pass to the receiver contract.
+    /// @param verificationData any additional data to verify the validity of the mint
+    /// @return id of the minted token.
+    function mint(
+        uint256 value,
+        bytes memory data,
+        bytes memory verificationData
+    ) public virtual returns (uint256) {
+        require(
+            validateMint(msg.sender, verificationData),
+            "InverseAppProjected1155: invalid verification data"
+        );
+        uint256 tokenId = currentTokenId;
+        _mint(msg.sender, tokenId, value, data);
+        mintCount[msg.sender] += 1;
+        uint256 userTokenId = mintCount[msg.sender];
+        tokenToMint[tokenId] = MintEntry(msg.sender, userTokenId);
+        _initialSupply[tokenId] = value;
+
+        currentTokenId++;
+
+        emit Minted(tokenId, msg.sender, userTokenId, value);
+        return tokenId;
+    }
+
+    /// @dev This works identically to the other function with an extra data parameter,
+    ///      except this function just sets data to "".
+    function mint(uint256 value, bytes memory data) public returns (uint256) {
+        return mint(value, data, bytes(""));
+    }
+
+    /// @dev Burns `value` amount of token of ID `id` from transaction sender.
+    /// Reverts if transaction sender's balance of `id` is less than `value`.
+    function burn(uint256 id, uint256 value) public virtual {
+        _burn(msg.sender, id, value);
+    }
+
+    /// @dev Burns batch of `values` amounts of tokens of IDs `ids` from transaction sender.
+    /// Reverts if transaction sender's balance of any `id` is less than `value`.
+    function burnBatch(uint256[] memory ids, uint256[] memory values) public virtual {
+        _burnBatch(msg.sender, ids, values);
+    }
+
+    /// @dev Returns the token URI of specified `id` using the default set base URI.
+    function uri(
+        uint256 id
+    ) public view virtual override(ERC1155, IERC1155MetadataURI) returns (string memory) {
+        return uri(id, baseURI);
+    }
+
+    /// @dev Returns the token URI of specified `id` using a custom base URI.
+    function uri(
+        uint256 id,
+        string memory customBaseUri
+    ) public view virtual returns (string memory) {
+        require(_totalSupply[id] > 0, "InverseAppProjected1155: URI query for nonexistent token");
+        MintEntry memory entry = tokenToMint[id];
+        string memory URI = bytes(customBaseUri).length > 0
+            ? string.concat(
+                customBaseUri,
+                "eip155:",
+                block.chainid.toString(),
+                "/",
+                Strings.toHexString(uint160(entry.minter), 20),
+                "/",
+                entry.userTokenId.toString(),
+                "/",
+                _initialSupply[id].toString()
+            )
+            : "";
+        return string(abi.encodePacked(URI, baseExtension));
+    }
+
+    /// @dev Returns the token URI of specified `id` using a call to contract implementing `IUri`.
+    function uri(uint256 id, IUri customUriInterface) public view virtual returns (string memory) {
+        return customUriInterface.uri(id);
+    }
+
+    /// @dev Sets `_URI` as the `baseURI` of the NFT.
+    /// Callable only by the contract owner.
+    /// Emits the `SetBaseURI` event.
+    function setBaseURI(string memory _URI) public virtual onlyOwner {
+        string memory oldURI = baseURI;
+        baseURI = _URI;
+        emit SetBaseURI(oldURI, _URI);
+    }
+
+    /// @dev Sets `_newBaseExtension` as the `baseExtension` of the NFT.
+    /// Callable only by the contract owner.
+    function setBaseExtension(string memory _newBaseExtension) public virtual onlyOwner {
+        string memory oldBaseExtension = baseExtension;
+        baseExtension = _newBaseExtension;
+        emit SetBaseURI(oldBaseExtension, _newBaseExtension);
+    }
+
+    /// @dev Function that emits an event to notify third-parties (e.g. NFT marketplaces) about
+    /// an update to consecutive range of tokens. Can be overridden in inheriting contract.
+    function updateMetadataBatch(uint256 _fromTokenId, uint256 _toTokenId) public virtual {
+        emit BatchMetadataUpdate(_fromTokenId, _toTokenId);
+    }
+
+    /// @dev Function that emits an event to notify third-parties (e.g. NFT marketplaces) about
+    /// an update to a single token. Can be overridden in inheriting contract.
+    function updateMetadata(uint256 _tokenId) public virtual {
+        emit MetadataUpdate(_tokenId);
+    }
+
+    /// @dev See {ERC1155-_update}.
+    function _update(
+        address from,
+        address to,
+        uint256[] memory ids,
+        uint256[] memory values
+    ) internal virtual override {
+        super._update(from, to, ids, values);
+
+        if (from == address(0)) {
+            for (uint256 i = 0; i < ids.length; ++i) {
+                // Overflow check required: The rest of the code assumes that totalSupply never overflows
+                _totalSupply[ids[i]] += values[i];
+            }
+        }
+
+        if (to == address(0)) {
+            for (uint256 i = 0; i < ids.length; ++i) {
+                unchecked {
+                    // Overflow not possible: values[i] <= balanceOf(from, ids[i]) <= totalSupply(ids[i])
+                    _totalSupply[ids[i]] -= values[i];
+                }
+            }
+        }
+    }
+}

package/src/contracts/token/InverseAppProjectedNft.sol

@@ -0,0 +1,192 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {Strings} from "@openzeppelin/contracts/utils/Strings.sol";
+import {ERC721} from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
+import {IERC721Metadata} from "@openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol";
+import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IInverseProjectedNft} from "./IInverseProjectedNft.sol";
+import {IInverseAppProjectedNft} from "./IInverseAppProjectedNft.sol";
+import {ITokenUri} from "./ITokenUri.sol";
+
+struct MintEntry {
+    address minter;
+    uint256 userTokenId;
+}
+
+/// @dev A standard ERC721 that accepts calldata in the mint function for any initialization data needed in a Paima dApp.
+/// See PRC3 for more.
+contract InverseAppProjectedNft is IInverseAppProjectedNft, ERC721, Ownable {
+    using Strings for uint256;
+
+    /// @dev tokenId => MintEntry.
+    mapping(uint256 => MintEntry) public tokenToMint;
+    mapping(address => uint256) public mintCount;
+
+    /// @dev The token ID that will be minted when calling the `mint` function.
+    uint256 public currentTokenId;
+    /// @dev Base URI that is used in the `tokenURI` function to form the start of the token URI.
+    string public baseURI;
+    /// @dev Total token supply, increased by minting and decreased by burning.
+    uint256 public totalSupply;
+    /// @dev Base extension that is used in the `tokenURI` function to form the end of the token URI.
+    string public baseExtension;
+
+    /// @dev Reverts if `msg.sender` is not the specified token's owner.
+    modifier onlyTokenOwner(uint256 tokenId) {
+        require(msg.sender == ownerOf(tokenId), "InverseAppProjectedNft: not owner");
+        _;
+    }
+
+    /// @dev Sets the NFT's `name`, `symbol`, and transfers ownership to `owner`.
+    /// Also sets `currentTokenId` to 1 and `baseExtension` to `".json"`.
+    constructor(
+        string memory name,
+        string memory symbol,
+        address owner
+    ) ERC721(name, symbol) Ownable(owner) {
+        currentTokenId = 1;
+        baseExtension = ".json";
+    }
+
+    /// @dev Returns true if this contract implements the interface defined by `interfaceId`. See EIP165.
+    function supportsInterface(
+        bytes4 interfaceId
+    ) public view virtual override(IERC165, ERC721) returns (bool) {
+        return
+            interfaceId == type(IInverseProjectedNft).interfaceId ||
+            interfaceId == type(IInverseAppProjectedNft).interfaceId ||
+            interfaceId == bytes4(0x49064906) ||
+            super.supportsInterface(interfaceId);
+    }
+
+    function currentNonce(address user) public view returns (uint256) {
+        return mintCount[user];
+    }
+
+    function validateMint(address, bytes memory) internal virtual returns (bool) {
+        // Base contract allows any mint
+        // Replace this with any custom verification logic
+        return true;
+    }
+
+    /// @dev Mints a new token to address `_to`
+    /// Increases the `totalSupply` and `currentTokenId`.
+    /// Reverts if `_to` is a zero address or if it refers to smart contract but does not implement IERC721Receiver-onERC721Received.
+    /// Emits the `Minted` event.
+    /// @param _to where to send the NFT to
+    /// @param _verificationData any additional data to verify the validity of the mint
+    /// @param _data any additional data to pass to the receiver contract
+    /// @return id of the minted token
+    function mint(
+        address _to,
+        bytes memory _verificationData,
+        bytes memory _data
+    ) public virtual returns (uint256) {
+        require(_to != address(0), "InverseAppProjectedNft: zero receiver address");
+        require(
+            validateMint(_to, _verificationData),
+            "InverseAppProjectedNft: invalid verification data"
+        );
+
+        uint256 tokenId = currentTokenId;
+        _safeMint(_to, tokenId, _data);
+        mintCount[_to] += 1;
+        uint256 userTokenId = mintCount[_to];
+        tokenToMint[tokenId] = MintEntry(_to, userTokenId);
+
+        totalSupply++;
+        currentTokenId++;
+
+        emit Minted(tokenId, _to, userTokenId);
+        return tokenId;
+    }
+
+    /// @dev Shorthand function that calls the `mint` function with empty `_data`.
+    function mint(address _to, bytes memory _verificationData) public virtual returns (uint256) {
+        return mint(_to, _verificationData, bytes(""));
+    }
+
+    /// @dev Shorthand function that calls the `mint` function with empty `_verificationData` and empty `_data`.
+    function mint(address _to) public returns (uint256) {
+        return mint(_to, bytes(""), bytes(""));
+    }
+
+    /// @dev Burns token of ID `_tokenId`. Callable only by the owner of the specified token.
+    /// Reverts if `_tokenId` does not exist.
+    function burn(uint256 _tokenId) public virtual onlyTokenOwner(_tokenId) {
+        totalSupply--;
+        _burn(_tokenId);
+    }
+
+    /// @dev Returns the `baseURI` of this NFT.
+    function _baseURI() internal view virtual override returns (string memory) {
+        return baseURI;
+    }
+
+    /// @dev Returns the token URI of specified `tokenId` using the default set base URI.
+    function tokenURI(
+        uint256 tokenId
+    ) public view virtual override(ERC721, IERC721Metadata) returns (string memory) {
+        return tokenURI(tokenId, _baseURI());
+    }
+
+    /// @dev Returns the token URI of specified `tokenId` using a custom base URI.
+    function tokenURI(
+        uint256 tokenId,
+        string memory customBaseUri
+    ) public view virtual returns (string memory) {
+        _requireOwned(tokenId);
+        MintEntry memory entry = tokenToMint[tokenId];
+        string memory URI = bytes(customBaseUri).length > 0
+            ? string.concat(
+                customBaseUri,
+                "eip155:",
+                block.chainid.toString(),
+                "/",
+                Strings.toHexString(uint160(entry.minter), 20),
+                "/",
+                entry.userTokenId.toString()
+            )
+            : "";
+        return string(abi.encodePacked(URI, baseExtension));
+    }
+
+    /// @dev Returns the token URI of specified `tokenId` using a call to contract implementing `ITokenUri`.
+    function tokenURI(
+        uint256 tokenId,
+        ITokenUri customUriInterface
+    ) public view returns (string memory) {
+        return customUriInterface.tokenURI(tokenId);
+    }
+
+    /// @dev Sets `_URI` as the `baseURI` of the NFT.
+    /// Callable only by the contract owner.
+    /// Emits the `SetBaseURI` event.
+    function setBaseURI(string memory _URI) public virtual onlyOwner {
+        string memory oldURI = baseURI;
+        baseURI = _URI;
+        emit SetBaseURI(oldURI, _URI);
+    }
+
+    /// @dev Sets `_newBaseExtension` as the `baseExtension` of the NFT.
+    /// Callable only by the contract owner.
+    function setBaseExtension(string memory _newBaseExtension) public virtual onlyOwner {
+        string memory oldBaseExtension = baseExtension;
+        baseExtension = _newBaseExtension;
+        emit SetBaseURI(oldBaseExtension, _newBaseExtension);
+    }
+
+    /// @dev Function that emits an event to notify third-parties (e.g. NFT marketplaces) about
+    /// an update to consecutive range of tokens. Can be overridden in inheriting contract.
+    function updateMetadataBatch(uint256 _fromTokenId, uint256 _toTokenId) public virtual {
+        emit BatchMetadataUpdate(_fromTokenId, _toTokenId);
+    }
+
+    /// @dev Function that emits an event to notify third-parties (e.g. NFT marketplaces) about
+    /// an update to a single token. Can be overridden in inheriting contract.
+    function updateMetadata(uint256 _tokenId) public virtual {
+        emit MetadataUpdate(_tokenId);
+    }
+}