@latticexyz/cli 2.0.0-next.10 → 2.0.0-next.12

package/src/deploy/assertNamespaceOwner.ts

@@ -0,0 +1,42 @@
+import { Account, Chain, Client, Hex, Transport, getAddress } from "viem";
+import { WorldDeploy, worldTables } from "./common";
+import { hexToResource, resourceToHex } from "@latticexyz/common";
+import { getResourceIds } from "./getResourceIds";
+import { getTableValue } from "./getTableValue";
+
+export async function assertNamespaceOwner({
+  client,
+  worldDeploy,
+  resourceIds,
+}: {
+  readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly worldDeploy: WorldDeploy;
+  readonly resourceIds: readonly Hex[];
+}): Promise<void> {
+  const desiredNamespaces = Array.from(new Set(resourceIds.map((resourceId) => hexToResource(resourceId).namespace)));
+  const existingResourceIds = await getResourceIds({ client, worldDeploy });
+  const existingNamespaces = Array.from(
+    new Set(existingResourceIds.map((resourceId) => hexToResource(resourceId).namespace))
+  );
+
+  const namespaces = desiredNamespaces.filter((namespace) => existingNamespaces.includes(namespace));
+  const namespaceOwners = await Promise.all(
+    namespaces.map(async (namespace) => {
+      const { owner } = await getTableValue({
+        client,
+        worldDeploy,
+        table: worldTables.world_NamespaceOwner,
+        key: { namespaceId: resourceToHex({ type: "namespace", namespace, name: "" }) },
+      });
+      return [namespace, owner];
+    })
+  );
+
+  const unauthorizedNamespaces = namespaceOwners
+    .filter(([, owner]) => getAddress(owner) !== getAddress(client.account.address))
+    .map(([namespace]) => namespace);
+
+  if (unauthorizedNamespaces.length) {
+    throw new Error(`You are attempting to deploy to namespaces you do not own: ${unauthorizedNamespaces.join(", ")}`);
+  }
+}

package/src/deploy/common.ts

@@ -0,0 +1,72 @@
+import { Abi, Address, Hex, padHex } from "viem";
+import storeConfig from "@latticexyz/store/mud.config.js";
+import worldConfig from "@latticexyz/world/mud.config.js";
+import IBaseWorldAbi from "@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json" assert { type: "json" };
+import IModuleAbi from "@latticexyz/world-modules/out/IModule.sol/IModule.abi.json" assert { type: "json" };
+import { Tables, configToTables } from "./configToTables";
+import { StoreConfig, helloStoreEvent } from "@latticexyz/store";
+import { WorldConfig, helloWorldEvent } from "@latticexyz/world";
+
+export const salt = padHex("0x", { size: 32 });
+
+// TODO: add `as const` to mud config so these get more strongly typed (blocked by current config parsing not using readonly)
+export const storeTables = configToTables(storeConfig);
+export const worldTables = configToTables(worldConfig);
+
+export const worldDeployEvents = [helloStoreEvent, helloWorldEvent] as const;
+
+export const worldAbi = [...IBaseWorldAbi, ...IModuleAbi] as const;
+
+// Ideally, this should be an append-only list. Before adding more versions here, be sure to add backwards-compatible support for old Store/World versions.
+export const supportedStoreVersions = ["1.0.0-unaudited"];
+export const supportedWorldVersions = ["1.0.0-unaudited"];
+
+export type WorldDeploy = {
+  readonly address: Address;
+  readonly worldVersion: string;
+  readonly storeVersion: string;
+  /** Block number where the world was deployed */
+  readonly deployBlock: bigint;
+  /**
+   * Block number at the time of fetching world deploy.
+   * We use this block number when requesting data from the chain to align chain state
+   * with the same block during the introspection steps of the deploy.
+   */
+  readonly stateBlock: bigint;
+};
+
+export type WorldFunction = {
+  readonly signature: string;
+  readonly selector: Hex;
+  readonly systemId: Hex;
+  readonly systemFunctionSignature: string;
+  readonly systemFunctionSelector: Hex;
+};
+
+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 functions: readonly WorldFunction[];
+};
+
+export type Module = DeterministicContract & {
+  readonly name: string;
+  readonly installAsRoot: boolean;
+  readonly installData: Hex; // TODO: figure out better naming for this
+};
+
+export type ConfigInput = StoreConfig & WorldConfig;
+export type Config<config extends ConfigInput> = {
+  readonly tables: Tables<config>;
+  readonly systems: readonly System[];
+  readonly modules: readonly Module[];
+};

package/src/deploy/configToTables.ts

@@ -0,0 +1,68 @@
+import { resourceToHex } from "@latticexyz/common";
+import { KeySchema, ValueSchema } from "@latticexyz/protocol-parser";
+import { SchemaAbiType, StaticAbiType } from "@latticexyz/schema-type";
+import { StoreConfig, resolveUserTypes } from "@latticexyz/store";
+import { Hex } from "viem";
+
+// TODO: we shouldn't need this file once our config parsing returns nicely formed tables
+
+type UserTypes<config extends StoreConfig = StoreConfig> = config["userTypes"];
+// TODO: fix strong enum types and avoid every schema getting `{ [k: string]: "uint8" }`
+// type UserTypes<config extends StoreConfig = StoreConfig> = config["userTypes"] & {
+//   [k in keyof config["enums"]]: { internalType: "uint8" };
+// };
+
+export type TableKey<
+  config extends StoreConfig = StoreConfig,
+  table extends config["tables"][keyof config["tables"]] = config["tables"][keyof config["tables"]]
+> = `${config["namespace"]}_${table["name"]}`;
+
+export type Table<
+  config extends StoreConfig = StoreConfig,
+  table extends config["tables"][keyof config["tables"]] = config["tables"][keyof config["tables"]]
+> = {
+  readonly namespace: config["namespace"];
+  readonly name: table["name"];
+  readonly tableId: Hex;
+  readonly keySchema: table["keySchema"] extends KeySchema<UserTypes<config>>
+    ? KeySchema & {
+        readonly [k in keyof table["keySchema"]]: UserTypes<config>[table["keySchema"][k]]["internalType"] extends StaticAbiType
+          ? UserTypes<config>[table["keySchema"][k]]["internalType"]
+          : table["keySchema"][k];
+      }
+    : KeySchema;
+  readonly valueSchema: table["valueSchema"] extends ValueSchema<UserTypes<config>>
+    ? {
+        readonly [k in keyof table["valueSchema"]]: UserTypes<config>[table["valueSchema"][k]]["internalType"] extends SchemaAbiType
+          ? UserTypes<config>[table["valueSchema"][k]]["internalType"]
+          : table["valueSchema"][k];
+      }
+    : ValueSchema;
+};
+
+export type Tables<config extends StoreConfig = StoreConfig> = {
+  readonly [k in keyof config["tables"] as TableKey<config, config["tables"][k]>]: Table<config, config["tables"][k]>;
+};
+
+export function configToTables<config extends StoreConfig>(config: config): Tables<config> {
+  const userTypes = {
+    ...config.userTypes,
+    ...Object.fromEntries(Object.entries(config.enums).map(([key]) => [key, { internalType: "uint8" }] as const)),
+  };
+  return Object.fromEntries(
+    Object.entries(config.tables).map(([tableName, table]) => [
+      `${config.namespace}_${tableName}` satisfies TableKey<config, config["tables"][keyof config["tables"]]>,
+      {
+        namespace: config.namespace,
+        name: table.name,
+        tableId: resourceToHex({
+          type: table.offchainOnly ? "offchainTable" : "table",
+          namespace: config.namespace,
+          name: table.name,
+        }),
+        keySchema: resolveUserTypes(table.keySchema, userTypes) as any,
+        valueSchema: resolveUserTypes(table.valueSchema, userTypes) as any,
+      } satisfies Table<config, config["tables"][keyof config["tables"]]>,
+    ])
+  ) as Tables<config>;
+}

package/src/deploy/create2/README.md

@@ -0,0 +1,9 @@
+Files generated by
+
+```
+git clone https://github.com/Arachnid/deterministic-deployment-proxy.git
+cd deterministic-deployment-proxy
+git checkout b3bb19c
+npm install
+npm run build
+```

package/src/deploy/create2/deployment.json

@@ -0,0 +1,7 @@
+{
+  "gasPrice": 100000000000,
+  "gasLimit": 100000,
+  "signerAddress": "3fab184622dc19b6109349b94811493bf2a45362",
+  "transaction": "f8a58085174876e800830186a08080b853604580600e600039806000f350fe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf31ba02222222222222222222222222222222222222222222222222222222222222222a02222222222222222222222222222222222222222222222222222222222222222",
+  "address": "4e59b44847b379578588920ca78fbf26c0b4956c"
+}

package/src/deploy/debug.ts

@@ -0,0 +1,3 @@
+import { debug as parentDebug } from "../debug";
+
+export const debug = parentDebug.extend("deploy");

package/src/deploy/deploy.ts

@@ -0,0 +1,108 @@
+import { Account, Address, Chain, Client, Transport, getAddress } 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 { assertNamespaceOwner } from "./assertNamespaceOwner";
+import { debug } from "./debug";
+import { resourceLabel } from "./resourceLabel";
+import { ensureContract } from "./ensureContract";
+import { uniqueBy } from "@latticexyz/common/utils";
+import { ensureContractsDeployed } from "./ensureContractsDeployed";
+import { coreModuleBytecode, worldFactoryBytecode } from "./ensureWorldFactory";
+
+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> {
+  const tables = Object.values(config.tables) as Table[];
+  const systems = Object.values(config.systems);
+
+  await ensureDeployer(client);
+
+  // deploy all dependent contracts, because system registration, module install, etc. all expect these contracts to be callable.
+  await ensureContractsDeployed({
+    client,
+    contracts: [
+      { bytecode: coreModuleBytecode, label: "core module" },
+      { bytecode: worldFactoryBytecode, label: "world factory" },
+      ...uniqueBy(systems, (system) => getAddress(system.address)).map((system) => ({
+        bytecode: system.bytecode,
+        label: `${resourceLabel(system)} system`,
+      })),
+      ...uniqueBy(config.modules, (mod) => getAddress(mod.address)).map((mod) => ({
+        bytecode: mod.bytecode,
+        label: `${mod.name} module`,
+      })),
+    ],
+  });
+
+  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}`);
+  }
+
+  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 txs = [...tableTxs, ...systemTxs, ...functionTxs, ...moduleTxs];
+
+  // wait for each tx separately/serially, because parallelizing results in RPC errors
+  debug("waiting for all transactions to confirm");
+  for (const tx of txs) {
+    await waitForTransactionReceipt(client, { hash: tx });
+    // TODO: throw if there was a revert?
+  }
+
+  debug("deploy complete");
+  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,49 @@
+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";
+import pRetry from "p-retry";
+import { wait } from "@latticexyz/common/utils";
+
+export type Contract = {
+  bytecode: Hex;
+  label?: string;
+};
+
+export async function ensureContract({
+  client,
+  bytecode,
+  label = "contract",
+}: {
+  readonly client: Client<Transport, Chain | undefined, Account>;
+} & Contract): 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 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/ensureContractsDeployed.ts

@@ -0,0 +1,25 @@
+import { Client, Transport, Chain, Account, Hex } from "viem";
+import { waitForTransactionReceipt } from "viem/actions";
+import { debug } from "./debug";
+import { Contract, ensureContract } from "./ensureContract";
+
+export async function ensureContractsDeployed({
+  client,
+  contracts,
+}: {
+  readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly contracts: readonly Contract[];
+}): Promise<readonly Hex[]> {
+  const txs = (await Promise.all(contracts.map((contract) => ensureContract({ client, ...contract })))).flat();
+
+  if (txs.length) {
+    debug("waiting for contracts");
+    // wait for each tx separately/serially, because parallelizing results in RPC errors
+    for (const tx of txs) {
+      await waitForTransactionReceipt(client, { hash: tx });
+      // TODO: throw if there was a revert?
+    }
+  }
+
+  return txs;
+}

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