@rarible/external-contracts 3.11.4

package/LICENSE.md

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1.  Definitions.
+
+    "License" shall mean the terms and conditions for use, reproduction,
+    and distribution as defined by Sections 1 through 9 of this document.
+
+    "Licensor" shall mean the copyright owner or entity authorized by
+    the copyright owner that is granting the License.
+
+    "Legal Entity" shall mean the union of the acting entity and all
+    other entities that control, are controlled by, or are under common
+    control with that entity. For the purposes of this definition,
+    "control" means (i) the power, direct or indirect, to cause the
+    direction or management of such entity, whether by contract or
+    otherwise, or (ii) ownership of fifty percent (50%) or more of the
+    outstanding shares, or (iii) beneficial ownership of such entity.
+
+    "You" (or "Your") shall mean an individual or Legal Entity
+    exercising permissions granted by this License.
+
+    "Source" form shall mean the preferred form for making modifications,
+    including but not limited to software source code, documentation
+    source, and configuration files.
+
+    "Object" form shall mean any form resulting from mechanical
+    transformation or translation of a Source form, including but
+    not limited to compiled object code, generated documentation,
+    and conversions to other media types.
+
+    "Work" shall mean the work of authorship, whether in Source or
+    Object form, made available under the License, as indicated by a
+    copyright notice that is included in or attached to the work
+    (an example is provided in the Appendix below).
+
+    "Derivative Works" shall mean any work, whether in Source or Object
+    form, that is based on (or derived from) the Work and for which the
+    editorial revisions, annotations, elaborations, or other modifications
+    represent, as a whole, an original work of authorship. For the purposes
+    of this License, Derivative Works shall not include works that remain
+    separable from, or merely link (or bind by name) to the interfaces of,
+    the Work and Derivative Works thereof.
+
+    "Contribution" shall mean any work of authorship, including
+    the original version of the Work and any modifications or additions
+    to that Work or Derivative Works thereof, that is intentionally
+    submitted to Licensor for inclusion in the Work by the copyright owner
+    or by an individual or Legal Entity authorized to submit on behalf of
+    the copyright owner. For the purposes of this definition, "submitted"
+    means any form of electronic, verbal, or written communication sent
+    to the Licensor or its representatives, including but not limited to
+    communication on electronic mailing lists, source code control systems,
+    and issue tracking systems that are managed by, or on behalf of, the
+    Licensor for the purpose of discussing and improving the Work, but
+    excluding communication that is conspicuously marked or otherwise
+    designated in writing by the copyright owner as "Not a Contribution."
+
+    "Contributor" shall mean Licensor and any individual or Legal Entity
+    on behalf of whom a Contribution has been received by Licensor and
+    subsequently incorporated within the Work.
+
+2.  Grant of Copyright License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    copyright license to reproduce, prepare Derivative Works of,
+    publicly display, publicly perform, sublicense, and distribute the
+    Work and such Derivative Works in Source or Object form.
+
+3.  Grant of Patent License. Subject to the terms and conditions of
+    this License, each Contributor hereby grants to You a perpetual,
+    worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+    (except as stated in this section) patent license to make, have made,
+    use, offer to sell, sell, import, and otherwise transfer the Work,
+    where such license applies only to those patent claims licensable
+    by such Contributor that are necessarily infringed by their
+    Contribution(s) alone or by combination of their Contribution(s)
+    with the Work to which such Contribution(s) was submitted. If You
+    institute patent litigation against any entity (including a
+    cross-claim or counterclaim in a lawsuit) alleging that the Work
+    or a Contribution incorporated within the Work constitutes direct
+    or contributory patent infringement, then any patent licenses
+    granted to You under this License for that Work shall terminate
+    as of the date such litigation is filed.
+
+4.  Redistribution. You may reproduce and distribute copies of the
+    Work or Derivative Works thereof in any medium, with or without
+    modifications, and in Source or Object form, provided that You
+    meet the following conditions:
+
+    (a) You must give any other recipients of the Work or
+    Derivative Works a copy of this License; and
+
+    (b) You must cause any modified files to carry prominent notices
+    stating that You changed the files; and
+
+    (c) You must retain, in the Source form of any Derivative Works
+    that You distribute, all copyright, patent, trademark, and
+    attribution notices from the Source form of the Work,
+    excluding those notices that do not pertain to any part of
+    the Derivative Works; and
+
+    (d) If the Work includes a "NOTICE" text file as part of its
+    distribution, then any Derivative Works that You distribute must
+    include a readable copy of the attribution notices contained
+    within such NOTICE file, excluding those notices that do not
+    pertain to any part of the Derivative Works, in at least one
+    of the following places: within a NOTICE text file distributed
+    as part of the Derivative Works; within the Source form or
+    documentation, if provided along with the Derivative Works; or,
+    within a display generated by the Derivative Works, if and
+    wherever such third-party notices normally appear. The contents
+    of the NOTICE file are for informational purposes only and
+    do not modify the License. You may add Your own attribution
+    notices within Derivative Works that You distribute, alongside
+    or as an addendum to the NOTICE text from the Work, provided
+    that such additional attribution notices cannot be construed
+    as modifying the License.
+
+    You may add Your own copyright statement to Your modifications and
+    may provide additional or different license terms and conditions
+    for use, reproduction, or distribution of Your modifications, or
+    for any such Derivative Works as a whole, provided Your use,
+    reproduction, and distribution of the Work otherwise complies with
+    the conditions stated in this License.
+
+5.  Submission of Contributions. Unless You explicitly state otherwise,
+    any Contribution intentionally submitted for inclusion in the Work
+    by You to the Licensor shall be under the terms and conditions of
+    this License, without any additional terms or conditions.
+    Notwithstanding the above, nothing herein shall supersede or modify
+    the terms of any separate license agreement you may have executed
+    with Licensor regarding such Contributions.
+
+6.  Trademarks. This License does not grant permission to use the trade
+    names, trademarks, service marks, or product names of the Licensor,
+    except as required for reasonable and customary use in describing the
+    origin of the Work and reproducing the content of the NOTICE file.
+
+7.  Disclaimer of Warranty. Unless required by applicable law or
+    agreed to in writing, Licensor provides the Work (and each
+    Contributor provides its Contributions) on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+    implied, including, without limitation, any warranties or conditions
+    of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+    PARTICULAR PURPOSE. You are solely responsible for determining the
+    appropriateness of using or redistributing the Work and assume any
+    risks associated with Your exercise of permissions under this License.
+
+8.  Limitation of Liability. In no event and under no legal theory,
+    whether in tort (including negligence), contract, or otherwise,
+    unless required by applicable law (such as deliberate and grossly
+    negligent acts) or agreed to in writing, shall any Contributor be
+    liable to You for damages, including any direct, indirect, special,
+    incidental, or consequential damages of any character arising as a
+    result of this License or out of the use or inability to use the
+    Work (including but not limited to damages for loss of goodwill,
+    work stoppage, computer failure or malfunction, or any and all
+    other commercial damages or losses), even if such Contributor
+    has been advised of the possibility of such damages.
+
+9.  Accepting Warranty or Additional Liability. While redistributing
+    the Work or Derivative Works thereof, You may choose to offer,
+    and charge a fee for, acceptance of support, warranty, indemnity,
+    or other liability obligations and/or rights consistent with this
+    License. However, in accepting such obligations, You may act only
+    on Your own behalf and on Your sole responsibility, not on behalf
+    of any other Contributor, and only if You agree to indemnify,
+    defend, and hold each Contributor harmless for any liability
+    incurred by, or claims asserted against, such Contributor by reason
+    of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+Copyright 2021 Non-Fungible Labs, Inc
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/README.md

@@ -0,0 +1,144 @@
+<p align="center">
+<br />
+<a href="https://thirdweb.com"><img src="https://github.com/thirdweb-dev/typescript-sdk/blob/main/logo.svg?raw=true" width="200" alt=""/></a>
+<br />
+</p>
+<h1 align="center">thirdweb Contracts forked by Rarible</h1>
+<p align="center">
+<a href="https://www.npmjs.com/package/@thirdweb-dev/contracts"><img src="https://img.shields.io/npm/v/@thirdweb-dev/contracts?color=red&logo=npm" alt="npm version"/></a>
+<a href="https://github.com/thirdweb-dev/contracts/actions"><img alt="Build Status" src="https://github.com/thirdweb-dev/contracts/actions/workflows/tests.yml/badge.svg"/></a>
+<a href="https://discord.gg/thirdweb"><img alt="Join our Discord!" src="https://img.shields.io/discord/834227967404146718.svg?color=7289da&label=discord&logo=discord&style=flat"/></a>
+
+</p>
+<p align="center"><strong>Collection of smart contracts deployable via the thirdweb SDK, dashboard and CLI forked by Rarible</strong></p>
+<br />
+
+## Installation
+
+```shell
+# Forge projects
+forge install https://github.com/thirdweb-dev/contracts
+
+# Hardhat / npm based projects
+npm i @thirdweb-dev/contracts
+```
+
+```bash
+contracts
+|
+|-- extension: "extensions that can be inherited by NON-upgradeable contracts"
+|   |-- interface: "interfaces of all extension contracts"
+|   |-- upgradeable: "extensions that can be inherited by upgradeable contracts"
+|   |-- [$prebuilt-category]: "legacy extensions written specifically for a prebuilt contract"
+|
+|-- base: "NON-upgradeable base contracts to build on top of"
+|   |-- interface: "interfaces for all base contracts"
+|   |--  upgradeable: "upgradeable base contracts to build on top of"
+|
+|-- prebuilt: "audited, ready-to-deploy thirdweb smart contracts"
+|   |-- interface: "interfaces for all prebuilt contracts"
+|   |--[$prebuilt-category]: "feature-based group of prebuilt contracts"
+|   |-- unaudited: "yet-to-audit thirdweb smart contracts"
+|       |-- [$prebuilt-category]: "feature-based group of prebuilt contracts"
+|
+|-- infra: "onchain infrastructure contracts"
+|   |-- interface: "interfaces for all infrastructure contracts"
+|
+|-- eip: "implementations of relevant EIP standards"
+|   |-- interface "all interfaces of relevant EIP standards"
+|
+|-- lib: "Solidity libraries"
+|
+|-- external-deps: "modified / copied over external dependencies"
+|   |-- openzeppelin: "modified / copied over openzeppelin dependencies"
+|   |-- chainlink: "modified / copied over chainlink dependencies"
+|
+|-- legacy-contracts: "maintained legacy thirdweb contracts"
+```
+
+## Running Tests
+
+1. `yarn`: install contracts dependencies
+2. `forge install`: install tests dependencies
+3. `forge test`: run the tests
+
+This repository is a [forge](https://github.com/foundry-rs/foundry/tree/master/forge) project.
+
+First install the relevant dependencies of the project:
+
+```bash
+yarn
+
+forge install
+```
+
+To compile contracts, run:
+
+```bash
+forge build
+```
+
+To run tests:
+
+```bash
+forge test
+```
+
+## Pre-built Contracts
+
+Pre-built contracts are written by the thirdweb team, and cover the most common use cases for smart contracts.
+
+- [DropERC20](https://thirdweb.com/deployer.thirdweb.eth/DropERC20)
+- [DropERC721](https://thirdweb.com/deployer.thirdweb.eth/DropERC721)
+- [DropERC1155](https://thirdweb.com/deployer.thirdweb.eth/DropERC1155)
+- [SignatureDrop](https://thirdweb.com/deployer.thirdweb.eth/SignatureDrop)
+- [Marketplace](https://thirdweb.com/deployer.thirdweb.eth/Marketplace)
+- [Multiwrap](https://thirdweb.com/deployer.thirdweb.eth/Multiwrap)
+- [TokenERC20](https://thirdweb.com/deployer.thirdweb.eth/TokenERC20)
+- [TokenERC721](https://thirdweb.com/deployer.thirdweb.eth/TokenERC721)
+- [TokenERC1155](https://thirdweb.com/deployer.thirdweb.eth/TokenERC1155)
+- [VoteERC20](https://thirdweb.com/deployer.thirdweb.eth/VoteERC20)
+- [Split](https://thirdweb.com/deployer.thirdweb.eth/Split)
+
+[Learn more about pre-built contracts](https://portal.thirdweb.com/pre-built-contracts)
+
+## Extensions
+
+Extensions are building blocks that help enrich smart contracts with features.
+
+Some blocks come packaged together as Base Contracts, which come with a full set of features out of the box that you can modify and extend. These contracts are available at `contracts/base/`.
+
+Other (smaller) blocks are Features, which provide a way for you to pick and choose which individual pieces you want to put into your contract; with full customization of how those features work. These are available at `contracts/extension/`.
+
+[Learn more about extensions](https://portal.thirdweb.com/extensions)
+
+## Contract Audits
+
+- [Audit 1](audit-reports/audit-1.pdf)
+- [Audit 2](audit-reports/audit-2.pdf)
+- [Audit 3](audit-reports/audit-3.pdf)
+- [Audit 4](audit-reports/audit-4.pdf)
+- [Audit 5](audit-reports/audit-5.pdf)
+- [Audit 6](audit-reports/audit-6.pdf)
+- [Audit 7](audit-reports/audit-7.pdf)
+- [Audit 8](audit-reports/audit-8.pdf)
+- [Audit 9](audit-reports/audit-9.pdf)
+- [Audit 10](audit-reports/audit-10.pdf)
+- [Audit 11](audit-reports/audit-11.pdf)
+- [Audit 12](audit-reports/audit-12.pdf)
+
+## Bug reports
+
+Found a security issue with our smart contracts? Send bug reports to security@thirdweb.com and we'll continue communicating with you from there. We're actively developing a bug bounty program; bug report payouts happen on a case by case basis, for now.
+
+## Feedback
+
+If you have any feedback, please reach out to us at support@thirdweb.com.
+
+## Authors
+
+- [thirdweb](https://thirdweb.com)
+
+## License
+
+[Apache 2.0](https://www.apache.org/licenses/LICENSE-2.0.txt)

package/contracts/base/ERC1155Base.sol

@@ -0,0 +1,282 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity ^0.8.0;
+
+/// @author thirdweb
+
+import { ERC1155 } from "../eip/ERC1155.sol";
+
+import "../extension/ContractMetadata.sol";
+import "../extension/Multicall.sol";
+import "../extension/Ownable.sol";
+import "../extension/Royalty.sol";
+import "../extension/BatchMintMetadata.sol";
+
+import "../lib/Strings.sol";
+
+/**
+ *  The `ERC1155Base` smart contract implements the ERC1155 NFT standard.
+ *  It includes the following additions to standard ERC1155 logic:
+ *
+ *      - Ability to mint NFTs via the provided `mintTo` and `batchMintTo` functions.
+ *
+ *      - Contract metadata for royalty support on platforms such as OpenSea that use
+ *        off-chain information to distribute roaylties.
+ *
+ *      - Ownership of the contract, with the ability to restrict certain functions to
+ *        only be called by the contract's owner.
+ *
+ *      - Multicall capability to perform multiple actions atomically
+ *
+ *      - EIP 2981 compliance for royalty support on NFT marketplaces.
+ */
+
+contract ERC1155Base is ERC1155, ContractMetadata, Ownable, Royalty, Multicall, BatchMintMetadata {
+    using Strings for uint256;
+
+    /*//////////////////////////////////////////////////////////////
+                        State variables
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev The tokenId of the next NFT to mint.
+    uint256 internal nextTokenIdToMint_;
+
+    /*//////////////////////////////////////////////////////////////
+                        Mappings
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @notice Returns the total supply of NFTs of a given tokenId
+     *  @dev Mapping from tokenId => total circulating supply of NFTs of that tokenId.
+     */
+    mapping(uint256 => uint256) public totalSupply;
+
+    /*//////////////////////////////////////////////////////////////
+                            Constructor
+    //////////////////////////////////////////////////////////////*/
+
+    constructor(
+        address _defaultAdmin,
+        string memory _name,
+        string memory _symbol,
+        address _royaltyRecipient,
+        uint128 _royaltyBps
+    ) ERC1155(_name, _symbol) {
+        _setupOwner(_defaultAdmin);
+        _setupDefaultRoyaltyInfo(_royaltyRecipient, _royaltyBps);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                    Overriden metadata logic
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice Returns the metadata URI for the given tokenId.
+    /// @param _tokenId The tokenId of the token for which a URI should be returned.
+    /// @return The metadata URI for the given tokenId.
+    function uri(uint256 _tokenId) public view virtual override returns (string memory) {
+        string memory uriForToken = _uri[_tokenId];
+        if (bytes(uriForToken).length > 0) {
+            return uriForToken;
+        }
+
+        string memory batchUri = _getBaseURI(_tokenId);
+        return string(abi.encodePacked(batchUri, _tokenId.toString()));
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                        Mint / burn logic
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     *  @notice          Lets an authorized address mint NFTs to a recipient.
+     *  @dev             - The logic in the `_canMint` function determines whether the caller is authorized to mint NFTs.
+     *                   - If `_tokenId == type(uint256).max` a new NFT at tokenId `nextTokenIdToMint` is minted. If the given
+     *                     `tokenId < nextTokenIdToMint`, then additional supply of an existing NFT is being minted.
+     *
+     *  @param _to       The recipient of the NFTs to mint.
+     *  @param _tokenId  The tokenId of the NFT to mint.
+     *  @param _tokenURI The full metadata URI for the NFTs minted (if a new NFT is being minted).
+     *  @param _amount   The amount of the same NFT to mint.
+     */
+    function mintTo(address _to, uint256 _tokenId, string memory _tokenURI, uint256 _amount) public virtual {
+        require(_canMint(), "Not authorized to mint.");
+
+        uint256 tokenIdToMint;
+        uint256 nextIdToMint = nextTokenIdToMint();
+
+        if (_tokenId == type(uint256).max) {
+            tokenIdToMint = nextIdToMint;
+            nextTokenIdToMint_ += 1;
+            _setTokenURI(nextIdToMint, _tokenURI);
+        } else {
+            require(_tokenId < nextIdToMint, "invalid id");
+            tokenIdToMint = _tokenId;
+        }
+
+        _mint(_to, tokenIdToMint, _amount, "");
+    }
+
+    /**
+     *  @notice          Lets an authorized address mint multiple NEW NFTs at once to a recipient.
+     *  @dev             The logic in the `_canMint` function determines whether the caller is authorized to mint NFTs.
+     *                   If `_tokenIds[i] == type(uint256).max` a new NFT at tokenId `nextTokenIdToMint` is minted. If the given
+     *                   `tokenIds[i] < nextTokenIdToMint`, then additional supply of an existing NFT is minted.
+     *                   The metadata for each new NFT is stored at `baseURI/{tokenID of NFT}`
+     *
+     *  @param _to       The recipient of the NFT to mint.
+     *  @param _tokenIds The tokenIds of the NFTs to mint.
+     *  @param _amounts  The amounts of each NFT to mint.
+     *  @param _baseURI  The baseURI for the `n` number of NFTs minted. The metadata for each NFT is `baseURI/tokenId`
+     */
+    function batchMintTo(
+        address _to,
+        uint256[] memory _tokenIds,
+        uint256[] memory _amounts,
+        string memory _baseURI
+    ) public virtual {
+        require(_canMint(), "Not authorized to mint.");
+        require(_amounts.length > 0, "Minting zero tokens.");
+        require(_tokenIds.length == _amounts.length, "Length mismatch.");
+
+        uint256 nextIdToMint = nextTokenIdToMint();
+        uint256 startNextIdToMint = nextIdToMint;
+
+        uint256 numOfNewNFTs;
+
+        for (uint256 i = 0; i < _tokenIds.length; i += 1) {
+            if (_tokenIds[i] == type(uint256).max) {
+                _tokenIds[i] = nextIdToMint;
+
+                nextIdToMint += 1;
+                numOfNewNFTs += 1;
+            } else {
+                require(_tokenIds[i] < nextIdToMint, "invalid id");
+            }
+        }
+
+        if (numOfNewNFTs > 0) {
+            _batchMintMetadata(startNextIdToMint, numOfNewNFTs, _baseURI);
+        }
+
+        nextTokenIdToMint_ = nextIdToMint;
+        _mintBatch(_to, _tokenIds, _amounts, "");
+    }
+
+    /**
+     *  @notice         Lets an owner or approved operator burn NFTs of the given tokenId.
+     *
+     *  @param _owner   The owner of the NFT to burn.
+     *  @param _tokenId The tokenId of the NFT to burn.
+     *  @param _amount  The amount of the NFT to burn.
+     */
+    function burn(address _owner, uint256 _tokenId, uint256 _amount) external virtual {
+        address caller = msg.sender;
+
+        require(caller == _owner || isApprovedForAll[_owner][caller], "Unapproved caller");
+        require(balanceOf[_owner][_tokenId] >= _amount, "Not enough tokens owned");
+
+        _burn(_owner, _tokenId, _amount);
+    }
+
+    /**
+     *  @notice         Lets an owner or approved operator burn NFTs of the given tokenIds.
+     *
+     *  @param _owner    The owner of the NFTs to burn.
+     *  @param _tokenIds The tokenIds of the NFTs to burn.
+     *  @param _amounts  The amounts of the NFTs to burn.
+     */
+    function burnBatch(address _owner, uint256[] memory _tokenIds, uint256[] memory _amounts) external virtual {
+        address caller = msg.sender;
+
+        require(caller == _owner || isApprovedForAll[_owner][caller], "Unapproved caller");
+        require(_tokenIds.length == _amounts.length, "Length mismatch");
+
+        for (uint256 i = 0; i < _tokenIds.length; i += 1) {
+            require(balanceOf[_owner][_tokenIds[i]] >= _amounts[i], "Not enough tokens owned");
+        }
+
+        _burnBatch(_owner, _tokenIds, _amounts);
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                            ERC165 Logic
+    //////////////////////////////////////////////////////////////*/
+
+    /**
+     * @dev See ERC165: https://eips.ethereum.org/EIPS/eip-165
+     * @inheritdoc IERC165
+     */
+    function supportsInterface(bytes4 interfaceId) public view virtual override(ERC1155, IERC165) returns (bool) {
+        return
+            interfaceId == 0x01ffc9a7 || // ERC165 Interface ID for ERC165
+            interfaceId == 0xd9b67a26 || // ERC165 Interface ID for ERC1155
+            interfaceId == 0x0e89341c || // ERC165 Interface ID for ERC1155MetadataURI
+            interfaceId == type(IERC2981).interfaceId; // ERC165 ID for ERC2981
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                            View functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @notice The tokenId assigned to the next new NFT to be minted.
+    function nextTokenIdToMint() public view virtual returns (uint256) {
+        return nextTokenIdToMint_;
+    }
+
+    /*//////////////////////////////////////////////////////////////
+                    Internal (overrideable) functions
+    //////////////////////////////////////////////////////////////*/
+
+    /// @dev Returns whether contract metadata can be set in the given execution context.
+    /// @return Whether contract metadata can be set in the given execution context.
+    function _canSetContractURI() internal view virtual override returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @dev Returns whether a token can be minted in the given execution context.
+    /// @return Whether a token can be minted in the given execution context.
+    function _canMint() internal view virtual returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @dev Returns whether owner can be set in the given execution context.
+    /// @return Whether owner can be set in the given execution context.
+    function _canSetOwner() internal view virtual override returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @dev Returns whether royalty info can be set in the given execution context.
+    /// @return Whether royalty info can be set in the given execution context.
+    function _canSetRoyaltyInfo() internal view virtual override returns (bool) {
+        return msg.sender == owner();
+    }
+
+    /// @dev Runs before every token transfer / mint / burn.
+    /// @param operator The address of the caller.
+    /// @param from The address of the sender.
+    /// @param to The address of the recipient.
+    /// @param ids The tokenIds of the tokens being transferred.
+    /// @param amounts The amounts of the tokens being transferred.
+    /// @param data Additional data with no specified format.
+    function _beforeTokenTransfer(
+        address operator,
+        address from,
+        address to,
+        uint256[] memory ids,
+        uint256[] memory amounts,
+        bytes memory data
+    ) internal virtual override {
+        super._beforeTokenTransfer(operator, from, to, ids, amounts, data);
+
+        if (from == address(0)) {
+            for (uint256 i = 0; i < ids.length; ++i) {
+                totalSupply[ids[i]] += amounts[i];
+            }
+        }
+
+        if (to == address(0)) {
+            for (uint256 i = 0; i < ids.length; ++i) {
+                totalSupply[ids[i]] -= amounts[i];
+            }
+        }
+    }
+}