@latticexyz/cli 2.0.0-main-e241c056 → 2.0.0-main-29c3f508

package/src/deploy/deploy.ts

@@ -0,0 +1,84 @@
+import { Account, Address, Chain, Client, Transport } from "viem";
+import { ensureDeployer } from "./ensureDeployer";
+import { deployWorld } from "./deployWorld";
+import { ensureTables } from "./ensureTables";
+import { Config, ConfigInput, WorldDeploy, supportedStoreVersions, supportedWorldVersions } from "./common";
+import { ensureSystems } from "./ensureSystems";
+import { waitForTransactionReceipt } from "viem/actions";
+import { getWorldDeploy } from "./getWorldDeploy";
+import { ensureFunctions } from "./ensureFunctions";
+import { ensureModules } from "./ensureModules";
+import { Table } from "./configToTables";
+import { getResourceIds } from "./getResourceIds";
+import { assertNamespaceOwner } from "./assertNamespaceOwner";
+
+type DeployOptions<configInput extends ConfigInput> = {
+  client: Client<Transport, Chain | undefined, Account>;
+  config: Config<configInput>;
+  worldAddress?: Address;
+};
+
+/**
+ * Given a viem client and MUD config, we attempt to introspect the world
+ * (or deploy a new one if no world address is provided) and do the minimal
+ * amount of work to make the world match the config (e.g. deploy new tables,
+ * replace systems, etc.)
+ */
+export async function deploy<configInput extends ConfigInput>({
+  client,
+  config,
+  worldAddress: existingWorldAddress,
+}: DeployOptions<configInput>): Promise<WorldDeploy> {
+  await ensureDeployer(client);
+
+  const worldDeploy = existingWorldAddress
+    ? await getWorldDeploy(client, existingWorldAddress)
+    : await deployWorld(client);
+
+  if (!supportedStoreVersions.includes(worldDeploy.storeVersion)) {
+    throw new Error(`Unsupported Store version: ${worldDeploy.storeVersion}`);
+  }
+  if (!supportedWorldVersions.includes(worldDeploy.worldVersion)) {
+    throw new Error(`Unsupported World version: ${worldDeploy.worldVersion}`);
+  }
+
+  const tables = Object.values(config.tables) as Table[];
+  const systems = Object.values(config.systems);
+
+  await assertNamespaceOwner({
+    client,
+    worldDeploy,
+    resourceIds: [...tables.map((table) => table.tableId), ...systems.map((system) => system.systemId)],
+  });
+
+  const tableTxs = await ensureTables({
+    client,
+    worldDeploy,
+    tables,
+  });
+  const systemTxs = await ensureSystems({
+    client,
+    worldDeploy,
+    systems,
+  });
+  const functionTxs = await ensureFunctions({
+    client,
+    worldDeploy,
+    functions: systems.flatMap((system) => system.functions),
+  });
+  const moduleTxs = await ensureModules({
+    client,
+    worldDeploy,
+    modules: config.modules,
+  });
+
+  const receipts = await Promise.all(
+    [...tableTxs, ...systemTxs, ...functionTxs, ...moduleTxs].map((tx) =>
+      waitForTransactionReceipt(client, { hash: tx })
+    )
+  );
+
+  // TODO: throw if there was a revert? or attempt to re-run deploy?
+
+  return worldDeploy;
+}

package/src/deploy/deployWorld.ts

@@ -0,0 +1,33 @@
+import { Account, Chain, Client, Log, Transport } from "viem";
+import { waitForTransactionReceipt } from "viem/actions";
+import { ensureWorldFactory, worldFactory } from "./ensureWorldFactory";
+import WorldFactoryAbi from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.abi.json" assert { type: "json" };
+import { writeContract } from "@latticexyz/common";
+import { debug } from "./debug";
+import { logsToWorldDeploy } from "./logsToWorldDeploy";
+import { WorldDeploy } from "./common";
+
+export async function deployWorld(client: Client<Transport, Chain | undefined, Account>): Promise<WorldDeploy> {
+  await ensureWorldFactory(client);
+
+  debug("deploying world");
+  const tx = await writeContract(client, {
+    chain: client.chain ?? null,
+    address: worldFactory,
+    abi: WorldFactoryAbi,
+    functionName: "deployWorld",
+  });
+
+  debug("waiting for world deploy");
+  const receipt = await waitForTransactionReceipt(client, { hash: tx });
+  if (receipt.status !== "success") {
+    console.error("world deploy failed", receipt);
+    throw new Error("world deploy failed");
+  }
+
+  // TODO: remove type casting once https://github.com/wagmi-dev/viem/pull/1330 is merged
+  const deploy = logsToWorldDeploy(receipt.logs.map((log) => log as Log<bigint, number, false>));
+  debug("deployed world to", deploy.address, "at block", deploy.deployBlock);
+
+  return { ...deploy, stateBlock: deploy.deployBlock };
+}

package/src/deploy/ensureContract.ts

@@ -0,0 +1,33 @@
+import { Client, Transport, Chain, Account, concatHex, getCreate2Address, Hex } from "viem";
+import { getBytecode } from "viem/actions";
+import { deployer } from "./ensureDeployer";
+import { salt } from "./common";
+import { sendTransaction } from "@latticexyz/common";
+import { debug } from "./debug";
+
+export async function ensureContract({
+  client,
+  bytecode,
+  label = "contract",
+}: {
+  readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly bytecode: Hex;
+  readonly label?: string;
+}): Promise<readonly Hex[]> {
+  const address = getCreate2Address({ from: deployer, salt, bytecode });
+
+  const contractCode = await getBytecode(client, { address, blockTag: "pending" });
+  if (contractCode) {
+    debug("found", label, "at", address);
+    return [];
+  }
+
+  debug("deploying", label, "at", address);
+  return [
+    await sendTransaction(client, {
+      chain: client.chain ?? null,
+      to: deployer,
+      data: concatHex([salt, bytecode]),
+    }),
+  ];
+}

package/src/deploy/ensureDeployer.ts

@@ -0,0 +1,36 @@
+import { Account, Chain, Client, Transport } from "viem";
+import { getBytecode, sendRawTransaction, sendTransaction, waitForTransactionReceipt } from "viem/actions";
+import deployment from "./create2/deployment.json";
+import { debug } from "./debug";
+
+export const deployer = `0x${deployment.address}` as const;
+
+export async function ensureDeployer(client: Client<Transport, Chain | undefined, Account>): Promise<void> {
+  const bytecode = await getBytecode(client, { address: deployer });
+  if (bytecode) {
+    debug("found create2 deployer at", deployer);
+    return;
+  }
+
+  // send gas to signer
+  debug("sending gas for create2 deployer to signer at", deployment.signerAddress);
+  const gasTx = await sendTransaction(client, {
+    chain: client.chain ?? null,
+    to: `0x${deployment.signerAddress}`,
+    value: BigInt(deployment.gasLimit) * BigInt(deployment.gasPrice),
+  });
+  const gasReceipt = await waitForTransactionReceipt(client, { hash: gasTx });
+  if (gasReceipt.status !== "success") {
+    console.error("failed to send gas to deployer signer", gasReceipt);
+    throw new Error("failed to send gas to deployer signer");
+  }
+
+  // deploy the deployer
+  debug("deploying create2 deployer at", deployer);
+  const deployTx = await sendRawTransaction(client, { serializedTransaction: `0x${deployment.transaction}` });
+  const deployReceipt = await waitForTransactionReceipt(client, { hash: deployTx });
+  if (deployReceipt.contractAddress !== deployer) {
+    console.error("unexpected contract address for deployer", deployReceipt);
+    throw new Error("unexpected contract address for deployer");
+  }
+}

package/src/deploy/ensureFunctions.ts

@@ -0,0 +1,62 @@
+import { Client, Transport, Chain, Account, Hex } from "viem";
+import { hexToResource, writeContract } from "@latticexyz/common";
+import { WorldDeploy, WorldFunction, worldAbi } from "./common";
+import { debug } from "./debug";
+import { getFunctions } from "./getFunctions";
+
+export async function ensureFunctions({
+  client,
+  worldDeploy,
+  functions,
+}: {
+  readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly worldDeploy: WorldDeploy;
+  readonly functions: readonly WorldFunction[];
+}): Promise<readonly Hex[]> {
+  const worldFunctions = await getFunctions({ client, worldDeploy });
+  const worldSelectorToFunction = Object.fromEntries(worldFunctions.map((func) => [func.selector, func]));
+
+  const toSkip = functions.filter((func) => worldSelectorToFunction[func.selector]);
+  const toAdd = functions.filter((func) => !toSkip.includes(func));
+
+  if (toSkip.length) {
+    debug("functions already registered:", toSkip.map((func) => func.signature).join(", "));
+    const wrongSystem = toSkip.filter((func) => func.systemId !== worldSelectorToFunction[func.selector]?.systemId);
+    if (wrongSystem.length) {
+      console.warn(
+        "found",
+        wrongSystem.length,
+        "functions already registered but pointing at a different system ID:",
+        wrongSystem.map((func) => func.signature).join(", ")
+      );
+    }
+  }
+
+  if (!toAdd.length) return [];
+
+  debug("registering functions:", toAdd.map((func) => func.signature).join(", "));
+
+  return Promise.all(
+    toAdd.map((func) => {
+      const { namespace } = hexToResource(func.systemId);
+      if (namespace === "") {
+        return writeContract(client, {
+          chain: client.chain ?? null,
+          address: worldDeploy.address,
+          abi: worldAbi,
+          // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+          functionName: "registerRootFunctionSelector",
+          args: [func.systemId, func.systemFunctionSignature, func.systemFunctionSelector],
+        });
+      }
+      return writeContract(client, {
+        chain: client.chain ?? null,
+        address: worldDeploy.address,
+        abi: worldAbi,
+        // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+        functionName: "registerFunctionSelector",
+        args: [func.systemId, func.systemFunctionSignature],
+      });
+    })
+  );
+}

package/src/deploy/ensureModules.ts

@@ -0,0 +1,48 @@
+import { Client, Transport, Chain, Account, Hex } from "viem";
+import { writeContract } from "@latticexyz/common";
+import { Module, WorldDeploy, worldAbi } from "./common";
+import { ensureContract } from "./ensureContract";
+import { debug } from "./debug";
+
+export async function ensureModules({
+  client,
+  worldDeploy,
+  modules,
+}: {
+  readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly worldDeploy: WorldDeploy;
+  readonly modules: readonly Module[];
+}): Promise<readonly Hex[]> {
+  if (!modules.length) return [];
+
+  // kick off contract deployments first, otherwise installing modules can fail
+  const contractTxs = await Promise.all(
+    modules.map((mod) => ensureContract({ client, bytecode: mod.bytecode, label: `${mod.name} module` }))
+  );
+
+  // then start installing modules
+  debug("installing modules:", modules.map((mod) => mod.name).join(", "));
+  const installTxs = await Promise.all(
+    modules.map((mod) =>
+      mod.installAsRoot
+        ? writeContract(client, {
+            chain: client.chain ?? null,
+            address: worldDeploy.address,
+            abi: worldAbi,
+            // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+            functionName: "installRootModule",
+            args: [mod.address, mod.installData],
+          })
+        : writeContract(client, {
+            chain: client.chain ?? null,
+            address: worldDeploy.address,
+            abi: worldAbi,
+            // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+            functionName: "installModule",
+            args: [mod.address, mod.installData],
+          })
+    )
+  );
+
+  return (await Promise.all([...contractTxs, ...installTxs])).flat();
+}

package/src/deploy/ensureSystems.ts

@@ -0,0 +1,128 @@
+import { Client, Transport, Chain, Account, Hex, getAddress } from "viem";
+import { writeContract } from "@latticexyz/common";
+import { System, WorldDeploy, worldAbi } from "./common";
+import { ensureContract } from "./ensureContract";
+import { debug } from "./debug";
+import { resourceLabel } from "./resourceLabel";
+import { getSystems } from "./getSystems";
+import { getResourceAccess } from "./getResourceAccess";
+
+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 = await Promise.all([
+    ...accessToRemove.map((access) =>
+      writeContract(client, {
+        chain: client.chain ?? null,
+        address: worldDeploy.address,
+        abi: worldAbi,
+        functionName: "revokeAccess",
+        args: [access.resourceId, access.address],
+      })
+    ),
+    ...accessToAdd.map((access) =>
+      writeContract(client, {
+        chain: client.chain ?? null,
+        address: worldDeploy.address,
+        abi: worldAbi,
+        functionName: "grantAccess",
+        args: [access.resourceId, access.address],
+      })
+    ),
+  ]);
+
+  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(", "));
+  }
+
+  // kick off contract deployments first, otherwise registering systems can fail
+  const contractTxs = await Promise.all(
+    missingSystems.map((system) =>
+      ensureContract({ client, bytecode: system.bytecode, label: `${resourceLabel(system)} system` })
+    )
+  );
+
+  // then start registering systems
+  const registerTxs = await Promise.all(
+    missingSystems.map((system) =>
+      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],
+      })
+    )
+  );
+
+  return (await Promise.all([...accessTxs, ...contractTxs, ...registerTxs])).flat();
+}

package/src/deploy/ensureTables.ts

@@ -0,0 +1,52 @@
+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";
+
+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) =>
+        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),
+          ],
+        })
+      )
+    );
+  }
+
+  return [];
+}

package/src/deploy/ensureWorldFactory.ts

@@ -0,0 +1,33 @@
+import coreModuleBuild from "@latticexyz/world/out/CoreModule.sol/CoreModule.json" assert { type: "json" };
+import worldFactoryBuild from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.json" assert { type: "json" };
+import { Client, Transport, Chain, Account, Hex, parseAbi, getCreate2Address, encodeDeployData } from "viem";
+import { ensureContract } from "./ensureContract";
+import { deployer } from "./ensureDeployer";
+import { salt } from "./common";
+
+const coreModuleBytecode = encodeDeployData({
+  bytecode: coreModuleBuild.bytecode.object as Hex,
+  abi: [],
+});
+
+const coreModule = getCreate2Address({ from: deployer, bytecode: coreModuleBytecode, salt });
+
+const worldFactoryBytecode = encodeDeployData({
+  bytecode: worldFactoryBuild.bytecode.object as Hex,
+  abi: parseAbi(["constructor(address)"]),
+  args: [coreModule],
+});
+
+export const worldFactory = getCreate2Address({ from: deployer, bytecode: worldFactoryBytecode, salt });
+
+export async function ensureWorldFactory(
+  client: Client<Transport, Chain | undefined, Account>
+): Promise<readonly Hex[]> {
+  // WorldFactory constructor doesn't call CoreModule, only sets its address, so we can do these in parallel since the address is deterministic
+  return (
+    await Promise.all([
+      ensureContract({ client, bytecode: coreModuleBytecode, label: "core module" }),
+      ensureContract({ client, bytecode: worldFactoryBytecode, label: "world factory" }),
+    ])
+  ).flat();
+}

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;
+}