@latticexyz/cli 2.0.0-alpha.94 → 2.0.0-main-0d434816

package/src/utils/{deploy-v2.ts → deploy.ts}

@@ -1,21 +1,24 @@
 import { existsSync, readFileSync } from "fs";
 import path from "path";
-import { MUDConfig, resolveWithContext } from "@latticexyz/config";
-import { MUDError } from "@latticexyz/config";
-import { getOutDirectory, getScriptDirectory, cast, forge } from "./foundry.js";
-import { BigNumber, ContractInterface, ethers } from "ethers";
-import { IBaseWorld } from "@latticexyz/world/types/ethers-contracts/IBaseWorld.js";
 import chalk from "chalk";
-import { encodeSchema } from "@latticexyz/schema-type";
-import { resolveAbiOrUserType } from "../render-solidity/userType.js";
-import { defaultAbiCoder as abi, Fragment } from "ethers/lib/utils.js";
-
-import WorldData from "@latticexyz/world/abi/World.json" assert { type: "json" };
-import IBaseWorldData from "@latticexyz/world/abi/IBaseWorld.json" assert { type: "json" };
-import CoreModuleData from "@latticexyz/world/abi/CoreModule.json" assert { type: "json" };
-import RegistrationModuleData from "@latticexyz/world/abi/RegistrationModule.json" assert { type: "json" };
-import KeysWithValueModuleData from "@latticexyz/world/abi/KeysWithValueModule.json" assert { type: "json" };
-import UniqueEntityModuleData from "@latticexyz/world/abi/UniqueEntityModule.json" assert { type: "json" };
+import { BigNumber, ContractInterface, ethers } from "ethers";
+import { defaultAbiCoder as abi, Fragment, ParamType } from "ethers/lib/utils.js";
+
+import { getOutDirectory, getScriptDirectory, cast, forge } from "@latticexyz/common/foundry";
+import { resolveWithContext } from "@latticexyz/config";
+import { MUDError } from "@latticexyz/common/errors";
+import { encodeSchema } from "@latticexyz/schema-type/deprecated";
+import { StoreConfig } from "@latticexyz/store";
+import { resolveAbiOrUserType } from "@latticexyz/store/codegen";
+import { WorldConfig, resolveWorldConfig } from "@latticexyz/world";
+import { IBaseWorld } from "@latticexyz/world/types/ethers-contracts/IBaseWorld";
+import WorldData from "@latticexyz/world/abi/World.sol/World.json" assert { type: "json" };
+import IBaseWorldData from "@latticexyz/world/abi/IBaseWorld.sol/IBaseWorld.json" assert { type: "json" };
+import CoreModuleData from "@latticexyz/world/abi/CoreModule.sol/CoreModule.json" assert { type: "json" };
+import KeysWithValueModuleData from "@latticexyz/world/abi/KeysWithValueModule.sol/KeysWithValueModule.json" assert { type: "json" };
+import KeysInTableModuleData from "@latticexyz/world/abi/KeysInTableModule.sol/KeysInTableModule.json" assert { type: "json" };
+import UniqueEntityModuleData from "@latticexyz/world/abi/UniqueEntityModule.sol/UniqueEntityModule.json" assert { type: "json" };
+import SnapSyncModuleData from "@latticexyz/world/abi/SnapSyncModule.sol/SnapSyncModule.json" assert { type: "json" };
 
 export interface DeployConfig {
   profile?: string;
@@ -24,6 +27,8 @@ export interface DeployConfig {
   priorityFeeMultiplier: number;
   debug?: boolean;
   worldAddress?: string;
+  disableTxWait: boolean;
+  pollInterval: number;
 }
 
 export interface DeploymentInfo {
@@ -31,14 +36,22 @@ export interface DeploymentInfo {
   worldAddress: string;
 }
 
-export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig): Promise<DeploymentInfo> {
+export async function deploy(
+  mudConfig: StoreConfig & WorldConfig,
+  existingContractNames: string[],
+  deployConfig: DeployConfig
+): Promise<DeploymentInfo> {
+  const resolvedConfig = resolveWorldConfig(mudConfig, existingContractNames);
+
   const startTime = Date.now();
   const { worldContractName, namespace, postDeployScript } = mudConfig;
-  const { profile, rpc, privateKey, priorityFeeMultiplier, debug, worldAddress } = deployConfig;
+  const { profile, rpc, privateKey, priorityFeeMultiplier, debug, worldAddress, disableTxWait, pollInterval } =
+    deployConfig;
   const forgeOutDirectory = await getOutDirectory(profile);
 
   // Set up signer for deployment
   const provider = new ethers.providers.StaticJsonRpcProvider(rpc);
+  provider.pollingInterval = pollInterval;
   const signer = new ethers.Wallet(privateKey, provider);
 
   // Manual nonce handling to allow for faster sending of transactions without waiting for previous transactions
@@ -48,7 +61,7 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
   // Compute maxFeePerGas and maxPriorityFeePerGas like ethers, but allow for a multiplier to allow replacing pending transactions
   let maxPriorityFeePerGas: number;
   let maxFeePerGas: BigNumber;
-  setInternalFeePerGas(priorityFeeMultiplier);
+  await setInternalFeePerGas(priorityFeeMultiplier);
 
   // Catch all to await any promises before exiting the script
   let promises: Promise<unknown>[] = [];
@@ -62,42 +75,54 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
     World: worldAddress
       ? Promise.resolve(worldAddress)
       : worldContractName
-      ? deployContractByName(worldContractName)
-      : deployContract(IBaseWorldData.abi, WorldData.bytecode, "World"),
+      ? deployContractByName(worldContractName, disableTxWait)
+      : deployContract(IBaseWorldData.abi, WorldData.bytecode, disableTxWait, "World"),
   };
 
   // Deploy Systems
-  const systemPromises = Object.keys(mudConfig.systems).reduce<Record<string, Promise<string>>>((acc, systemName) => {
-    acc[systemName] = deployContractByName(systemName);
-    return acc;
-  }, {});
+  const systemPromises = Object.keys(resolvedConfig.systems).reduce<Record<string, Promise<string>>>(
+    (acc, systemName) => {
+      acc[systemName] = deployContractByName(systemName, disableTxWait);
+      return acc;
+    },
+    {}
+  );
 
   // Deploy default World modules
   const defaultModules: Record<string, Promise<string>> = {
     // TODO: these only need to be deployed once per chain, add a check if they exist already
-    CoreModule: deployContract(CoreModuleData.abi, CoreModuleData.bytecode, "CoreModule"),
-    RegistrationModule: deployContract(
-      RegistrationModuleData.abi,
-      RegistrationModuleData.bytecode,
-      "RegistrationModule"
-    ),
+    CoreModule: deployContract(CoreModuleData.abi, CoreModuleData.bytecode, disableTxWait, "CoreModule"),
     KeysWithValueModule: deployContract(
       KeysWithValueModuleData.abi,
       KeysWithValueModuleData.bytecode,
+      disableTxWait,
       "KeysWithValueModule"
     ),
+    KeysInTableModule: deployContract(
+      KeysInTableModuleData.abi,
+      KeysInTableModuleData.bytecode,
+      disableTxWait,
+      "KeysInTableModule"
+    ),
     UniqueEntityModule: deployContract(
       UniqueEntityModuleData.abi,
       UniqueEntityModuleData.bytecode,
+      disableTxWait,
       "UniqueEntityModule"
     ),
+    SnapSyncModule: deployContract(
+      SnapSyncModuleData.abi,
+      SnapSyncModuleData.bytecode,
+      disableTxWait,
+      "SnapSyncModule"
+    ),
   };
 
   // Deploy user Modules
   const modulePromises = mudConfig.modules
     .filter((module) => !defaultModules[module.name]) // Only deploy user modules here, not default modules
     .reduce<Record<string, Promise<string>>>((acc, module) => {
-      acc[module.name] = deployContractByName(module.name);
+      acc[module.name] = deployContractByName(module.name, disableTxWait);
       return acc;
     }, defaultModules);
 
@@ -107,22 +132,23 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
   // Create World contract instance from deployed address
   const WorldContract = new ethers.Contract(await contractPromises.World, IBaseWorldData.abi, signer) as IBaseWorld;
 
+  const confirmations = disableTxWait ? 0 : 1;
+
   // Install core Modules
   if (!worldAddress) {
     console.log(chalk.blue("Installing core World modules"));
-    await fastTxExecute(WorldContract, "installRootModule", [await modulePromises.CoreModule, "0x"]);
-    await fastTxExecute(WorldContract, "installRootModule", [await modulePromises.RegistrationModule, "0x"]);
+    await fastTxExecute(WorldContract, "installRootModule", [await modulePromises.CoreModule, "0x"], confirmations);
     console.log(chalk.green("Installed core World modules"));
   }
 
   // Register namespace
-  if (namespace) await fastTxExecute(WorldContract, "registerNamespace", [toBytes16(namespace)]);
+  if (namespace) await fastTxExecute(WorldContract, "registerNamespace", [toBytes16(namespace)], confirmations);
 
   // Register tables
   const tableIds: { [tableName: string]: Uint8Array } = {};
   promises = [
     ...promises,
-    ...Object.entries(mudConfig.tables).map(async ([tableName, { name, schema, primaryKeys }]) => {
+    ...Object.entries(mudConfig.tables).map(async ([tableName, { name, schema, keySchema }]) => {
       console.log(chalk.blue(`Registering table ${tableName} at ${namespace}/${name}`));
 
       // Store the tableId for later use
@@ -134,25 +160,25 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
         return schemaType;
       });
 
-      const keyTypes = Object.values(primaryKeys).map((abiOrUserType) => {
+      const keyTypes = Object.values(keySchema).map((abiOrUserType) => {
         const { schemaType } = resolveAbiOrUserType(abiOrUserType, mudConfig);
         return schemaType;
       });
 
-      await fastTxExecute(WorldContract, "registerTable", [
-        toBytes16(namespace),
-        toBytes16(name),
-        encodeSchema(schemaTypes),
-        encodeSchema(keyTypes),
-      ]);
+      await fastTxExecute(
+        WorldContract,
+        "registerTable",
+        [toBytes16(namespace), toBytes16(name), encodeSchema(schemaTypes), encodeSchema(keyTypes)],
+        confirmations
+      );
 
       // Register table metadata
-      await fastTxExecute(WorldContract, "setMetadata(bytes16,bytes16,string,string[])", [
-        toBytes16(namespace),
-        toBytes16(name),
-        tableName,
-        Object.keys(schema),
-      ]);
+      await fastTxExecute(
+        WorldContract,
+        "setMetadata(bytes16,bytes16,string,string[])",
+        [toBytes16(namespace), toBytes16(name), tableName, Object.keys(schema)],
+        confirmations
+      );
 
       console.log(chalk.green(`Registered table ${tableName} at ${name}`));
     }),
@@ -161,55 +187,57 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
   // Register systems (using forEach instead of for..of to avoid blocking on async calls)
   promises = [
     ...promises,
-    ...Object.entries(mudConfig.systems).map(async ([systemName, { name, openAccess, registerFunctionSelectors }]) => {
-      // Register system at route
-      console.log(chalk.blue(`Registering system ${systemName} at ${namespace}/${name}`));
-      await fastTxExecute(WorldContract, "registerSystem", [
-        toBytes16(namespace),
-        toBytes16(name),
-        await contractPromises[systemName],
-        openAccess,
-      ]);
-      console.log(chalk.green(`Registered system ${systemName} at ${namespace}/${name}`));
-
-      // Register function selectors for the system
-      if (registerFunctionSelectors) {
-        const functionSignatures: FunctionSignature[] = await loadFunctionSignatures(systemName);
-        const isRoot = namespace === "";
-        // Using Promise.all to avoid blocking on async calls
-        await Promise.all(
-          functionSignatures.map(async ({ functionName, functionArgs }) => {
-            const functionSignature = isRoot
-              ? functionName + functionArgs
-              : `${namespace}_${name}_${functionName}${functionArgs}`;
-
-            console.log(chalk.blue(`Registering function "${functionSignature}"`));
-            if (isRoot) {
-              const worldFunctionSelector = toFunctionSelector(
-                functionSignature === ""
-                  ? { functionName: systemName, functionArgs } // Register the system's fallback function as `<systemName>(<args>)`
-                  : { functionName, functionArgs }
-              );
-              const systemFunctionSelector = toFunctionSelector({ functionName, functionArgs });
-              await fastTxExecute(WorldContract, "registerRootFunctionSelector", [
-                toBytes16(namespace),
-                toBytes16(name),
-                worldFunctionSelector,
-                systemFunctionSelector,
-              ]);
-            } else {
-              await fastTxExecute(WorldContract, "registerFunctionSelector", [
-                toBytes16(namespace),
-                toBytes16(name),
-                functionName,
-                functionArgs,
-              ]);
-            }
-            console.log(chalk.green(`Registered function "${functionSignature}"`));
-          })
+    ...Object.entries(resolvedConfig.systems).map(
+      async ([systemName, { name, openAccess, registerFunctionSelectors }]) => {
+        // Register system at route
+        console.log(chalk.blue(`Registering system ${systemName} at ${namespace}/${name}`));
+        await fastTxExecute(
+          WorldContract,
+          "registerSystem",
+          [toBytes16(namespace), toBytes16(name), await contractPromises[systemName], openAccess],
+          confirmations
         );
+        console.log(chalk.green(`Registered system ${systemName} at ${namespace}/${name}`));
+
+        // Register function selectors for the system
+        if (registerFunctionSelectors) {
+          const functionSignatures: FunctionSignature[] = await loadFunctionSignatures(systemName);
+          const isRoot = namespace === "";
+          // Using Promise.all to avoid blocking on async calls
+          await Promise.all(
+            functionSignatures.map(async ({ functionName, functionArgs }) => {
+              const functionSignature = isRoot
+                ? functionName + functionArgs
+                : `${namespace}_${name}_${functionName}${functionArgs}`;
+
+              console.log(chalk.blue(`Registering function "${functionSignature}"`));
+              if (isRoot) {
+                const worldFunctionSelector = toFunctionSelector(
+                  functionSignature === ""
+                    ? { functionName: systemName, functionArgs } // Register the system's fallback function as `<systemName>(<args>)`
+                    : { functionName, functionArgs }
+                );
+                const systemFunctionSelector = toFunctionSelector({ functionName, functionArgs });
+                await fastTxExecute(
+                  WorldContract,
+                  "registerRootFunctionSelector",
+                  [toBytes16(namespace), toBytes16(name), worldFunctionSelector, systemFunctionSelector],
+                  confirmations
+                );
+              } else {
+                await fastTxExecute(
+                  WorldContract,
+                  "registerFunctionSelector",
+                  [toBytes16(namespace), toBytes16(name), functionName, functionArgs],
+                  confirmations
+                );
+              }
+              console.log(chalk.green(`Registered function "${functionSignature}"`));
+            })
+          );
+        }
       }
-    }),
+    ),
   ];
 
   // Wait for resources to be registered before granting access to them
@@ -217,7 +245,7 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
   promises = [];
 
   // Grant access to systems
-  for (const [systemName, { name, accessListAddresses, accessListSystems }] of Object.entries(mudConfig.systems)) {
+  for (const [systemName, { name, accessListAddresses, accessListSystems }] of Object.entries(resolvedConfig.systems)) {
     const resourceSelector = `${namespace}/${name}`;
 
     // Grant access to addresses
@@ -225,11 +253,12 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
       ...promises,
       ...accessListAddresses.map(async (address) => {
         console.log(chalk.blue(`Grant ${address} access to ${systemName} (${resourceSelector})`));
-        await fastTxExecute(WorldContract, "grantAccess(bytes16,bytes16,address)", [
-          toBytes16(namespace),
-          toBytes16(name),
-          address,
-        ]);
+        await fastTxExecute(
+          WorldContract,
+          "grantAccess",
+          [toBytes16(namespace), toBytes16(name), address],
+          confirmations
+        );
         console.log(chalk.green(`Granted ${address} access to ${systemName} (${namespace}/${name})`));
       }),
     ];
@@ -239,11 +268,12 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
       ...promises,
       ...accessListSystems.map(async (granteeSystem) => {
         console.log(chalk.blue(`Grant ${granteeSystem} access to ${systemName} (${resourceSelector})`));
-        await fastTxExecute(WorldContract, "grantAccess(bytes16,bytes16,address)", [
-          toBytes16(namespace),
-          toBytes16(name),
-          await contractPromises[granteeSystem],
-        ]);
+        await fastTxExecute(
+          WorldContract,
+          "grantAccess",
+          [toBytes16(namespace), toBytes16(name), await contractPromises[granteeSystem]],
+          confirmations
+        );
         console.log(chalk.green(`Granted ${granteeSystem} access to ${systemName} (${resourceSelector})`));
       }),
     ];
@@ -268,10 +298,12 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
       if (!moduleAddress) throw new Error(`Module ${module.name} not found`);
 
       // Send transaction to install module
-      await fastTxExecute(WorldContract, module.root ? "installRootModule" : "installModule", [
-        moduleAddress,
-        abi.encode(types, values),
-      ]);
+      await fastTxExecute(
+        WorldContract,
+        module.root ? "installRootModule" : "installModule",
+        [moduleAddress, abi.encode(types, values)],
+        confirmations
+      );
 
       console.log(chalk.green(`Installed${module.root ? " root " : " "}module ${module.name}`));
     }),
@@ -279,6 +311,27 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
 
   // Await all promises before executing PostDeploy script
   await Promise.all(promises); // ----------------------------------------------------------------------------------------------
+
+  // Confirm the current nonce is the expected nonce to make sure all transactions have been included
+  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."
+    );
+  }
+
   promises = [];
 
   // Execute postDeploy forge script
@@ -315,36 +368,43 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
   /**
    * Deploy a contract and return the address
    * @param contractName Name of the contract to deploy (must exist in the file system)
+   * @param disableTxWait Disable waiting for contract deployment
    * @returns Address of the deployed contract
    */
-  async function deployContractByName(contractName: string): Promise<string> {
+  async function deployContractByName(contractName: string, disableTxWait: boolean): Promise<string> {
     console.log(chalk.blue("Deploying", contractName));
 
     const { abi, bytecode } = await getContractData(contractName);
-    return deployContract(abi, bytecode, contractName);
+    return deployContract(abi, bytecode, disableTxWait, contractName);
   }
 
   /**
    * Deploy a contract and return the address
    * @param abi The contract interface
    * @param bytecode The contract bytecode
+   * @param disableTxWait Disable waiting for contract deployment
    * @param contractName The contract name (optional, used for logs)
+   * @param retryCount
    * @returns Address of the deployed contract
    */
   async function deployContract(
     abi: ContractInterface,
     bytecode: string | { object: string },
+    disableTxWait: boolean,
     contractName?: string,
     retryCount = 0
   ): Promise<string> {
     try {
       const factory = new ethers.ContractFactory(abi, bytecode, signer);
       console.log(chalk.gray(`executing deployment of ${contractName} with nonce ${nonce}`));
-      const deployPromise = factory.deploy({
-        nonce: nonce++,
-        maxPriorityFeePerGas,
-        maxFeePerGas,
-      });
+      const deployPromise = factory
+        .deploy({
+          nonce: nonce++,
+          maxPriorityFeePerGas,
+          maxFeePerGas,
+        })
+        .then((c) => (disableTxWait ? c : c.deployed()));
+
       promises.push(deployPromise);
       const { address } = await deployPromise;
 
@@ -356,7 +416,7 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
         // If the deployment failed because the transaction was already imported,
         // retry with a higher priority fee
         setInternalFeePerGas(priorityFeeMultiplier * 1.1);
-        return deployContract(abi, bytecode, contractName, retryCount++);
+        return deployContract(abi, bytecode, disableTxWait, contractName, retryCount++);
       } else if (error?.message.includes("invalid bytecode")) {
         throw new MUDError(
           `Error deploying ${contractName}: invalid bytecode. Note that linking of public libraries is not supported yet, make sure none of your libraries use "external" functions.`
@@ -398,10 +458,30 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
       .map((item) => {
         if (item.type === "fallback") return { functionName: "", functionArgs: "" };
 
-        return { functionName: item.name, functionArgs: `(${item.inputs.map((arg) => arg.type).join(",")})` };
+        return {
+          functionName: item.name,
+          functionArgs: parseComponents(item.inputs),
+        };
       });
   }
 
+  /**
+   * 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})`;
+  }
+
   /**
    * Only await gas estimation (for speed), only execute if gas estimation succeeds (for safety)
    */
@@ -409,8 +489,8 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
     contract: C,
     func: F,
     args: Parameters<C[F]>,
-    retryCount = 0,
-    confirmations = 1
+    confirmations = 1,
+    retryCount = 0
   ): Promise<Awaited<ReturnType<Awaited<ReturnType<C[F]>>["wait"]>>> {
     const functionName = `${func as string}(${args.map((arg) => `'${arg}'`).join(",")})`;
     try {
@@ -418,7 +498,7 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
       console.log(chalk.gray(`executing transaction: ${functionName} with nonce ${nonce}`));
       const txPromise = contract[func]
         .apply(null, [...args, { gasLimit, nonce: nonce++, maxPriorityFeePerGas, maxFeePerGas }])
-        .then((tx: any) => tx.wait(confirmations));
+        .then((tx: any) => (confirmations === 0 ? tx : tx.wait(confirmations)));
       promises.push(txPromise);
       return txPromise;
     } catch (error: any) {
@@ -427,7 +507,7 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
         // If the deployment failed because the transaction was already imported,
         // retry with a higher priority fee
         setInternalFeePerGas(priorityFeeMultiplier * 1.1);
-        return fastTxExecute(contract, func, args, retryCount++, confirmations);
+        return fastTxExecute(contract, func, args, confirmations, retryCount++);
       } else throw new MUDError(`Gas estimation error for ${functionName}: ${error?.reason}`);
     }
   }
@@ -463,6 +543,10 @@ export async function deploy(mudConfig: MUDConfig, deployConfig: DeployConfig):
     // Compute maxFeePerGas and maxPriorityFeePerGas like ethers, but allow for a multiplier to allow replacing pending transactions
     const feeData = await provider.getFeeData();
     if (!feeData.lastBaseFeePerGas) throw new MUDError("Can not fetch lastBaseFeePerGas from RPC");
+    if (!feeData.lastBaseFeePerGas.eq(0) && (await signer.getBalance()).eq(0)) {
+      throw new MUDError(`Attempting to deploy to a chain with non-zero base fee with an account that has no balance.
+If you're deploying to the Lattice testnet, you can fund your account by running 'pnpm mud faucet --address ${await signer.getAddress()}'`);
+    }
 
     // Set the priority fee to 0 for development chains with no base fee, to allow transactions from unfunded wallets
     maxPriorityFeePerGas = feeData.lastBaseFeePerGas.eq(0) ? 0 : Math.floor(1_500_000_000 * multiplier);

package/src/utils/deployHandler.ts

@@ -0,0 +1,87 @@
+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 { getChainId } from "../utils/getChainId";
+import { getExistingContracts } from "./getExistingContracts";
+
+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"], { profile });
+
+  // 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/errors.ts

@@ -2,7 +2,7 @@ import chalk from "chalk";
 import { ZodError } from "zod";
 import { fromZodError, ValidationError } from "zod-validation-error";
 import { NotInsideProjectError } from "@latticexyz/config";
-import { MUDError } from "@latticexyz/config";
+import { MUDError } from "@latticexyz/common/errors";
 
 export function logError(error: unknown) {
   if (error instanceof ValidationError) {

package/src/utils/getExistingContracts.ts

@@ -0,0 +1,12 @@
+import glob from "glob";
+import { basename } from "path";
+
+/**
+ * Get a list of all contract paths/names within the provided src directory
+ */
+export function getExistingContracts(srcDir: string) {
+  return glob.sync(`${srcDir}/**/*.sol`).map((path) => ({
+    path,
+    basename: basename(path, ".sol"),
+  }));
+}

package/src/utils/index.ts

@@ -1,5 +1,7 @@
-export * from "./errors.js";
-export * from "./foundry.js";
-export * from "./format.js";
-export * from "./formatAndWrite.js";
-export * from "./deploy-v2.js";
+export * from "./deploy";
+export * from "./deployHandler";
+export * from "./errors";
+export * from "./getChainId";
+export * from "./getExistingContracts";
+export * from "./printMUD";
+export * from "./worldtypes";