@latticexyz/cli 2.0.7-account-kit-49e54f3e → 2.0.7-account-kit-46c44c7e

package/src/commands/index.ts

@@ -14,6 +14,7 @@ import setVersion from "./set-version";
 import test from "./test";
 import trace from "./trace";
 import devContracts from "./dev-contracts";
+import verify from "./verify";
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Each command has different options
 export const commands: CommandModule<any, any>[] = [
@@ -30,4 +31,5 @@ export const commands: CommandModule<any, any>[] = [
   trace,
   devContracts,
   abiTs,
+  verify,
 ];

package/src/commands/tablegen.ts

@@ -16,7 +16,7 @@ const commandModule: CommandModule<Options, Options> = {
 
   builder(yargs) {
     return yargs.options({
-      configPath: { type: "string", desc: "Path to the config file" },
+      configPath: { type: "string", desc: "Path to the MUD config file" },
     });
   },
 

package/src/commands/trace.ts

@@ -43,7 +43,7 @@ const commandModule: CommandModule<Options, Options> = {
         type: "string",
         description: "World contract address. Defaults to the value from worlds.json, based on rpc's chainId",
       },
-      configPath: { type: "string", description: "Path to the config file" },
+      configPath: { type: "string", description: "Path to the MUD config file" },
       profile: { type: "string", description: "The foundry profile to use" },
       srcDir: { type: "string", description: "Source directory. Defaults to foundry src directory." },
       rpc: { type: "string", description: "json rpc endpoint. Defaults to foundry's configured eth_rpc_url" },

package/src/commands/verify.ts

@@ -0,0 +1,111 @@
+import type { CommandModule, InferredOptionTypes } from "yargs";
+import { verify } from "../verify";
+import { loadConfig } from "@latticexyz/config/node";
+import { World as WorldConfig } from "@latticexyz/world";
+import { resolveWorldConfig } from "@latticexyz/world/internal";
+import { worldToV1 } from "@latticexyz/world/config/v2";
+import { getOutDirectory, getRpcUrl, getSrcDirectory } from "@latticexyz/common/foundry";
+import { getExistingContracts } from "../utils/getExistingContracts";
+import { getContractData } from "../utils/getContractData";
+import { defaultModuleContracts } from "../utils/defaultModuleContracts";
+import { Hex, createWalletClient, http } from "viem";
+import chalk from "chalk";
+
+const verifyOptions = {
+  deployerAddress: {
+    type: "string",
+    desc: "Deploy using an existing deterministic deployer (https://github.com/Arachnid/deterministic-deployment-proxy)",
+  },
+  worldAddress: { type: "string", required: true, desc: "Verify an existing World at the given address" },
+  configPath: { type: "string", desc: "Path to the MUD config file" },
+  profile: { type: "string", desc: "The foundry profile to use" },
+  rpc: { type: "string", desc: "The RPC URL to use. Defaults to the RPC url from the local foundry.toml" },
+  rpcBatch: {
+    type: "boolean",
+    desc: "Enable batch processing of RPC requests in viem client (defaults to batch size of 100 and wait of 1s)",
+  },
+  srcDir: { type: "string", desc: "Source directory. Defaults to foundry src directory." },
+  verifier: { type: "string", desc: "The verifier to use" },
+  verifierUrl: {
+    type: "string",
+    desc: "The verification provider.",
+  },
+} as const;
+
+type Options = InferredOptionTypes<typeof verifyOptions>;
+
+const commandModule: CommandModule<Options, Options> = {
+  command: "verify",
+
+  describe: "Verify contracts",
+
+  builder(yargs) {
+    return yargs.options(verifyOptions);
+  },
+
+  async handler(opts) {
+    const profile = opts.profile ?? process.env.FOUNDRY_PROFILE;
+
+    const configV2 = (await loadConfig(opts.configPath)) as WorldConfig;
+    const config = worldToV1(configV2);
+
+    const srcDir = opts.srcDir ?? (await getSrcDirectory(profile));
+    const outDir = await getOutDirectory(profile);
+
+    const rpc = opts.rpc ?? (await getRpcUrl(profile));
+    console.log(
+      chalk.bgBlue(
+        chalk.whiteBright(`\n Verifying MUD contracts${profile ? " with profile " + profile : ""} to RPC ${rpc} \n`),
+      ),
+    );
+
+    const client = createWalletClient({
+      transport: http(rpc, {
+        batch: opts.rpcBatch
+          ? {
+              batchSize: 100,
+              wait: 1000,
+            }
+          : undefined,
+      }),
+    });
+
+    const contractNames = getExistingContracts(srcDir).map(({ basename }) => basename);
+    const resolvedWorldConfig = resolveWorldConfig(config, contractNames);
+
+    const systems = Object.keys(resolvedWorldConfig.systems).map((name) => {
+      const contractData = getContractData(`${name}.sol`, name, outDir);
+
+      return {
+        name,
+        bytecode: contractData.bytecode,
+      };
+    });
+
+    // Get modules
+    const modules = config.modules.map((mod) => {
+      const contractData =
+        defaultModuleContracts.find((defaultMod) => defaultMod.name === mod.name) ??
+        getContractData(`${mod.name}.sol`, mod.name, outDir);
+
+      return {
+        name: mod.name,
+        bytecode: contractData.bytecode,
+      };
+    });
+
+    await verify({
+      client,
+      rpc,
+      foundryProfile: profile,
+      systems,
+      modules,
+      deployerAddress: opts.deployerAddress as Hex | undefined,
+      worldAddress: opts.worldAddress as Hex,
+      verifier: opts.verifier,
+      verifierUrl: opts.verifierUrl,
+    });
+  },
+};
+
+export default commandModule;

package/src/commands/worldgen.ts

@@ -21,7 +21,7 @@ const commandModule: CommandModule<Options, Options> = {
 
   builder(yargs) {
     return yargs.options({
-      configPath: { type: "string", desc: "Path to the config file" },
+      configPath: { type: "string", desc: "Path to the MUD config file" },
       clean: {
         type: "boolean",
         desc: "Clear the worldgen directory before generating new interfaces (defaults to true)",

package/src/deploy/deploy.ts

@@ -28,6 +28,7 @@ type DeployOptions<configInput extends ConfigInput> = {
    * not have a deterministic address.
    */
   deployerAddress?: Hex;
+  withWorldProxy?: boolean;
 };
 
 /**
@@ -42,12 +43,13 @@ export async function deploy<configInput extends ConfigInput>({
   salt,
   worldAddress: existingWorldAddress,
   deployerAddress: initialDeployerAddress,
+  withWorldProxy,
 }: DeployOptions<configInput>): Promise<WorldDeploy> {
   const tables = Object.values(config.tables) as Table[];
 
   const deployerAddress = initialDeployerAddress ?? (await ensureDeployer(client));
 
-  await ensureWorldFactory(client, deployerAddress);
+  await ensureWorldFactory(client, deployerAddress, withWorldProxy);
 
   // deploy all dependent contracts, because system registration, module install, etc. all expect these contracts to be callable.
   await ensureContractsDeployed({
@@ -74,7 +76,7 @@ export async function deploy<configInput extends ConfigInput>({
 
   const worldDeploy = existingWorldAddress
     ? await getWorldDeploy(client, existingWorldAddress)
-    : await deployWorld(client, deployerAddress, salt ?? `0x${randomBytes(32).toString("hex")}`);
+    : await deployWorld(client, deployerAddress, salt ?? `0x${randomBytes(32).toString("hex")}`, withWorldProxy);
 
   if (!supportedStoreVersions.includes(worldDeploy.storeVersion)) {
     throw new Error(`Unsupported Store version: ${worldDeploy.storeVersion}`);

package/src/deploy/deployWorld.ts

@@ -11,8 +11,9 @@ export async function deployWorld(
   client: Client<Transport, Chain | undefined, Account>,
   deployerAddress: Hex,
   salt: Hex,
+  withWorldProxy?: boolean,
 ): Promise<WorldDeploy> {
-  const worldFactory = await ensureWorldFactory(client, deployerAddress);
+  const worldFactory = await ensureWorldFactory(client, deployerAddress, withWorldProxy);
 
   debug("deploying world");
   const tx = await writeContract(client, {

package/src/deploy/ensureDeployer.ts

@@ -1,21 +1,15 @@
-import { Account, Address, Chain, Client, Transport, sliceHex } from "viem";
-import { getBalance, getBytecode, sendRawTransaction, sendTransaction, waitForTransactionReceipt } from "viem/actions";
+import { Account, Address, Chain, Client, Transport } from "viem";
+import { getBalance, sendRawTransaction, sendTransaction, waitForTransactionReceipt } from "viem/actions";
 import deployment from "./create2/deployment.json";
 import { debug } from "./debug";
+import { getDeployer } from "./getDeployer";
 
 const deployer = `0x${deployment.address}` as const;
 
 export async function ensureDeployer(client: Client<Transport, Chain | undefined, Account>): Promise<Address> {
-  const bytecode = await getBytecode(client, { address: deployer });
-  if (bytecode) {
-    debug("found CREATE2 deployer at", deployer);
-    // check if deployed bytecode is the same as the expected bytecode (minus 14-bytes creation code prefix)
-    if (bytecode !== sliceHex(`0x${deployment.creationCode}`, 14)) {
-      console.warn(
-        `\n  ⚠️ Bytecode for deployer at ${deployer} did not match the expected CREATE2 bytecode. You may have unexpected results.\n`,
-      );
-    }
-    return deployer;
+  const existingDeployer = await getDeployer(client);
+  if (existingDeployer !== undefined) {
+    return existingDeployer;
   }
 
   // There's not really a way to simulate a pre-EIP-155 (no chain ID) transaction,

package/src/deploy/ensureWorldFactory.ts

@@ -1,105 +1,30 @@
-import accessManagementSystemBuild from "@latticexyz/world/out/AccessManagementSystem.sol/AccessManagementSystem.json" assert { type: "json" };
-import balanceTransferSystemBuild from "@latticexyz/world/out/BalanceTransferSystem.sol/BalanceTransferSystem.json" assert { type: "json" };
-import batchCallSystemBuild from "@latticexyz/world/out/BatchCallSystem.sol/BatchCallSystem.json" assert { type: "json" };
-import registrationSystemBuild from "@latticexyz/world/out/RegistrationSystem.sol/RegistrationSystem.json" assert { type: "json" };
-import initModuleBuild from "@latticexyz/world/out/InitModule.sol/InitModule.json" assert { type: "json" };
-import initModuleAbi from "@latticexyz/world/out/InitModule.sol/InitModule.abi.json" assert { type: "json" };
-import worldFactoryBuild from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.json" assert { type: "json" };
-import worldFactoryAbi from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.abi.json" assert { type: "json" };
-import { Client, Transport, Chain, Account, Hex, getCreate2Address, encodeDeployData, size, Address } from "viem";
-import { salt } from "./common";
+import { Client, Transport, Chain, Account, Hex, Address } from "viem";
 import { ensureContractsDeployed } from "./ensureContractsDeployed";
-import { Contract } from "./ensureContract";
+import { getWorldFactoryContracts } from "./getWorldFactoryContracts";
+import { getWorldProxyFactoryContracts } from "./getWorldProxyFactoryContracts";
 
 export async function ensureWorldFactory(
   client: Client<Transport, Chain | undefined, Account>,
   deployerAddress: Hex,
+  withWorldProxy?: boolean,
 ): Promise<Address> {
-  const accessManagementSystemDeployedBytecodeSize = size(accessManagementSystemBuild.deployedBytecode.object as Hex);
-  const accessManagementSystemBytecode = accessManagementSystemBuild.bytecode.object as Hex;
-  const accessManagementSystem = getCreate2Address({
-    from: deployerAddress,
-    bytecode: accessManagementSystemBytecode,
-    salt,
-  });
-
-  const balanceTransferSystemDeployedBytecodeSize = size(balanceTransferSystemBuild.deployedBytecode.object as Hex);
-  const balanceTransferSystemBytecode = balanceTransferSystemBuild.bytecode.object as Hex;
-  const balanceTransferSystem = getCreate2Address({
-    from: deployerAddress,
-    bytecode: balanceTransferSystemBytecode,
-    salt,
-  });
-
-  const batchCallSystemDeployedBytecodeSize = size(batchCallSystemBuild.deployedBytecode.object as Hex);
-  const batchCallSystemBytecode = batchCallSystemBuild.bytecode.object as Hex;
-  const batchCallSystem = getCreate2Address({ from: deployerAddress, bytecode: batchCallSystemBytecode, salt });
-
-  const registrationDeployedBytecodeSize = size(registrationSystemBuild.deployedBytecode.object as Hex);
-  const registrationBytecode = registrationSystemBuild.bytecode.object as Hex;
-  const registration = getCreate2Address({
-    from: deployerAddress,
-    bytecode: registrationBytecode,
-    salt,
-  });
-
-  const initModuleDeployedBytecodeSize = size(initModuleBuild.deployedBytecode.object as Hex);
-  const initModuleBytecode = encodeDeployData({
-    bytecode: initModuleBuild.bytecode.object as Hex,
-    abi: initModuleAbi,
-    args: [accessManagementSystem, balanceTransferSystem, batchCallSystem, registration],
-  });
-
-  const initModule = getCreate2Address({ from: deployerAddress, bytecode: initModuleBytecode, salt });
-
-  const worldFactoryDeployedBytecodeSize = size(worldFactoryBuild.deployedBytecode.object as Hex);
-  const worldFactoryBytecode = encodeDeployData({
-    bytecode: worldFactoryBuild.bytecode.object as Hex,
-    abi: worldFactoryAbi,
-    args: [initModule],
-  });
-
-  const worldFactory = getCreate2Address({ from: deployerAddress, bytecode: worldFactoryBytecode, salt });
-
-  const worldFactoryContracts: readonly Contract[] = [
-    {
-      bytecode: accessManagementSystemBytecode,
-      deployedBytecodeSize: accessManagementSystemDeployedBytecodeSize,
-      label: "access management system",
-    },
-    {
-      bytecode: balanceTransferSystemBytecode,
-      deployedBytecodeSize: balanceTransferSystemDeployedBytecodeSize,
-      label: "balance transfer system",
-    },
-    {
-      bytecode: batchCallSystemBytecode,
-      deployedBytecodeSize: batchCallSystemDeployedBytecodeSize,
-      label: "batch call system",
-    },
-    {
-      bytecode: registrationBytecode,
-      deployedBytecodeSize: registrationDeployedBytecodeSize,
-      label: "core registration system",
-    },
-    {
-      bytecode: initModuleBytecode,
-      deployedBytecodeSize: initModuleDeployedBytecodeSize,
-      label: "core module",
-    },
-    {
-      bytecode: worldFactoryBytecode,
-      deployedBytecodeSize: worldFactoryDeployedBytecodeSize,
-      label: "world factory",
-    },
-  ];
-
-  // WorldFactory constructor doesn't call InitModule, only sets its address, so we can do these in parallel since the address is deterministic
+  if (withWorldProxy) {
+    const contracts = getWorldProxyFactoryContracts(deployerAddress);
+    // We can deploy these contracts in parallel because they do not call each other at this point.
+    await ensureContractsDeployed({
+      client,
+      deployerAddress,
+      contracts: Object.values(contracts),
+    });
+    return contracts.WorldProxyFactory.address;
+  }
+
+  const contracts = getWorldFactoryContracts(deployerAddress);
+  // We can deploy these contracts in parallel because they do not call each other at this point.
   await ensureContractsDeployed({
     client,
     deployerAddress,
-    contracts: worldFactoryContracts,
+    contracts: Object.values(contracts),
   });
-
-  return worldFactory;
+  return contracts.WorldFactory.address;
 }

package/src/deploy/getDeployer.ts

@@ -0,0 +1,20 @@
+import { Address, Chain, Client, Transport, sliceHex } from "viem";
+import { getBytecode } from "viem/actions";
+import deployment from "./create2/deployment.json";
+import { debug } from "./debug";
+
+const deployer = `0x${deployment.address}` as const;
+
+export async function getDeployer(client: Client<Transport, Chain | undefined>): Promise<Address | undefined> {
+  const bytecode = await getBytecode(client, { address: deployer });
+  if (bytecode) {
+    debug("found CREATE2 deployer at", deployer);
+    // check if deployed bytecode is the same as the expected bytecode (minus 14-bytes creation code prefix)
+    if (bytecode !== sliceHex(`0x${deployment.creationCode}`, 14)) {
+      console.warn(
+        `\n  ⚠️ Bytecode for deployer at ${deployer} did not match the expected CREATE2 bytecode. You may have unexpected results.\n`,
+      );
+    }
+    return deployer;
+  }
+}

package/src/deploy/getResourceIds.ts

@@ -1,8 +1,9 @@
-import { Client, parseAbiItem, Hex } from "viem";
+import { Client, parseAbiItem, Hex, HttpRequestError } from "viem";
 import { getLogs } from "viem/actions";
 import { storeSpliceStaticDataEvent } from "@latticexyz/store";
 import { WorldDeploy, storeTables } from "./common";
 import { debug } from "./debug";
+import pRetry from "p-retry";
 
 export async function getResourceIds({
   client,
@@ -15,15 +16,28 @@ export async function getResourceIds({
   // TODO: PR to viem's getLogs to accept topics array so we can filter on all store events and quickly recreate this table's current state
 
   debug("looking up resource IDs for", worldDeploy.address);
-  const logs = await getLogs(client, {
-    strict: true,
-    address: worldDeploy.address,
-    fromBlock: worldDeploy.deployBlock,
-    toBlock: worldDeploy.stateBlock,
-    event: parseAbiItem(storeSpliceStaticDataEvent),
-    args: { tableId: storeTables.store_ResourceIds.tableId },
-  });
+  const logs = await pRetry(
+    () =>
+      getLogs(client, {
+        strict: true,
+        address: worldDeploy.address,
+        fromBlock: worldDeploy.deployBlock,
+        toBlock: worldDeploy.stateBlock,
+        event: parseAbiItem(storeSpliceStaticDataEvent),
+        args: { tableId: storeTables.store_ResourceIds.tableId },
+      }),
+    {
+      retries: 3,
+      onFailedAttempt: async (error) => {
+        const shouldRetry =
+          error instanceof HttpRequestError && error.status === 400 && error.message.includes("block is out of range");
 
+        if (!shouldRetry) {
+          throw error;
+        }
+      },
+    },
+  );
   const resourceIds = logs.map((log) => log.args.keyTuple[0]);
   debug("found", resourceIds.length, "resource IDs for", worldDeploy.address);
 

package/src/deploy/getWorldContracts.ts

@@ -0,0 +1,79 @@
+import accessManagementSystemBuild from "@latticexyz/world/out/AccessManagementSystem.sol/AccessManagementSystem.json" assert { type: "json" };
+import balanceTransferSystemBuild from "@latticexyz/world/out/BalanceTransferSystem.sol/BalanceTransferSystem.json" assert { type: "json" };
+import batchCallSystemBuild from "@latticexyz/world/out/BatchCallSystem.sol/BatchCallSystem.json" assert { type: "json" };
+import registrationSystemBuild from "@latticexyz/world/out/RegistrationSystem.sol/RegistrationSystem.json" assert { type: "json" };
+import initModuleBuild from "@latticexyz/world/out/InitModule.sol/InitModule.json" assert { type: "json" };
+import initModuleAbi from "@latticexyz/world/out/InitModule.sol/InitModule.abi.json" assert { type: "json" };
+import { Hex, getCreate2Address, encodeDeployData, size } from "viem";
+import { salt } from "./common";
+
+export function getWorldContracts(deployerAddress: Hex) {
+  const accessManagementSystemDeployedBytecodeSize = size(accessManagementSystemBuild.deployedBytecode.object as Hex);
+  const accessManagementSystemBytecode = accessManagementSystemBuild.bytecode.object as Hex;
+  const accessManagementSystem = getCreate2Address({
+    from: deployerAddress,
+    bytecode: accessManagementSystemBytecode,
+    salt,
+  });
+
+  const balanceTransferSystemDeployedBytecodeSize = size(balanceTransferSystemBuild.deployedBytecode.object as Hex);
+  const balanceTransferSystemBytecode = balanceTransferSystemBuild.bytecode.object as Hex;
+  const balanceTransferSystem = getCreate2Address({
+    from: deployerAddress,
+    bytecode: balanceTransferSystemBytecode,
+    salt,
+  });
+
+  const batchCallSystemDeployedBytecodeSize = size(batchCallSystemBuild.deployedBytecode.object as Hex);
+  const batchCallSystemBytecode = batchCallSystemBuild.bytecode.object as Hex;
+  const batchCallSystem = getCreate2Address({ from: deployerAddress, bytecode: batchCallSystemBytecode, salt });
+
+  const registrationDeployedBytecodeSize = size(registrationSystemBuild.deployedBytecode.object as Hex);
+  const registrationBytecode = registrationSystemBuild.bytecode.object as Hex;
+  const registration = getCreate2Address({
+    from: deployerAddress,
+    bytecode: registrationBytecode,
+    salt,
+  });
+
+  const initModuleDeployedBytecodeSize = size(initModuleBuild.deployedBytecode.object as Hex);
+  const initModuleBytecode = encodeDeployData({
+    bytecode: initModuleBuild.bytecode.object as Hex,
+    abi: initModuleAbi,
+    args: [accessManagementSystem, balanceTransferSystem, batchCallSystem, registration],
+  });
+  const initModule = getCreate2Address({ from: deployerAddress, bytecode: initModuleBytecode, salt });
+
+  return {
+    AccessManagementSystem: {
+      bytecode: accessManagementSystemBytecode,
+      deployedBytecodeSize: accessManagementSystemDeployedBytecodeSize,
+      label: "access management system",
+      address: accessManagementSystem,
+    },
+    BalanceTransferSystem: {
+      bytecode: balanceTransferSystemBytecode,
+      deployedBytecodeSize: balanceTransferSystemDeployedBytecodeSize,
+      label: "balance transfer system",
+      address: balanceTransferSystem,
+    },
+    BatchCallSystem: {
+      bytecode: batchCallSystemBytecode,
+      deployedBytecodeSize: batchCallSystemDeployedBytecodeSize,
+      label: "batch call system",
+      address: batchCallSystem,
+    },
+    RegistrationSystem: {
+      bytecode: registrationBytecode,
+      deployedBytecodeSize: registrationDeployedBytecodeSize,
+      label: "core registration system",
+      address: registration,
+    },
+    InitModule: {
+      bytecode: initModuleBytecode,
+      deployedBytecodeSize: initModuleDeployedBytecodeSize,
+      label: "core module",
+      address: initModule,
+    },
+  };
+}

package/src/deploy/getWorldFactoryContracts.ts

@@ -0,0 +1,27 @@
+import worldFactoryBuild from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.json" assert { type: "json" };
+import worldFactoryAbi from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.abi.json" assert { type: "json" };
+import { Hex, getCreate2Address, encodeDeployData, size } from "viem";
+import { salt } from "./common";
+import { getWorldContracts } from "./getWorldContracts";
+
+export function getWorldFactoryContracts(deployerAddress: Hex) {
+  const worldContracts = getWorldContracts(deployerAddress);
+
+  const worldFactoryDeployedBytecodeSize = size(worldFactoryBuild.deployedBytecode.object as Hex);
+  const worldFactoryBytecode = encodeDeployData({
+    bytecode: worldFactoryBuild.bytecode.object as Hex,
+    abi: worldFactoryAbi,
+    args: [worldContracts.InitModule.address],
+  });
+  const worldFactory = getCreate2Address({ from: deployerAddress, bytecode: worldFactoryBytecode, salt });
+
+  return {
+    ...worldContracts,
+    WorldFactory: {
+      bytecode: worldFactoryBytecode,
+      deployedBytecodeSize: worldFactoryDeployedBytecodeSize,
+      label: "world factory",
+      address: worldFactory,
+    },
+  };
+}

package/src/deploy/getWorldProxyFactoryContracts.ts

@@ -0,0 +1,27 @@
+import worldProxyFactoryBuild from "@latticexyz/world/out/WorldProxyFactory.sol/WorldProxyFactory.json" assert { type: "json" };
+import worldProxyFactoryAbi from "@latticexyz/world/out/WorldProxyFactory.sol/WorldProxyFactory.abi.json" assert { type: "json" };
+import { Hex, getCreate2Address, encodeDeployData, size } from "viem";
+import { salt } from "./common";
+import { getWorldContracts } from "./getWorldContracts";
+
+export function getWorldProxyFactoryContracts(deployerAddress: Hex) {
+  const worldContracts = getWorldContracts(deployerAddress);
+
+  const worldProxyFactoryDeployedBytecodeSize = size(worldProxyFactoryBuild.deployedBytecode.object as Hex);
+  const worldProxyFactoryBytecode = encodeDeployData({
+    bytecode: worldProxyFactoryBuild.bytecode.object as Hex,
+    abi: worldProxyFactoryAbi,
+    args: [worldContracts.InitModule.address],
+  });
+  const worldProxyFactory = getCreate2Address({ from: deployerAddress, bytecode: worldProxyFactoryBytecode, salt });
+
+  return {
+    ...worldContracts,
+    WorldProxyFactory: {
+      bytecode: worldProxyFactoryBytecode,
+      deployedBytecodeSize: worldProxyFactoryDeployedBytecodeSize,
+      label: "world proxy factory",
+      address: worldProxyFactory,
+    },
+  };
+}

package/src/runDeploy.ts

@@ -17,7 +17,7 @@ import { WorldDeploy } from "./deploy/common";
 import { build } from "./build";
 
 export const deployOptions = {
-  configPath: { type: "string", desc: "Path to the config file" },
+  configPath: { type: "string", desc: "Path to the MUD config file" },
   printConfig: { type: "boolean", desc: "Print the resolved config" },
   profile: { type: "string", desc: "The foundry profile to use" },
   saveDeployment: { type: "boolean", desc: "Save the deployment info to a file", default: true },
@@ -37,6 +37,7 @@ export const deployOptions = {
     type: "boolean",
     desc: "Always run PostDeploy.s.sol after each deploy (including during upgrades). By default, PostDeploy.s.sol is only run once after a new world is deployed.",
   },
+  forgeScriptOptions: { type: "string", description: "Options to pass to forge script PostDeploy.s.sol" },
   salt: {
     type: "string",
     desc: "The deployment salt to use. Defaults to a random salt.",
@@ -110,9 +111,10 @@ in your contracts directory to use the default anvil private key.`,
     worldAddress: opts.worldAddress as Hex | undefined,
     client,
     config: resolvedConfig,
+    withWorldProxy: configV2.deploy.useProxy,
   });
   if (opts.worldAddress == null || opts.alwaysRunPostDeploy) {
-    await postDeploy(config.postDeployScript, worldDeploy.address, rpc, profile);
+    await postDeploy(config.postDeployScript, worldDeploy.address, rpc, profile, opts.forgeScriptOptions);
   }
   console.log(chalk.green("Deployment completed in", (Date.now() - startTime) / 1000, "seconds"));
 

package/src/utils/postDeploy.ts

@@ -2,24 +2,48 @@ import { existsSync } from "fs";
 import path from "path";
 import chalk from "chalk";
 import { getScriptDirectory, forge } from "@latticexyz/common/foundry";
+import { execSync } from "child_process";
+import { formatGwei } from "viem";
 
 export async function postDeploy(
   postDeployScript: string,
   worldAddress: string,
   rpc: string,
   profile: string | undefined,
+  forgeOptions: string | undefined,
 ): Promise<void> {
-  // Execute postDeploy forge script
+  // TODO: make this more robust as it is likely to fail for any args that have a space in them
+  const userOptions = forgeOptions?.replaceAll("\\", "").split(" ") ?? [];
   const postDeployPath = path.join(await getScriptDirectory(), postDeployScript + ".s.sol");
-  if (existsSync(postDeployPath)) {
-    console.log(chalk.blue(`Executing post deploy script at ${postDeployPath}`));
-    await forge(
-      ["script", postDeployScript, "--sig", "run(address)", worldAddress, "--broadcast", "--rpc-url", rpc, "-vvv"],
-      {
-        profile: profile,
-      },
-    );
-  } else {
+  if (!existsSync(postDeployPath)) {
     console.log(`No script at ${postDeployPath}, skipping post deploy hook`);
+    return;
   }
+
+  // TODO: replace this with a viem call
+  const gasPrice = BigInt(execSync(`cast gas-price --rpc-url ${rpc}`, { encoding: "utf-8" }).trim());
+
+  console.log(chalk.blue(`Executing post deploy script at ${postDeployPath}`));
+  console.log(chalk.blue(`  using gas price of ${formatGwei(gasPrice)} gwei`));
+
+  await forge(
+    [
+      "script",
+      postDeployScript,
+      "--broadcast",
+      "--sig",
+      "run(address)",
+      worldAddress,
+      // TODO: also set priority fee?
+      "--with-gas-price",
+      gasPrice.toString(),
+      "--rpc-url",
+      rpc,
+      "-vvv",
+      ...userOptions,
+    ],
+    {
+      profile: profile,
+    },
+  );
 }