feat(store,world): replace ResourceSelector with ResourceId and WorldResourceId

.changeset/stale-seahorses-pay.md

@@ -0,0 +1,69 @@
+---
+"@latticexyz/cli": major
+"@latticexyz/common": major
+"@latticexyz/config": major
+"@latticexyz/store": major
+---
+- `ResourceSelector` is replaced with `ResourceId`, `ResourceIdLib`, `ResourceIdInstance`, `WorldResourceIdLib` and `WorldResourceIdInstance`.
+
+  Previously a "resource selector" was a `bytes32` value with the first 16 bytes reserved for the resource's namespace, and the last 16 bytes reserved for the resource's name.
+  Now a "resource ID" is a `bytes32` value with the first 14 bytes reserved for the resource's namespace, the next 16 bytes reserved for the resource's name, and the last 2 bytes reserved for the resource type.
+
+  Previously `ResouceSelector` was a library and the resource selector type was a plain `bytes32`.
+  Now `ResourceId` is a user type, and the functionality is implemented in the `ResourceIdInstance` (for type) and `WorldResourceIdInstance` (for namespace and name) libraries.
+  We split the logic into two libraries, because `Store` also uses `ResourceId` now and needs awareness of resource types, but not of namespaces/names.
+
+  ```diff
+  - import { ResourceSelector } from "@latticexyz/world/src/ResourceSelector.sol";
+  + import { ResourceId, ResourceIdInstance } from "@latticexyz/store/src/ResourceId.sol";
+  + import { WorldResourceIdLib, WorldResourceIdInstance } from "@latticexyz/world/src/WorldResourceId.sol";
+  + import { RESOURCE_SYSTEM } from "@latticexyz/world/src/worldResourceTypes.sol";
+
+  - bytes32 systemId = ResourceSelector.from("namespace", "name");
+  + ResourceId systemId = WorldResourceIdLib.encode("namespace", "name", RESOURCE_SYSTEM);
+
+  - using ResourceSelector for bytes32;
+  + using WorldResourceIdInstance for ResourceId;
+  + using ResourceIdInstance for ResourceId;
+
+    systemId.getName();
+    systemId.getNamespace();
+  + systemId.getType();
+
+  ```
+
+- All `Store` and `World` methods now use the `ResourceId` type for `tableId`, `systemId`, `moduleId` and `namespaceId`.
+  All mentions of `resourceSelector` were renamed to `resourceId` or the more specific type (e.g. `tableId`, `systemId`)
+
+  ```diff
+  import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+
+  IStore {
+    function setRecord(
+  -   bytes32 tableId,
+  +   ResourceId tableId,
+      bytes32[] calldata keyTuple,
+      bytes calldata staticData,
+      PackedCounter encodedLengths,
+      bytes calldata dynamicData,
+      FieldLayout fieldLayout
+    ) external;
+
+    // Same for all other methods
+  }
+  ```
+
+    ```diff
+  import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+
+  IBaseWorld {
+    function callFrom(
+      address delegator,
+  -   bytes32 resourceSelector,
+  +   ResourceId systemId,
+      bytes memory callData
+    ) external payable returns (bytes memory);
+
+    // Same for all other methods
+  }
+  ```

examples/minimal/packages/contracts/script/PostDeploy.s.sol

@@ -3,7 +3,8 @@ pragma solidity >=0.8.0;
 
 import { Script } from "forge-std/Script.sol";
 import { console } from "forge-std/console.sol";
-import { ResourceSelector } from "@latticexyz/world/src/ResourceSelector.sol";
+import { ResourceId, WorldResourceIdLib } from "@latticexyz/world/src/WorldResourceId.sol";
+import { RESOURCE_SYSTEM } from "@latticexyz/world/src/worldResourceTypes.sol";
 import { IWorld } from "../src/codegen/world/IWorld.sol";
 
 import { MessageTable, MessageTableTableId } from "../src/codegen/index.sol";
@@ -19,16 +20,9 @@ contract PostDeploy is Script {
 
     // Manually deploy a system with another namespace
     ChatNamespacedSystem chatNamespacedSystem = new ChatNamespacedSystem();
-    IWorld(worldAddress).registerSystem(
-      ResourceSelector.from("namespace", "ChatNamespaced"),
-      chatNamespacedSystem,
-      true
-    );
-    IWorld(worldAddress).registerFunctionSelector(
-      ResourceSelector.from("namespace", "ChatNamespaced"),
-      "sendMessage",
-      "(string)"
-    );
+    ResourceId systemId = WorldResourceIdLib.encode("namespace", "ChatNamespaced", RESOURCE_SYSTEM);
+    IWorld(worldAddress).registerSystem(systemId, chatNamespacedSystem, true);
+    IWorld(worldAddress).registerFunctionSelector(systemId, "sendMessage", "(string)");
     // Grant this system access to MessageTable
     IWorld(worldAddress).grantAccess(MessageTableTableId, address(chatNamespacedSystem));
 

packages/common/src/codegen/render-solidity/common.ts

@@ -44,7 +44,7 @@ export function renderCommonData({
 } {
   // static resource means static tableId as well, and no tableId arguments
   const _tableId = staticResourceData ? "" : "_tableId";
-  const _typedTableId = staticResourceData ? "" : "bytes32 _tableId";
+  const _typedTableId = staticResourceData ? "" : "ResourceId _tableId";
 
   const _keyArgs = renderArguments(keyTuple.map(({ name }) => name));
   const _typedKeyArgs = renderArguments(keyTuple.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
@@ -150,11 +150,11 @@ export function renderTableId(staticResourceData: StaticResourceData): {
   hardcodedTableId: string;
   tableIdDefinition: string;
 } {
-  const hardcodedTableId = `bytes32(abi.encodePacked(bytes16("${staticResourceData.namespace}"), bytes16("${staticResourceData.name}")))`;
+  const hardcodedTableId = `ResourceId.wrap(bytes32(abi.encodePacked(bytes14("${staticResourceData.namespace}"), bytes16("${staticResourceData.name}"), RESOURCE_TABLE)))`;
 
   const tableIdDefinition = `
-    bytes32 constant _tableId = ${hardcodedTableId};
-    bytes32 constant ${staticResourceData.tableIdName} = _tableId;
+    ResourceId constant _tableId = ${hardcodedTableId};
+    ResourceId constant ${staticResourceData.tableIdName} = _tableId;
   `;
   return {
     hardcodedTableId,

packages/config/src/library/commonSchemas.ts

@@ -9,6 +9,7 @@ import {
   validateSingleLevelRoute,
   validateUncapitalizedName,
   validateSelector,
+  validateNamespace,
 } from "./validation";
 
 /** Capitalized names of objects, like tables and systems */
@@ -30,5 +31,8 @@ export const zBaseRoute = z.string().superRefine(validateBaseRoute);
 /** A valid Ethereum address */
 export const zEthereumAddress = z.string().superRefine(validateEthereumAddress);
 
-/** A selector for namespace/file/resource */
+/** A selector for file/resource */
 export const zSelector = z.string().superRefine(validateSelector);
+
+/** A namespace */
+export const zNamespace = z.string().superRefine(validateNamespace);

packages/config/src/library/validation.ts

@@ -2,6 +2,7 @@ import { utils } from "ethers";
 import { ZodIssueCode, RefinementCtx } from "zod";
 
 export const STORE_SELECTOR_MAX_LENGTH = 16;
+export const STORE_NAMESPACE_MAX_LENGTH = 14;
 
 export function validateName(name: string, ctx: RefinementCtx) {
   if (!/^\w+$/.test(name)) {
@@ -139,6 +140,21 @@ export function getDuplicates<T>(array: T[]) {
   return [...duplicates];
 }
 
+export function validateNamespace(name: string, ctx: RefinementCtx) {
+  if (name.length > STORE_NAMESPACE_MAX_LENGTH) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: `Namespace must be <= ${STORE_NAMESPACE_MAX_LENGTH} characters`,
+    });
+  }
+  if (!/^\w*$/.test(name)) {
+    ctx.addIssue({
+      code: ZodIssueCode.custom,
+      message: `Selector must contain only alphanumeric & underscore characters`,
+    });
+  }
+}
+
 export function validateSelector(name: string, ctx: RefinementCtx) {
   if (name.length > STORE_SELECTOR_MAX_LENGTH) {
     ctx.addIssue({