@theqrl/qrl-contracts 0.1.0

package/token/SQRCTN1/SQRCTN1.hyp

@@ -0,0 +1,430 @@
+// SPDX-License-Identifier: MIT
+// QRL Contracts (last updated v0.1.0) (token/SQRCTN1/SQRCTN1.hyp)
+
+pragma hyperion >=0.0;
+
+import {ISQRCTN1} from "./ISQRCTN1.hyp";
+import {ISQRCTN1Metadata} from "./extensions/ISQRCTN1Metadata.hyp";
+import {SQRCTN1Utils} from "./utils/SQRCTN1Utils.hyp";
+import {Context} from "../../utils/Context.hyp";
+import {Strings} from "../../utils/Strings.hyp";
+import {IZRC165, ZRC165} from "../../utils/introspection/ZRC165.hyp";
+import {ISQRCTN1Errors} from "../../interfaces/draft-IZRC6093.hyp";
+
+/**
+ * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[SQRC-TN1] Non-Fungible Token Standard, including
+ * the Metadata extension, but not including the Enumerable extension, which is available separately as
+ * {SQRCTN1Enumerable}.
+ */
+abstract contract SQRCTN1 is Context, ZRC165, ISQRCTN1, ISQRCTN1Metadata, ISQRCTN1Errors {
+    using Strings for uint256;
+
+    // Token name
+    string private _name;
+
+    // Token symbol
+    string private _symbol;
+
+    mapping(uint256 tokenId => address) private _owners;
+
+    mapping(address owner => uint256) private _balances;
+
+    mapping(uint256 tokenId => address) private _tokenApprovals;
+
+    mapping(address owner => mapping(address operator => bool)) private _operatorApprovals;
+
+    /**
+     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
+     */
+    constructor(string memory name_, string memory symbol_) {
+        _name = name_;
+        _symbol = symbol_;
+    }
+
+    /// @inheritdoc IZRC165
+    function supportsInterface(bytes4 interfaceId) public view virtual override(ZRC165, IZRC165) returns (bool) {
+        return
+            interfaceId == type(ISQRCTN1).interfaceId ||
+            interfaceId == type(ISQRCTN1Metadata).interfaceId ||
+            super.supportsInterface(interfaceId);
+    }
+
+    /// @inheritdoc ISQRCTN1
+    function balanceOf(address owner) public view virtual returns (uint256) {
+        if (owner == address(0)) {
+            revert SQRCTN1InvalidOwner(address(0));
+        }
+        return _balances[owner];
+    }
+
+    /// @inheritdoc ISQRCTN1
+    function ownerOf(uint256 tokenId) public view virtual returns (address) {
+        return _requireOwned(tokenId);
+    }
+
+    /// @inheritdoc ISQRCTN1Metadata
+    function name() public view virtual returns (string memory) {
+        return _name;
+    }
+
+    /// @inheritdoc ISQRCTN1Metadata
+    function symbol() public view virtual returns (string memory) {
+        return _symbol;
+    }
+
+    /// @inheritdoc ISQRCTN1Metadata
+    function tokenURI(uint256 tokenId) public view virtual returns (string memory) {
+        _requireOwned(tokenId);
+
+        string memory baseURI = _baseURI();
+        return bytes(baseURI).length > 0 ? string.concat(baseURI, tokenId.toString()) : "";
+    }
+
+    /**
+     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
+     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
+     * by default, can be overridden in child contracts.
+     */
+    function _baseURI() internal view virtual returns (string memory) {
+        return "";
+    }
+
+    /// @inheritdoc ISQRCTN1
+    function approve(address to, uint256 tokenId) public virtual {
+        _approve(to, tokenId, _msgSender());
+    }
+
+    /// @inheritdoc ISQRCTN1
+    function getApproved(uint256 tokenId) public view virtual returns (address) {
+        _requireOwned(tokenId);
+
+        return _getApproved(tokenId);
+    }
+
+    /// @inheritdoc ISQRCTN1
+    function setApprovalForAll(address operator, bool approved) public virtual {
+        _setApprovalForAll(_msgSender(), operator, approved);
+    }
+
+    /// @inheritdoc ISQRCTN1
+    function isApprovedForAll(address owner, address operator) public view virtual returns (bool) {
+        return _operatorApprovals[owner][operator];
+    }
+
+    /// @inheritdoc ISQRCTN1
+    function transferFrom(address from, address to, uint256 tokenId) public virtual {
+        if (to == address(0)) {
+            revert SQRCTN1InvalidReceiver(address(0));
+        }
+        // Setting an "auth" arguments enables the `_isAuthorized` check which verifies that the token exists
+        // (from != 0). Therefore, it is not needed to verify that the return value is not 0 here.
+        address previousOwner = _update(to, tokenId, _msgSender());
+        if (previousOwner != from) {
+            revert SQRCTN1IncorrectOwner(from, tokenId, previousOwner);
+        }
+    }
+
+    /// @inheritdoc ISQRCTN1
+    function safeTransferFrom(address from, address to, uint256 tokenId) public {
+        safeTransferFrom(from, to, tokenId, "");
+    }
+
+    /// @inheritdoc ISQRCTN1
+    function safeTransferFrom(address from, address to, uint256 tokenId, bytes memory data) public virtual {
+        transferFrom(from, to, tokenId);
+        SQRCTN1Utils.checkOnSQRCTN1Received(_msgSender(), from, to, tokenId, data);
+    }
+
+    /**
+     * @dev Returns the owner of the `tokenId`. Does NOT revert if token doesn't exist
+     *
+     * IMPORTANT: Any overrides to this function that add ownership of tokens not tracked by the
+     * core SQRC-TN1 logic MUST be matched with the use of {_increaseBalance} to keep balances
+     * consistent with ownership. The invariant to preserve is that for any address `a` the value returned by
+     * `balanceOf(a)` must be equal to the number of tokens such that `_ownerOf(tokenId)` is `a`.
+     */
+    function _ownerOf(uint256 tokenId) internal view virtual returns (address) {
+        return _owners[tokenId];
+    }
+
+    /**
+     * @dev Returns the approved address for `tokenId`. Returns 0 if `tokenId` is not minted.
+     */
+    function _getApproved(uint256 tokenId) internal view virtual returns (address) {
+        return _tokenApprovals[tokenId];
+    }
+
+    /**
+     * @dev Returns whether `spender` is allowed to manage `owner`'s tokens, or `tokenId` in
+     * particular (ignoring whether it is owned by `owner`).
+     *
+     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
+     * assumption.
+     */
+    function _isAuthorized(address owner, address spender, uint256 tokenId) internal view virtual returns (bool) {
+        return
+            spender != address(0) &&
+            (owner == spender || isApprovedForAll(owner, spender) || _getApproved(tokenId) == spender);
+    }
+
+    /**
+     * @dev Checks if `spender` can operate on `tokenId`, assuming the provided `owner` is the actual owner.
+     * Reverts if:
+     * - `spender` does not have approval from `owner` for `tokenId`.
+     * - `spender` does not have approval to manage all of `owner`'s assets.
+     *
+     * WARNING: This function assumes that `owner` is the actual owner of `tokenId` and does not verify this
+     * assumption.
+     */
+    function _checkAuthorized(address owner, address spender, uint256 tokenId) internal view virtual {
+        if (!_isAuthorized(owner, spender, tokenId)) {
+            if (owner == address(0)) {
+                revert SQRCTN1NonexistentToken(tokenId);
+            } else {
+                revert SQRCTN1InsufficientApproval(spender, tokenId);
+            }
+        }
+    }
+
+    /**
+     * @dev Unsafe write access to the balances, used by extensions that "mint" tokens using an {ownerOf} override.
+     *
+     * NOTE: the value is limited to type(uint128).max. This protect against _balance overflow. It is unrealistic that
+     * a uint256 would ever overflow from increments when these increments are bounded to uint128 values.
+     *
+     * WARNING: Increasing an account's balance using this function tends to be paired with an override of the
+     * {_ownerOf} function to resolve the ownership of the corresponding tokens so that balances and ownership
+     * remain consistent with one another.
+     */
+    function _increaseBalance(address account, uint128 value) internal virtual {
+        unchecked {
+            _balances[account] += value;
+        }
+    }
+
+    /**
+     * @dev Transfers `tokenId` from its current owner to `to`, or alternatively mints (or burns) if the current owner
+     * (or `to`) is the zero address. Returns the owner of the `tokenId` before the update.
+     *
+     * The `auth` argument is optional. If the value passed is non 0, then this function will check that
+     * `auth` is either the owner of the token, or approved to operate on the token (by the owner).
+     *
+     * Emits a {Transfer} event.
+     *
+     * NOTE: If overriding this function in a way that tracks balances, see also {_increaseBalance}.
+     */
+    function _update(address to, uint256 tokenId, address auth) internal virtual returns (address) {
+        address from = _ownerOf(tokenId);
+
+        // Perform (optional) operator check
+        if (auth != address(0)) {
+            _checkAuthorized(from, auth, tokenId);
+        }
+
+        // Execute the update
+        if (from != address(0)) {
+            // Clear approval. No need to re-authorize or emit the Approval event
+            _approve(address(0), tokenId, address(0), false);
+
+            unchecked {
+                _balances[from] -= 1;
+            }
+        }
+
+        if (to != address(0)) {
+            unchecked {
+                _balances[to] += 1;
+            }
+        }
+
+        _owners[tokenId] = to;
+
+        emit Transfer(from, to, tokenId);
+
+        return from;
+    }
+
+    /**
+     * @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 {
+        if (to == address(0)) {
+            revert SQRCTN1InvalidReceiver(address(0));
+        }
+        address previousOwner = _update(to, tokenId, address(0));
+        if (previousOwner != address(0)) {
+            revert SQRCTN1InvalidSender(address(0));
+        }
+    }
+
+    /**
+     * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.
+     *
+     * Requirements:
+     *
+     * - `tokenId` must not exist.
+     * - If `to` refers to a smart contract, it must implement {ISQRCTN1Receiver-onSQRCTN1Received}, which is called upon a safe transfer.
+     *
+     * Emits a {Transfer} event.
+     */
+    function _safeMint(address to, uint256 tokenId) internal {
+        _safeMint(to, tokenId, "");
+    }
+
+    /**
+     * @dev Same as {xref-SQRCTN1-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
+     * forwarded in {ISQRCTN1Receiver-onSQRCTN1Received} to contract recipients.
+     */
+    function _safeMint(address to, uint256 tokenId, bytes memory data) internal virtual {
+        _mint(to, tokenId);
+        SQRCTN1Utils.checkOnSQRCTN1Received(_msgSender(), address(0), to, tokenId, data);
+    }
+
+    /**
+     * @dev Destroys `tokenId`.
+     * The approval is cleared when the token is burned.
+     * This is an internal function that does not check if the sender is authorized to operate on the token.
+     *
+     * Requirements:
+     *
+     * - `tokenId` must exist.
+     *
+     * Emits a {Transfer} event.
+     */
+    function _burn(uint256 tokenId) internal {
+        address previousOwner = _update(address(0), tokenId, address(0));
+        if (previousOwner == address(0)) {
+            revert SQRCTN1NonexistentToken(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 {
+        if (to == address(0)) {
+            revert SQRCTN1InvalidReceiver(address(0));
+        }
+        address previousOwner = _update(to, tokenId, address(0));
+        if (previousOwner == address(0)) {
+            revert SQRCTN1NonexistentToken(tokenId);
+        } else if (previousOwner != from) {
+            revert SQRCTN1IncorrectOwner(from, tokenId, previousOwner);
+        }
+    }
+
+    /**
+     * @dev Safely transfers `tokenId` token from `from` to `to`, checking that contract recipients
+     * are aware of the SQRC-TN1 standard 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 like {safeTransferFrom} in the sense that it invokes
+     * {ISQRCTN1Receiver-onSQRCTN1Received} on the receiver, and can be used to e.g.
+     * implement alternative mechanisms to perform token transfer, such as signature-based.
+     *
+     * Requirements:
+     *
+     * - `tokenId` token must exist and be owned by `from`.
+     * - `to` cannot be the zero address.
+     * - `from` cannot be the zero address.
+     * - If `to` refers to a smart contract, it must implement {ISQRCTN1Receiver-onSQRCTN1Received}, which is called upon a safe transfer.
+     *
+     * Emits a {Transfer} event.
+     */
+    function _safeTransfer(address from, address to, uint256 tokenId) internal {
+        _safeTransfer(from, to, tokenId, "");
+    }
+
+    /**
+     * @dev Same as {xref-SQRCTN1-_safeTransfer-address-address-uint256-}[`_safeTransfer`], with an additional `data` parameter which is
+     * forwarded in {ISQRCTN1Receiver-onSQRCTN1Received} to contract recipients.
+     */
+    function _safeTransfer(address from, address to, uint256 tokenId, bytes memory data) internal virtual {
+        _transfer(from, to, tokenId);
+        SQRCTN1Utils.checkOnSQRCTN1Received(_msgSender(), from, to, tokenId, data);
+    }
+
+    /**
+     * @dev Approve `to` to operate on `tokenId`
+     *
+     * The `auth` argument is optional. If the value passed is non 0, then this function will check that `auth` is
+     * either the owner of the token, or approved to operate on all tokens held by this owner.
+     *
+     * Emits an {Approval} event.
+     *
+     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
+     */
+    function _approve(address to, uint256 tokenId, address auth) internal {
+        _approve(to, tokenId, auth, true);
+    }
+
+    /**
+     * @dev Variant of `_approve` with an optional flag to enable or disable the {Approval} event. The event is not
+     * emitted in the context of transfers.
+     */
+    function _approve(address to, uint256 tokenId, address auth, bool emitEvent) internal virtual {
+        // Avoid reading the owner unless necessary
+        if (emitEvent || auth != address(0)) {
+            address owner = _requireOwned(tokenId);
+
+            // We do not use _isAuthorized because single-token approvals should not be able to call approve
+            if (auth != address(0) && owner != auth && !isApprovedForAll(owner, auth)) {
+                revert SQRCTN1InvalidApprover(auth);
+            }
+
+            if (emitEvent) {
+                emit Approval(owner, to, tokenId);
+            }
+        }
+
+        _tokenApprovals[tokenId] = to;
+    }
+
+    /**
+     * @dev Approve `operator` to operate on all of `owner` tokens
+     *
+     * Requirements:
+     * - operator can't be the address zero.
+     *
+     * Emits an {ApprovalForAll} event.
+     */
+    function _setApprovalForAll(address owner, address operator, bool approved) internal virtual {
+        if (operator == address(0)) {
+            revert SQRCTN1InvalidOperator(operator);
+        }
+        _operatorApprovals[owner][operator] = approved;
+        emit ApprovalForAll(owner, operator, approved);
+    }
+
+    /**
+     * @dev Reverts if the `tokenId` doesn't have a current owner (it hasn't been minted, or it has been burned).
+     * Returns the owner.
+     *
+     * Overrides to ownership logic should be done to {_ownerOf}.
+     */
+    function _requireOwned(uint256 tokenId) internal view returns (address) {
+        address owner = _ownerOf(tokenId);
+        if (owner == address(0)) {
+            revert SQRCTN1NonexistentToken(tokenId);
+        }
+        return owner;
+    }
+}

package/token/SQRCTN1/extensions/ISQRCTN1Metadata.hyp

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+// QRL Contracts (last updated v0.1.0) (token/SQRCTN1/extensions/ISQRCTN1Metadata.hyp)
+
+pragma hyperion >=0.0;
+
+import {ISQRCTN1} from "../ISQRCTN1.hyp";
+
+/**
+ * @title SQRC-TN1 Non-Fungible Token Standard, optional metadata extension
+ * @dev See https://eips.ethereum.org/EIPS/eip-721
+ */
+interface ISQRCTN1Metadata is ISQRCTN1 {
+    /**
+     * @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);
+}

package/token/SQRCTN1/extensions/SQRCTN1URIStorage.hyp

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: MIT
+// QRL Contracts (last updated v0.1.0) (token/SQRCTN1/extensions/SQRCTN1URIStorage.hyp)
+
+pragma hyperion >=0.0;
+
+import {SQRCTN1} from "../SQRCTN1.hyp";
+import {ISQRCTN1Metadata} from "./ISQRCTN1Metadata.hyp";
+import {Strings} from "../../../utils/Strings.hyp";
+import {IZRC4906} from "../../../interfaces/IZRC4906.hyp";
+import {IZRC165} from "../../../interfaces/IZRC165.hyp";
+
+/**
+ * @dev SQRC-TN1 token with storage based token URI management.
+ */
+abstract contract SQRCTN1URIStorage is IZRC4906, SQRCTN1 {
+    using Strings for uint256;
+
+    // Interface ID as defined in ZRC-4906. This does not correspond to a traditional interface ID as ZRC-4906 only
+    // defines events and does not include any external function.
+    bytes4 private constant ZRC4906_INTERFACE_ID = bytes4(0x49064906);
+
+    // Optional mapping for token URIs
+    mapping(uint256 tokenId => string) private _tokenURIs;
+
+    /// @inheritdoc IZRC165
+    function supportsInterface(bytes4 interfaceId) public view virtual override(SQRCTN1, IZRC165) returns (bool) {
+        return interfaceId == ZRC4906_INTERFACE_ID || super.supportsInterface(interfaceId);
+    }
+
+    /// @inheritdoc ISQRCTN1Metadata
+    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
+        _requireOwned(tokenId);
+
+        string memory _tokenURI = _tokenURIs[tokenId];
+        string memory base = _baseURI();
+
+        // If there is no base URI, return the token URI.
+        if (bytes(base).length == 0) {
+            return _tokenURI;
+        }
+        // If both are set, concatenate the baseURI and tokenURI (via string.concat).
+        if (bytes(_tokenURI).length > 0) {
+            return string.concat(base, _tokenURI);
+        }
+
+        return super.tokenURI(tokenId);
+    }
+
+    /**
+     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
+     *
+     * Emits {IZRC4906-MetadataUpdate}.
+     */
+    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
+        _tokenURIs[tokenId] = _tokenURI;
+        emit MetadataUpdate(tokenId);
+    }
+}

package/token/SQRCTN1/utils/SQRCTN1Utils.hyp

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+// QRL Contracts (last updated v0.1.0) (token/SQRCTN1/utils/SQRCTN1Utils.hyp)
+
+pragma hyperion >=0.0;
+
+import {ISQRCTN1Receiver} from "../ISQRCTN1Receiver.hyp";
+import {ISQRCTN1Errors} from "../../../interfaces/draft-IZRC6093.hyp";
+
+/**
+ * @dev Library that provide common SQRC-TN1 utility functions.
+ *
+ * See https://eips.ethereum.org/EIPS/eip-721[SQRC-TN1].
+ *
+ * _Available since v5.1._
+ */
+library SQRCTN1Utils {
+    /**
+     * @dev Performs an acceptance check for the provided `operator` by calling {ISQRCTN1Receiver-onSQRCTN1Received}
+     * on the `to` address. The `operator` is generally the address that initiated the token transfer (i.e. `msg.sender`).
+     *
+     * The acceptance call is not executed and treated as a no-op if the target address doesn't contain code (i.e. an EOA).
+     * Otherwise, the recipient must implement {ISQRCTN1Receiver-onSQRCTN1Received} and return the acceptance magic value to accept
+     * the transfer.
+     */
+    function checkOnSQRCTN1Received(
+        address operator,
+        address from,
+        address to,
+        uint256 tokenId,
+        bytes memory data
+    ) internal {
+        if (to.code.length > 0) {
+            try ISQRCTN1Receiver(to).onSQRCTN1Received(operator, from, tokenId, data) returns (bytes4 retval) {
+                if (retval != ISQRCTN1Receiver.onSQRCTN1Received.selector) {
+                    // Token rejected
+                    revert ISQRCTN1Errors.SQRCTN1InvalidReceiver(to);
+                }
+            } catch (bytes memory reason) {
+                if (reason.length == 0) {
+                    // non-ISQRCTN1Receiver implementer
+                    revert ISQRCTN1Errors.SQRCTN1InvalidReceiver(to);
+                } else {
+                    assembly ("memory-safe") {
+                        revert(add(32, reason), mload(reason))
+                    }
+                }
+            }
+        }
+    }
+}