@latticexyz/cli 1.41.1-alpha.41 → 1.42.0

package/src/commands/test-v2.ts

@@ -0,0 +1,71 @@
+import type { CommandModule } from "yargs";
+import { deployHandler, DeployOptions } from "./deploy-v2.js";
+import { yDeployOptions } from "./deploy-v2.js";
+import { anvil, forge, getRpcUrl, getTestDirectory } from "../utils/foundry.js";
+import chalk from "chalk";
+import { rmSync, writeFileSync } from "fs";
+import path from "path";
+
+type Options = DeployOptions & { port?: number; worldAddress?: string; forgeOptions?: string };
+
+const WORLD_ADDRESS_FILE = ".mudtest";
+
+const commandModule: CommandModule<Options, Options> = {
+  command: "test-v2",
+
+  describe: "Run tests in MUD v2 contracts",
+
+  builder(yargs) {
+    return yargs.options({
+      ...yDeployOptions,
+      port: { type: "number", description: "Port to run internal node for fork testing on", default: 4242 },
+      worldAddress: {
+        type: "string",
+        description:
+          "Address of an existing world contract. If provided, deployment is skipped and the RPC provided in the foundry.toml is used for fork testing.",
+      },
+      forgeOptions: { type: "string", description: "Options to pass to forge test" },
+    });
+  },
+
+  async handler(args) {
+    // Start an internal anvil process if no world address is provided
+    if (!args.worldAddress) {
+      const anvilArgs = ["--block-base-fee-per-gas", "0", "--port", String(args.port)];
+      anvil(anvilArgs);
+    }
+
+    const forkRpc = args.worldAddress ? await getRpcUrl(args.profile) : `http://127.0.0.1:${args.port}`;
+
+    const worldAddress =
+      args.worldAddress ??
+      (
+        await deployHandler({
+          ...args,
+          saveDeployment: false,
+          rpc: forkRpc,
+        })
+      ).worldAddress;
+
+    console.log(chalk.blue("World address", worldAddress));
+
+    // Create a temporary file to pass the world address to the tests
+    writeFileSync(WORLD_ADDRESS_FILE, worldAddress);
+
+    const userOptions = args.forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
+    try {
+      const testResult = await forge(["test", "--fork-url", forkRpc, ...userOptions], {
+        profile: args.profile,
+      });
+      console.log(testResult);
+    } catch (e) {
+      console.error(e);
+    }
+
+    rmSync(WORLD_ADDRESS_FILE);
+
+    process.exit(0);
+  },
+};
+
+export default commandModule;

package/src/commands/tsgen.ts

@@ -0,0 +1,33 @@
+import type { CommandModule } from "yargs";
+import { loadStoreConfig } from "@latticexyz/config";
+import { tsgen } from "../render-ts/tsgen.js";
+
+type Options = {
+  configPath: string;
+  out: string;
+};
+
+const commandModule: CommandModule<Options, Options> = {
+  command: "tsgen",
+
+  describe: "Autogenerate MUD typescript definitions based on the config file",
+
+  builder(yargs) {
+    return yargs.options({
+      configPath: { type: "string", demandOption: true, desc: "Path to the config file" },
+      out: { type: "string", demandOption: true, desc: "Directory to output MUD typescript definition files" },
+    });
+  },
+
+  async handler(args) {
+    const { configPath, out } = args;
+
+    const config = await loadStoreConfig(configPath);
+
+    await tsgen(config, out);
+
+    process.exit(0);
+  },
+};
+
+export default commandModule;

package/src/commands/worldgen.ts

@@ -1,6 +1,5 @@
 import type { CommandModule } from "yargs";
-import { loadStoreConfig } from "../config/loadStoreConfig.js";
-import { loadWorldConfig } from "../config/index.js";
+import { loadStoreConfig, loadWorldConfig } from "@latticexyz/config";
 import { getSrcDirectory } from "../utils/foundry.js";
 import glob from "glob";
 import path, { basename } from "path";
@@ -42,11 +41,13 @@ const commandModule: CommandModule<Options, Options> = {
     const storeConfig = await loadStoreConfig(configPath);
     const mudConfig = { ...worldConfig, ...storeConfig };
 
+    const outputBaseDirectory = path.join(srcDir, mudConfig.codegenDirectory);
+
     // clear the worldgen directory
-    if (clean) rmSync(path.join(srcDir, worldConfig.worldgenDirectory), { recursive: true, force: true });
+    if (clean) rmSync(path.join(outputBaseDirectory, mudConfig.worldgenDirectory), { recursive: true, force: true });
 
     // generate new interfaces
-    await worldgen(mudConfig, existingContracts, srcDir);
+    await worldgen(mudConfig, existingContracts, outputBaseDirectory);
 
     process.exit(0);
   },

package/src/contracts/BulkUpload.sol

@@ -1,14 +1,14 @@
 // SPDX-License-Identifier: MIT
 pragma solidity >=0.8.0;
 
-import {Script} from "forge-std/Script.sol";
-import {console} from "forge-std/console.sol";
+import { Script } from "forge-std/Script.sol";
+import { console } from "forge-std/console.sol";
 
-import {BulkSetStateSystem, ID as BulkSetStateSystemID, ECSEvent} from "std-contracts/systems/BulkSetStateSystem.sol";
-import {World} from "solecs/World.sol";
-import {System} from "solecs/System.sol";
-import {getAddressById} from "solecs/utils.sol";
-import {Set} from "solecs/Set.sol";
+import { BulkSetStateSystem, ID as BulkSetStateSystemID, ECSEvent } from "std-contracts/systems/BulkSetStateSystem.sol";
+import { World } from "solecs/World.sol";
+import { System } from "solecs/System.sol";
+import { getAddressById } from "solecs/utils.sol";
+import { Set } from "solecs/Set.sol";
 
 struct ParsedState {
   string[] componentIds;
@@ -33,11 +33,7 @@ struct State {
  * forge script --sig "run(string, address)" --rpc-url http://localhost:8545 src/contracts/BulkUpload.sol:BulkUpload path/to/ecs-map-test.json <WORLD_ADDRESS>
  */
 contract BulkUpload is Script {
-  function run(
-    string memory path,
-    address worldAddress,
-    uint256 eventsPerTx
-  ) public {
+  function run(string memory path, address worldAddress, uint256 eventsPerTx) public {
     vmSafe.startBroadcast();
 
     // Read JSON
@@ -108,9 +104,10 @@ contract BulkUpload is Script {
   }
 }
 
-function transformEventsToOnlyUseNeededEntities(uint256[] memory entities, ECSEvent[] memory events)
-  returns (uint256[] memory, ECSEvent[] memory)
-{
+function transformEventsToOnlyUseNeededEntities(
+  uint256[] memory entities,
+  ECSEvent[] memory events
+) returns (uint256[] memory, ECSEvent[] memory) {
   Set uniqueEntityIndices = new Set();
 
   // Find unique entity indices
@@ -167,11 +164,7 @@ function hexToBytes(string memory s) pure returns (bytes memory) {
   return r;
 }
 
-function substring(
-  string memory str,
-  uint256 start,
-  uint256 end
-) pure returns (string memory) {
+function substring(string memory str, uint256 start, uint256 end) pure returns (string memory) {
   bytes memory strBytes = bytes(str);
   bytes memory result = new bytes(end - start);
   for (uint256 i = start; i < end; i++) {

package/src/contracts/Deploy.sol

@@ -2,11 +2,11 @@
 pragma solidity >=0.8.0;
 
 // Foundry
-import {Script} from "forge-std/Script.sol";
-import {console} from "forge-std/console.sol";
+import { Script } from "forge-std/Script.sol";
+import { console } from "forge-std/console.sol";
 
 // Libraries
-import {LibDeploy, DeployResult} from "./LibDeploy.sol";
+import { LibDeploy, DeployResult } from "./LibDeploy.sol";
 
 contract Deploy is Script {
   function broadcastDeploy(

package/src/contracts/LibDeploy.sol

@@ -7,7 +7,7 @@ pragma solidity >=0.8.0;
 //        To manually generate the real LibDeploy.sol use
 //        `mud codegen-libdeploy`.
 
-import {IWorld} from "solecs/interfaces/IWorld.sol";
+import { IWorld } from "solecs/interfaces/IWorld.sol";
 
 struct DeployResult {
   IWorld world;

package/src/contracts/LibDeployStub.sol

@@ -7,7 +7,7 @@ pragma solidity >=0.8.0;
 //        To manually generate the real LibDeploy.sol use
 //        `mud codegen-libdeploy`.
 
-import {IWorld} from "solecs/interfaces/IWorld.sol";
+import { IWorld } from "solecs/interfaces/IWorld.sol";
 
 struct DeployResult {
   IWorld world;

package/src/index.ts

@@ -1,15 +1 @@
-export { loadStoreConfig } from "./config/loadStoreConfig.js";
-export { parseStoreConfig } from "./config/parseStoreConfig.js";
-export { loadWorldConfig, resolveWorldConfig, parseWorldConfig } from "./config/world/index.js";
-export { resolveTableId } from "./config/dynamicResolution.js";
-
-export type {
-  StoreUserConfig,
-  StoreConfig,
-  WorldUserConfig,
-  ResolvedWorldConfig,
-  MUDUserConfig,
-  MUDConfig,
-} from "./config/index.js";
-
-export { storeConfig, mudConfig } from "./config/index.js";
+export {};

package/src/mud.ts

@@ -1,8 +1,9 @@
-#!/usr/bin/env -S TS_NODE_COMPILER_OPTIONS={\"module\":\"esnext\"} node --loader=ts-node/esm --no-warnings
+#!/usr/bin/env node
 
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
-import { commands } from "./commands/index.js";
+import { commands as v2 } from "./commands/index.js";
+import { commands as v1 } from "./commands/deprecated/index.js";
 import { logError } from "./utils/errors.js";
 
 // Load .env file into process.env
@@ -14,7 +15,7 @@ yargs(hideBin(process.argv))
   .scriptName("mud")
   // Use the commands directory to scaffold
   // eslint-disable-next-line @typescript-eslint/no-explicit-any -- command array overload isn't typed, see https://github.com/yargs/yargs/blob/main/docs/advanced.md#esm-hierarchy
-  .command(commands as any)
+  .command([...v1, ...v2] as any)
   // Enable strict mode.
   .strict()
   // Custom error handler

package/src/mud2.ts

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+import { commands } from "./commands/index.js";
+import { logError } from "./utils/errors.js";
+
+// Load .env file into process.env
+import * as dotenv from "dotenv";
+dotenv.config();
+
+yargs(hideBin(process.argv))
+  // Explicit name to display in help (by default it's the entry file, which may not be "mud" for e.g. ts-node)
+  .scriptName("mud")
+  // Use the commands directory to scaffold
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- command array overload isn't typed, see https://github.com/yargs/yargs/blob/main/docs/advanced.md#esm-hierarchy
+  .command(commands as any)
+  // Enable strict mode.
+  .strict()
+  // Custom error handler
+  .fail((msg, err) => {
+    console.log("");
+    logError(err);
+    console.log("");
+
+    process.exit(1);
+  })
+  // Useful aliases.
+  .alias({ h: "help" }).argv;

package/src/render-solidity/common.ts

@@ -27,7 +27,7 @@ export function renderCommonData({
 }: Pick<RenderTableOptions, "staticResourceData" | "primaryKeys">) {
   // static resource means static tableId as well, and no tableId arguments
   const _tableId = staticResourceData ? "" : "_tableId";
-  const _typedTableId = staticResourceData ? "" : "uint256 _tableId";
+  const _typedTableId = staticResourceData ? "" : "bytes32 _tableId";
 
   const _keyArgs = renderArguments(primaryKeys.map(({ name }) => name));
   const _typedKeyArgs = renderArguments(primaryKeys.map(({ name, typeWithLocation }) => `${typeWithLocation} ${name}`));
@@ -100,11 +100,11 @@ export function renderWithStore(
 }
 
 export function renderTableId(staticResourceData: StaticResourceData) {
-  const hardcodedTableId = `uint256(bytes32(abi.encodePacked(bytes16("${staticResourceData.namespace}"), bytes16("${staticResourceData.fileSelector}"))))`;
+  const hardcodedTableId = `bytes32(abi.encodePacked(bytes16("${staticResourceData.namespace}"), bytes16("${staticResourceData.name}")))`;
 
   const tableIdDefinition = `
-    uint256 constant _tableId = ${hardcodedTableId};
-    uint256 constant ${staticResourceData.tableIdName} = _tableId;
+    bytes32 constant _tableId = ${hardcodedTableId};
+    bytes32 constant ${staticResourceData.tableIdName} = _tableId;
   `;
   return {
     hardcodedTableId,

package/src/render-solidity/field.ts

@@ -41,8 +41,6 @@ export function renderFieldMethods(options: RenderTableOptions) {
     `
     );
 
-    // TODO: this is super inefficient right now, need to add support for pushing to arrays to the store core library to avoid reading/writing the entire array
-    // (see https://github.com/latticexyz/mud/issues/438)
     if (field.isDynamic) {
       const portionData = fieldPortionData(field);
 
@@ -61,6 +59,29 @@ export function renderFieldMethods(options: RenderTableOptions) {
         }
       `
       );
+
+      result += renderWithStore(
+        storeArgument,
+        (_typedStore, _store, _commentSuffix) => `
+        /** Update ${portionData.title} of ${field.name}${_commentSuffix} at \`_index\` */
+        function update${field.methodNameSuffix}(${renderArguments([
+          _typedStore,
+          _typedTableId,
+          _typedKeyArgs,
+          "uint256 _index",
+          `${portionData.typeWithLocation} ${portionData.name}`,
+        ])}) internal {
+          ${_primaryKeysDefinition}
+          ${_store}.updateInField(
+            _tableId,
+            _primaryKeys,
+            ${index},
+            _index * ${portionData.elementLength},
+            ${portionData.encoded}
+          );
+        }
+      `
+      );
     }
   }
   return result;
@@ -109,6 +130,7 @@ function fieldPortionData(field: RenderTableField) {
       name: "_element",
       encoded: renderEncodeField({ ...field.arrayElement, arrayElement: undefined, name, methodNameSuffix }),
       title: "an element",
+      elementLength: field.arrayElement.staticByteLength,
     };
   } else {
     const name = "_slice";
@@ -117,6 +139,7 @@ function fieldPortionData(field: RenderTableField) {
       name,
       encoded: renderEncodeField({ ...field, name, methodNameSuffix }),
       title: "a slice",
+      elementLength: 1,
     };
   }
 }

package/src/render-solidity/record.ts

@@ -99,16 +99,20 @@ function renderDecodeFunction({ structName, fields, staticFields, dynamicFields
         ${fieldNamePrefix}${field.name} = ${renderDecodeValueType(field, staticOffsets[index])};
         `
       )}
-      uint256 _start;
-      uint256 _end = ${totalStaticLength + 32};
-      ${renderList(
-        dynamicFields,
-        (field, index) => `
-        _start = _end;
-        _end += _encodedLengths.atIndex(${index});
-        ${fieldNamePrefix}${field.name} = ${renderDecodeDynamicFieldPartial(field)};
-        `
-      )}
+      // Store trims the blob if dynamic fields are all empty
+      if (_blob.length > ${totalStaticLength}) {
+        uint256 _start;
+        // skip static data length + dynamic lengths word
+        uint256 _end = ${totalStaticLength + 32};
+        ${renderList(
+          dynamicFields,
+          (field, index) => `
+          _start = _end;
+          _end += _encodedLengths.atIndex(${index});
+          ${fieldNamePrefix}${field.name} = ${renderDecodeDynamicFieldPartial(field)};
+          `
+        )}
+      }
     }
   `;
   } else {

package/src/render-solidity/renderSystemInterface.ts

@@ -11,10 +11,10 @@ ${renderImports(imports)}
 interface ${name} {
   ${renderList(
     functions,
-    ({ name, parameters, returnParameters }) => `
-    function ${functionPrefix}${name}(${renderArguments(parameters)}) external ${renderReturnParameters(
-      returnParameters
-    )};
+    ({ name, parameters, stateMutability, returnParameters }) => `
+    function ${functionPrefix}${name}(
+      ${renderArguments(parameters)}
+    ) external ${stateMutability} ${renderReturnParameters(returnParameters)};
   `
   )}
 }

package/src/render-solidity/renderTableIndex.ts

@@ -0,0 +1,15 @@
+import { renderList, renderedSolidityHeader } from "./common.js";
+import { TableOptions } from "./tableOptions.js";
+
+export function renderTableIndex(options: TableOptions[]) {
+  return `${renderedSolidityHeader}
+
+${renderList(options, ({ outputPath, tableName, renderOptions: { structName, staticResourceData } }) => {
+  const imports = [tableName];
+  if (structName) imports.push(structName);
+  if (staticResourceData) imports.push(`${tableName}TableId`);
+
+  return `import { ${imports.join(", ")} } from "./${outputPath}";`;
+})}
+`;
+}

package/src/render-solidity/renderTypesFromConfig.ts

@@ -1,4 +1,4 @@
-import { StoreConfig } from "../config/parseStoreConfig.js";
+import { StoreConfig } from "@latticexyz/config";
 import { renderTypes } from "./renderTypes.js";
 
 export function renderTypesFromConfig(config: StoreConfig) {

package/src/render-solidity/tableOptions.ts

@@ -1,6 +1,6 @@
 import path from "path";
 import { SchemaTypeArrayToElement } from "@latticexyz/schema-type";
-import { StoreConfig } from "../config/parseStoreConfig.js";
+import { StoreConfig } from "@latticexyz/config";
 import {
   ImportDatum,
   RenderTableDynamicField,
@@ -80,7 +80,7 @@ export function getTableOptions(config: StoreConfig): TableOptions[] {
         return {
           tableIdName: tableName + "TableId",
           namespace: config.namespace,
-          fileSelector: tableData.fileSelector,
+          name: tableData.name,
         };
       }
     })();

package/src/render-solidity/tablegen.ts

@@ -1,33 +1,35 @@
-import { mkdirSync, writeFileSync } from "fs";
 import path from "path";
-import { StoreConfig } from "../config/index.js";
-import { formatSolidity } from "../utils/format.js";
+import { StoreConfig } from "@latticexyz/config";
 import { getTableOptions } from "./tableOptions.js";
 import { renderTable } from "./renderTable.js";
 import { renderTypesFromConfig } from "./renderTypesFromConfig.js";
+import { formatAndWriteSolidity } from "../utils/formatAndWrite.js";
+import { renderTableIndex } from "./renderTableIndex.js";
+import { rmSync } from "fs";
 
 export async function tablegen(config: StoreConfig, outputBaseDirectory: string) {
   const allTableOptions = getTableOptions(config);
+
+  const uniqueTableDirectories = new Set(allTableOptions.map(({ outputPath }) => path.dirname(outputPath)));
+  for (const tableDir of uniqueTableDirectories) {
+    rmSync(path.join(outputBaseDirectory, tableDir), { recursive: true, force: true });
+  }
+
   // write tables to files
   for (const { outputPath, renderOptions } of allTableOptions) {
     const fullOutputPath = path.join(outputBaseDirectory, outputPath);
     const output = renderTable(renderOptions);
-    formatAndWrite(output, fullOutputPath, "Generated table");
+    formatAndWriteSolidity(output, fullOutputPath, "Generated table");
   }
 
   // write types to file
   if (Object.keys(config.enums).length > 0) {
     const fullOutputPath = path.join(outputBaseDirectory, `${config.userTypesPath}.sol`);
     const output = renderTypesFromConfig(config);
-    formatAndWrite(output, fullOutputPath, "Generated types file");
+    formatAndWriteSolidity(output, fullOutputPath, "Generated types file");
   }
-}
-
-async function formatAndWrite(output: string, fullOutputPath: string, logPrefix: string) {
-  const formattedOutput = await formatSolidity(output);
-
-  mkdirSync(path.dirname(fullOutputPath), { recursive: true });
 
-  writeFileSync(fullOutputPath, formattedOutput);
-  console.log(`${logPrefix}: ${fullOutputPath}`);
+  const fullOutputPath = path.join(outputBaseDirectory, `Tables.sol`);
+  const output = renderTableIndex(allTableOptions);
+  formatAndWriteSolidity(output, fullOutputPath, "Generated table index");
 }

package/src/render-solidity/types.ts

@@ -29,7 +29,7 @@ export interface StaticResourceData {
   /** Name of the table id constant to render. */
   tableIdName: string;
   namespace: string;
-  fileSelector: string;
+  name: string;
 }
 
 export interface RenderTableType {
@@ -95,6 +95,7 @@ export interface RenderSystemInterfaceOptions {
 export interface RenderSystemInterfaceFunction {
   name: string;
   parameters: string[];
+  stateMutability: string;
   returnParameters: string[];
 }
 

package/src/render-solidity/userType.ts

@@ -1,7 +1,6 @@
 import { AbiTypeToSchemaType, getStaticByteLength, SchemaType, SchemaTypeToAbiType } from "@latticexyz/schema-type";
-import { StoreConfig } from "../config/index.js";
+import { StoreConfig, parseStaticArray } from "@latticexyz/config";
 import { ImportDatum, RenderTableType } from "./types.js";
-import { parseStaticArray } from "../config/validation.js";
 
 export type UserTypeInfo = ReturnType<typeof getUserTypeInfo>;
 

package/src/render-solidity/worldgen.ts

@@ -1,8 +1,8 @@
 import { readFileSync } from "fs";
 import path from "path";
-import { MUDConfig } from "../config/index.js";
+import { MUDConfig } from "@latticexyz/config";
 import { contractToInterface } from "../utils/contractToInterface.js";
-import { formatAndWrite } from "../utils/formatAndWrite.js";
+import { formatAndWriteSolidity } from "../utils/formatAndWrite.js";
 import { renderSystemInterface } from "./renderSystemInterface.js";
 import { renderWorld } from "./renderWorld.js";
 import { ImportDatum } from "./types.js";
@@ -27,16 +27,16 @@ export async function worldgen(
     }));
     const systemInterfaceName = `I${system.basename}`;
     // create an interface using the external functions and imports
-    const { fileSelector } = config.systems[system.basename];
+    const { name } = config.systems[system.basename];
     const output = renderSystemInterface({
       name: systemInterfaceName,
-      functionPrefix: config.namespace === "" ? "" : `${config.namespace}_${fileSelector}_`,
+      functionPrefix: config.namespace === "" ? "" : `${config.namespace}_${name}_`,
       functions,
       imports,
     });
     // write to file
     const fullOutputPath = path.join(worldgenBaseDirectory, systemInterfaceName + ".sol");
-    await formatAndWrite(output, fullOutputPath, "Generated system interface");
+    await formatAndWriteSolidity(output, fullOutputPath, "Generated system interface");
 
     // prepare imports for IWorld
     systemInterfaceImports.push({
@@ -47,14 +47,13 @@ export async function worldgen(
   }
 
   // render IWorld
-  const worldInterfaceName = "IWorld";
   const output = renderWorld({
-    interfaceName: worldInterfaceName,
+    interfaceName: config.worldInterfaceName,
     imports: systemInterfaceImports,
     storeImportPath: config.storeImportPath,
     worldImportPath: config.worldImportPath,
   });
   // write to file
-  const fullOutputPath = path.join(worldgenBaseDirectory, worldInterfaceName + ".sol");
-  await formatAndWrite(output, fullOutputPath, "Generated system interface");
+  const fullOutputPath = path.join(worldgenBaseDirectory, config.worldInterfaceName + ".sol");
+  await formatAndWriteSolidity(output, fullOutputPath, "Generated system interface");
 }

package/src/render-ts/index.ts

@@ -0,0 +1,5 @@
+export * from "./recsV1TableOptions.js";
+export * from "./renderRecsV1Tables.js";
+export * from "./schemaTypesToRecsTypeStrings.js";
+export * from "./tsgen.js";
+export * from "./types.js";

package/src/render-ts/recsV1TableOptions.ts

@@ -0,0 +1,39 @@
+import { StoreConfig } from "@latticexyz/config";
+import { resolveAbiOrUserType } from "../render-solidity/userType.js";
+import { schemaTypesToRecsTypeStrings } from "./schemaTypesToRecsTypeStrings.js";
+import { RecsV1TableOptions } from "./types.js";
+
+export function getRecsV1TableOptions(config: StoreConfig): RecsV1TableOptions {
+  const tableOptions = [];
+  for (const tableName of Object.keys(config.tables)) {
+    const tableData = config.tables[tableName];
+
+    const fields = Object.keys(tableData.schema).map((name) => {
+      const abiOrUserType = tableData.schema[name];
+      const { schemaType } = resolveAbiOrUserType(abiOrUserType, config);
+
+      const recsTypeString = schemaTypesToRecsTypeStrings[schemaType];
+
+      return {
+        recsTypeString,
+        name,
+      };
+    });
+
+    // WARNING: skip tables without a static tableId
+    if (tableData.tableIdArgument) continue;
+    const staticResourceData = {
+      namespace: config.namespace,
+      name: tableData.name,
+    };
+
+    tableOptions.push({
+      tableName,
+      fields,
+      staticResourceData,
+    });
+  }
+  return {
+    tables: tableOptions,
+  };
+}