@latticexyz/cli 2.0.0-skystrife-playtest-9e9511d4 → 2.0.0-transaction-context-324984c5

package/src/deploy/getTables.ts

@@ -0,0 +1,59 @@
+import { Client, parseAbiItem, decodeAbiParameters, parseAbiParameters } from "viem";
+import { Table } from "./configToTables";
+import { hexToResource } from "@latticexyz/common";
+import { WorldDeploy, storeTables } from "./common";
+import { debug } from "./debug";
+import { storeSetRecordEvent } from "@latticexyz/store";
+import { getLogs } from "viem/actions";
+import { KeySchema, ValueSchema, decodeKey, decodeValueArgs, hexToSchema } from "@latticexyz/protocol-parser";
+
+export async function getTables({
+  client,
+  worldDeploy,
+}: {
+  readonly client: Client;
+  readonly worldDeploy: WorldDeploy;
+}): Promise<readonly Table[]> {
+  // This assumes we only use `Tables._set(...)`, which is true as of this writing.
+  // 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
+  // TODO: consider moving this to a batched getRecord for Tables table
+
+  debug("looking up tables for", worldDeploy.address);
+  const logs = await getLogs(client, {
+    strict: true,
+    // this may fail for certain RPC providers with block range limits
+    // if so, could potentially use our fetchLogs helper (which does pagination)
+    fromBlock: worldDeploy.deployBlock,
+    toBlock: worldDeploy.stateBlock,
+    address: worldDeploy.address,
+    event: parseAbiItem(storeSetRecordEvent),
+    args: { tableId: storeTables.store_Tables.tableId },
+  });
+
+  // TODO: combine with store-sync logToTable and export from somewhere
+  const tables = logs.map((log) => {
+    const { tableId } = decodeKey(storeTables.store_Tables.keySchema, log.args.keyTuple);
+    const { namespace, name } = hexToResource(tableId);
+    const value = decodeValueArgs(storeTables.store_Tables.valueSchema, log.args);
+
+    // TODO: migrate to better helper
+    const keySchemaFields = hexToSchema(value.keySchema);
+    const valueSchemaFields = hexToSchema(value.valueSchema);
+    const keyNames = decodeAbiParameters(parseAbiParameters("string[]"), value.abiEncodedKeyNames)[0];
+    const fieldNames = decodeAbiParameters(parseAbiParameters("string[]"), value.abiEncodedFieldNames)[0];
+
+    const valueAbiTypes = [...valueSchemaFields.staticFields, ...valueSchemaFields.dynamicFields];
+
+    const keySchema = Object.fromEntries(
+      keySchemaFields.staticFields.map((abiType, i) => [keyNames[i], abiType])
+    ) as KeySchema;
+    const valueSchema = Object.fromEntries(valueAbiTypes.map((abiType, i) => [fieldNames[i], abiType])) as ValueSchema;
+
+    return { namespace, name, tableId, keySchema, valueSchema } as const;
+  });
+  // TODO: filter/detect duplicates?
+
+  debug("found", tables.length, "tables for", worldDeploy.address);
+
+  return tables;
+}

package/src/deploy/getWorldDeploy.ts

@@ -0,0 +1,39 @@
+import { Client, Address, getAddress, parseAbi } from "viem";
+import { getBlockNumber, getLogs } from "viem/actions";
+import { WorldDeploy, worldDeployEvents } from "./common";
+import { debug } from "./debug";
+import { logsToWorldDeploy } from "./logsToWorldDeploy";
+
+const deploys = new Map<Address, WorldDeploy>();
+
+export async function getWorldDeploy(client: Client, worldAddress: Address): Promise<WorldDeploy> {
+  const address = getAddress(worldAddress);
+
+  let deploy = deploys.get(address);
+  if (deploy != null) {
+    return deploy;
+  }
+
+  debug("looking up world deploy for", address);
+
+  const stateBlock = await getBlockNumber(client);
+  const logs = await getLogs(client, {
+    strict: true,
+    address,
+    events: parseAbi(worldDeployEvents),
+    // this may fail for certain RPC providers with block range limits
+    // if so, could potentially use our fetchLogs helper (which does pagination)
+    fromBlock: "earliest",
+    toBlock: stateBlock,
+  });
+
+  deploy = {
+    ...logsToWorldDeploy(logs),
+    stateBlock,
+  };
+  deploys.set(address, deploy);
+
+  debug("found world deploy for", address, "at block", deploy.deployBlock);
+
+  return deploy;
+}

package/src/deploy/logsToWorldDeploy.ts

@@ -0,0 +1,49 @@
+import { AbiEventSignatureNotFoundError, Log, decodeEventLog, hexToString, parseAbi, trim } from "viem";
+import { WorldDeploy, worldDeployEvents } from "./common";
+import { isDefined } from "@latticexyz/common/utils";
+
+export function logsToWorldDeploy(logs: readonly Log<bigint, number, false>[]): Omit<WorldDeploy, "stateBlock"> {
+  const deployLogs = logs
+    .map((log) => {
+      try {
+        return {
+          ...log,
+          ...decodeEventLog({
+            strict: true,
+            abi: parseAbi(worldDeployEvents),
+            topics: log.topics,
+            data: log.data,
+          }),
+        };
+      } catch (error: unknown) {
+        if (error instanceof AbiEventSignatureNotFoundError) {
+          return;
+        }
+        throw error;
+      }
+    })
+    .filter(isDefined);
+
+  // TODO: should this test for/validate that only one of each of these events is present? and that the address/block number don't change between each?
+  const { address, deployBlock, worldVersion, storeVersion } = deployLogs.reduce<Partial<WorldDeploy>>(
+    (deploy, log) => ({
+      ...deploy,
+      address: log.address,
+      deployBlock: log.blockNumber,
+      ...(log.eventName === "HelloWorld"
+        ? { worldVersion: hexToString(trim(log.args.worldVersion, { dir: "right" })) }
+        : null),
+      ...(log.eventName === "HelloStore"
+        ? { storeVersion: hexToString(trim(log.args.storeVersion, { dir: "right" })) }
+        : null),
+    }),
+    {}
+  );
+
+  if (address == null) throw new Error("could not find world address");
+  if (deployBlock == null) throw new Error("could not find world deploy block number");
+  if (worldVersion == null) throw new Error("could not find world version");
+  if (storeVersion == null) throw new Error("could not find store version");
+
+  return { address, deployBlock, worldVersion, storeVersion };
+}

package/src/deploy/resolveConfig.ts

@@ -0,0 +1,151 @@
+import { resolveWorldConfig } from "@latticexyz/world";
+import { Config, ConfigInput, WorldFunction, salt } from "./common";
+import { resourceToHex, hexToResource } from "@latticexyz/common";
+import { resolveWithContext } from "@latticexyz/config";
+import { encodeField } from "@latticexyz/protocol-parser";
+import { SchemaAbiType, SchemaAbiTypeToPrimitiveType } from "@latticexyz/schema-type";
+import {
+  getFunctionSelector,
+  Hex,
+  getCreate2Address,
+  getAddress,
+  hexToBytes,
+  Abi,
+  bytesToHex,
+  getFunctionSignature,
+} from "viem";
+import { getExistingContracts } from "../utils/getExistingContracts";
+import { defaultModuleContracts } from "../utils/modules/constants";
+import { getContractData } from "../utils/utils/getContractData";
+import { configToTables } from "./configToTables";
+import { deployer } from "./ensureDeployer";
+import { resourceLabel } from "./resourceLabel";
+
+// TODO: this should be replaced by https://github.com/latticexyz/mud/issues/1668
+
+export function resolveConfig<config extends ConfigInput>({
+  config,
+  forgeSourceDir,
+  forgeOutDir,
+}: {
+  config: config;
+  forgeSourceDir: string;
+  forgeOutDir: string;
+}): Config<config> {
+  const tables = configToTables(config);
+
+  // TODO: should the config parser/loader help with resolving systems?
+  const contractNames = getExistingContracts(forgeSourceDir).map(({ basename }) => basename);
+  const resolvedConfig = resolveWorldConfig(config, contractNames);
+  const baseSystemContractData = getContractData("System", forgeOutDir);
+  const baseSystemFunctions = baseSystemContractData.abi
+    .filter((item): item is typeof item & { type: "function" } => item.type === "function")
+    .map(getFunctionSignature);
+
+  const systems = Object.entries(resolvedConfig.systems).map(([systemName, system]) => {
+    const namespace = config.namespace;
+    const name = system.name;
+    const systemId = resourceToHex({ type: "system", namespace, name });
+    const contractData = getContractData(systemName, forgeOutDir);
+
+    const systemFunctions = contractData.abi
+      .filter((item): item is typeof item & { type: "function" } => item.type === "function")
+      .map(getFunctionSignature)
+      .filter((sig) => !baseSystemFunctions.includes(sig))
+      .map((sig): WorldFunction => {
+        // TODO: figure out how to not duplicate contract behavior (https://github.com/latticexyz/mud/issues/1708)
+        const worldSignature = namespace === "" ? sig : `${namespace}__${sig}`;
+        return {
+          signature: worldSignature,
+          selector: getFunctionSelector(worldSignature),
+          systemId,
+          systemFunctionSignature: sig,
+          systemFunctionSelector: getFunctionSelector(sig),
+        };
+      });
+
+    return {
+      namespace,
+      name,
+      systemId,
+      allowAll: system.openAccess,
+      allowedAddresses: system.accessListAddresses as Hex[],
+      allowedSystemIds: system.accessListSystems.map((name) =>
+        resourceToHex({ type: "system", namespace, name: resolvedConfig.systems[name].name })
+      ),
+      address: getCreate2Address({ from: deployer, bytecode: contractData.bytecode, salt }),
+      bytecode: contractData.bytecode,
+      deployedBytecodeSize: contractData.deployedBytecodeSize,
+      abi: contractData.abi,
+      functions: systemFunctions,
+    };
+  });
+
+  // resolve allowedSystemIds
+  // TODO: resolve this at deploy time so we can allow for arbitrary system IDs registered in the world as the source-of-truth rather than config
+  const systemsWithAccess = systems.map(({ allowedAddresses, allowedSystemIds, ...system }) => {
+    const allowedSystemAddresses = allowedSystemIds.map((systemId) => {
+      const targetSystem = systems.find((s) => s.systemId === systemId);
+      if (!targetSystem) {
+        throw new Error(
+          `System ${resourceLabel(system)} wanted access to ${resourceLabel(
+            hexToResource(systemId)
+          )}, but it wasn't found in the config.`
+        );
+      }
+      return targetSystem.address;
+    });
+    return {
+      ...system,
+      allowedAddresses: Array.from(
+        new Set([...allowedAddresses, ...allowedSystemAddresses].map((addr) => getAddress(addr)))
+      ),
+    };
+  });
+
+  // ugh (https://github.com/latticexyz/mud/issues/1668)
+  const resolveContext = {
+    tableIds: Object.fromEntries(
+      Object.entries(config.tables).map(([tableName, table]) => [
+        tableName,
+        hexToBytes(
+          resourceToHex({
+            type: table.offchainOnly ? "offchainTable" : "table",
+            namespace: config.namespace,
+            name: table.name,
+          })
+        ),
+      ])
+    ),
+  };
+
+  const modules = config.modules.map((mod) => {
+    const contractData =
+      defaultModuleContracts.find((defaultMod) => defaultMod.name === mod.name) ??
+      getContractData(mod.name, forgeOutDir);
+    const installArgs = mod.args
+      .map((arg) => resolveWithContext(arg, resolveContext))
+      .map((arg) => {
+        const value = arg.value instanceof Uint8Array ? bytesToHex(arg.value) : arg.value;
+        return encodeField(arg.type as SchemaAbiType, value as SchemaAbiTypeToPrimitiveType<SchemaAbiType>);
+      });
+    if (installArgs.length > 1) {
+      throw new Error(`${mod.name} module should only have 0-1 args, but had ${installArgs.length} args.`);
+    }
+    return {
+      name: mod.name,
+      installAsRoot: mod.root,
+      installData: installArgs.length === 0 ? "0x" : installArgs[0],
+      address: getCreate2Address({ from: deployer, bytecode: contractData.bytecode, salt }),
+      bytecode: contractData.bytecode,
+      deployedBytecodeSize: contractData.deployedBytecodeSize,
+      abi: contractData.abi,
+    };
+  });
+
+  return {
+    tables,
+    systems: systemsWithAccess,
+    modules,
+  };
+}

package/src/deploy/resourceLabel.ts

@@ -0,0 +1,3 @@
+export function resourceLabel({ namespace, name }: { readonly namespace: string; readonly name: string }): string {
+  return `${namespace}:${name}`;
+}

package/src/index.ts

@@ -1 +1 @@
-export * from "./utils/deployHandler";
+// nothing to export

package/src/mud.ts

@@ -1,39 +1,45 @@
 #!/usr/bin/env node
 
-import yargs from "yargs";
-import { hideBin } from "yargs/helpers";
-import { commands } from "./commands";
-import { logError } from "./utils/errors";
-
 // Load .env file into process.env
 import * as dotenv from "dotenv";
-import chalk from "chalk";
 dotenv.config();
 
-yargs(hideBin(process.argv))
-  // Explicit name to display in help (by default it's the entry file, which may not be "mud" for e.g. ts-node)
-  .scriptName("mud")
-  // Use the commands directory to scaffold
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- command array overload isn't typed, see https://github.com/yargs/yargs/blob/main/docs/advanced.md#esm-hierarchy
-  .command(commands as any)
-  // Enable strict mode.
-  .strict()
-  // Custom error handler
-  .fail((msg, err) => {
-    console.error(chalk.red(msg));
-    if (msg.includes("Missing required argument")) {
-      console.log(
-        chalk.yellow(`Run 'pnpm mud ${process.argv[2]} --help' for a list of available and required arguments.`)
-      );
-    }
-    console.log("");
-    // Even though `.fail` type says we should get an `Error`, this can sometimes be undefined
-    if (err != null) {
-      logError(err);
+async function run() {
+  // Import everything else async so they can pick up env vars in .env
+  const { default: yargs } = await import("yargs");
+  const { default: chalk } = await import("chalk");
+  const { hideBin } = await import("yargs/helpers");
+  const { logError } = await import("./utils/errors");
+  const { commands } = await import("./commands");
+
+  yargs(hideBin(process.argv))
+    // Explicit name to display in help (by default it's the entry file, which may not be "mud" for e.g. ts-node)
+    .scriptName("mud")
+    // Use the commands directory to scaffold
+    // command array overload isn't typed, see https://github.com/yargs/yargs/blob/main/docs/advanced.md#esm-hierarchy
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    .command(commands as any)
+    // Enable strict mode.
+    .strict()
+    // Custom error handler
+    .fail((msg, err) => {
+      console.error(chalk.red(msg));
+      if (msg.includes("Missing required argument")) {
+        console.log(
+          chalk.yellow(`Run 'pnpm mud ${process.argv[2]} --help' for a list of available and required arguments.`)
+        );
+      }
       console.log("");
-    }
+      // Even though `.fail` type says we should get an `Error`, this can sometimes be undefined
+      if (err != null) {
+        logError(err);
+        console.log("");
+      }
+
+      process.exit(1);
+    })
+    // Useful aliases.
+    .alias({ h: "help" }).argv;
+}
 
-    process.exit(1);
-  })
-  // Useful aliases.
-  .alias({ h: "help" }).argv;
+run();

package/src/mudPackages.ts

@@ -0,0 +1,24 @@
+import { ZodError, z } from "zod";
+import { MudPackages } from "./common";
+
+const envSchema = z.object({
+  MUD_PACKAGES: z.string().transform((value) => JSON.parse(value) as MudPackages),
+});
+
+function parseEnv(): z.infer<typeof envSchema> {
+  try {
+    return envSchema.parse({
+      // tsup replaces the env vars with their values at compile time
+      MUD_PACKAGES: process.env.MUD_PACKAGES,
+    });
+  } catch (error) {
+    if (error instanceof ZodError) {
+      const { _errors, ...invalidEnvVars } = error.format();
+      console.error(`\nMissing or invalid environment variables:\n\n  ${Object.keys(invalidEnvVars).join("\n  ")}\n`);
+      process.exit(1);
+    }
+    throw error;
+  }
+}
+
+export const mudPackages = parseEnv().MUD_PACKAGES;

package/src/runDeploy.ts

@@ -0,0 +1,131 @@
+import path from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { InferredOptionTypes, Options } from "yargs";
+import { deploy } from "./deploy/deploy";
+import { createWalletClient, http, Hex, isHex } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { loadConfig } from "@latticexyz/config/node";
+import { StoreConfig } from "@latticexyz/store";
+import { WorldConfig } from "@latticexyz/world";
+import { getOutDirectory, getRpcUrl, getSrcDirectory } from "@latticexyz/common/foundry";
+import chalk from "chalk";
+import { MUDError } from "@latticexyz/common/errors";
+import { resolveConfig } from "./deploy/resolveConfig";
+import { getChainId } from "viem/actions";
+import { postDeploy } from "./utils/utils/postDeploy";
+import { WorldDeploy } from "./deploy/common";
+import { build } from "./build";
+
+export const deployOptions = {
+  configPath: { type: "string", desc: "Path to the 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 },
+  rpc: { type: "string", desc: "The RPC URL to use. Defaults to the RPC url from the local foundry.toml" },
+  worldAddress: { type: "string", desc: "Deploy to an existing World at the given address" },
+  srcDir: { type: "string", desc: "Source directory. Defaults to foundry src directory." },
+  skipBuild: { type: "boolean", desc: "Skip rebuilding the contracts before deploying" },
+  alwaysRunPostDeploy: {
+    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.",
+  },
+  salt: {
+    type: "string",
+    desc: "The deployment salt to use. Defaults to a random salt.",
+  },
+} as const satisfies Record<string, Options>;
+
+export type DeployOptions = InferredOptionTypes<typeof deployOptions>;
+
+/**
+ * Given some CLI arguments, finds and resolves a MUD config, foundry profile, and runs a deploy.
+ * This is used by the deploy, test, and dev-contracts CLI commands.
+ */
+export async function runDeploy(opts: DeployOptions): Promise<WorldDeploy> {
+  const salt = opts.salt;
+  if (salt != null && !isHex(salt)) {
+    throw new MUDError("Expected hex string for salt");
+  }
+
+  const profile = opts.profile ?? process.env.FOUNDRY_PROFILE;
+
+  const config = (await loadConfig(opts.configPath)) as StoreConfig & WorldConfig;
+  if (opts.printConfig) {
+    console.log(chalk.green("\nResolved config:\n"), JSON.stringify(config, null, 2));
+  }
+
+  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 Deploying MUD contracts${profile ? " with profile " + profile : ""} to RPC ${rpc} \n`)
+    )
+  );
+
+  // Run build
+  if (!opts.skipBuild) {
+    await build({ config, srcDir, foundryProfile: profile });
+  }
+
+  const privateKey = process.env.PRIVATE_KEY as Hex;
+  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 resolvedConfig = resolveConfig({ config, forgeSourceDir: srcDir, forgeOutDir: outDir });
+
+  const client = createWalletClient({
+    transport: http(rpc),
+    account: privateKeyToAccount(privateKey),
+  });
+  console.log("Deploying from", client.account.address);
+
+  const startTime = Date.now();
+  const worldDeploy = await deploy({
+    salt,
+    worldAddress: opts.worldAddress as Hex | undefined,
+    client,
+    config: resolvedConfig,
+  });
+  if (opts.worldAddress == null || opts.alwaysRunPostDeploy) {
+    await postDeploy(config.postDeployScript, worldDeploy.address, rpc, profile);
+  }
+  console.log(chalk.green("Deployment completed in", (Date.now() - startTime) / 1000, "seconds"));
+
+  const deploymentInfo = {
+    worldAddress: worldDeploy.address,
+    blockNumber: Number(worldDeploy.deployBlock),
+  };
+
+  if (opts.saveDeployment) {
+    const chainId = await getChainId(client);
+    const deploysDir = path.join(config.deploysDirectory, chainId.toString());
+    mkdirSync(deploysDir, { recursive: true });
+    writeFileSync(path.join(deploysDir, "latest.json"), JSON.stringify(deploymentInfo, null, 2));
+    writeFileSync(path.join(deploysDir, Date.now() + ".json"), JSON.stringify(deploymentInfo, null, 2));
+
+    const localChains = [1337, 31337];
+    const deploys = existsSync(config.worldsFile) ? JSON.parse(readFileSync(config.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(config.worldsFile, JSON.stringify(deploys, null, 2));
+
+    console.log(
+      chalk.bgGreen(chalk.whiteBright(`\n Deployment result (written to ${config.worldsFile} and ${deploysDir}): \n`))
+    );
+  }
+
+  console.log(deploymentInfo);
+
+  return worldDeploy;
+}

package/src/utils/modules/constants.ts

@@ -0,0 +1,26 @@
+import KeysWithValueModuleData from "@latticexyz/world-modules/out/KeysWithValueModule.sol/KeysWithValueModule.json" assert { type: "json" };
+import KeysInTableModuleData from "@latticexyz/world-modules/out/KeysInTableModule.sol/KeysInTableModule.json" assert { type: "json" };
+import UniqueEntityModuleData from "@latticexyz/world-modules/out/UniqueEntityModule.sol/UniqueEntityModule.json" assert { type: "json" };
+import { Abi, Hex, size } from "viem";
+
+// These modules are always deployed
+export const defaultModuleContracts = [
+  {
+    name: "KeysWithValueModule",
+    abi: KeysWithValueModuleData.abi as Abi,
+    bytecode: KeysWithValueModuleData.bytecode.object as Hex,
+    deployedBytecodeSize: size(KeysWithValueModuleData.deployedBytecode.object as Hex),
+  },
+  {
+    name: "KeysInTableModule",
+    abi: KeysInTableModuleData.abi as Abi,
+    bytecode: KeysInTableModuleData.bytecode.object as Hex,
+    deployedBytecodeSize: size(KeysInTableModuleData.deployedBytecode.object as Hex),
+  },
+  {
+    name: "UniqueEntityModule",
+    abi: UniqueEntityModuleData.abi as Abi,
+    bytecode: UniqueEntityModuleData.bytecode.object as Hex,
+    deployedBytecodeSize: size(UniqueEntityModuleData.deployedBytecode.object as Hex),
+  },
+];

package/src/utils/utils/getContractData.ts

@@ -0,0 +1,32 @@
+import { readFileSync } from "fs";
+import path from "path";
+import { MUDError } from "@latticexyz/common/errors";
+import { Abi, Hex, size } from "viem";
+
+/**
+ * Load the contract's abi and bytecode from the file system
+ * @param contractName: Name of the contract to load
+ */
+export function getContractData(
+  contractName: string,
+  forgeOutDirectory: string
+): { bytecode: Hex; abi: Abi; deployedBytecodeSize: number } {
+  let data: any;
+  const contractDataPath = path.join(forgeOutDirectory, contractName + ".sol", contractName + ".json");
+  try {
+    data = JSON.parse(readFileSync(contractDataPath, "utf8"));
+  } catch (error: any) {
+    throw new MUDError(`Error reading file at ${contractDataPath}`);
+  }
+
+  const bytecode = data?.bytecode?.object;
+  if (!bytecode) throw new MUDError(`No bytecode found in ${contractDataPath}`);
+
+  const deployedBytecode = data?.deployedBytecode?.object;
+  if (!deployedBytecode) throw new MUDError(`No deployed bytecode found in ${contractDataPath}`);
+
+  const abi = data?.abi;
+  if (!abi) throw new MUDError(`No ABI found in ${contractDataPath}`);
+
+  return { abi, bytecode, deployedBytecodeSize: size(deployedBytecode as Hex) };
+}

package/src/utils/utils/postDeploy.ts

@@ -0,0 +1,25 @@
+import { existsSync } from "fs";
+import path from "path";
+import chalk from "chalk";
+import { getScriptDirectory, forge } from "@latticexyz/common/foundry";
+
+export async function postDeploy(
+  postDeployScript: string,
+  worldAddress: string,
+  rpc: string,
+  profile: string | undefined
+): Promise<void> {
+  // Execute postDeploy forge script
+  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 {
+    console.log(`No script at ${postDeployPath}, skipping post deploy hook`);
+  }
+}