@latticexyz/cli 2.0.0-snapshot-test-32d38619 → 2.0.0

package/src/deploy/ensureSystems.ts

@@ -0,0 +1,187 @@
+import { Client, Transport, Chain, Account, Hex, getAddress, Address } from "viem";
+import { writeContract, resourceToLabel } from "@latticexyz/common";
+import { Library, System, WorldDeploy, worldAbi } from "./common";
+import { debug } from "./debug";
+import { getSystems } from "./getSystems";
+import { getResourceAccess } from "./getResourceAccess";
+import { wait } from "@latticexyz/common/utils";
+import pRetry from "p-retry";
+import { ensureContractsDeployed } from "./ensureContractsDeployed";
+
+// TODO: move each system registration+access to batch call to be atomic
+
+export async function ensureSystems({
+  client,
+  deployerAddress,
+  libraries,
+  worldDeploy,
+  systems,
+}: {
+  readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly deployerAddress: Hex;
+  readonly libraries: readonly Library[];
+  readonly worldDeploy: WorldDeploy;
+  readonly systems: readonly System[];
+}): Promise<readonly Hex[]> {
+  const [worldSystems, worldAccess] = await Promise.all([
+    getSystems({ client, worldDeploy }),
+    getResourceAccess({ client, worldDeploy }),
+  ]);
+
+  // Register or replace systems
+
+  const existingSystems = systems.filter((system) =>
+    worldSystems.some(
+      (worldSystem) =>
+        worldSystem.systemId === system.systemId &&
+        getAddress(worldSystem.address) === getAddress(system.prepareDeploy(deployerAddress, libraries).address),
+    ),
+  );
+  if (existingSystems.length) {
+    debug("existing systems", existingSystems.map(resourceToLabel).join(", "));
+  }
+  const existingSystemIds = existingSystems.map((system) => system.systemId);
+
+  const missingSystems = systems.filter((system) => !existingSystemIds.includes(system.systemId));
+  if (!missingSystems.length) return [];
+
+  const systemsToUpgrade = missingSystems.filter((system) =>
+    worldSystems.some(
+      (worldSystem) =>
+        worldSystem.systemId === system.systemId &&
+        getAddress(worldSystem.address) !== getAddress(system.prepareDeploy(deployerAddress, libraries).address),
+    ),
+  );
+  if (systemsToUpgrade.length) {
+    debug("upgrading systems", systemsToUpgrade.map(resourceToLabel).join(", "));
+  }
+
+  const systemsToAdd = missingSystems.filter(
+    (system) => !worldSystems.some((worldSystem) => worldSystem.systemId === system.systemId),
+  );
+  if (systemsToAdd.length) {
+    debug("registering new systems", systemsToAdd.map(resourceToLabel).join(", "));
+  }
+
+  await ensureContractsDeployed({
+    client,
+    deployerAddress,
+    contracts: missingSystems.map((system) => ({
+      bytecode: system.prepareDeploy(deployerAddress, libraries).bytecode,
+      deployedBytecodeSize: system.deployedBytecodeSize,
+      label: `${resourceToLabel(system)} system`,
+    })),
+  });
+
+  const registerTxs = await Promise.all(
+    missingSystems.map((system) =>
+      pRetry(
+        () =>
+          writeContract(client, {
+            chain: client.chain ?? null,
+            address: worldDeploy.address,
+            abi: worldAbi,
+            // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+            functionName: "registerSystem",
+            args: [system.systemId, system.prepareDeploy(deployerAddress, libraries).address, system.allowAll],
+          }),
+        {
+          retries: 3,
+          onFailedAttempt: async (error) => {
+            const delay = error.attemptNumber * 500;
+            debug(`failed to register system ${resourceToLabel(system)}, retrying in ${delay}ms...`);
+            await wait(delay);
+          },
+        },
+      ),
+    ),
+  );
+
+  // Adjust system access
+
+  const systemIds = systems.map((system) => system.systemId);
+  const currentAccess = worldAccess.filter(({ resourceId }) => systemIds.includes(resourceId));
+  const desiredAccess = [
+    ...systems.flatMap((system) =>
+      system.allowedAddresses.map((address) => ({ resourceId: system.systemId, address })),
+    ),
+    ...systems.flatMap((system) =>
+      system.allowedSystemIds
+        .map((systemId) => ({
+          resourceId: system.systemId,
+          address:
+            worldSystems.find((s) => s.systemId === systemId)?.address ??
+            systems.find((s) => s.systemId === systemId)?.prepareDeploy(deployerAddress, libraries).address,
+        }))
+        .filter((access): access is typeof access & { address: Address } => access.address != null),
+    ),
+  ];
+
+  const accessToAdd = desiredAccess.filter(
+    (access) =>
+      !currentAccess.some(
+        ({ resourceId, address }) =>
+          resourceId === access.resourceId && getAddress(address) === getAddress(access.address),
+      ),
+  );
+
+  const accessToRemove = currentAccess.filter(
+    (access) =>
+      !desiredAccess.some(
+        ({ resourceId, address }) =>
+          resourceId === access.resourceId && getAddress(address) === getAddress(access.address),
+      ),
+  );
+
+  if (accessToRemove.length) {
+    debug("revoking", accessToRemove.length, "access grants");
+  }
+  if (accessToAdd.length) {
+    debug("adding", accessToAdd.length, "access grants");
+  }
+
+  const accessTxs = await Promise.all([
+    ...accessToRemove.map((access) =>
+      pRetry(
+        () =>
+          writeContract(client, {
+            chain: client.chain ?? null,
+            address: worldDeploy.address,
+            abi: worldAbi,
+            functionName: "revokeAccess",
+            args: [access.resourceId, access.address],
+          }),
+        {
+          retries: 3,
+          onFailedAttempt: async (error) => {
+            const delay = error.attemptNumber * 500;
+            debug(`failed to revoke access, retrying in ${delay}ms...`);
+            await wait(delay);
+          },
+        },
+      ),
+    ),
+    ...accessToAdd.map((access) =>
+      pRetry(
+        () =>
+          writeContract(client, {
+            chain: client.chain ?? null,
+            address: worldDeploy.address,
+            abi: worldAbi,
+            functionName: "grantAccess",
+            args: [access.resourceId, access.address],
+          }),
+        {
+          retries: 3,
+          onFailedAttempt: async (error) => {
+            const delay = error.attemptNumber * 500;
+            debug(`failed to grant access, retrying in ${delay}ms...`);
+            await wait(delay);
+          },
+        },
+      ),
+    ),
+  ]);
+
+  return [...registerTxs, ...accessTxs];
+}

package/src/deploy/ensureTables.ts

@@ -0,0 +1,64 @@
+import { Client, Transport, Chain, Account, Hex } from "viem";
+import { Table } from "./configToTables";
+import { resourceToLabel, writeContract } from "@latticexyz/common";
+import { WorldDeploy, worldAbi } from "./common";
+import { valueSchemaToFieldLayoutHex, keySchemaToHex, valueSchemaToHex } from "@latticexyz/protocol-parser/internal";
+import { debug } from "./debug";
+import { getTables } from "./getTables";
+import pRetry from "p-retry";
+import { wait } from "@latticexyz/common/utils";
+
+export async function ensureTables({
+  client,
+  worldDeploy,
+  tables,
+}: {
+  readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly worldDeploy: WorldDeploy;
+  readonly tables: readonly Table[];
+}): Promise<readonly Hex[]> {
+  const worldTables = await getTables({ client, worldDeploy });
+  const worldTableIds = worldTables.map((table) => table.tableId);
+
+  const existingTables = tables.filter((table) => worldTableIds.includes(table.tableId));
+  if (existingTables.length) {
+    debug("existing tables", existingTables.map(resourceToLabel).join(", "));
+  }
+
+  const missingTables = tables.filter((table) => !worldTableIds.includes(table.tableId));
+  if (missingTables.length) {
+    debug("registering tables", missingTables.map(resourceToLabel).join(", "));
+    return await Promise.all(
+      missingTables.map((table) =>
+        pRetry(
+          () =>
+            writeContract(client, {
+              chain: client.chain ?? null,
+              address: worldDeploy.address,
+              abi: worldAbi,
+              // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+              functionName: "registerTable",
+              args: [
+                table.tableId,
+                valueSchemaToFieldLayoutHex(table.valueSchema),
+                keySchemaToHex(table.keySchema),
+                valueSchemaToHex(table.valueSchema),
+                Object.keys(table.keySchema),
+                Object.keys(table.valueSchema),
+              ],
+            }),
+          {
+            retries: 3,
+            onFailedAttempt: async (error) => {
+              const delay = error.attemptNumber * 500;
+              debug(`failed to register table ${resourceToLabel(table)}, retrying in ${delay}ms...`);
+              await wait(delay);
+            },
+          },
+        ),
+      ),
+    );
+  }
+
+  return [];
+}

package/src/deploy/ensureWorldFactory.ts

@@ -0,0 +1,105 @@
+import accessManagementSystemBuild from "@latticexyz/world/out/AccessManagementSystem.sol/AccessManagementSystem.json" assert { type: "json" };
+import balanceTransferSystemBuild from "@latticexyz/world/out/BalanceTransferSystem.sol/BalanceTransferSystem.json" assert { type: "json" };
+import batchCallSystemBuild from "@latticexyz/world/out/BatchCallSystem.sol/BatchCallSystem.json" assert { type: "json" };
+import registrationSystemBuild from "@latticexyz/world/out/RegistrationSystem.sol/RegistrationSystem.json" assert { type: "json" };
+import initModuleBuild from "@latticexyz/world/out/InitModule.sol/InitModule.json" assert { type: "json" };
+import initModuleAbi from "@latticexyz/world/out/InitModule.sol/InitModule.abi.json" assert { type: "json" };
+import worldFactoryBuild from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.json" assert { type: "json" };
+import worldFactoryAbi from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.abi.json" assert { type: "json" };
+import { Client, Transport, Chain, Account, Hex, getCreate2Address, encodeDeployData, size, Address } from "viem";
+import { salt } from "./common";
+import { ensureContractsDeployed } from "./ensureContractsDeployed";
+import { Contract } from "./ensureContract";
+
+export async function ensureWorldFactory(
+  client: Client<Transport, Chain | undefined, Account>,
+  deployerAddress: Hex,
+): Promise<Address> {
+  const accessManagementSystemDeployedBytecodeSize = size(accessManagementSystemBuild.deployedBytecode.object as Hex);
+  const accessManagementSystemBytecode = accessManagementSystemBuild.bytecode.object as Hex;
+  const accessManagementSystem = getCreate2Address({
+    from: deployerAddress,
+    bytecode: accessManagementSystemBytecode,
+    salt,
+  });
+
+  const balanceTransferSystemDeployedBytecodeSize = size(balanceTransferSystemBuild.deployedBytecode.object as Hex);
+  const balanceTransferSystemBytecode = balanceTransferSystemBuild.bytecode.object as Hex;
+  const balanceTransferSystem = getCreate2Address({
+    from: deployerAddress,
+    bytecode: balanceTransferSystemBytecode,
+    salt,
+  });
+
+  const batchCallSystemDeployedBytecodeSize = size(batchCallSystemBuild.deployedBytecode.object as Hex);
+  const batchCallSystemBytecode = batchCallSystemBuild.bytecode.object as Hex;
+  const batchCallSystem = getCreate2Address({ from: deployerAddress, bytecode: batchCallSystemBytecode, salt });
+
+  const registrationDeployedBytecodeSize = size(registrationSystemBuild.deployedBytecode.object as Hex);
+  const registrationBytecode = registrationSystemBuild.bytecode.object as Hex;
+  const registration = getCreate2Address({
+    from: deployerAddress,
+    bytecode: registrationBytecode,
+    salt,
+  });
+
+  const initModuleDeployedBytecodeSize = size(initModuleBuild.deployedBytecode.object as Hex);
+  const initModuleBytecode = encodeDeployData({
+    bytecode: initModuleBuild.bytecode.object as Hex,
+    abi: initModuleAbi,
+    args: [accessManagementSystem, balanceTransferSystem, batchCallSystem, registration],
+  });
+
+  const initModule = getCreate2Address({ from: deployerAddress, bytecode: initModuleBytecode, salt });
+
+  const worldFactoryDeployedBytecodeSize = size(worldFactoryBuild.deployedBytecode.object as Hex);
+  const worldFactoryBytecode = encodeDeployData({
+    bytecode: worldFactoryBuild.bytecode.object as Hex,
+    abi: worldFactoryAbi,
+    args: [initModule],
+  });
+
+  const worldFactory = getCreate2Address({ from: deployerAddress, bytecode: worldFactoryBytecode, salt });
+
+  const worldFactoryContracts: readonly Contract[] = [
+    {
+      bytecode: accessManagementSystemBytecode,
+      deployedBytecodeSize: accessManagementSystemDeployedBytecodeSize,
+      label: "access management system",
+    },
+    {
+      bytecode: balanceTransferSystemBytecode,
+      deployedBytecodeSize: balanceTransferSystemDeployedBytecodeSize,
+      label: "balance transfer system",
+    },
+    {
+      bytecode: batchCallSystemBytecode,
+      deployedBytecodeSize: batchCallSystemDeployedBytecodeSize,
+      label: "batch call system",
+    },
+    {
+      bytecode: registrationBytecode,
+      deployedBytecodeSize: registrationDeployedBytecodeSize,
+      label: "core registration system",
+    },
+    {
+      bytecode: initModuleBytecode,
+      deployedBytecodeSize: initModuleDeployedBytecodeSize,
+      label: "core module",
+    },
+    {
+      bytecode: worldFactoryBytecode,
+      deployedBytecodeSize: worldFactoryDeployedBytecodeSize,
+      label: "world factory",
+    },
+  ];
+
+  // WorldFactory constructor doesn't call InitModule, only sets its address, so we can do these in parallel since the address is deterministic
+  await ensureContractsDeployed({
+    client,
+    deployerAddress,
+    contracts: worldFactoryContracts,
+  });
+
+  return worldFactory;
+}

package/src/deploy/findLibraries.ts

@@ -0,0 +1,36 @@
+import { readFileSync } from "fs";
+import glob from "glob";
+import { orderByDependencies } from "./orderByDependencies";
+import { LinkReferences } from "../utils/findPlaceholders";
+
+export function findLibraries(forgeOutDir: string): readonly {
+  readonly path: string;
+  readonly name: string;
+}[] {
+  const artifacts = glob
+    .sync(`${forgeOutDir}/**/*.json`, { ignore: "**/*.abi.json" })
+    .map((path) => JSON.parse(readFileSync(path, "utf8")));
+
+  const libraries = artifacts.flatMap((artifact) => {
+    if (!artifact.metadata) return [];
+
+    const contractPath = Object.keys(artifact.metadata.settings.compilationTarget)[0];
+    const contractName = artifact.metadata.settings.compilationTarget[contractPath];
+    const linkReferences = artifact.bytecode.linkReferences as LinkReferences;
+
+    return Object.entries(linkReferences).flatMap(([libraryPath, reference]) =>
+      Object.keys(reference).map((libraryName) => ({
+        path: libraryPath,
+        name: libraryName,
+        dependentPath: contractPath,
+        dependentName: contractName,
+      })),
+    );
+  });
+
+  return orderByDependencies(
+    libraries,
+    (lib) => `${lib.path}:${lib.name}`,
+    (lib) => [`${lib.dependentPath}:${lib.dependentName}`],
+  );
+}

package/src/deploy/getFunctions.ts

@@ -0,0 +1,58 @@
+import { Client, toFunctionSelector, parseAbiItem } from "viem";
+import { WorldDeploy, WorldFunction, worldTables } from "./common";
+import { debug } from "./debug";
+import { storeSetRecordEvent } from "@latticexyz/store";
+import { getLogs } from "viem/actions";
+import { decodeValueArgs } from "@latticexyz/protocol-parser/internal";
+import { getTableValue } from "./getTableValue";
+import { hexToResource } from "@latticexyz/common";
+
+export async function getFunctions({
+  client,
+  worldDeploy,
+}: {
+  readonly client: Client;
+  readonly worldDeploy: WorldDeploy;
+}): Promise<readonly WorldFunction[]> {
+  // This assumes we only use `FunctionSelectors._set(...)`, which is true as of this writing.
+  debug("looking up function signatures for", worldDeploy.address);
+  const logs = await getLogs(client, {
+    strict: true,
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    event: parseAbiItem(storeSetRecordEvent),
+    args: { tableId: worldTables.world_FunctionSignatures.tableId },
+  });
+
+  const signatures = logs.map((log) => {
+    const value = decodeValueArgs(worldTables.world_FunctionSignatures.valueSchema, log.args);
+    return value.functionSignature;
+  });
+  debug("found", signatures.length, "function signatures for", worldDeploy.address);
+
+  // TODO: parallelize with a bulk getRecords
+  const functions = await Promise.all(
+    signatures.map(async (signature) => {
+      const selector = toFunctionSelector(signature);
+      const { systemId, systemFunctionSelector } = await getTableValue({
+        client,
+        worldDeploy,
+        table: worldTables.world_FunctionSelectors,
+        key: { worldFunctionSelector: selector },
+      });
+      const { namespace, name } = hexToResource(systemId);
+      // TODO: find away around undoing contract logic (https://github.com/latticexyz/mud/issues/1708)
+      const systemFunctionSignature = namespace === "" ? signature : signature.replace(`${namespace}_${name}_`, "");
+      return {
+        signature,
+        selector,
+        systemId,
+        systemFunctionSignature,
+        systemFunctionSelector,
+      };
+    }),
+  );
+
+  return functions;
+}

package/src/deploy/getResourceAccess.ts

@@ -0,0 +1,51 @@
+import { Client, parseAbiItem, Hex, Address, getAddress } from "viem";
+import { WorldDeploy, worldTables } from "./common";
+import { debug } from "./debug";
+import { storeSpliceStaticDataEvent } from "@latticexyz/store";
+import { getLogs } from "viem/actions";
+import { decodeKey } from "@latticexyz/protocol-parser/internal";
+import { getTableValue } from "./getTableValue";
+
+export async function getResourceAccess({
+  client,
+  worldDeploy,
+}: {
+  readonly client: Client;
+  readonly worldDeploy: WorldDeploy;
+}): Promise<readonly { readonly resourceId: Hex; readonly address: Address }[]> {
+  // This assumes we only use `ResourceAccess._set(...)`, which is true as of this writing.
+  // TODO: PR to viem's getLogs to accept topics array so we can filter on all store events and quickly recreate this table's current state
+
+  debug("looking up resource access for", worldDeploy.address);
+
+  const logs = await getLogs(client, {
+    strict: true,
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    // our usage of `ResourceAccess._set(...)` emits a splice instead of set record
+    // TODO: https://github.com/latticexyz/mud/issues/479
+    event: parseAbiItem(storeSpliceStaticDataEvent),
+    args: { tableId: worldTables.world_ResourceAccess.tableId },
+  });
+
+  const keys = logs.map((log) => decodeKey(worldTables.world_ResourceAccess.keySchema, log.args.keyTuple));
+
+  const access = (
+    await Promise.all(
+      keys.map(
+        async (key) =>
+          [key, await getTableValue({ client, worldDeploy, table: worldTables.world_ResourceAccess, key })] as const,
+      ),
+    )
+  )
+    .filter(([, value]) => value.access)
+    .map(([key]) => ({
+      resourceId: key.resourceId,
+      address: getAddress(key.caller),
+    }));
+
+  debug("found", access.length, "resource<>address access pairs");
+
+  return access;
+}

package/src/deploy/getResourceIds.ts

@@ -0,0 +1,31 @@
+import { Client, parseAbiItem, Hex } from "viem";
+import { getLogs } from "viem/actions";
+import { storeSpliceStaticDataEvent } from "@latticexyz/store";
+import { WorldDeploy, storeTables } from "./common";
+import { debug } from "./debug";
+
+export async function getResourceIds({
+  client,
+  worldDeploy,
+}: {
+  readonly client: Client;
+  readonly worldDeploy: WorldDeploy;
+}): Promise<readonly Hex[]> {
+  // This assumes we only use `ResourceIds._setExists(true)`, which is true as of this writing.
+  // TODO: PR to viem's getLogs to accept topics array so we can filter on all store events and quickly recreate this table's current state
+
+  debug("looking up resource IDs for", worldDeploy.address);
+  const logs = await getLogs(client, {
+    strict: true,
+    address: worldDeploy.address,
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock,
+    event: parseAbiItem(storeSpliceStaticDataEvent),
+    args: { tableId: storeTables.store_ResourceIds.tableId },
+  });
+
+  const resourceIds = logs.map((log) => log.args.keyTuple[0]);
+  debug("found", resourceIds.length, "resource IDs for", worldDeploy.address);
+
+  return resourceIds;
+}

package/src/deploy/getSystems.ts

@@ -0,0 +1,47 @@
+import { DeployedSystem, WorldDeploy, worldTables } from "./common";
+import { Client } from "viem";
+import { getResourceIds } from "./getResourceIds";
+import { hexToResource, resourceToLabel } from "@latticexyz/common";
+import { getTableValue } from "./getTableValue";
+import { debug } from "./debug";
+import { getFunctions } from "./getFunctions";
+import { getResourceAccess } from "./getResourceAccess";
+
+export async function getSystems({
+  client,
+  worldDeploy,
+}: {
+  readonly client: Client;
+  readonly worldDeploy: WorldDeploy;
+}): Promise<readonly DeployedSystem[]> {
+  const [resourceIds, functions, resourceAccess] = await Promise.all([
+    getResourceIds({ client, worldDeploy }),
+    getFunctions({ client, worldDeploy }),
+    getResourceAccess({ client, worldDeploy }),
+  ]);
+  const systems = resourceIds.map(hexToResource).filter((resource) => resource.type === "system");
+
+  debug("looking up systems", systems.map(resourceToLabel).join(", "));
+  return await Promise.all(
+    systems.map(async (system): Promise<DeployedSystem> => {
+      const { system: address, publicAccess } = await getTableValue({
+        client,
+        worldDeploy,
+        table: worldTables.world_Systems,
+        key: { systemId: system.resourceId },
+      });
+      const systemFunctions = functions.filter((func) => func.systemId === system.resourceId);
+      return {
+        address,
+        namespace: system.namespace,
+        name: system.name,
+        systemId: system.resourceId,
+        allowAll: publicAccess,
+        allowedAddresses: resourceAccess
+          .filter(({ resourceId }) => resourceId === system.resourceId)
+          .map(({ address }) => address),
+        functions: systemFunctions,
+      };
+    }),
+  );
+}

package/src/deploy/getTableValue.ts

@@ -0,0 +1,30 @@
+import { SchemaToPrimitives, decodeValueArgs, encodeKey } from "@latticexyz/protocol-parser/internal";
+import { WorldDeploy, worldAbi } from "./common";
+import { Client } from "viem";
+import { readContract } from "viem/actions";
+import { Table } from "./configToTables";
+
+export async function getTableValue<table extends Table>({
+  client,
+  worldDeploy,
+  table,
+  key,
+}: {
+  readonly client: Client;
+  readonly worldDeploy: WorldDeploy;
+  readonly table: table;
+  readonly key: SchemaToPrimitives<table["keySchema"]>;
+}): Promise<SchemaToPrimitives<table["valueSchema"]>> {
+  const [staticData, encodedLengths, dynamicData] = await readContract(client, {
+    blockNumber: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    abi: worldAbi,
+    functionName: "getRecord",
+    args: [table.tableId, encodeKey(table.keySchema, key)],
+  });
+  return decodeValueArgs(table.valueSchema, {
+    staticData,
+    encodedLengths,
+    dynamicData,
+  });
+}

package/src/deploy/getTables.ts

@@ -0,0 +1,59 @@
+import { Client, parseAbiItem, decodeAbiParameters, parseAbiParameters } from "viem";
+import { Table } from "./configToTables";
+import { hexToResource } from "@latticexyz/common";
+import { WorldDeploy, storeTables } from "./common";
+import { debug } from "./debug";
+import { storeSetRecordEvent } from "@latticexyz/store";
+import { getLogs } from "viem/actions";
+import { KeySchema, ValueSchema, decodeKey, decodeValueArgs, hexToSchema } from "@latticexyz/protocol-parser/internal";
+
+export async function getTables({
+  client,
+  worldDeploy,
+}: {
+  readonly client: Client;
+  readonly worldDeploy: WorldDeploy;
+}): Promise<readonly Table[]> {
+  // This assumes we only use `Tables._set(...)`, which is true as of this writing.
+  // TODO: PR to viem's getLogs to accept topics array so we can filter on all store events and quickly recreate this table's current state
+  // TODO: consider moving this to a batched getRecord for Tables table
+
+  debug("looking up tables for", worldDeploy.address);
+  const logs = await getLogs(client, {
+    strict: true,
+    // this may fail for certain RPC providers with block range limits
+    // if so, could potentially use our fetchLogs helper (which does pagination)
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    event: parseAbiItem(storeSetRecordEvent),
+    args: { tableId: storeTables.store_Tables.tableId },
+  });
+
+  // TODO: combine with store-sync logToTable and export from somewhere
+  const tables = logs.map((log) => {
+    const { tableId } = decodeKey(storeTables.store_Tables.keySchema, log.args.keyTuple);
+    const { namespace, name } = hexToResource(tableId);
+    const value = decodeValueArgs(storeTables.store_Tables.valueSchema, log.args);
+
+    // TODO: migrate to better helper
+    const keySchemaFields = hexToSchema(value.keySchema);
+    const valueSchemaFields = hexToSchema(value.valueSchema);
+    const keyNames = decodeAbiParameters(parseAbiParameters("string[]"), value.abiEncodedKeyNames)[0];
+    const fieldNames = decodeAbiParameters(parseAbiParameters("string[]"), value.abiEncodedFieldNames)[0];
+
+    const valueAbiTypes = [...valueSchemaFields.staticFields, ...valueSchemaFields.dynamicFields];
+
+    const keySchema = Object.fromEntries(
+      keySchemaFields.staticFields.map((abiType, i) => [keyNames[i], abiType]),
+    ) as KeySchema;
+    const valueSchema = Object.fromEntries(valueAbiTypes.map((abiType, i) => [fieldNames[i], abiType])) as ValueSchema;
+
+    return { namespace, name, tableId, keySchema, valueSchema } as const;
+  });
+  // TODO: filter/detect duplicates?
+
+  debug("found", tables.length, "tables for", worldDeploy.address);
+
+  return tables;
+}