@latticexyz/cli 2.0.0-next.11 → 2.0.0-next.13

package/src/deploy/ensureFunctions.ts

@@ -0,0 +1,86 @@
+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";
+import pRetry from "p-retry";
+import { wait } from "@latticexyz/common/utils";
+
+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 pRetry(
+          () =>
+            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],
+            }),
+          {
+            retries: 3,
+            onFailedAttempt: async (error) => {
+              const delay = error.attemptNumber * 500;
+              debug(`failed to register function ${func.signature}, retrying in ${delay}ms...`);
+              await wait(delay);
+            },
+          }
+        );
+      }
+      return pRetry(
+        () =>
+          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],
+          }),
+        {
+          retries: 3,
+          onFailedAttempt: async (error) => {
+            const delay = error.attemptNumber * 500;
+            debug(`failed to register function ${func.signature}, retrying in ${delay}ms...`);
+            await wait(delay);
+          },
+        }
+      );
+    })
+  );
+}

package/src/deploy/ensureModules.ts

@@ -0,0 +1,72 @@
+import { Client, Transport, Chain, Account, Hex, BaseError, getAddress } from "viem";
+import { writeContract } from "@latticexyz/common";
+import { Module, WorldDeploy, worldAbi } from "./common";
+import { debug } from "./debug";
+import { isDefined, uniqueBy, wait } from "@latticexyz/common/utils";
+import pRetry from "p-retry";
+import { ensureContractsDeployed } from "./ensureContractsDeployed";
+
+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 [];
+
+  await ensureContractsDeployed({
+    client,
+    contracts: uniqueBy(modules, (mod) => getAddress(mod.address)).map((mod) => ({
+      bytecode: mod.bytecode,
+      label: `${mod.name} module`,
+    })),
+  });
+
+  debug("installing modules:", modules.map((mod) => mod.name).join(", "));
+  return (
+    await Promise.all(
+      modules.map((mod) =>
+        pRetry(
+          async () => {
+            try {
+              return mod.installAsRoot
+                ? await 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],
+                  })
+                : await 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],
+                  });
+            } catch (error) {
+              if (error instanceof BaseError && error.message.includes("Module_AlreadyInstalled")) {
+                debug(`module ${mod.name} already installed`);
+                return;
+              }
+              throw error;
+            }
+          },
+          {
+            retries: 3,
+            onFailedAttempt: async (error) => {
+              const delay = error.attemptNumber * 500;
+              debug(`failed to install module ${mod.name}, retrying in ${delay}ms...`);
+              await wait(delay);
+            },
+          }
+        )
+      )
+    )
+  ).filter(isDefined);
+}

package/src/deploy/ensureSystems.ts

@@ -0,0 +1,161 @@
+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,
+      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,34 @@
+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 { deployer } from "./ensureDeployer";
+import { salt } from "./common";
+import { ensureContractsDeployed } from "./ensureContractsDeployed";
+
+export const coreModuleBytecode = encodeDeployData({
+  bytecode: coreModuleBuild.bytecode.object as Hex,
+  abi: [],
+});
+
+export const coreModule = getCreate2Address({ from: deployer, bytecode: coreModuleBytecode, salt });
+
+export 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 ensureContractsDeployed({
+    client,
+    contracts: [
+      { bytecode: coreModuleBytecode, label: "core module" },
+      { bytecode: worldFactoryBytecode, label: "world factory" },
+    ],
+  });
+}

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">[]> {
+  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,
+  });
+}