@latticexyz/world-modules 2.0.12-type-resolutions-effc7ab1 → 2.0.12-type-resolutions-ad8cc987

package/src/modules/erc721-puppet/IERC721Errors.sol

@@ -0,0 +1,61 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/draft-IERC6093.sol)
+pragma solidity >=0.8.24;
+
+/**
+ * @dev Standard ERC721 Errors
+ * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC721 tokens.
+ */
+interface IERC721Errors {
+  /**
+   * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in EIP-20.
+   * Used in balance queries.
+   * @param owner Address of the current owner of a token.
+   */
+  error ERC721InvalidOwner(address owner);
+
+  /**
+   * @dev Indicates a `tokenId` whose `owner` is the zero address.
+   * @param tokenId Identifier number of a token.
+   */
+  error ERC721NonexistentToken(uint256 tokenId);
+
+  /**
+   * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
+   * @param sender Address whose tokens are being transferred.
+   * @param tokenId Identifier number of a token.
+   * @param owner Address of the current owner of a token.
+   */
+  error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
+
+  /**
+   * @dev Indicates a failure with the token `sender`. Used in transfers.
+   * @param sender Address whose tokens are being transferred.
+   */
+  error ERC721InvalidSender(address sender);
+
+  /**
+   * @dev Indicates a failure with the token `receiver`. Used in transfers.
+   * @param receiver Address to which tokens are being transferred.
+   */
+  error ERC721InvalidReceiver(address receiver);
+
+  /**
+   * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
+   * @param operator Address that may be allowed to operate on tokens without being their owner.
+   * @param tokenId Identifier number of a token.
+   */
+  error ERC721InsufficientApproval(address operator, uint256 tokenId);
+
+  /**
+   * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
+   * @param approver Address initiating an approval operation.
+   */
+  error ERC721InvalidApprover(address approver);
+
+  /**
+   * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
+   * @param operator Address that may be allowed to operate on tokens without being their owner.
+   */
+  error ERC721InvalidOperator(address operator);
+}

package/src/modules/erc721-puppet/IERC721Events.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721.sol)
+pragma solidity >=0.8.24;
+
+/**
+ * @dev Events emitted by an ERC721 compliant contract.
+ */
+interface IERC721Events {
+  /**
+   * @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);
+}

package/src/modules/erc721-puppet/IERC721Metadata.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/extensions/IERC721Metadata.sol)
+pragma solidity >=0.8.24;
+
+import { IERC721 } from "./IERC721.sol";
+
+/**
+ * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
+ * @author MUD (https://mud.dev) by Lattice (https://lattice.xyz)
+ * @dev See https://eips.ethereum.org/EIPS/eip-721
+ */
+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);
+}

package/src/modules/erc721-puppet/IERC721Mintable.sol

@@ -0,0 +1,53 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)
+pragma solidity >=0.8.24;
+
+import { IERC721 } from "./IERC721.sol";
+
+/**
+ * @dev Extending the ERC721 standard with permissioned mint and burn functions.
+ */
+interface IERC721Mintable is IERC721 {
+  /**
+   * @dev Mints `tokenId` and transfers it to `to`.
+   *
+   * Requirements:
+   *
+   * - `tokenId` must not exist.
+   * - `to` cannot be the zero address.
+   *
+   * Emits a {Transfer} event.
+   */
+  function mint(address to, uint256 tokenId) external;
+
+  /**
+   * @dev Mints `tokenId`, transfers it to `to` and checks for `to` acceptance.
+   *
+   * Requirements:
+   *
+   * - caller must own the namespace
+   * - `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) external;
+
+  /**
+   * @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) external;
+
+  /**
+   * @dev Destroys `tokenId`.
+   * The approval is cleared when the token is burned.
+   *
+   * Requirements:
+   *
+   * - `tokenId` must exist.
+   *
+   * Emits a {Transfer} event.
+   */
+  function burn(uint256 tokenId) external;
+}

package/src/modules/erc721-puppet/IERC721Receiver.sol

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: MIT
+// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC721/IERC721Receiver.sol)
+pragma solidity >=0.8.24;
+
+/**
+ * @title ERC721 token receiver interface
+ * @author MUD (https://mud.dev) by Lattice (https://lattice.xyz)
+ * @dev Interface for any contract that wants to support safeTransfers
+ * from ERC721 asset contracts.
+ */
+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 `IERC721Receiver.onERC721Received.selector`.
+   */
+  function onERC721Received(
+    address operator,
+    address from,
+    uint256 tokenId,
+    bytes calldata data
+  ) external returns (bytes4);
+}

package/src/modules/erc721-puppet/constants.sol

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+import { RESOURCE_TABLE } from "@latticexyz/store/src/storeResourceTypes.sol";
+import { RESOURCE_SYSTEM, RESOURCE_NAMESPACE } from "@latticexyz/world/src/worldResourceTypes.sol";
+
+bytes14 constant MODULE_NAMESPACE = "erc721-puppet";
+ResourceId constant MODULE_NAMESPACE_ID = ResourceId.wrap(
+  bytes32(abi.encodePacked(RESOURCE_NAMESPACE, MODULE_NAMESPACE))
+);
+
+bytes16 constant TOKEN_URI_NAME = "TokenURI";
+bytes16 constant BALANCES_NAME = "Balances";
+bytes16 constant METADATA_NAME = "Metadata";
+bytes16 constant OPERATOR_APPROVAL_NAME = "OperatorApproval";
+bytes16 constant TOKEN_APPROVAL_NAME = "TokenApproval";
+bytes16 constant OWNERS_NAME = "Owners";
+
+bytes16 constant ERC721_SYSTEM_NAME = "ERC721System";
+
+ResourceId constant ERC721_REGISTRY_TABLE_ID = ResourceId.wrap(
+  bytes32(abi.encodePacked(RESOURCE_TABLE, MODULE_NAMESPACE, bytes16("ERC721Registry")))
+);

package/src/modules/erc721-puppet/libraries/LibString.sol

@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.0;
+
+/// @notice Efficient library for creating string representations of integers.
+/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
+/// @author Modified from Solady (https://github.com/Vectorized/solady/blob/main/src/utils/LibString.sol)
+library LibString {
+  function toString(int256 value) internal pure returns (string memory str) {
+    if (value >= 0) return toString(uint256(value));
+
+    unchecked {
+      str = toString(uint256(-value));
+
+      /// @solidity memory-safe-assembly
+      assembly {
+        // Note: This is only safe because we over-allocate memory
+        // and write the string from right to left in toString(uint256),
+        // and thus can be sure that sub(str, 1) is an unused memory location.
+
+        let length := mload(str) // Load the string length.
+        // Put the - character at the start of the string contents.
+        mstore(str, 45) // 45 is the ASCII code for the - character.
+        str := sub(str, 1) // Move back the string pointer by a byte.
+        mstore(str, add(length, 1)) // Update the string length.
+      }
+    }
+  }
+
+  function toString(uint256 value) internal pure returns (string memory str) {
+    /// @solidity memory-safe-assembly
+    assembly {
+      // The maximum value of a uint256 contains 78 digits (1 byte per digit), but we allocate 160 bytes
+      // to keep the free memory pointer word aligned. We'll need 1 word for the length, 1 word for the
+      // trailing zeros padding, and 3 other words for a max of 78 digits. In total: 5 * 32 = 160 bytes.
+      let newFreeMemoryPointer := add(mload(0x40), 160)
+
+      // Update the free memory pointer to avoid overriding our string.
+      mstore(0x40, newFreeMemoryPointer)
+
+      // Assign str to the end of the zone of newly allocated memory.
+      str := sub(newFreeMemoryPointer, 32)
+
+      // Clean the last word of memory it may not be overwritten.
+      mstore(str, 0)
+
+      // Cache the end of the memory to calculate the length later.
+      let end := str
+
+      // We write the string from rightmost digit to leftmost digit.
+      // The following is essentially a do-while loop that also handles the zero case.
+      // prettier-ignore
+      for { let temp := value } 1 {} {
+                // Move the pointer 1 byte to the left.
+                str := sub(str, 1)
+
+                // Write the character to the pointer.
+                // The ASCII index of the '0' character is 48.
+                mstore8(str, add(48, mod(temp, 10)))
+
+                // Keep dividing temp until zero.
+                temp := div(temp, 10)
+
+                 // prettier-ignore
+                if iszero(temp) { break }
+            }
+
+      // Compute and cache the final total length of the string.
+      let length := sub(end, str)
+
+      // Move the pointer 32 bytes leftwards to make room for the length.
+      str := sub(str, 32)
+
+      // Store the string's length at the start of memory allocated for our string.
+      mstore(str, length)
+    }
+  }
+}

package/src/modules/erc721-puppet/registerERC721.sol

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: MIT
+pragma solidity >=0.8.24;
+
+import { IBaseWorld } from "@latticexyz/world/src/codegen/interfaces/IBaseWorld.sol";
+import { NamespaceOwner } from "@latticexyz/world/src/codegen/tables/NamespaceOwner.sol";
+import { WorldResourceIdLib } from "@latticexyz/world/src/WorldResourceId.sol";
+
+import { SystemSwitch } from "../../utils/SystemSwitch.sol";
+
+import { ERC721Module } from "./ERC721Module.sol";
+import { MODULE_NAMESPACE_ID, ERC721_REGISTRY_TABLE_ID } from "./constants.sol";
+import { IERC721Mintable } from "./IERC721Mintable.sol";
+
+import { ERC721MetadataData } from "./tables/ERC721Metadata.sol";
+import { ERC721Registry } from "./tables/ERC721Registry.sol";
+
+/**
+ * @notice Register a new ERC721 token with the given metadata in a given namespace
+ * @dev This function must be called within a Store context (i.e. using StoreSwitch.setStoreAddress())
+ */
+function registerERC721(
+  IBaseWorld world,
+  bytes14 namespace,
+  ERC721MetadataData memory metadata
+) returns (IERC721Mintable token) {
+  // Get the ERC721 module
+  ERC721Module erc721Module = ERC721Module(NamespaceOwner.get(MODULE_NAMESPACE_ID));
+  if (address(erc721Module) == address(0)) {
+    erc721Module = new ERC721Module();
+  }
+
+  // Install the ERC721 module with the provided args
+  world.installModule(erc721Module, abi.encode(namespace, metadata));
+
+  // Return the newly created ERC721 token
+  token = IERC721Mintable(ERC721Registry.get(ERC721_REGISTRY_TABLE_ID, WorldResourceIdLib.encodeNamespace(namespace)));
+}