@latticexyz/cli 2.0.0-snapshot-test-32d38619 → 2.0.0

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 } 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(log.args.worldVersion).replace(/\0+$/, "") }
+        : null),
+      ...(log.eventName === "HelloStore"
+        ? { storeVersion: hexToString(log.args.storeVersion).replace(/\0+$/, "") }
+        : 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/orderByDependencies.ts

@@ -0,0 +1,12 @@
+import toposort from "toposort";
+
+export function orderByDependencies<T>(
+  items: readonly T[],
+  itemKey: (item: T) => string,
+  dependencyKeys: (item: T) => string[],
+): readonly T[] {
+  const dependencyOrder = toposort(
+    items.flatMap((item) => dependencyKeys(item).map((dependency) => [itemKey(item), dependency] as [string, string])),
+  );
+  return [...items].sort((a, b) => dependencyOrder.indexOf(itemKey(a)) - dependencyOrder.indexOf(itemKey(b)));
+}

package/src/deploy/resolveConfig.ts

@@ -0,0 +1,148 @@
+import path from "path";
+import { resolveWorldConfig } from "@latticexyz/world/internal";
+import { Config, ConfigInput, Library, Module, System, WorldFunction } from "./common";
+import { resourceToHex } from "@latticexyz/common";
+import { resolveWithContext } from "@latticexyz/config/library";
+import { encodeField } from "@latticexyz/protocol-parser/internal";
+import { SchemaAbiType, SchemaAbiTypeToPrimitiveType } from "@latticexyz/schema-type/internal";
+import { Hex, hexToBytes, bytesToHex, toFunctionSelector, toFunctionSignature } from "viem";
+import { getExistingContracts } from "../utils/getExistingContracts";
+import { defaultModuleContracts } from "../utils/defaultModuleContracts";
+import { getContractData } from "../utils/getContractData";
+import { configToTables } from "./configToTables";
+import { groupBy } from "@latticexyz/common/utils";
+import { findLibraries } from "./findLibraries";
+import { createPrepareDeploy } from "./createPrepareDeploy";
+
+// 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 libraries = findLibraries(forgeOutDir).map((library): Library => {
+    // foundry/solc flattens artifacts, so we just use the path basename
+    const contractData = getContractData(path.basename(library.path), library.name, forgeOutDir);
+    return {
+      path: library.path,
+      name: library.name,
+      abi: contractData.abi,
+      prepareDeploy: createPrepareDeploy(contractData.bytecode, contractData.placeholders),
+      deployedBytecodeSize: contractData.deployedBytecodeSize,
+    };
+  });
+
+  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.sol", "System", forgeOutDir);
+  const baseSystemFunctions = baseSystemContractData.abi
+    .filter((item): item is typeof item & { type: "function" } => item.type === "function")
+    .map(toFunctionSignature);
+
+  const systems = Object.entries(resolvedConfig.systems).map(([systemName, system]): System => {
+    const namespace = config.namespace;
+    const name = system.name;
+    const systemId = resourceToHex({ type: "system", namespace, name });
+    const contractData = getContractData(`${systemName}.sol`, systemName, forgeOutDir);
+
+    const systemFunctions = contractData.abi
+      .filter((item): item is typeof item & { type: "function" } => item.type === "function")
+      .map(toFunctionSignature)
+      .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: toFunctionSelector(worldSignature),
+          systemId,
+          systemFunctionSignature: sig,
+          systemFunctionSelector: toFunctionSelector(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 }),
+      ),
+      prepareDeploy: createPrepareDeploy(contractData.bytecode, contractData.placeholders),
+      deployedBytecodeSize: contractData.deployedBytecodeSize,
+      abi: contractData.abi,
+      functions: systemFunctions,
+    };
+  });
+
+  // Check for overlapping system IDs (since names get truncated when turning into IDs)
+  // TODO: move this into the world config resolve step once it resolves system IDs
+  const systemsById = groupBy(systems, (system) => system.systemId);
+  const overlappingSystems = Array.from(systemsById.values())
+    .filter((matches) => matches.length > 1)
+    .flat();
+  if (overlappingSystems.length) {
+    const names = overlappingSystems.map((system) => system.name);
+    throw new Error(
+      `Found systems with overlapping system ID: ${names.join(
+        ", ",
+      )}.\n\nSystem IDs are generated from the first 16 bytes of the name, so you may need to rename them to avoid the overlap.`,
+    );
+  }
+
+  // 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): Module => {
+    const contractData =
+      defaultModuleContracts.find((defaultMod) => defaultMod.name === mod.name) ??
+      getContractData(`${mod.name}.sol`, 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],
+      prepareDeploy: createPrepareDeploy(contractData.bytecode, contractData.placeholders),
+      deployedBytecodeSize: contractData.deployedBytecodeSize,
+      abi: contractData.abi,
+    };
+  });
+
+  return {
+    tables,
+    systems,
+    modules,
+    libraries,
+  };
+}

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 { ...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,149 @@
+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 { World as WorldConfig } from "@latticexyz/world";
+import { worldToV1 } from "@latticexyz/world/config/v2";
+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/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" },
+  rpcBatch: {
+    type: "boolean",
+    desc: "Enable batch processing of RPC requests in viem client (defaults to batch size of 100 and wait of 1s)",
+  },
+  deployerAddress: {
+    type: "string",
+    desc: "Deploy using an existing deterministic deployer (https://github.com/Arachnid/deterministic-deployment-proxy)",
+  },
+  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 configV2 = (await loadConfig(opts.configPath)) as WorldConfig;
+  const config = worldToV1(configV2);
+  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: configV2, 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, {
+      batch: opts.rpcBatch
+        ? {
+            batchSize: 100,
+            wait: 1000,
+          }
+        : undefined,
+    }),
+    account: privateKeyToAccount(privateKey),
+  });
+
+  console.log("Deploying from", client.account.address);
+
+  const startTime = Date.now();
+  const worldDeploy = await deploy({
+    deployerAddress: opts.deployerAddress as Hex | undefined,
+    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/defaultModuleContracts.ts

@@ -0,0 +1,30 @@
+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";
+import { findPlaceholders } from "./findPlaceholders";
+
+// These modules are always deployed
+export const defaultModuleContracts = [
+  {
+    name: "KeysWithValueModule",
+    abi: KeysWithValueModuleData.abi as Abi,
+    bytecode: KeysWithValueModuleData.bytecode.object as Hex,
+    placeholders: findPlaceholders(KeysWithValueModuleData.bytecode.linkReferences),
+    deployedBytecodeSize: size(KeysWithValueModuleData.deployedBytecode.object as Hex),
+  },
+  {
+    name: "KeysInTableModule",
+    abi: KeysInTableModuleData.abi as Abi,
+    bytecode: KeysInTableModuleData.bytecode.object as Hex,
+    placeholders: findPlaceholders(KeysInTableModuleData.bytecode.linkReferences),
+    deployedBytecodeSize: size(KeysInTableModuleData.deployedBytecode.object as Hex),
+  },
+  {
+    name: "UniqueEntityModule",
+    abi: UniqueEntityModuleData.abi as Abi,
+    bytecode: UniqueEntityModuleData.bytecode.object as Hex,
+    placeholders: findPlaceholders(UniqueEntityModuleData.bytecode.linkReferences),
+    deployedBytecodeSize: size(UniqueEntityModuleData.deployedBytecode.object as Hex),
+  },
+];

package/src/utils/errors.ts

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

package/src/utils/findPlaceholders.ts

@@ -0,0 +1,27 @@
+import { LibraryPlaceholder } from "../deploy/common";
+
+// TODO: move this to a broader solc artifact type
+/** From `artifact.bytecode.linkReferences` where `artifact` is the solc JSON output of a compiled Solidity contract */
+export type LinkReferences = {
+  [filename: string]: {
+    [name: string]: {
+      start: number;
+      length: number;
+    }[];
+  };
+};
+
+export function findPlaceholders(linkReferences: LinkReferences): readonly LibraryPlaceholder[] {
+  return Object.entries(linkReferences).flatMap(([path, contracts]) =>
+    Object.entries(contracts).flatMap(([contractName, locations]) =>
+      locations.map(
+        (location): LibraryPlaceholder => ({
+          path,
+          name: contractName,
+          start: location.start,
+          length: location.length,
+        }),
+      ),
+    ),
+  );
+}

package/src/utils/getContractData.ts

@@ -0,0 +1,38 @@
+import { readFileSync } from "fs";
+import path from "path";
+import { MUDError } from "@latticexyz/common/errors";
+import { Abi, Hex, size } from "viem";
+import { LibraryPlaceholder } from "../deploy/common";
+import { findPlaceholders } from "./findPlaceholders";
+
+/**
+ * Load the contract's abi and bytecode from the file system
+ * @param contractName: Name of the contract to load
+ */
+export function getContractData(
+  filename: string,
+  contractName: string,
+  forgeOutDirectory: string,
+): { bytecode: Hex; placeholders: readonly LibraryPlaceholder[]; abi: Abi; deployedBytecodeSize: number } {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let data: any;
+  const contractDataPath = path.join(forgeOutDirectory, filename, contractName + ".json");
+  try {
+    data = JSON.parse(readFileSync(contractDataPath, "utf8"));
+  } catch (error) {
+    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}`);
+
+  const placeholders = findPlaceholders(data?.bytecode?.linkReferences ?? {});
+
+  return { abi, bytecode, placeholders, deployedBytecodeSize: size(deployedBytecode as Hex) };
+}

package/src/utils/{utils/postDeploy.ts → postDeploy.ts}

@@ -7,7 +7,7 @@ export async function postDeploy(
   postDeployScript: string,
   worldAddress: string,
   rpc: string,
-  profile: string | undefined
+  profile: string | undefined,
 ): Promise<void> {
   // Execute postDeploy forge script
   const postDeployPath = path.join(await getScriptDirectory(), postDeployScript + ".s.sol");
@@ -17,7 +17,7 @@ export async function postDeploy(
       ["script", postDeployScript, "--sig", "run(address)", worldAddress, "--broadcast", "--rpc-url", rpc, "-vvv"],
       {
         profile: profile,
-      }
+      },
     );
   } else {
     console.log(`No script at ${postDeployPath}, skipping post deploy hook`);

package/src/utils/printMUD.ts

@@ -9,6 +9,6 @@ export function printMUD() {
 | :\\/: || :\\/: || (__) |
 | '--'M|| '--'U|| '--'D|
 '------''------''------'
-`)
+`),
   );
 }