@latticexyz/world-modules 2.0.0-main-711f6e2a → 2.0.0-march-19-skystrife-playtest-f0a343b1

package/src/modules/keysintable/KeysInTableModule.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 import { BEFORE_SET_RECORD, AFTER_SPLICE_STATIC_DATA, AFTER_SPLICE_DYNAMIC_DATA, BEFORE_DELETE_RECORD } from "@latticexyz/store/src/storeHookTypes.sol";
 import { ResourceIds } from "@latticexyz/store/src/codegen/tables/ResourceIds.sol";
@@ -13,8 +13,8 @@ import { ResourceId, WorldResourceIdInstance } from "@latticexyz/world/src/World
 import { revertWithBytes } from "@latticexyz/world/src/revertWithBytes.sol";
 
 import { KeysInTableHook } from "./KeysInTableHook.sol";
-import { KeysInTable } from "./tables/KeysInTable.sol";
-import { UsedKeysIndex } from "./tables/UsedKeysIndex.sol";
+import { KeysInTable, KeysInTableTableId } from "./tables/KeysInTable.sol";
+import { UsedKeysIndex, UsedKeysIndexTableId } from "./tables/UsedKeysIndex.sol";
 
 /**
  * This module deploys a hook that is called when a value is set in the `sourceTableId`
@@ -33,13 +33,19 @@ contract KeysInTableModule is Module {
   // from the source table id (passed as argument to the hook methods)
   KeysInTableHook private immutable hook = new KeysInTableHook();
 
-  function installRoot(bytes memory encodedArgs) public override {
+  function getName() public pure returns (bytes16) {
+    return bytes16("keysInTable");
+  }
+
+  function installRoot(bytes memory args) public override {
     // Naive check to ensure this is only installed once
     // TODO: only revert if there's nothing to do
-    requireNotInstalled(__self, encodedArgs);
+    if (InstalledModules.getModuleAddress(getName(), keccak256(args)) != address(0)) {
+      revert Module_AlreadyInstalled();
+    }
 
     // Extract source table id from args
-    ResourceId sourceTableId = ResourceId.wrap(abi.decode(encodedArgs, (bytes32)));
+    ResourceId sourceTableId = ResourceId.wrap(abi.decode(args, (bytes32)));
 
     IBaseWorld world = IBaseWorld(_world());
 
@@ -47,16 +53,16 @@ contract KeysInTableModule is Module {
     bool success;
     bytes memory returnData;
 
-    if (!ResourceIds._getExists(KeysInTable._tableId)) {
+    if (!ResourceIds._getExists(KeysInTableTableId)) {
       // Register the tables
       (success, returnData) = address(world).delegatecall(
         abi.encodeCall(
           world.registerTable,
           (
-            KeysInTable._tableId,
-            KeysInTable._fieldLayout,
-            KeysInTable._keySchema,
-            KeysInTable._valueSchema,
+            KeysInTableTableId,
+            KeysInTable.getFieldLayout(),
+            KeysInTable.getKeySchema(),
+            KeysInTable.getValueSchema(),
             KeysInTable.getKeyNames(),
             KeysInTable.getFieldNames()
           )
@@ -68,10 +74,10 @@ contract KeysInTableModule is Module {
         abi.encodeCall(
           world.registerTable,
           (
-            UsedKeysIndex._tableId,
-            UsedKeysIndex._fieldLayout,
-            UsedKeysIndex._keySchema,
-            UsedKeysIndex._valueSchema,
+            UsedKeysIndexTableId,
+            UsedKeysIndex.getFieldLayout(),
+            UsedKeysIndex.getKeySchema(),
+            UsedKeysIndex.getValueSchema(),
             UsedKeysIndex.getKeyNames(),
             UsedKeysIndex.getFieldNames()
           )
@@ -81,12 +87,12 @@ contract KeysInTableModule is Module {
 
       // Grant the hook access to the tables
       (success, returnData) = address(world).delegatecall(
-        abi.encodeCall(world.grantAccess, (KeysInTable._tableId, address(hook)))
+        abi.encodeCall(world.grantAccess, (KeysInTableTableId, address(hook)))
       );
       if (!success) revertWithBytes(returnData);
 
       (success, returnData) = address(world).delegatecall(
-        abi.encodeCall(world.grantAccess, (UsedKeysIndex._tableId, address(hook)))
+        abi.encodeCall(world.grantAccess, (UsedKeysIndexTableId, address(hook)))
       );
       if (!success) revertWithBytes(returnData);
     }

package/src/modules/keysintable/constants.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 // Limiting the module namespace to 8 bytes so the last 8 bytes
 // can be used for an identifier of the source table namespace to avoid

package/src/modules/keysintable/getKeysInTable.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 import { IStore } from "@latticexyz/store/src/IStore.sol";
 import { Schema } from "@latticexyz/store/src/Schema.sol";

package/src/modules/keysintable/hasKey.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 import { IStore } from "@latticexyz/store/src/IStore.sol";
 import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";

package/src/modules/keysintable/query.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 import { IStore } from "@latticexyz/store/src/IStore.sol";
 import { PackedCounter } from "@latticexyz/store/src/PackedCounter.sol";

package/src/modules/keysintable/tables/KeysInTable.sol

@@ -1,8 +1,11 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 /* Autogenerated file. Do not edit manually. */
 
+// Import schema type
+import { SchemaType } from "@latticexyz/schema-type/src/solidity/SchemaType.sol";
+
 // Import store internals
 import { IStore } from "@latticexyz/store/src/IStore.sol";
 import { StoreSwitch } from "@latticexyz/store/src/StoreSwitch.sol";
@@ -11,14 +14,24 @@ import { Bytes } from "@latticexyz/store/src/Bytes.sol";
 import { Memory } from "@latticexyz/store/src/Memory.sol";
 import { SliceLib } from "@latticexyz/store/src/Slice.sol";
 import { EncodeArray } from "@latticexyz/store/src/tightcoder/EncodeArray.sol";
-import { FieldLayout } from "@latticexyz/store/src/FieldLayout.sol";
-import { Schema } from "@latticexyz/store/src/Schema.sol";
+import { FieldLayout, FieldLayoutLib } from "@latticexyz/store/src/FieldLayout.sol";
+import { Schema, SchemaLib } from "@latticexyz/store/src/Schema.sol";
 import { PackedCounter, PackedCounterLib } from "@latticexyz/store/src/PackedCounter.sol";
 import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+import { RESOURCE_TABLE, RESOURCE_OFFCHAIN_TABLE } from "@latticexyz/store/src/storeResourceTypes.sol";
 
 // Import user types
 import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
 
+ResourceId constant _tableId = ResourceId.wrap(
+  bytes32(abi.encodePacked(RESOURCE_TABLE, bytes14(""), bytes16("KeysInTable")))
+);
+ResourceId constant KeysInTableTableId = _tableId;
+
+FieldLayout constant _fieldLayout = FieldLayout.wrap(
+  0x0000000500000000000000000000000000000000000000000000000000000000
+);
+
 struct KeysInTableData {
   bytes32[] keys0;
   bytes32[] keys1;
@@ -28,16 +41,39 @@ struct KeysInTableData {
 }
 
 library KeysInTable {
-  // Hex below is the result of `WorldResourceIdLib.encode({ namespace: "", name: "KeysInTable", typeId: RESOURCE_TABLE });`
-  ResourceId constant _tableId = ResourceId.wrap(0x746200000000000000000000000000004b657973496e5461626c650000000000);
+  /**
+   * @notice Get the table values' field layout.
+   * @return _fieldLayout The field layout for the table.
+   */
+  function getFieldLayout() internal pure returns (FieldLayout) {
+    return _fieldLayout;
+  }
+
+  /**
+   * @notice Get the table's key schema.
+   * @return _keySchema The key schema for the table.
+   */
+  function getKeySchema() internal pure returns (Schema) {
+    SchemaType[] memory _keySchema = new SchemaType[](1);
+    _keySchema[0] = SchemaType.BYTES32;
 
-  FieldLayout constant _fieldLayout =
-    FieldLayout.wrap(0x0000000500000000000000000000000000000000000000000000000000000000);
+    return SchemaLib.encode(_keySchema);
+  }
 
-  // Hex-encoded key schema of (bytes32)
-  Schema constant _keySchema = Schema.wrap(0x002001005f000000000000000000000000000000000000000000000000000000);
-  // Hex-encoded value schema of (bytes32[], bytes32[], bytes32[], bytes32[], bytes32[])
-  Schema constant _valueSchema = Schema.wrap(0x00000005c1c1c1c1c10000000000000000000000000000000000000000000000);
+  /**
+   * @notice Get the table's value schema.
+   * @return _valueSchema The value schema for the table.
+   */
+  function getValueSchema() internal pure returns (Schema) {
+    SchemaType[] memory _valueSchema = new SchemaType[](5);
+    _valueSchema[0] = SchemaType.BYTES32_ARRAY;
+    _valueSchema[1] = SchemaType.BYTES32_ARRAY;
+    _valueSchema[2] = SchemaType.BYTES32_ARRAY;
+    _valueSchema[3] = SchemaType.BYTES32_ARRAY;
+    _valueSchema[4] = SchemaType.BYTES32_ARRAY;
+
+    return SchemaLib.encode(_valueSchema);
+  }
 
   /**
    * @notice Get the table's key field names.
@@ -65,21 +101,21 @@ library KeysInTable {
    * @notice Register the table with its config.
    */
   function register() internal {
-    StoreSwitch.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+    StoreSwitch.registerTable(_tableId, _fieldLayout, getKeySchema(), getValueSchema(), getKeyNames(), getFieldNames());
   }
 
   /**
    * @notice Register the table with its config.
    */
   function _register() internal {
-    StoreCore.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+    StoreCore.registerTable(_tableId, _fieldLayout, getKeySchema(), getValueSchema(), getKeyNames(), getFieldNames());
   }
 
   /**
    * @notice Register the table with its config (using the specified store).
    */
   function register(IStore _store) internal {
-    _store.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+    _store.registerTable(_tableId, _fieldLayout, getKeySchema(), getValueSchema(), getKeyNames(), getFieldNames());
   }
 
   /**
@@ -1592,7 +1628,7 @@ library KeysInTable {
    * @notice Encode all of a record's fields.
    * @return The static (fixed length) data, encoded into a sequence of bytes.
    * @return The lengths of the dynamic fields (packed into a single bytes32 value).
-   * @return The dynamic (variable length) data, encoded into a sequence of bytes.
+   * @return The dyanmic (variable length) data, encoded into a sequence of bytes.
    */
   function encode(
     bytes32[] memory keys0,

package/src/modules/keysintable/tables/UsedKeysIndex.sol

@@ -1,8 +1,11 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 /* Autogenerated file. Do not edit manually. */
 
+// Import schema type
+import { SchemaType } from "@latticexyz/schema-type/src/solidity/SchemaType.sol";
+
 // Import store internals
 import { IStore } from "@latticexyz/store/src/IStore.sol";
 import { StoreSwitch } from "@latticexyz/store/src/StoreSwitch.sol";
@@ -11,25 +14,56 @@ import { Bytes } from "@latticexyz/store/src/Bytes.sol";
 import { Memory } from "@latticexyz/store/src/Memory.sol";
 import { SliceLib } from "@latticexyz/store/src/Slice.sol";
 import { EncodeArray } from "@latticexyz/store/src/tightcoder/EncodeArray.sol";
-import { FieldLayout } from "@latticexyz/store/src/FieldLayout.sol";
-import { Schema } from "@latticexyz/store/src/Schema.sol";
+import { FieldLayout, FieldLayoutLib } from "@latticexyz/store/src/FieldLayout.sol";
+import { Schema, SchemaLib } from "@latticexyz/store/src/Schema.sol";
 import { PackedCounter, PackedCounterLib } from "@latticexyz/store/src/PackedCounter.sol";
 import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+import { RESOURCE_TABLE, RESOURCE_OFFCHAIN_TABLE } from "@latticexyz/store/src/storeResourceTypes.sol";
 
 // Import user types
 import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
 
+ResourceId constant _tableId = ResourceId.wrap(
+  bytes32(abi.encodePacked(RESOURCE_TABLE, bytes14(""), bytes16("UsedKeysIndex")))
+);
+ResourceId constant UsedKeysIndexTableId = _tableId;
+
+FieldLayout constant _fieldLayout = FieldLayout.wrap(
+  0x0006020001050000000000000000000000000000000000000000000000000000
+);
+
 library UsedKeysIndex {
-  // Hex below is the result of `WorldResourceIdLib.encode({ namespace: "", name: "UsedKeysIndex", typeId: RESOURCE_TABLE });`
-  ResourceId constant _tableId = ResourceId.wrap(0x74620000000000000000000000000000557365644b657973496e646578000000);
+  /**
+   * @notice Get the table values' field layout.
+   * @return _fieldLayout The field layout for the table.
+   */
+  function getFieldLayout() internal pure returns (FieldLayout) {
+    return _fieldLayout;
+  }
+
+  /**
+   * @notice Get the table's key schema.
+   * @return _keySchema The key schema for the table.
+   */
+  function getKeySchema() internal pure returns (Schema) {
+    SchemaType[] memory _keySchema = new SchemaType[](2);
+    _keySchema[0] = SchemaType.BYTES32;
+    _keySchema[1] = SchemaType.BYTES32;
 
-  FieldLayout constant _fieldLayout =
-    FieldLayout.wrap(0x0006020001050000000000000000000000000000000000000000000000000000);
+    return SchemaLib.encode(_keySchema);
+  }
 
-  // Hex-encoded key schema of (bytes32, bytes32)
-  Schema constant _keySchema = Schema.wrap(0x004002005f5f0000000000000000000000000000000000000000000000000000);
-  // Hex-encoded value schema of (bool, uint40)
-  Schema constant _valueSchema = Schema.wrap(0x0006020060040000000000000000000000000000000000000000000000000000);
+  /**
+   * @notice Get the table's value schema.
+   * @return _valueSchema The value schema for the table.
+   */
+  function getValueSchema() internal pure returns (Schema) {
+    SchemaType[] memory _valueSchema = new SchemaType[](2);
+    _valueSchema[0] = SchemaType.BOOL;
+    _valueSchema[1] = SchemaType.UINT40;
+
+    return SchemaLib.encode(_valueSchema);
+  }
 
   /**
    * @notice Get the table's key field names.
@@ -55,21 +89,21 @@ library UsedKeysIndex {
    * @notice Register the table with its config.
    */
   function register() internal {
-    StoreSwitch.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+    StoreSwitch.registerTable(_tableId, _fieldLayout, getKeySchema(), getValueSchema(), getKeyNames(), getFieldNames());
   }
 
   /**
    * @notice Register the table with its config.
    */
   function _register() internal {
-    StoreCore.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+    StoreCore.registerTable(_tableId, _fieldLayout, getKeySchema(), getValueSchema(), getKeyNames(), getFieldNames());
   }
 
   /**
    * @notice Register the table with its config (using the specified store).
    */
   function register(IStore _store) internal {
-    _store.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+    _store.registerTable(_tableId, _fieldLayout, getKeySchema(), getValueSchema(), getKeyNames(), getFieldNames());
   }
 
   /**
@@ -314,9 +348,9 @@ library UsedKeysIndex {
    * @notice Decode the tightly packed blob of static data using this table's field layout.
    */
   function decodeStatic(bytes memory _blob) internal pure returns (bool has, uint40 index) {
-    has = (_toBool(uint8(Bytes.getBytes1(_blob, 0))));
+    has = (_toBool(uint8(Bytes.slice1(_blob, 0))));
 
-    index = (uint40(Bytes.getBytes5(_blob, 1)));
+    index = (uint40(Bytes.slice5(_blob, 1)));
   }
 
   /**
@@ -378,7 +412,7 @@ library UsedKeysIndex {
    * @notice Encode all of a record's fields.
    * @return The static (fixed length) data, encoded into a sequence of bytes.
    * @return The lengths of the dynamic fields (packed into a single bytes32 value).
-   * @return The dynamic (variable length) data, encoded into a sequence of bytes.
+   * @return The dyanmic (variable length) data, encoded into a sequence of bytes.
    */
   function encode(bool has, uint40 index) internal pure returns (bytes memory, PackedCounter, bytes memory) {
     bytes memory _staticData = encodeStatic(has, index);

package/src/modules/keyswithvalue/KeysWithValueHook.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 import { StoreHook } from "@latticexyz/store/src/StoreHook.sol";
 import { Bytes } from "@latticexyz/store/src/Bytes.sol";

package/src/modules/keyswithvalue/KeysWithValueModule.sol

@@ -1,10 +1,9 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 import { StoreSwitch } from "@latticexyz/store/src/StoreSwitch.sol";
 import { BEFORE_SET_RECORD, BEFORE_SPLICE_STATIC_DATA, AFTER_SPLICE_STATIC_DATA, BEFORE_SPLICE_DYNAMIC_DATA, AFTER_SPLICE_DYNAMIC_DATA, BEFORE_DELETE_RECORD } from "@latticexyz/store/src/storeHookTypes.sol";
-import { ResourceIds } from "@latticexyz/store/src/codegen/tables/ResourceIds.sol";
-
 import { Module } from "@latticexyz/world/src/Module.sol";
+
 import { IBaseWorld } from "@latticexyz/world/src/codegen/interfaces/IBaseWorld.sol";
 import { InstalledModules } from "@latticexyz/world/src/codegen/index.sol";
 
@@ -35,45 +34,41 @@ contract KeysWithValueModule is Module {
   // from the source table id (passed as argument to the hook methods)
   KeysWithValueHook private immutable hook = new KeysWithValueHook();
 
-  function installRoot(bytes memory encodedArgs) public {
+  function getName() public pure returns (bytes16) {
+    return bytes16("index");
+  }
+
+  function installRoot(bytes memory args) public {
     // Naive check to ensure this is only installed once
     // TODO: only revert if there's nothing to do
-    requireNotInstalled(__self, encodedArgs);
+    if (InstalledModules.getModuleAddress(getName(), keccak256(args)) != address(0)) {
+      revert Module_AlreadyInstalled();
+    }
 
     // Extract source table id from args
-    ResourceId sourceTableId = ResourceId.wrap(abi.decode(encodedArgs, (bytes32)));
-    ResourceId targetTableId = getTargetTableId(MODULE_NAMESPACE, sourceTableId);
+    ResourceId sourceTableId = ResourceId.wrap(abi.decode(args, (bytes32)));
+    ResourceId targetTableSelector = getTargetTableId(MODULE_NAMESPACE, sourceTableId);
 
     IBaseWorld world = IBaseWorld(_world());
 
-    // Register the target namespace if it doesn't exist yet
-    if (!ResourceIds.getExists(targetTableId.getNamespaceId())) {
-      (bool registrationSuccess, bytes memory registrationReturnData) = address(world).delegatecall(
-        abi.encodeCall(world.registerNamespace, (targetTableId.getNamespaceId()))
-      );
-      if (!registrationSuccess) revertWithBytes(registrationReturnData);
-    }
-
     // Register the target table
     (bool success, bytes memory returnData) = address(world).delegatecall(
       abi.encodeCall(
         world.registerTable,
         (
-          targetTableId,
-          KeysWithValue._fieldLayout,
-          KeysWithValue._keySchema,
-          KeysWithValue._valueSchema,
+          targetTableSelector,
+          KeysWithValue.getFieldLayout(),
+          KeysWithValue.getKeySchema(),
+          KeysWithValue.getValueSchema(),
           KeysWithValue.getKeyNames(),
           KeysWithValue.getFieldNames()
         )
       )
     );
 
-    if (!success) revertWithBytes(returnData);
-
     // Grant the hook access to the target table
     (success, returnData) = address(world).delegatecall(
-      abi.encodeCall(world.grantAccess, (targetTableId, address(hook)))
+      abi.encodeCall(world.grantAccess, (targetTableSelector, address(hook)))
     );
 
     if (!success) revertWithBytes(returnData);

package/src/modules/keyswithvalue/constants.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 // Limiting the module namespace to 7 bytes so the remaining 7 bytes
 // can be used for an identifier of the source table namespace to avoid

package/src/modules/keyswithvalue/getKeysWithValue.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 import { IStore } from "@latticexyz/store/src/IStore.sol";
 import { PackedCounter } from "@latticexyz/store/src/PackedCounter.sol";

package/src/modules/keyswithvalue/getTargetTableId.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 import { TYPE_BITS } from "@latticexyz/store/src/ResourceId.sol";
 import { ResourceId, WorldResourceIdInstance, NAME_BITS } from "@latticexyz/world/src/WorldResourceId.sol";

package/src/modules/keyswithvalue/tables/KeysWithValue.sol

@@ -1,8 +1,11 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 /* Autogenerated file. Do not edit manually. */
 
+// Import schema type
+import { SchemaType } from "@latticexyz/schema-type/src/solidity/SchemaType.sol";
+
 // Import store internals
 import { IStore } from "@latticexyz/store/src/IStore.sol";
 import { StoreSwitch } from "@latticexyz/store/src/StoreSwitch.sol";
@@ -11,19 +14,46 @@ import { Bytes } from "@latticexyz/store/src/Bytes.sol";
 import { Memory } from "@latticexyz/store/src/Memory.sol";
 import { SliceLib } from "@latticexyz/store/src/Slice.sol";
 import { EncodeArray } from "@latticexyz/store/src/tightcoder/EncodeArray.sol";
-import { FieldLayout } from "@latticexyz/store/src/FieldLayout.sol";
-import { Schema } from "@latticexyz/store/src/Schema.sol";
+import { FieldLayout, FieldLayoutLib } from "@latticexyz/store/src/FieldLayout.sol";
+import { Schema, SchemaLib } from "@latticexyz/store/src/Schema.sol";
 import { PackedCounter, PackedCounterLib } from "@latticexyz/store/src/PackedCounter.sol";
 import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
+import { RESOURCE_TABLE, RESOURCE_OFFCHAIN_TABLE } from "@latticexyz/store/src/storeResourceTypes.sol";
+
+FieldLayout constant _fieldLayout = FieldLayout.wrap(
+  0x0000000100000000000000000000000000000000000000000000000000000000
+);
 
 library KeysWithValue {
-  FieldLayout constant _fieldLayout =
-    FieldLayout.wrap(0x0000000100000000000000000000000000000000000000000000000000000000);
+  /**
+   * @notice Get the table values' field layout.
+   * @return _fieldLayout The field layout for the table.
+   */
+  function getFieldLayout() internal pure returns (FieldLayout) {
+    return _fieldLayout;
+  }
+
+  /**
+   * @notice Get the table's key schema.
+   * @return _keySchema The key schema for the table.
+   */
+  function getKeySchema() internal pure returns (Schema) {
+    SchemaType[] memory _keySchema = new SchemaType[](1);
+    _keySchema[0] = SchemaType.BYTES32;
+
+    return SchemaLib.encode(_keySchema);
+  }
 
-  // Hex-encoded key schema of (bytes32)
-  Schema constant _keySchema = Schema.wrap(0x002001005f000000000000000000000000000000000000000000000000000000);
-  // Hex-encoded value schema of (bytes32[])
-  Schema constant _valueSchema = Schema.wrap(0x00000001c1000000000000000000000000000000000000000000000000000000);
+  /**
+   * @notice Get the table's value schema.
+   * @return _valueSchema The value schema for the table.
+   */
+  function getValueSchema() internal pure returns (Schema) {
+    SchemaType[] memory _valueSchema = new SchemaType[](1);
+    _valueSchema[0] = SchemaType.BYTES32_ARRAY;
+
+    return SchemaLib.encode(_valueSchema);
+  }
 
   /**
    * @notice Get the table's key field names.
@@ -47,21 +77,21 @@ library KeysWithValue {
    * @notice Register the table with its config.
    */
   function register(ResourceId _tableId) internal {
-    StoreSwitch.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+    StoreSwitch.registerTable(_tableId, _fieldLayout, getKeySchema(), getValueSchema(), getKeyNames(), getFieldNames());
   }
 
   /**
    * @notice Register the table with its config.
    */
   function _register(ResourceId _tableId) internal {
-    StoreCore.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+    StoreCore.registerTable(_tableId, _fieldLayout, getKeySchema(), getValueSchema(), getKeyNames(), getFieldNames());
   }
 
   /**
    * @notice Register the table with its config (using the specified store).
    */
   function register(IStore _store, ResourceId _tableId) internal {
-    _store.registerTable(_tableId, _fieldLayout, _keySchema, _valueSchema, getKeyNames(), getFieldNames());
+    _store.registerTable(_tableId, _fieldLayout, getKeySchema(), getValueSchema(), getKeyNames(), getFieldNames());
   }
 
   /**
@@ -646,7 +676,7 @@ library KeysWithValue {
    * @notice Encode all of a record's fields.
    * @return The static (fixed length) data, encoded into a sequence of bytes.
    * @return The lengths of the dynamic fields (packed into a single bytes32 value).
-   * @return The dynamic (variable length) data, encoded into a sequence of bytes.
+   * @return The dyanmic (variable length) data, encoded into a sequence of bytes.
    */
   function encode(bytes32[] memory keysWithValue) internal pure returns (bytes memory, PackedCounter, bytes memory) {
     bytes memory _staticData;

package/src/modules/puppet/Puppet.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 import { StoreSwitch } from "@latticexyz/store/src/StoreSwitch.sol";
 import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";

package/src/modules/puppet/PuppetDelegationControl.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 import { DelegationControl } from "@latticexyz/world/src/DelegationControl.sol";
 import { ResourceId } from "@latticexyz/world/src/WorldResourceId.sol";

package/src/modules/puppet/PuppetFactorySystem.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
 import { System } from "@latticexyz/world/src/System.sol";

package/src/modules/puppet/PuppetMaster.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity >=0.8.24;
+pragma solidity >=0.8.21;
 
 import { ResourceId } from "@latticexyz/store/src/ResourceId.sol";
 import { SystemRegistry } from "@latticexyz/world/src/codegen/tables/SystemRegistry.sol";