@latticexyz/cli 2.0.0-snapshot-test-32d38619 → 2.0.0-transaction-context-af4b168c

package/src/deploy/ensureSystems.ts

@@ -0,0 +1,162 @@
+import { Client, Transport, Chain, Account, Hex, getAddress } from "viem";
+import { writeContract } from "@latticexyz/common";
+import { System, WorldDeploy, worldAbi } from "./common";
+import { debug } from "./debug";
+import { resourceLabel } from "./resourceLabel";
+import { getSystems } from "./getSystems";
+import { getResourceAccess } from "./getResourceAccess";
+import { uniqueBy, wait } from "@latticexyz/common/utils";
+import pRetry from "p-retry";
+import { ensureContractsDeployed } from "./ensureContractsDeployed";
+
+export async function ensureSystems({
+  client,
+  worldDeploy,
+  systems,
+}: {
+  readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly worldDeploy: WorldDeploy;
+  readonly systems: readonly System[];
+}): Promise<readonly Hex[]> {
+  const [worldSystems, worldAccess] = await Promise.all([
+    getSystems({ client, worldDeploy }),
+    getResourceAccess({ client, worldDeploy }),
+  ]);
+  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 }))
+  );
+
+  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)
+      )
+  );
+
+  // TODO: move each system access+registration to batch call to be atomic
+
+  if (accessToRemove.length) {
+    debug("revoking", accessToRemove.length, "access grants");
+  }
+  if (accessToAdd.length) {
+    debug("adding", accessToAdd.length, "access grants");
+  }
+
+  const accessTxs = [
+    ...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);
+          },
+        }
+      )
+    ),
+  ];
+
+  const existingSystems = systems.filter((system) =>
+    worldSystems.some(
+      (worldSystem) =>
+        worldSystem.systemId === system.systemId && getAddress(worldSystem.address) === getAddress(system.address)
+    )
+  );
+  if (existingSystems.length) {
+    debug("existing systems", existingSystems.map(resourceLabel).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.address)
+    )
+  );
+  if (systemsToUpgrade.length) {
+    debug("upgrading systems", systemsToUpgrade.map(resourceLabel).join(", "));
+  }
+
+  const systemsToAdd = missingSystems.filter(
+    (system) => !worldSystems.some((worldSystem) => worldSystem.systemId === system.systemId)
+  );
+  if (systemsToAdd.length) {
+    debug("registering new systems", systemsToAdd.map(resourceLabel).join(", "));
+  }
+
+  await ensureContractsDeployed({
+    client,
+    contracts: uniqueBy(missingSystems, (system) => getAddress(system.address)).map((system) => ({
+      bytecode: system.bytecode,
+      deployedBytecodeSize: system.deployedBytecodeSize,
+      label: `${resourceLabel(system)} system`,
+    })),
+  });
+
+  const registerTxs = 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.address, system.allowAll],
+        }),
+      {
+        retries: 3,
+        onFailedAttempt: async (error) => {
+          const delay = error.attemptNumber * 500;
+          debug(`failed to register system ${resourceLabel(system)}, retrying in ${delay}ms...`);
+          await wait(delay);
+        },
+      }
+    )
+  );
+
+  return await Promise.all([...accessTxs, ...registerTxs]);
+}

package/src/deploy/ensureTables.ts

@@ -0,0 +1,65 @@
+import { Client, Transport, Chain, Account, Hex } from "viem";
+import { Table } from "./configToTables";
+import { writeContract } from "@latticexyz/common";
+import { WorldDeploy, worldAbi } from "./common";
+import { valueSchemaToFieldLayoutHex, keySchemaToHex, valueSchemaToHex } from "@latticexyz/protocol-parser";
+import { debug } from "./debug";
+import { resourceLabel } from "./resourceLabel";
+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(resourceLabel).join(", "));
+  }
+
+  const missingTables = tables.filter((table) => !worldTableIds.includes(table.tableId));
+  if (missingTables.length) {
+    debug("registering tables", missingTables.map(resourceLabel).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 ${resourceLabel(table)}, retrying in ${delay}ms...`);
+              await wait(delay);
+            },
+          }
+        )
+      )
+    );
+  }
+
+  return [];
+}

package/src/deploy/ensureWorldFactory.ts

@@ -0,0 +1,118 @@
+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 } from "viem";
+import { deployer } from "./ensureDeployer";
+import { salt } from "./common";
+import { ensureContractsDeployed } from "./ensureContractsDeployed";
+import { Contract } from "./ensureContract";
+
+export const accessManagementSystemDeployedBytecodeSize = size(
+  accessManagementSystemBuild.deployedBytecode.object as Hex
+);
+export const accessManagementSystemBytecode = encodeDeployData({
+  bytecode: accessManagementSystemBuild.bytecode.object as Hex,
+  abi: [],
+});
+export const accessManagementSystem = getCreate2Address({
+  from: deployer,
+  bytecode: accessManagementSystemBytecode,
+  salt,
+});
+
+export const balanceTransferSystemDeployedBytecodeSize = size(
+  balanceTransferSystemBuild.deployedBytecode.object as Hex
+);
+export const balanceTransferSystemBytecode = encodeDeployData({
+  bytecode: balanceTransferSystemBuild.bytecode.object as Hex,
+  abi: [],
+});
+export const balanceTransferSystem = getCreate2Address({
+  from: deployer,
+  bytecode: balanceTransferSystemBytecode,
+  salt,
+});
+
+export const batchCallSystemDeployedBytecodeSize = size(batchCallSystemBuild.deployedBytecode.object as Hex);
+export const batchCallSystemBytecode = encodeDeployData({
+  bytecode: batchCallSystemBuild.bytecode.object as Hex,
+  abi: [],
+});
+export const batchCallSystem = getCreate2Address({ from: deployer, bytecode: batchCallSystemBytecode, salt });
+
+export const registrationDeployedBytecodeSize = size(registrationSystemBuild.deployedBytecode.object as Hex);
+export const registrationBytecode = encodeDeployData({
+  bytecode: registrationSystemBuild.bytecode.object as Hex,
+  abi: [],
+});
+export const registration = getCreate2Address({
+  from: deployer,
+  bytecode: registrationBytecode,
+  salt,
+});
+
+export const initModuleDeployedBytecodeSize = size(initModuleBuild.deployedBytecode.object as Hex);
+export const initModuleBytecode = encodeDeployData({
+  bytecode: initModuleBuild.bytecode.object as Hex,
+  abi: initModuleAbi,
+  args: [accessManagementSystem, balanceTransferSystem, batchCallSystem, registration],
+});
+
+export const initModule = getCreate2Address({ from: deployer, bytecode: initModuleBytecode, salt });
+
+export const worldFactoryDeployedBytecodeSize = size(worldFactoryBuild.deployedBytecode.object as Hex);
+export const worldFactoryBytecode = encodeDeployData({
+  bytecode: worldFactoryBuild.bytecode.object as Hex,
+  abi: worldFactoryAbi,
+  args: [initModule],
+});
+
+export const worldFactory = getCreate2Address({ from: deployer, bytecode: worldFactoryBytecode, salt });
+
+export 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",
+  },
+];
+
+export async function ensureWorldFactory(
+  client: Client<Transport, Chain | undefined, Account>
+): Promise<readonly Hex[]> {
+  // WorldFactory constructor doesn't call InitModule, only sets its address, so we can do these in parallel since the address is deterministic
+  return await ensureContractsDeployed({
+    client,
+    contracts: worldFactoryContracts,
+  });
+}

package/src/deploy/getFunctions.ts

@@ -0,0 +1,58 @@
+import { Client, getFunctionSelector, 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";
+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 = getFunctionSelector(signature);
+      const { systemId, systemFunctionSelector } = await getTableValue({
+        client,
+        worldDeploy,
+        table: worldTables.world_FunctionSelectors,
+        key: { functionSelector: 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";
+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,48 @@
+import { System, WorldDeploy, worldTables } from "./common";
+import { Client } from "viem";
+import { getResourceIds } from "./getResourceIds";
+import { hexToResource } from "@latticexyz/common";
+import { getTableValue } from "./getTableValue";
+import { debug } from "./debug";
+import { resourceLabel } from "./resourceLabel";
+import { getFunctions } from "./getFunctions";
+import { getResourceAccess } from "./getResourceAccess";
+
+export async function getSystems({
+  client,
+  worldDeploy,
+}: {
+  readonly client: Client;
+  readonly worldDeploy: WorldDeploy;
+}): Promise<readonly Omit<System, "abi" | "bytecode" | "deployedBytecodeSize">[]> {
+  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(resourceLabel).join(", "));
+  return await Promise.all(
+    systems.map(async (system) => {
+      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";
+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";
+
+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;
+}

package/src/deploy/getWorldDeploy.ts

@@ -0,0 +1,39 @@
+import { Client, Address, getAddress, parseAbi } from "viem";
+import { getBlockNumber, getLogs } from "viem/actions";
+import { WorldDeploy, worldDeployEvents } from "./common";
+import { debug } from "./debug";
+import { logsToWorldDeploy } from "./logsToWorldDeploy";
+
+const deploys = new Map<Address, WorldDeploy>();
+
+export async function getWorldDeploy(client: Client, worldAddress: Address): Promise<WorldDeploy> {
+  const address = getAddress(worldAddress);
+
+  let deploy = deploys.get(address);
+  if (deploy != null) {
+    return deploy;
+  }
+
+  debug("looking up world deploy for", address);
+
+  const stateBlock = await getBlockNumber(client);
+  const logs = await getLogs(client, {
+    strict: true,
+    address,
+    events: parseAbi(worldDeployEvents),
+    // this may fail for certain RPC providers with block range limits
+    // if so, could potentially use our fetchLogs helper (which does pagination)
+    fromBlock: "earliest",
+    toBlock: stateBlock,
+  });
+
+  deploy = {
+    ...logsToWorldDeploy(logs),
+    stateBlock,
+  };
+  deploys.set(address, deploy);
+
+  debug("found world deploy for", address, "at block", deploy.deployBlock);
+
+  return deploy;
+}