@latticexyz/cli 2.0.0-main-e667ee80 → 2.0.0-main-61c6ab70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@latticexyz/cli",
-  "version": "2.0.0-main-e667ee80",
+  "version": "2.0.0-main-61c6ab70",
   "description": "Command line interface for mud",
   "repository": {
     "type": "git",
@@ -31,6 +31,7 @@
     "glob": "^8.0.3",
     "nice-grpc-web": "^2.0.1",
     "openurl": "^1.1.1",
+    "p-retry": "^5.1.2",
     "path": "^0.12.7",
     "rxjs": "7.5.5",
     "throttle-debounce": "^5.0.0",
@@ -39,17 +40,17 @@
     "yargs": "^17.7.1",
     "zod": "^3.21.4",
     "zod-validation-error": "^1.3.0",
-    "@latticexyz/abi-ts": "2.0.0-main-e667ee80",
-    "@latticexyz/common": "2.0.0-main-e667ee80",
-    "@latticexyz/config": "2.0.0-main-e667ee80",
-    "@latticexyz/gas-report": "2.0.0-main-e667ee80",
-    "@latticexyz/protocol-parser": "2.0.0-main-e667ee80",
-    "@latticexyz/schema-type": "2.0.0-main-e667ee80",
-    "@latticexyz/services": "2.0.0-main-e667ee80",
-    "@latticexyz/store": "2.0.0-main-e667ee80",
-    "@latticexyz/utils": "2.0.0-main-e667ee80",
-    "@latticexyz/world": "2.0.0-main-e667ee80",
-    "@latticexyz/world-modules": "2.0.0-main-e667ee80"
+    "@latticexyz/abi-ts": "2.0.0-main-61c6ab70",
+    "@latticexyz/common": "2.0.0-main-61c6ab70",
+    "@latticexyz/config": "2.0.0-main-61c6ab70",
+    "@latticexyz/gas-report": "2.0.0-main-61c6ab70",
+    "@latticexyz/protocol-parser": "2.0.0-main-61c6ab70",
+    "@latticexyz/schema-type": "2.0.0-main-61c6ab70",
+    "@latticexyz/services": "2.0.0-main-61c6ab70",
+    "@latticexyz/store": "2.0.0-main-61c6ab70",
+    "@latticexyz/utils": "2.0.0-main-61c6ab70",
+    "@latticexyz/world": "2.0.0-main-61c6ab70",
+    "@latticexyz/world-modules": "2.0.0-main-61c6ab70"
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",

package/src/deploy/common.ts

@@ -38,25 +38,25 @@ export type WorldFunction = {
   readonly systemFunctionSelector: Hex;
 };
 
-export type System = {
+export type DeterministicContract = {
+  readonly address: Address;
+  readonly bytecode: Hex;
+  readonly abi: Abi;
+};
+
+export type System = DeterministicContract & {
   readonly namespace: string;
   readonly name: string;
   readonly systemId: Hex;
   readonly allowAll: boolean;
   readonly allowedAddresses: readonly Hex[];
-  readonly address: Address;
-  readonly bytecode: Hex;
-  readonly abi: Abi;
   readonly functions: readonly WorldFunction[];
 };
 
-export type Module = {
+export type Module = DeterministicContract & {
   readonly name: string;
   readonly installAsRoot: boolean;
   readonly installData: Hex; // TODO: figure out better naming for this
-  readonly address: Address;
-  readonly bytecode: Hex;
-  readonly abi: Abi;
 };
 
 export type ConfigInput = StoreConfig & WorldConfig;

package/src/deploy/deploy.ts

@@ -4,13 +4,16 @@ import { deployWorld } from "./deployWorld";
 import { ensureTables } from "./ensureTables";
 import { Config, ConfigInput, WorldDeploy, supportedStoreVersions, supportedWorldVersions } from "./common";
 import { ensureSystems } from "./ensureSystems";
-import { getTransactionReceipt, waitForTransactionReceipt } from "viem/actions";
+import { waitForTransactionReceipt } from "viem/actions";
 import { getWorldDeploy } from "./getWorldDeploy";
 import { ensureFunctions } from "./ensureFunctions";
 import { ensureModules } from "./ensureModules";
 import { Table } from "./configToTables";
 import { assertNamespaceOwner } from "./assertNamespaceOwner";
 import { debug } from "./debug";
+import { resourceLabel } from "./resourceLabel";
+import { ensureContract } from "./ensureContract";
+import { uniqueBy } from "@latticexyz/common/utils";
 
 type DeployOptions<configInput extends ConfigInput> = {
   client: Client<Transport, Chain | undefined, Account>;
@@ -51,6 +54,27 @@ export async function deploy<configInput extends ConfigInput>({
     resourceIds: [...tables.map((table) => table.tableId), ...systems.map((system) => system.systemId)],
   });
 
+  // deploy all dependent contracts, because system registration, module install, etc. all expect these contracts to be callable.
+  const contractTxs = (
+    await Promise.all([
+      ...uniqueBy(systems, (system) => system.address).map((system) =>
+        ensureContract({ client, bytecode: system.bytecode, label: `${resourceLabel(system)} system` })
+      ),
+      ...uniqueBy(config.modules, (mod) => mod.address).map((mod) =>
+        ensureContract({ client, bytecode: mod.bytecode, label: `${mod.name} module` })
+      ),
+    ])
+  ).flat();
+
+  if (contractTxs.length) {
+    debug("waiting for contracts");
+    // wait for each tx separately/serially, because parallelizing results in RPC errors
+    for (const tx of contractTxs) {
+      await waitForTransactionReceipt(client, { hash: tx });
+      // TODO: throw if there was a revert?
+    }
+  }
+
   const tableTxs = await ensureTables({
     client,
     worldDeploy,
@@ -75,7 +99,7 @@ export async function deploy<configInput extends ConfigInput>({
   const txs = [...tableTxs, ...systemTxs, ...functionTxs, ...moduleTxs];
 
   // wait for each tx separately/serially, because parallelizing results in RPC errors
-  debug("waiting for transactions to confirm");
+  debug("waiting for all transactions to confirm");
   for (const tx of txs) {
     await waitForTransactionReceipt(client, { hash: tx });
     // TODO: throw if there was a revert?

package/src/deploy/ensureContract.ts

@@ -4,6 +4,8 @@ import { deployer } from "./ensureDeployer";
 import { salt } from "./common";
 import { sendTransaction } from "@latticexyz/common";
 import { debug } from "./debug";
+import pRetry from "p-retry";
+import { wait } from "@latticexyz/common/utils";
 
 export async function ensureContract({
   client,
@@ -24,10 +26,21 @@ export async function ensureContract({
 
   debug("deploying", label, "at", address);
   return [
-    await sendTransaction(client, {
-      chain: client.chain ?? null,
-      to: deployer,
-      data: concatHex([salt, bytecode]),
-    }),
+    await pRetry(
+      () =>
+        sendTransaction(client, {
+          chain: client.chain ?? null,
+          to: deployer,
+          data: concatHex([salt, bytecode]),
+        }),
+      {
+        retries: 3,
+        onFailedAttempt: async (error) => {
+          const delay = error.attemptNumber * 500;
+          debug(`failed to deploy ${label}, retrying in ${delay}ms...`);
+          await wait(delay);
+        },
+      }
+    ),
   ];
 }

package/src/deploy/ensureFunctions.ts

@@ -3,6 +3,8 @@ 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,
@@ -40,23 +42,45 @@ export async function ensureFunctions({
     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 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 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],
-      });
+      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

@@ -1,9 +1,9 @@
 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";
-import { uniqueBy } from "@latticexyz/common/utils";
+import { wait } from "@latticexyz/common/utils";
+import pRetry from "p-retry";
 
 export async function ensureModules({
   client,
@@ -16,36 +16,50 @@ export async function ensureModules({
 }): Promise<readonly Hex[]> {
   if (!modules.length) return [];
 
-  // kick off contract deployments first, otherwise installing modules can fail
-  const contractTxs = await Promise.all(
-    uniqueBy(modules, (mod) => mod.address).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],
-          })
+        ? pRetry(
+            () =>
+              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],
+              }),
+            {
+              retries: 3,
+              onFailedAttempt: async (error) => {
+                const delay = error.attemptNumber * 500;
+                debug(`failed to install root module ${mod.name}, retrying in ${delay}ms...`);
+                await wait(delay);
+              },
+            }
+          )
+        : pRetry(
+            () =>
+              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],
+              }),
+            {
+              retries: 3,
+              onFailedAttempt: async (error) => {
+                const delay = error.attemptNumber * 500;
+                debug(`failed to install module ${mod.name}, retrying in ${delay}ms...`);
+                await wait(delay);
+              },
+            }
+          )
     )
   );
 
-  return (await Promise.all([...contractTxs, ...installTxs])).flat();
+  return await Promise.all(installTxs);
 }

package/src/deploy/ensureSystems.ts

@@ -1,12 +1,12 @@
 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";
-import { uniqueBy } from "@latticexyz/common/utils";
+import { wait } from "@latticexyz/common/utils";
+import pRetry from "p-retry";
 
 export async function ensureSystems({
   client,
@@ -52,26 +52,48 @@ export async function ensureSystems({
     debug("adding", accessToAdd.length, "access grants");
   }
 
-  const accessTxs = await Promise.all([
+  const accessTxs = [
     ...accessToRemove.map((access) =>
-      writeContract(client, {
-        chain: client.chain ?? null,
-        address: worldDeploy.address,
-        abi: worldAbi,
-        functionName: "revokeAccess",
-        args: [access.resourceId, access.address],
-      })
+      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) =>
-      writeContract(client, {
-        chain: client.chain ?? null,
-        address: worldDeploy.address,
-        abi: worldAbi,
-        functionName: "grantAccess",
-        args: [access.resourceId, access.address],
-      })
+      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(
@@ -104,26 +126,27 @@ export async function ensureSystems({
     debug("registering new systems", systemsToAdd.map(resourceLabel).join(", "));
   }
 
-  // kick off contract deployments first, otherwise registering systems can fail
-  const contractTxs = await Promise.all(
-    uniqueBy(missingSystems, (system) => system.address).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],
-      })
+  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, ...contractTxs, ...registerTxs])).flat();
+  return await Promise.all([...accessTxs, ...registerTxs]);
 }

package/src/deploy/ensureTables.ts

@@ -6,6 +6,8 @@ import { valueSchemaToFieldLayoutHex, keySchemaToHex, valueSchemaToHex } from "@
 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,
@@ -29,21 +31,32 @@ export async function ensureTables({
     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),
-          ],
-        })
+        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);
+            },
+          }
+        )
       )
     );
   }

package/src/runDeploy.ts

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { InferredOptionTypes, Options } from "yargs";
 import { deploy } from "./deploy/deploy";
 import { createWalletClient, http, Hex } from "viem";