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

package/src/utils/deploy.ts

@@ -1,254 +0,0 @@
-import chalk from "chalk";
-import path from "path";
-import { ethers } from "ethers";
-import { getOutDirectory, cast, getSrcDirectory, getRemappings } from "@latticexyz/common/foundry";
-import { StoreConfig } from "@latticexyz/store";
-import { WorldConfig, resolveWorldConfig } from "@latticexyz/world";
-import { deployWorldContract } from "./world";
-import IBaseWorldAbi from "@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json" assert { type: "json" };
-import CoreModuleData from "@latticexyz/world/out/CoreModule.sol/CoreModule.json" assert { type: "json" };
-import { defaultModuleContracts } from "./modules/constants";
-import { getInstallModuleCallData } from "./modules/getInstallModuleCallData";
-import { getUserModules } from "./modules/getUserModules";
-import { getGrantAccessCallData } from "./systems/getGrantAccessCallData";
-import { getRegisterFunctionSelectorsCallData } from "./systems/getRegisterFunctionSelectorsCallData";
-import { getRegisterSystemCallData } from "./systems/getRegisterSystemCallData";
-import { getRegisterTableCallData } from "./tables/getRegisterTableCallData";
-import { getTableIds } from "./tables/getTableIds";
-import { confirmNonce } from "./utils/confirmNonce";
-import { deployContract } from "./utils/deployContract";
-import { fastTxExecute } from "./utils/fastTxExecute";
-import { getContractData } from "./utils/getContractData";
-import { postDeploy } from "./utils/postDeploy";
-import { setInternalFeePerGas } from "./utils/setInternalFeePerGas";
-import { ContractCode } from "./utils/types";
-import { resourceIdToHex } from "@latticexyz/common";
-
-export interface DeployConfig {
-  profile?: string;
-  rpc: string;
-  privateKey: string;
-  priorityFeeMultiplier: number;
-  debug?: boolean;
-  worldAddress?: string;
-  disableTxWait: boolean;
-  pollInterval: number;
-}
-
-export interface DeploymentInfo {
-  blockNumber: number;
-  worldAddress: string;
-}
-
-export async function deploy(
-  mudConfig: StoreConfig & WorldConfig,
-  existingContractNames: string[],
-  deployConfig: DeployConfig
-): Promise<DeploymentInfo> {
-  const startTime = Date.now();
-  const { profile, rpc, privateKey, priorityFeeMultiplier, debug, worldAddress, disableTxWait, pollInterval } =
-    deployConfig;
-  const resolvedConfig = resolveWorldConfig(mudConfig, existingContractNames);
-  const forgeOutDirectory = await getOutDirectory(profile);
-  const remappings = await getRemappings(profile);
-  const outputBaseDirectory = path.join(await getSrcDirectory(profile), mudConfig.codegenDirectory);
-
-  // Set up signer for deployment
-  const provider = new ethers.providers.StaticJsonRpcProvider(rpc);
-  provider.pollingInterval = pollInterval;
-  const signer = new ethers.Wallet(privateKey, provider);
-  console.log("Deploying from", signer.address);
-
-  let nonce = await signer.getTransactionCount();
-  console.log("Initial nonce", nonce);
-
-  const txParams = await setInternalFeePerGas(signer, priorityFeeMultiplier);
-
-  const txConfig = {
-    ...txParams,
-    signer,
-    debug: Boolean(debug),
-    disableTxWait,
-    confirmations: disableTxWait ? 0 : 1,
-  };
-
-  // Get block number before deploying
-  const blockNumber = Number(await cast(["block-number", "--rpc-url", rpc], { profile }));
-  console.log("Start deployment at block", blockNumber);
-
-  // Deploy the World contract. Non-blocking.
-  const worldPromise: Promise<string> = worldAddress
-    ? Promise.resolve(worldAddress)
-    : deployWorldContract({
-        ...txConfig,
-        nonce: nonce++,
-        worldContractName: mudConfig.worldContractName,
-        forgeOutDirectory,
-      });
-
-  // Filters any default modules from config
-  const userModules = getUserModules(defaultModuleContracts, mudConfig.modules);
-  const userModuleContracts = Object.keys(userModules).map((name) => {
-    const { abi, bytecode } = getContractData(name, forgeOutDirectory);
-    return {
-      name,
-      abi,
-      bytecode,
-    } as ContractCode;
-  });
-
-  const systemContracts = Object.keys(resolvedConfig.systems).map((name) => {
-    const { abi, bytecode } = getContractData(name, forgeOutDirectory);
-    return {
-      name,
-      abi,
-      bytecode,
-    } as ContractCode;
-  });
-
-  const contracts: ContractCode[] = [
-    {
-      name: "CoreModule",
-      abi: CoreModuleData.abi,
-      bytecode: CoreModuleData.bytecode,
-    },
-    ...defaultModuleContracts,
-    ...userModuleContracts,
-    ...systemContracts,
-  ];
-
-  // Deploy the System and Module contracts
-  const deployedContracts = contracts.reduce<Record<string, Promise<string>>>((acc, contract) => {
-    acc[contract.name] = deployContract({
-      ...txConfig,
-      nonce: nonce++,
-      contract,
-    });
-    return acc;
-  }, {});
-
-  // Wait for world to be deployed
-  const deployedWorldAddress = await worldPromise;
-  const worldContract = new ethers.Contract(deployedWorldAddress, IBaseWorldAbi);
-
-  // If an existing World is passed assume its coreModule is already installed - blocking to install if not
-  if (!worldAddress) {
-    console.log(chalk.blue("Installing CoreModule"));
-    await fastTxExecute({
-      ...txConfig,
-      nonce: nonce++,
-      contract: worldContract,
-      func: "initialize",
-      args: [await deployedContracts["CoreModule"]],
-    });
-    console.log(chalk.green("Installed CoreModule"));
-  }
-
-  if (mudConfig.namespace) {
-    console.log(chalk.blue("Registering Namespace"));
-    await fastTxExecute({
-      ...txConfig,
-      nonce: nonce++,
-      contract: worldContract,
-      func: "registerNamespace",
-      args: [resourceIdToHex({ type: "namespace", namespace: mudConfig.namespace, name: "" })],
-    });
-    console.log(chalk.green("Namespace registered"));
-  }
-
-  const tableIds = getTableIds(mudConfig);
-
-  const registerTableCalls = Object.values(mudConfig.tables).map((table) =>
-    getRegisterTableCallData(table, mudConfig, outputBaseDirectory, remappings)
-  );
-
-  console.log(chalk.blue("Registering tables"));
-  await Promise.all(
-    registerTableCalls.map((call) =>
-      fastTxExecute({
-        ...txConfig,
-        nonce: nonce++,
-        contract: worldContract,
-        ...call,
-      })
-    )
-  );
-  console.log(chalk.green(`Tables registered`));
-
-  console.log(chalk.blue("Registering Systems and Functions"));
-  const systemCalls = await Promise.all(
-    Object.entries(resolvedConfig.systems).map(([systemKey, system]) =>
-      getRegisterSystemCallData({
-        systemContracts: deployedContracts,
-        systemKey,
-        system,
-        namespace: mudConfig.namespace,
-      })
-    )
-  );
-  const functionCalls = Object.entries(resolvedConfig.systems).flatMap(([systemKey, system]) =>
-    getRegisterFunctionSelectorsCallData({
-      systemContractName: systemKey,
-      system,
-      namespace: mudConfig.namespace,
-      forgeOutDirectory,
-    })
-  );
-  await Promise.all(
-    [...systemCalls, ...functionCalls].map((call) =>
-      fastTxExecute({
-        ...txConfig,
-        nonce: nonce++,
-        contract: worldContract,
-        ...call,
-      })
-    )
-  );
-  console.log(chalk.green(`Systems and Functions registered`));
-
-  // Wait for System access to be granted before installing modules
-  const grantCalls = await getGrantAccessCallData({
-    systems: Object.values(resolvedConfig.systems),
-    systemContracts: deployedContracts,
-    namespace: mudConfig.namespace,
-  });
-
-  console.log(chalk.blue("Granting Access"));
-  await Promise.all(
-    grantCalls.map((call) =>
-      fastTxExecute({
-        ...txConfig,
-        nonce: nonce++,
-        contract: worldContract,
-        ...call,
-      })
-    )
-  );
-  console.log(chalk.green(`Access granted`));
-
-  const moduleCalls = await Promise.all(
-    mudConfig.modules.map((m) => getInstallModuleCallData(deployedContracts, m, tableIds))
-  );
-
-  console.log(chalk.blue("Installing User Modules"));
-  await Promise.all(
-    moduleCalls.map((call) =>
-      fastTxExecute({
-        ...txConfig,
-        nonce: nonce++,
-        contract: worldContract,
-        ...call,
-      })
-    )
-  );
-  console.log(chalk.green(`User Modules Installed`));
-
-  // Double check that all transactions have been included by confirming the current nonce is the expected nonce
-  await confirmNonce(signer, nonce, pollInterval);
-
-  await postDeploy(mudConfig.postDeployScript, deployedWorldAddress, rpc, profile);
-
-  console.log(chalk.green("Deployment completed in", (Date.now() - startTime) / 1000, "seconds"));
-
-  return { worldAddress: deployedWorldAddress, blockNumber };
-}

package/src/utils/deployHandler.ts

@@ -1,93 +0,0 @@
-import chalk from "chalk";
-import path from "path";
-import { MUDError } from "@latticexyz/common/errors";
-import { loadConfig } from "@latticexyz/config/node";
-import { StoreConfig } from "@latticexyz/store";
-import { WorldConfig } from "@latticexyz/world";
-import { deploy } from "../utils/deploy";
-import { forge, getRpcUrl, getSrcDirectory } from "@latticexyz/common/foundry";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
-import { getExistingContracts } from "./getExistingContracts";
-import { execa } from "execa";
-import { getChainId } from "./utils/getChainId";
-
-export type DeployOptions = {
-  configPath?: string;
-  printConfig?: boolean;
-  profile?: string;
-  priorityFeeMultiplier: number;
-  clean?: boolean;
-  debug?: boolean;
-  saveDeployment: boolean;
-  rpc?: string;
-  worldAddress?: string;
-  srcDir?: string;
-  disableTxWait: boolean;
-  pollInterval: number;
-  skipBuild?: boolean;
-};
-
-export async function deployHandler(args: DeployOptions) {
-  args.profile ??= process.env.FOUNDRY_PROFILE;
-  const { configPath, printConfig, profile, clean, skipBuild } = args;
-
-  const rpc = args.rpc ?? (await getRpcUrl(profile));
-  console.log(
-    chalk.bgBlue(
-      chalk.whiteBright(`\n Deploying MUD contracts${profile ? " with profile " + profile : ""} to RPC ${rpc} \n`)
-    )
-  );
-
-  if (clean) {
-    await forge(["clean"], { profile });
-  }
-
-  // Run forge build
-  if (!skipBuild) {
-    await forge(["build", "--skip", "test", "script"], { profile });
-    await execa("mud", ["abi-ts"], { stdio: "inherit" });
-  }
-
-  // Get a list of all contract names
-  const srcDir = args?.srcDir ?? (await getSrcDirectory());
-  const existingContractNames = getExistingContracts(srcDir).map(({ basename }) => basename);
-
-  // Load the config
-  const mudConfig = (await loadConfig(configPath)) as StoreConfig & WorldConfig;
-
-  if (printConfig) console.log(chalk.green("\nResolved config:\n"), JSON.stringify(mudConfig, null, 2));
-
-  const privateKey = process.env.PRIVATE_KEY;
-  if (!privateKey)
-    throw new MUDError(
-      `Missing PRIVATE_KEY environment variable.
-Run 'echo "PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80" > .env'
-in your contracts directory to use the default anvil private key.`
-    );
-  const deploymentInfo = await deploy(mudConfig, existingContractNames, { ...args, rpc, privateKey });
-
-  if (args.saveDeployment) {
-    // Write deployment result to file (latest and timestamp)
-    const chainId = await getChainId(rpc);
-    const outputDir = path.join(mudConfig.deploysDirectory, chainId.toString());
-    mkdirSync(outputDir, { recursive: true });
-    writeFileSync(path.join(outputDir, "latest.json"), JSON.stringify(deploymentInfo, null, 2));
-    writeFileSync(path.join(outputDir, Date.now() + ".json"), JSON.stringify(deploymentInfo, null, 2));
-
-    const localChains = [1337, 31337];
-    const deploys = existsSync(mudConfig.worldsFile) ? JSON.parse(readFileSync(mudConfig.worldsFile, "utf-8")) : {};
-    deploys[chainId] = {
-      address: deploymentInfo.worldAddress,
-      // We expect the worlds file to be committed and since local deployments are often a consistent address but different block number, we'll ignore the block number.
-      blockNumber: localChains.includes(chainId) ? undefined : deploymentInfo.blockNumber,
-    };
-    writeFileSync(mudConfig.worldsFile, JSON.stringify(deploys, null, 2));
-
-    console.log(
-      chalk.bgGreen(chalk.whiteBright(`\n Deployment result (written to ${mudConfig.worldsFile} and ${outputDir}): \n`))
-    );
-  }
-
-  console.log(deploymentInfo);
-  return deploymentInfo;
-}

package/src/utils/modules/getInstallModuleCallData.ts

@@ -1,27 +0,0 @@
-import { defaultAbiCoder } from "ethers/lib/utils.js";
-import { resolveWithContext } from "@latticexyz/config";
-import { Module } from "./types";
-import { CallData } from "../utils/types";
-import { TableIds } from "../tables/types";
-
-export async function getInstallModuleCallData(
-  moduleContracts: Record<string, Promise<string>>,
-  module: Module,
-  tableIds: TableIds
-): Promise<CallData> {
-  const moduleAddress = await moduleContracts[module.name];
-  if (!moduleAddress) throw new Error(`Module ${module.name} not found`);
-  // Resolve arguments
-  const resolvedArgs = module.args.map((arg) =>
-    resolveWithContext(arg, {
-      tableIds,
-    })
-  );
-  const values = resolvedArgs.map((arg) => arg.value);
-  const types = resolvedArgs.map((arg) => arg.type);
-
-  return {
-    func: module.root ? "installRootModule" : "installModule",
-    args: [moduleAddress, defaultAbiCoder.encode(types, values)],
-  };
-}

package/src/utils/modules/getUserModules.ts

@@ -1,5 +0,0 @@
-import { Module } from "./types";
-
-export function getUserModules(defaultModules: { name: string }[], configModules: Module[]): Omit<Module, "address">[] {
-  return configModules.filter((module) => !defaultModules.some((m) => m.name === module.name));
-}

package/src/utils/modules/types.ts

@@ -1,14 +0,0 @@
-export type Module = {
-  name: string;
-  root: boolean;
-  args: (
-    | {
-        value: (string | number | Uint8Array) & (string | number | Uint8Array | undefined);
-        type: string;
-      }
-    | {
-        type: any;
-        input: string;
-      }
-  )[];
-};

package/src/utils/systems/getGrantAccessCallData.ts

@@ -1,29 +0,0 @@
-import { System } from "./types";
-import { CallData } from "../utils/types";
-import { resourceIdToHex } from "@latticexyz/common";
-
-export async function getGrantAccessCallData(input: {
-  systems: System[];
-  systemContracts: Record<string, Promise<string>>;
-  namespace: string;
-}): Promise<CallData[]> {
-  const { systems, namespace, systemContracts } = input;
-  const calls: CallData[] = [];
-  for (const { name, accessListAddresses, accessListSystems } of systems) {
-    // Grant access to addresses
-    accessListAddresses.map(async (address) => calls.push(getGrantSystemAccessCallData(name, namespace, address)));
-
-    // Grant access to other systems
-    accessListSystems.map(async (granteeSystem) =>
-      calls.push(getGrantSystemAccessCallData(name, namespace, await systemContracts[granteeSystem]))
-    );
-  }
-  return calls;
-}
-
-function getGrantSystemAccessCallData(name: string, namespace: string, address: string): CallData {
-  return {
-    func: "grantAccess",
-    args: [resourceIdToHex({ type: "system", namespace, name }), address],
-  };
-}

package/src/utils/systems/getRegisterFunctionSelectorsCallData.ts

@@ -1,57 +0,0 @@
-import { resourceIdToHex } from "@latticexyz/common";
-import { System } from "./types";
-import { loadFunctionSignatures, toFunctionSelector } from "./utils";
-import { CallData } from "../utils/types";
-
-export function getRegisterFunctionSelectorsCallData(input: {
-  systemContractName: string;
-  system: System;
-  namespace: string;
-  forgeOutDirectory: string;
-}): CallData[] {
-  // Register system at route
-  const callData: CallData[] = [];
-  const { systemContractName, namespace, forgeOutDirectory, system } = input;
-
-  if (system.registerFunctionSelectors) {
-    const baseSystemFunctionSignatures = loadFunctionSignatures("System", forgeOutDirectory);
-    const systemFunctionSignatures = loadFunctionSignatures(systemContractName, forgeOutDirectory).filter(
-      (functionSignature) =>
-        systemContractName === "System" || !baseSystemFunctionSignatures.includes(functionSignature)
-    );
-    const isRoot = namespace === "";
-    for (const systemFunctionSignature of systemFunctionSignatures) {
-      callData.push(
-        getRegisterFunctionSelectorCallData({
-          namespace,
-          name: system.name,
-          systemFunctionSignature,
-          isRoot,
-        })
-      );
-    }
-  }
-  return callData;
-}
-
-function getRegisterFunctionSelectorCallData(input: {
-  namespace: string;
-  name: string;
-  systemFunctionSignature: string;
-  isRoot: boolean;
-}): CallData {
-  const { namespace, name, systemFunctionSignature, isRoot } = input;
-
-  if (isRoot) {
-    const functionSelector = toFunctionSelector(systemFunctionSignature);
-    return {
-      func: "registerRootFunctionSelector",
-      args: [resourceIdToHex({ type: "system", namespace, name }), systemFunctionSignature, functionSelector],
-    };
-  } else {
-    return {
-      func: "registerFunctionSelector",
-      args: [resourceIdToHex({ type: "system", namespace, name }), systemFunctionSignature],
-    };
-  }
-}

package/src/utils/systems/getRegisterSystemCallData.ts

@@ -1,17 +0,0 @@
-import { resourceIdToHex } from "@latticexyz/common";
-import { System } from "./types";
-import { CallData } from "../utils/types";
-
-export async function getRegisterSystemCallData(input: {
-  systemContracts: Record<string, Promise<string>>;
-  systemKey: string;
-  system: System;
-  namespace: string;
-}): Promise<CallData> {
-  const { namespace, systemContracts, systemKey, system } = input;
-  const systemAddress = await systemContracts[systemKey];
-  return {
-    func: "registerSystem",
-    args: [resourceIdToHex({ type: "system", namespace, name: system.name }), systemAddress, system.openAccess],
-  };
-}

package/src/utils/systems/types.ts

@@ -1,9 +0,0 @@
-export type System = {
-  name: string;
-  registerFunctionSelectors: boolean;
-  openAccess: boolean;
-  accessListAddresses: string[];
-  accessListSystems: string[];
-};
-
-export type SystemsConfig = Record<string, System>;

package/src/utils/systems/utils.ts

@@ -1,42 +0,0 @@
-import { ethers } from "ethers";
-import { ParamType } from "ethers/lib/utils.js";
-import { getContractData } from "../utils/getContractData";
-
-export function loadFunctionSignatures(contractName: string, forgeOutDirectory: string): string[] {
-  const { abi } = getContractData(contractName, forgeOutDirectory);
-
-  return abi
-    .filter((item) => ["fallback", "function"].includes(item.type))
-    .map((item) => {
-      return `${item.name}${parseComponents(item.inputs)}`;
-    });
-}
-
-// TODO: move this to utils as soon as utils are usable inside cli
-// (see https://github.com/latticexyz/mud/issues/499)
-export function toFunctionSelector(functionSignature: string): string {
-  return sigHash(functionSignature);
-}
-
-/**
- * Recursively turn (nested) structs in signatures into tuples
- */
-function parseComponents(params: ParamType[]): string {
-  const components = params.map((param) => {
-    const tupleMatch = param.type.match(/tuple(.*)/);
-    if (tupleMatch) {
-      // there can be arrays of tuples,
-      // `tupleMatch[1]` preserves the array brackets (or is empty string for non-arrays)
-      return parseComponents(param.components) + tupleMatch[1];
-    } else {
-      return param.type;
-    }
-  });
-  return `(${components})`;
-}
-
-// TODO: move this to utils as soon as utils are usable inside cli
-// (see https://github.com/latticexyz/mud/issues/499)
-function sigHash(signature: string) {
-  return ethers.utils.hexDataSlice(ethers.utils.keccak256(ethers.utils.toUtf8Bytes(signature)), 0, 4);
-}

package/src/utils/tables/getRegisterTableCallData.ts

@@ -1,49 +0,0 @@
-import { encodeSchema, getStaticByteLength } from "@latticexyz/schema-type/deprecated";
-import { StoreConfig } from "@latticexyz/store";
-import { resolveAbiOrUserType } from "@latticexyz/store/codegen";
-import { resourceIdToHex } from "@latticexyz/common";
-import { Table } from "./types";
-import { fieldLayoutToHex } from "@latticexyz/protocol-parser";
-import { CallData } from "../utils/types";
-import { loadAndExtractUserTypes } from "@latticexyz/common/codegen";
-
-export function getRegisterTableCallData(
-  table: Table,
-  storeConfig: StoreConfig,
-  outputBaseDirectory: string,
-  remappings: [string, string][]
-): CallData {
-  const { name, valueSchema, keySchema } = table;
-  if (!name) throw Error("Table missing name");
-
-  const solidityUserTypes = loadAndExtractUserTypes(storeConfig.userTypes, outputBaseDirectory, remappings);
-
-  const schemaTypes = Object.values(valueSchema).map((abiOrUserType) => {
-    const { schemaType } = resolveAbiOrUserType(abiOrUserType, storeConfig, solidityUserTypes);
-    return schemaType;
-  });
-
-  const schemaTypeLengths = schemaTypes.map((schemaType) => getStaticByteLength(schemaType));
-  const fieldLayout = {
-    staticFieldLengths: schemaTypeLengths.filter((schemaTypeLength) => schemaTypeLength > 0),
-    numDynamicFields: schemaTypeLengths.filter((schemaTypeLength) => schemaTypeLength === 0).length,
-  };
-
-  const keyTypes = Object.values(keySchema).map((abiOrUserType) => {
-    const { schemaType } = resolveAbiOrUserType(abiOrUserType, storeConfig, solidityUserTypes);
-    return schemaType;
-  });
-
-  return {
-    func: "registerTable",
-    args: [
-      // TODO: add support for table namespaces (https://github.com/latticexyz/mud/issues/994)
-      resourceIdToHex({ type: table.offchainOnly ? "offchainTable" : "table", namespace: storeConfig.namespace, name }),
-      fieldLayoutToHex(fieldLayout),
-      encodeSchema(keyTypes),
-      encodeSchema(schemaTypes),
-      Object.keys(keySchema),
-      Object.keys(valueSchema),
-    ],
-  };
-}

package/src/utils/tables/getTableIds.ts

@@ -1,18 +0,0 @@
-import { StoreConfig } from "@latticexyz/store";
-import { TableIds } from "./types";
-import { resourceIdToHex } from "@latticexyz/common";
-import { hexToBytes } from "viem";
-
-export function getTableIds(storeConfig: StoreConfig): TableIds {
-  const tableIds: TableIds = {};
-  for (const [tableName, { name, offchainOnly }] of Object.entries(storeConfig.tables)) {
-    tableIds[tableName] = hexToBytes(
-      resourceIdToHex({
-        type: offchainOnly ? "offchainTable" : "table",
-        namespace: storeConfig.namespace,
-        name,
-      })
-    );
-  }
-  return tableIds;
-}

package/src/utils/tables/types.ts

@@ -1,12 +0,0 @@
-export type Table = {
-  valueSchema: Record<string, string>;
-  keySchema: Record<string, string>;
-  directory: string;
-  tableIdArgument: boolean;
-  storeArgument: boolean;
-  offchainOnly: boolean;
-  name?: string | undefined;
-  dataStruct?: boolean | undefined;
-};
-
-export type TableIds = { [tableName: string]: Uint8Array };

package/src/utils/utils/confirmNonce.ts

@@ -1,24 +0,0 @@
-import chalk from "chalk";
-import { Wallet } from "ethers";
-import { MUDError } from "@latticexyz/common/errors";
-
-export async function confirmNonce(signer: Wallet, nonce: number, pollInterval: number): Promise<void> {
-  let remoteNonce = await signer.getTransactionCount();
-  let retryCount = 0;
-  const maxRetries = 100;
-  while (remoteNonce !== nonce && retryCount < maxRetries) {
-    console.log(
-      chalk.gray(
-        `Waiting for transactions to be included before executing postDeployScript (local nonce: ${nonce}, remote nonce: ${remoteNonce}, retry number ${retryCount}/${maxRetries})`
-      )
-    );
-    await new Promise((resolve) => setTimeout(resolve, pollInterval));
-    retryCount++;
-    remoteNonce = await signer.getTransactionCount();
-  }
-  if (remoteNonce !== nonce) {
-    throw new MUDError(
-      "Remote nonce doesn't match local nonce, indicating that not all deploy transactions were included."
-    );
-  }
-}