@latticexyz/cli 2.0.0-next.16 → 2.0.0-next.18

package/src/commands/build.ts

@@ -1,7 +1,6 @@
 import type { CommandModule } from "yargs";
 import { loadConfig } from "@latticexyz/config/node";
-import { StoreConfig } from "@latticexyz/store";
-import { WorldConfig } from "@latticexyz/world";
+import { World as WorldConfig } from "@latticexyz/world";
 
 import { getSrcDirectory } from "@latticexyz/common/foundry";
 import { build } from "../build";
@@ -24,7 +23,7 @@ const commandModule: CommandModule<Options, Options> = {
   },
 
   async handler({ configPath, profile }) {
-    const config = (await loadConfig(configPath)) as StoreConfig & WorldConfig;
+    const config = (await loadConfig(configPath)) as WorldConfig;
     const srcDir = await getSrcDirectory();
 
     await build({ config, srcDir, foundryProfile: profile });

package/src/commands/deploy.ts

@@ -15,7 +15,7 @@ const commandModule: CommandModule<typeof deployOptions, DeployOptions> = {
     // Wrap in try/catch, because yargs seems to swallow errors
     try {
       await runDeploy(opts);
-    } catch (error: any) {
+    } catch (error) {
       logError(error);
       process.exit(1);
     }

package/src/commands/dev-contracts.ts

@@ -3,9 +3,8 @@ import { anvil, getScriptDirectory, getSrcDirectory } from "@latticexyz/common/f
 import chalk from "chalk";
 import chokidar from "chokidar";
 import { loadConfig, resolveConfigPath } from "@latticexyz/config/node";
-import { StoreConfig } from "@latticexyz/store";
 import path from "path";
-import { WorldConfig } from "@latticexyz/world";
+import { World as WorldConfig } from "@latticexyz/world";
 import { homedir } from "os";
 import { rmSync } from "fs";
 import { deployOptions, runDeploy } from "../runDeploy";
@@ -34,7 +33,7 @@ const commandModule: CommandModule<typeof devOptions, InferredOptionTypes<typeof
     const configPath = opts.configPath ?? (await resolveConfigPath(opts.configPath));
     const srcDir = await getSrcDirectory();
     const scriptDir = await getScriptDirectory();
-    const initialConfig = (await loadConfig(configPath)) as StoreConfig & WorldConfig;
+    const initialConfig = (await loadConfig(configPath)) as WorldConfig;
 
     // Start an anvil instance in the background if no RPC url is provided
     if (!opts.rpc) {
@@ -61,7 +60,7 @@ const commandModule: CommandModule<typeof devOptions, InferredOptionTypes<typeof
       }
       if (updatePath.includes(srcDir) || updatePath.includes(scriptDir)) {
         // Ignore changes to codegen files to avoid an infinite loop
-        if (!updatePath.includes(initialConfig.codegenDirectory)) {
+        if (!updatePath.includes(initialConfig.codegen.outputDirectory)) {
           console.log(chalk.blue("Contracts changed, queuing deploy…"));
           lastChange$.next(Date.now());
         }
@@ -83,12 +82,15 @@ const commandModule: CommandModule<typeof devOptions, InferredOptionTypes<typeof
             ...opts,
             configPath,
             rpc,
+            rpcBatch: false,
             skipBuild: false,
             printConfig: false,
             profile: undefined,
             saveDeployment: true,
+            deployerAddress: undefined,
             worldAddress,
             srcDir,
+            salt: "0x",
           });
           worldAddress = deploy.address;
           // if there were changes while we were deploying, trigger it again
@@ -104,7 +106,7 @@ const commandModule: CommandModule<typeof devOptions, InferredOptionTypes<typeof
           console.log(chalk.gray("\nWaiting for file changes…\n"));
         }
       }),
-      filter(isDefined)
+      filter(isDefined),
     );
 
     deploys$.subscribe();

package/src/commands/set-version.ts

@@ -45,7 +45,7 @@ const commandModule: CommandModule<Options, Options> = {
       const mutuallyExclusiveOptions = ["mudVersion", "link", "tag", "commit", "restore"];
       const numMutuallyExclusiveOptions = mutuallyExclusiveOptions.reduce(
         (acc, opt) => (options[opt] ? acc + 1 : acc),
-        0
+        0,
       );
 
       if (numMutuallyExclusiveOptions === 0) {

package/src/commands/tablegen.ts

@@ -1,7 +1,7 @@
 import path from "path";
 import type { CommandModule } from "yargs";
 import { loadConfig } from "@latticexyz/config/node";
-import { StoreConfig } from "@latticexyz/store";
+import { Store as StoreConfig } from "@latticexyz/store";
 import { tablegen } from "@latticexyz/store/codegen";
 import { getRemappings, getSrcDirectory } from "@latticexyz/common/foundry";
 
@@ -25,7 +25,7 @@ const commandModule: CommandModule<Options, Options> = {
     const srcDir = await getSrcDirectory();
     const remappings = await getRemappings();
 
-    await tablegen(config, path.join(srcDir, config.codegenDirectory), remappings);
+    await tablegen(config, path.join(srcDir, config.codegen.outputDirectory), remappings);
 
     process.exit(0);
   },

package/src/commands/trace.ts

@@ -5,20 +5,21 @@ import { ethers } from "ethers";
 import { loadConfig } from "@latticexyz/config/node";
 import { MUDError } from "@latticexyz/common/errors";
 import { cast, getRpcUrl, getSrcDirectory } from "@latticexyz/common/foundry";
-import { StoreConfig } from "@latticexyz/store";
-import { resolveWorldConfig, WorldConfig } from "@latticexyz/world";
+import { resolveWorldConfig } from "@latticexyz/world/internal";
 import IBaseWorldAbi from "@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json" assert { type: "json" };
 import worldConfig from "@latticexyz/world/mud.config";
 import { resourceToHex } from "@latticexyz/common";
 import { getExistingContracts } from "../utils/getExistingContracts";
 import { createClient, http } from "viem";
 import { getChainId } from "viem/actions";
+import { World as WorldConfig } from "@latticexyz/world";
+import { worldToV1 } from "@latticexyz/world/config/v2";
 
 // TODO account for multiple namespaces (https://github.com/latticexyz/mud/issues/994)
 const systemsTableId = resourceToHex({
   type: "system",
   namespace: worldConfig.namespace,
-  name: worldConfig.tables.Systems.name,
+  name: worldConfig.tables.world__Systems.name,
 });
 
 type Options = {
@@ -59,11 +60,12 @@ const commandModule: CommandModule<Options, Options> = {
     const existingContracts = getExistingContracts(srcDir);
 
     // Load the config
-    const mudConfig = (await loadConfig(configPath)) as StoreConfig & WorldConfig;
+    const configV2 = (await loadConfig(configPath)) as WorldConfig;
+    const mudConfig = worldToV1(configV2);
 
     const resolvedConfig = resolveWorldConfig(
       mudConfig,
-      existingContracts.map(({ basename }) => basename)
+      existingContracts.map(({ basename }) => basename),
     );
 
     // Get worldAddress either from args or from worldsFile

package/src/commands/worldgen.ts

@@ -1,7 +1,6 @@
 import type { CommandModule } from "yargs";
 import { loadConfig } from "@latticexyz/config/node";
-import { StoreConfig } from "@latticexyz/store";
-import { WorldConfig } from "@latticexyz/world";
+import { World as WorldConfig } from "@latticexyz/world";
 import { worldgen } from "@latticexyz/world/node";
 import { getSrcDirectory } from "@latticexyz/common/foundry";
 import path from "path";
@@ -12,7 +11,7 @@ type Options = {
   configPath?: string;
   clean?: boolean;
   srcDir?: string;
-  config?: StoreConfig & WorldConfig;
+  config?: WorldConfig;
 };
 
 const commandModule: CommandModule<Options, Options> = {
@@ -43,12 +42,14 @@ export async function worldgenHandler(args: Options) {
   const existingContracts = getExistingContracts(srcDir);
 
   // Load the config
-  const mudConfig = args.config ?? ((await loadConfig(args.configPath)) as StoreConfig & WorldConfig);
+  const mudConfig = args.config ?? ((await loadConfig(args.configPath)) as WorldConfig);
 
-  const outputBaseDirectory = path.join(srcDir, mudConfig.codegenDirectory);
+  const outputBaseDirectory = path.join(srcDir, mudConfig.codegen.outputDirectory);
 
   // clear the worldgen directory
-  if (args.clean) rmSync(path.join(outputBaseDirectory, mudConfig.worldgenDirectory), { recursive: true, force: true });
+  if (args.clean) {
+    rmSync(path.join(outputBaseDirectory, mudConfig.codegen.worldgenDirectory), { recursive: true, force: true });
+  }
 
   // generate new interfaces
   await worldgen(mudConfig, existingContracts, outputBaseDirectory);

package/src/deploy/common.ts

@@ -4,8 +4,12 @@ import worldConfig from "@latticexyz/world/mud.config";
 import IBaseWorldAbi from "@latticexyz/world/out/IBaseWorld.sol/IBaseWorld.abi.json" assert { type: "json" };
 import IModuleAbi from "@latticexyz/world-modules/out/IModule.sol/IModule.abi.json" assert { type: "json" };
 import { Tables, configToTables } from "./configToTables";
-import { StoreConfig, helloStoreEvent } from "@latticexyz/store";
-import { WorldConfig, helloWorldEvent } from "@latticexyz/world";
+import { helloStoreEvent } from "@latticexyz/store";
+import { StoreConfig } from "@latticexyz/store/internal";
+import { helloWorldEvent } from "@latticexyz/world";
+import { WorldConfig } from "@latticexyz/world/internal";
+import { storeToV1 } from "@latticexyz/store/config/v2";
+import { worldToV1 } from "@latticexyz/world/config/v2";
 
 export const salt = padHex("0x", { size: 32 });
 
@@ -13,17 +17,18 @@ export const salt = padHex("0x", { size: 32 });
 export const contractSizeLimit = parseInt("6000", 16);
 
 // TODO: add `as const` to mud config so these get more strongly typed (blocked by current config parsing not using readonly)
-export const storeTables = configToTables(storeConfig);
-export const worldTables = configToTables(worldConfig);
+export const storeTables = configToTables(storeToV1(storeConfig));
+export const worldTables = configToTables(worldToV1(worldConfig));
 
 export const worldDeployEvents = [helloStoreEvent, helloWorldEvent] as const;
 
 export const worldAbi = [...IBaseWorldAbi, ...IModuleAbi] as const;
 
 // Ideally, this should be an append-only list. Before adding more versions here, be sure to add backwards-compatible support for old Store/World versions.
-export const supportedStoreVersions = ["1.0.0-unaudited"];
-export const supportedWorldVersions = ["1.0.0-unaudited"];
+export const supportedStoreVersions = ["2.0.0"];
+export const supportedWorldVersions = ["2.0.0"];
 
+// TODO: extend this to include factory+deployer address? so we can reuse the deployer for a world?
 export type WorldDeploy = {
   readonly address: Address;
   readonly worldVersion: string;
@@ -46,22 +51,62 @@ export type WorldFunction = {
   readonly systemFunctionSelector: Hex;
 };
 
+export type LibraryPlaceholder = {
+  /**
+   * Path to library source file, e.g. `src/libraries/SomeLib.sol`
+   */
+  path: string;
+  /**
+   * Library name, e.g. `SomeLib`
+   */
+  name: string;
+  /**
+   * Byte offset of placeholder in bytecode
+   */
+  start: number;
+  /**
+   * Size of placeholder to replace in bytes
+   */
+  length: number;
+};
+
 export type DeterministicContract = {
-  readonly address: Address;
-  readonly bytecode: Hex;
+  readonly prepareDeploy: (
+    deployer: Address,
+    libraries: readonly Library[],
+  ) => {
+    readonly address: Address;
+    readonly bytecode: Hex;
+  };
   readonly deployedBytecodeSize: number;
   readonly abi: Abi;
 };
 
+export type Library = DeterministicContract & {
+  /**
+   * Path to library source file, e.g. `src/libraries/SomeLib.sol`
+   */
+  path: string;
+  /**
+   * Library name, e.g. `SomeLib`
+   */
+  name: string;
+};
+
 export type System = DeterministicContract & {
   readonly namespace: string;
   readonly name: string;
   readonly systemId: Hex;
   readonly allowAll: boolean;
   readonly allowedAddresses: readonly Hex[];
+  readonly allowedSystemIds: readonly Hex[];
   readonly functions: readonly WorldFunction[];
 };
 
+export type DeployedSystem = Omit<System, "abi" | "prepareDeploy" | "deployedBytecodeSize" | "allowedSystemIds"> & {
+  address: Address;
+};
+
 export type Module = DeterministicContract & {
   readonly name: string;
   readonly installAsRoot: boolean;
@@ -73,4 +118,5 @@ export type Config<config extends ConfigInput> = {
   readonly tables: Tables<config>;
   readonly systems: readonly System[];
   readonly modules: readonly Module[];
+  readonly libraries: readonly Library[];
 };

package/src/deploy/configToTables.ts

@@ -1,7 +1,7 @@
 import { resourceToHex } from "@latticexyz/common";
-import { KeySchema, ValueSchema } from "@latticexyz/protocol-parser";
-import { SchemaAbiType, StaticAbiType } from "@latticexyz/schema-type";
-import { StoreConfig, resolveUserTypes } from "@latticexyz/store";
+import { KeySchema, ValueSchema } from "@latticexyz/protocol-parser/internal";
+import { SchemaAbiType, StaticAbiType } from "@latticexyz/schema-type/internal";
+import { StoreConfig, resolveUserTypes } from "@latticexyz/store/internal";
 import { Hex } from "viem";
 
 // TODO: we shouldn't need this file once our config parsing returns nicely formed tables
@@ -14,12 +14,12 @@ type UserTypes<config extends StoreConfig = StoreConfig> = config["userTypes"];
 
 export type TableKey<
   config extends StoreConfig = StoreConfig,
-  table extends config["tables"][keyof config["tables"]] = config["tables"][keyof config["tables"]]
+  table extends config["tables"][keyof config["tables"]] = config["tables"][keyof config["tables"]],
 > = `${config["namespace"]}_${table["name"]}`;
 
 export type Table<
   config extends StoreConfig = StoreConfig,
-  table extends config["tables"][keyof config["tables"]] = config["tables"][keyof config["tables"]]
+  table extends config["tables"][keyof config["tables"]] = config["tables"][keyof config["tables"]],
 > = {
   readonly namespace: config["namespace"];
   readonly name: table["name"];
@@ -60,9 +60,11 @@ export function configToTables<config extends StoreConfig>(config: config): Tabl
           namespace: config.namespace,
           name: table.name,
         }),
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         keySchema: resolveUserTypes(table.keySchema, userTypes) as any,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         valueSchema: resolveUserTypes(table.valueSchema, userTypes) as any,
       } satisfies Table<config, config["tables"][keyof config["tables"]]>,
-    ])
+    ]),
   ) as Tables<config>;
 }

package/src/deploy/create2/README.md

@@ -6,4 +6,8 @@ cd deterministic-deployment-proxy
 git checkout b3bb19c
 npm install
 npm run build
+cd output
+jq --arg bc "$(cat bytecode.txt)" '. + {bytecode: $bc}' deployment.json > deployment-with-bytecode.json
+mv deployment-with-bytecode.json deployment.json
+cp deployment.json ../path/to/this/dir
 ```

package/src/deploy/create2/deployment.json

@@ -3,5 +3,6 @@
   "gasLimit": 100000,
   "signerAddress": "3fab184622dc19b6109349b94811493bf2a45362",
   "transaction": "f8a58085174876e800830186a08080b853604580600e600039806000f350fe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf31ba02222222222222222222222222222222222222222222222222222222222222222a02222222222222222222222222222222222222222222222222222222222222222",
-  "address": "4e59b44847b379578588920ca78fbf26c0b4956c"
+  "address": "4e59b44847b379578588920ca78fbf26c0b4956c",
+  "bytecode": "604580600e600039806000f350fe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf3"
 }

package/src/deploy/createPrepareDeploy.ts

@@ -0,0 +1,28 @@
+import { DeterministicContract, Library, LibraryPlaceholder, salt } from "./common";
+import { spliceHex } from "@latticexyz/common";
+import { Hex, getCreate2Address, Address } from "viem";
+
+export function createPrepareDeploy(
+  bytecodeWithPlaceholders: Hex,
+  placeholders: readonly LibraryPlaceholder[],
+): DeterministicContract["prepareDeploy"] {
+  return function prepareDeploy(deployer: Address, libraries: readonly Library[]) {
+    let bytecode = bytecodeWithPlaceholders;
+    for (const placeholder of placeholders) {
+      const library = libraries.find((lib) => lib.path === placeholder.path && lib.name === placeholder.name);
+      if (!library) {
+        throw new Error(`Could not find library for bytecode placeholder ${placeholder.path}:${placeholder.name}`);
+      }
+      bytecode = spliceHex(
+        bytecode,
+        placeholder.start,
+        placeholder.length,
+        library.prepareDeploy(deployer, libraries).address,
+      );
+    }
+    return {
+      bytecode,
+      address: getCreate2Address({ from: deployer, bytecode, salt }),
+    };
+  };
+}

package/src/deploy/deploy.ts

@@ -1,4 +1,4 @@
-import { Account, Address, Chain, Client, Transport, getAddress } from "viem";
+import { Account, Address, Chain, Client, Hex, Transport } from "viem";
 import { ensureDeployer } from "./ensureDeployer";
 import { deployWorld } from "./deployWorld";
 import { ensureTables } from "./ensureTables";
@@ -11,15 +11,23 @@ import { ensureModules } from "./ensureModules";
 import { Table } from "./configToTables";
 import { ensureNamespaceOwner } from "./ensureNamespaceOwner";
 import { debug } from "./debug";
-import { resourceLabel } from "./resourceLabel";
-import { uniqueBy } from "@latticexyz/common/utils";
+import { resourceToLabel } from "@latticexyz/common";
 import { ensureContractsDeployed } from "./ensureContractsDeployed";
-import { worldFactoryContracts } from "./ensureWorldFactory";
+import { randomBytes } from "crypto";
+import { ensureWorldFactory } from "./ensureWorldFactory";
 
 type DeployOptions<configInput extends ConfigInput> = {
   client: Client<Transport, Chain | undefined, Account>;
   config: Config<configInput>;
+  salt?: Hex;
   worldAddress?: Address;
+  /**
+   * Address of determinstic deployment proxy: https://github.com/Arachnid/deterministic-deployment-proxy
+   * By default, we look for a deployment at 0x4e59b44847b379578588920ca78fbf26c0b4956c and, if not, deploy one.
+   * If the target chain does not support legacy transactions, we deploy the proxy bytecode anyway, but it will
+   * not have a deterministic address.
+   */
+  deployerAddress?: Hex;
 };
 
 /**
@@ -31,25 +39,33 @@ type DeployOptions<configInput extends ConfigInput> = {
 export async function deploy<configInput extends ConfigInput>({
   client,
   config,
+  salt,
   worldAddress: existingWorldAddress,
+  deployerAddress: initialDeployerAddress,
 }: DeployOptions<configInput>): Promise<WorldDeploy> {
   const tables = Object.values(config.tables) as Table[];
-  const systems = Object.values(config.systems);
 
-  await ensureDeployer(client);
+  const deployerAddress = initialDeployerAddress ?? (await ensureDeployer(client));
+
+  await ensureWorldFactory(client, deployerAddress);
 
   // deploy all dependent contracts, because system registration, module install, etc. all expect these contracts to be callable.
   await ensureContractsDeployed({
     client,
+    deployerAddress,
     contracts: [
-      ...worldFactoryContracts,
-      ...uniqueBy(systems, (system) => getAddress(system.address)).map((system) => ({
-        bytecode: system.bytecode,
+      ...config.libraries.map((library) => ({
+        bytecode: library.prepareDeploy(deployerAddress, config.libraries).bytecode,
+        deployedBytecodeSize: library.deployedBytecodeSize,
+        label: `${library.path}:${library.name} library`,
+      })),
+      ...config.systems.map((system) => ({
+        bytecode: system.prepareDeploy(deployerAddress, config.libraries).bytecode,
         deployedBytecodeSize: system.deployedBytecodeSize,
-        label: `${resourceLabel(system)} system`,
+        label: `${resourceToLabel(system)} system`,
       })),
-      ...uniqueBy(config.modules, (mod) => getAddress(mod.address)).map((mod) => ({
-        bytecode: mod.bytecode,
+      ...config.modules.map((mod) => ({
+        bytecode: mod.prepareDeploy(deployerAddress, config.libraries).bytecode,
         deployedBytecodeSize: mod.deployedBytecodeSize,
         label: `${mod.name} module`,
       })),
@@ -58,7 +74,7 @@ export async function deploy<configInput extends ConfigInput>({
 
   const worldDeploy = existingWorldAddress
     ? await getWorldDeploy(client, existingWorldAddress)
-    : await deployWorld(client);
+    : await deployWorld(client, deployerAddress, salt ?? `0x${randomBytes(32).toString("hex")}`);
 
   if (!supportedStoreVersions.includes(worldDeploy.storeVersion)) {
     throw new Error(`Unsupported Store version: ${worldDeploy.storeVersion}`);
@@ -70,7 +86,7 @@ export async function deploy<configInput extends ConfigInput>({
   const namespaceTxs = await ensureNamespaceOwner({
     client,
     worldDeploy,
-    resourceIds: [...tables.map((table) => table.tableId), ...systems.map((system) => system.systemId)],
+    resourceIds: [...tables.map((table) => table.tableId), ...config.systems.map((system) => system.systemId)],
   });
 
   debug("waiting for all namespace registration transactions to confirm");
@@ -85,16 +101,20 @@ export async function deploy<configInput extends ConfigInput>({
   });
   const systemTxs = await ensureSystems({
     client,
+    deployerAddress,
+    libraries: config.libraries,
     worldDeploy,
-    systems,
+    systems: config.systems,
   });
   const functionTxs = await ensureFunctions({
     client,
     worldDeploy,
-    functions: systems.flatMap((system) => system.functions),
+    functions: config.systems.flatMap((system) => system.functions),
   });
   const moduleTxs = await ensureModules({
     client,
+    deployerAddress,
+    libraries: config.libraries,
     worldDeploy,
     modules: config.modules,
   });

package/src/deploy/deployWorld.ts

@@ -1,14 +1,18 @@
-import { Account, Chain, Client, Log, Transport } from "viem";
+import { Account, Chain, Client, Hex, Log, Transport } from "viem";
 import { waitForTransactionReceipt } from "viem/actions";
-import { ensureWorldFactory, worldFactory } from "./ensureWorldFactory";
+import { ensureWorldFactory } from "./ensureWorldFactory";
 import WorldFactoryAbi from "@latticexyz/world/out/WorldFactory.sol/WorldFactory.abi.json" assert { type: "json" };
 import { writeContract } from "@latticexyz/common";
 import { debug } from "./debug";
 import { logsToWorldDeploy } from "./logsToWorldDeploy";
 import { WorldDeploy } from "./common";
 
-export async function deployWorld(client: Client<Transport, Chain | undefined, Account>): Promise<WorldDeploy> {
-  await ensureWorldFactory(client);
+export async function deployWorld(
+  client: Client<Transport, Chain | undefined, Account>,
+  deployerAddress: Hex,
+  salt: Hex,
+): Promise<WorldDeploy> {
+  const worldFactory = await ensureWorldFactory(client, deployerAddress);
 
   debug("deploying world");
   const tx = await writeContract(client, {
@@ -16,6 +20,7 @@ export async function deployWorld(client: Client<Transport, Chain | undefined, A
     address: worldFactory,
     abi: WorldFactoryAbi,
     functionName: "deployWorld",
+    args: [salt],
   });
 
   debug("waiting for world deploy");

package/src/deploy/ensureContract.ts

@@ -1,6 +1,5 @@
-import { Client, Transport, Chain, Account, concatHex, getCreate2Address, Hex, size } from "viem";
+import { Client, Transport, Chain, Account, concatHex, getCreate2Address, Hex } from "viem";
 import { getBytecode } from "viem/actions";
-import { deployer } from "./ensureDeployer";
 import { contractSizeLimit, salt } from "./common";
 import { sendTransaction } from "@latticexyz/common";
 import { debug } from "./debug";
@@ -15,13 +14,19 @@ export type Contract = {
 
 export async function ensureContract({
   client,
+  deployerAddress,
   bytecode,
   deployedBytecodeSize,
   label = "contract",
 }: {
   readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly deployerAddress: Hex;
 } & Contract): Promise<readonly Hex[]> {
-  const address = getCreate2Address({ from: deployer, salt, bytecode });
+  if (bytecode.includes("__$")) {
+    throw new Error(`Found unlinked public library in ${label} bytecode`);
+  }
+
+  const address = getCreate2Address({ from: deployerAddress, salt, bytecode });
 
   const contractCode = await getBytecode(client, { address, blockTag: "pending" });
   if (contractCode) {
@@ -31,11 +36,11 @@ export async function ensureContract({
 
   if (deployedBytecodeSize > contractSizeLimit) {
     console.warn(
-      `\nBytecode for ${label} (${deployedBytecodeSize} bytes) is over the contract size limit (${contractSizeLimit} bytes). Run \`forge build --sizes\` for more info.\n`
+      `\nBytecode for ${label} (${deployedBytecodeSize} bytes) is over the contract size limit (${contractSizeLimit} bytes). Run \`forge build --sizes\` for more info.\n`,
     );
   } else if (deployedBytecodeSize > contractSizeLimit * 0.95) {
     console.warn(
-      `\nBytecode for ${label} (${deployedBytecodeSize} bytes) is almost over the contract size limit (${contractSizeLimit} bytes). Run \`forge build --sizes\` for more info.\n`
+      `\nBytecode for ${label} (${deployedBytecodeSize} bytes) is almost over the contract size limit (${contractSizeLimit} bytes). Run \`forge build --sizes\` for more info.\n`,
     );
   }
 
@@ -45,7 +50,7 @@ export async function ensureContract({
       () =>
         sendTransaction(client, {
           chain: client.chain ?? null,
-          to: deployer,
+          to: deployerAddress,
           data: concatHex([salt, bytecode]),
         }),
       {
@@ -55,7 +60,7 @@ export async function ensureContract({
           debug(`failed to deploy ${label}, retrying in ${delay}ms...`);
           await wait(delay);
         },
-      }
+      },
     ),
   ];
 }

package/src/deploy/ensureContractsDeployed.ts

@@ -2,15 +2,23 @@ import { Client, Transport, Chain, Account, Hex } from "viem";
 import { waitForTransactionReceipt } from "viem/actions";
 import { debug } from "./debug";
 import { Contract, ensureContract } from "./ensureContract";
+import { uniqueBy } from "@latticexyz/common/utils";
 
 export async function ensureContractsDeployed({
   client,
+  deployerAddress,
   contracts,
 }: {
   readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly deployerAddress: Hex;
   readonly contracts: readonly Contract[];
 }): Promise<readonly Hex[]> {
-  const txs = (await Promise.all(contracts.map((contract) => ensureContract({ client, ...contract })))).flat();
+  // Deployments assume a deterministic deployer, so we only need to deploy the unique bytecode
+  const uniqueContracts = uniqueBy(contracts, (contract) => contract.bytecode);
+
+  const txs = (
+    await Promise.all(uniqueContracts.map((contract) => ensureContract({ client, deployerAddress, ...contract })))
+  ).flat();
 
   if (txs.length) {
     debug("waiting for contracts");