@latticexyz/cli 2.0.0-main-711f6e2a → 2.0.0-march-19-skystrife-playtest-f486281e

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@latticexyz/cli",
-  "version": "2.0.0-main-711f6e2a",
+  "version": "2.0.0-march-19-skystrife-playtest-f486281e",
   "description": "Command line interface for mud",
   "repository": {
     "type": "git",
@@ -35,23 +35,22 @@
     "path": "^0.12.7",
     "rxjs": "7.5.5",
     "throttle-debounce": "^5.0.0",
-    "toposort": "^2.0.2",
-    "typescript": "5.4.2",
-    "viem": "2.7.12",
+    "typescript": "5.1.6",
+    "viem": "1.14.0",
     "yargs": "^17.7.1",
     "zod": "^3.21.4",
     "zod-validation-error": "^1.3.0",
-    "@latticexyz/abi-ts": "2.0.0-main-711f6e2a",
-    "@latticexyz/common": "2.0.0-main-711f6e2a",
-    "@latticexyz/config": "2.0.0-main-711f6e2a",
-    "@latticexyz/gas-report": "2.0.0-main-711f6e2a",
-    "@latticexyz/protocol-parser": "2.0.0-main-711f6e2a",
-    "@latticexyz/schema-type": "2.0.0-main-711f6e2a",
-    "@latticexyz/services": "2.0.0-main-711f6e2a",
-    "@latticexyz/store": "2.0.0-main-711f6e2a",
-    "@latticexyz/utils": "2.0.0-main-711f6e2a",
-    "@latticexyz/world": "2.0.0-main-711f6e2a",
-    "@latticexyz/world-modules": "2.0.0-main-711f6e2a"
+    "@latticexyz/abi-ts": "2.0.0-march-19-skystrife-playtest-f486281e",
+    "@latticexyz/common": "2.0.0-march-19-skystrife-playtest-f486281e",
+    "@latticexyz/config": "2.0.0-march-19-skystrife-playtest-f486281e",
+    "@latticexyz/gas-report": "2.0.0-march-19-skystrife-playtest-f486281e",
+    "@latticexyz/protocol-parser": "2.0.0-march-19-skystrife-playtest-f486281e",
+    "@latticexyz/schema-type": "2.0.0-march-19-skystrife-playtest-f486281e",
+    "@latticexyz/services": "2.0.0-march-19-skystrife-playtest-f486281e",
+    "@latticexyz/store": "2.0.0-march-19-skystrife-playtest-f486281e",
+    "@latticexyz/utils": "2.0.0-march-19-skystrife-playtest-f486281e",
+    "@latticexyz/world": "2.0.0-march-19-skystrife-playtest-f486281e",
+    "@latticexyz/world-modules": "2.0.0-march-19-skystrife-playtest-f486281e"
   },
   "devDependencies": {
     "@types/debug": "^4.1.7",
@@ -60,13 +59,12 @@
     "@types/node": "^18.15.11",
     "@types/openurl": "^1.0.0",
     "@types/throttle-debounce": "^5.0.0",
-    "@types/toposort": "^2.0.6",
     "@types/yargs": "^17.0.10",
     "ds-test": "https://github.com/dapphub/ds-test.git#e282159d5170298eb2455a6c05280ab5a73a4ef0",
     "forge-std": "https://github.com/foundry-rs/forge-std.git#74cfb77e308dd188d2f58864aaf44963ae6b88b1",
     "tsup": "^6.7.0",
     "tsx": "^3.12.6",
-    "vitest": "0.34.6"
+    "vitest": "0.31.4"
   },
   "gitHead": "914a1e0ae4a573d685841ca2ea921435057deb8f",
   "scripts": {

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) {
+    } catch (error: any) {
       logError(error);
       process.exit(1);
     }

package/src/commands/dev-contracts.ts

@@ -83,15 +83,12 @@ 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
@@ -107,7 +104,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/trace.ts

@@ -63,7 +63,7 @@ const commandModule: CommandModule<Options, Options> = {
 
     const resolvedConfig = resolveWorldConfig(
       mudConfig,
-      existingContracts.map(({ basename }) => basename),
+      existingContracts.map(({ basename }) => basename)
     );
 
     // Get worldAddress either from args or from worldsFile

package/src/deploy/assertNamespaceOwner.ts

@@ -0,0 +1,42 @@
+import { Account, Chain, Client, Hex, Transport, getAddress } from "viem";
+import { WorldDeploy, worldTables } from "./common";
+import { hexToResource, resourceToHex } from "@latticexyz/common";
+import { getResourceIds } from "./getResourceIds";
+import { getTableValue } from "./getTableValue";
+
+export async function assertNamespaceOwner({
+  client,
+  worldDeploy,
+  resourceIds,
+}: {
+  readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly worldDeploy: WorldDeploy;
+  readonly resourceIds: readonly Hex[];
+}): Promise<void> {
+  const desiredNamespaces = Array.from(new Set(resourceIds.map((resourceId) => hexToResource(resourceId).namespace)));
+  const existingResourceIds = await getResourceIds({ client, worldDeploy });
+  const existingNamespaces = Array.from(
+    new Set(existingResourceIds.map((resourceId) => hexToResource(resourceId).namespace))
+  );
+
+  const namespaces = desiredNamespaces.filter((namespace) => existingNamespaces.includes(namespace));
+  const namespaceOwners = await Promise.all(
+    namespaces.map(async (namespace) => {
+      const { owner } = await getTableValue({
+        client,
+        worldDeploy,
+        table: worldTables.world_NamespaceOwner,
+        key: { namespaceId: resourceToHex({ type: "namespace", namespace, name: "" }) },
+      });
+      return [namespace, owner];
+    })
+  );
+
+  const unauthorizedNamespaces = namespaceOwners
+    .filter(([, owner]) => getAddress(owner) !== getAddress(client.account.address))
+    .map(([namespace]) => namespace);
+
+  if (unauthorizedNamespaces.length) {
+    throw new Error(`You are attempting to deploy to namespaces you do not own: ${unauthorizedNamespaces.join(", ")}`);
+  }
+}

package/src/deploy/common.ts

@@ -24,7 +24,6 @@ export const worldAbi = [...IBaseWorldAbi, ...IModuleAbi] as const;
 export const supportedStoreVersions = ["1.0.0-unaudited"];
 export const supportedWorldVersions = ["1.0.0-unaudited"];
 
-// 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;
@@ -47,62 +46,22 @@ 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 prepareDeploy: (
-    deployer: Address,
-    libraries: readonly Library[],
-  ) => {
-    readonly address: Address;
-    readonly bytecode: Hex;
-  };
+  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;
@@ -114,5 +73,4 @@ 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

@@ -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,11 +60,9 @@ 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,8 +6,4 @@ 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,6 +3,5 @@
   "gasLimit": 100000,
   "signerAddress": "3fab184622dc19b6109349b94811493bf2a45362",
   "transaction": "f8a58085174876e800830186a08080b853604580600e600039806000f350fe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf31ba02222222222222222222222222222222222222222222222222222222222222222a02222222222222222222222222222222222222222222222222222222222222222",
-  "address": "4e59b44847b379578588920ca78fbf26c0b4956c",
-  "bytecode": "604580600e600039806000f350fe7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe03601600081602082378035828234f58015156039578182fd5b8082525050506014600cf3"
+  "address": "4e59b44847b379578588920ca78fbf26c0b4956c"
 }

package/src/deploy/deploy.ts

@@ -1,4 +1,4 @@
-import { Account, Address, Chain, Client, Hex, Transport } from "viem";
+import { Account, Address, Chain, Client, Transport, getAddress } from "viem";
 import { ensureDeployer } from "./ensureDeployer";
 import { deployWorld } from "./deployWorld";
 import { ensureTables } from "./ensureTables";
@@ -9,25 +9,17 @@ import { getWorldDeploy } from "./getWorldDeploy";
 import { ensureFunctions } from "./ensureFunctions";
 import { ensureModules } from "./ensureModules";
 import { Table } from "./configToTables";
-import { ensureNamespaceOwner } from "./ensureNamespaceOwner";
+import { assertNamespaceOwner } from "./assertNamespaceOwner";
 import { debug } from "./debug";
-import { resourceToLabel } from "@latticexyz/common";
+import { resourceLabel } from "./resourceLabel";
+import { uniqueBy } from "@latticexyz/common/utils";
 import { ensureContractsDeployed } from "./ensureContractsDeployed";
-import { randomBytes } from "crypto";
-import { ensureWorldFactory } from "./ensureWorldFactory";
+import { coreModuleBytecode, worldFactoryBytecode, worldFactoryContracts } 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;
 };
 
 /**
@@ -39,33 +31,25 @@ 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);
 
-  const deployerAddress = initialDeployerAddress ?? (await ensureDeployer(client));
-
-  await ensureWorldFactory(client, deployerAddress);
+  await ensureDeployer(client);
 
   // deploy all dependent contracts, because system registration, module install, etc. all expect these contracts to be callable.
   await ensureContractsDeployed({
     client,
-    deployerAddress,
     contracts: [
-      ...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,
+      ...worldFactoryContracts,
+      ...uniqueBy(systems, (system) => getAddress(system.address)).map((system) => ({
+        bytecode: system.bytecode,
         deployedBytecodeSize: system.deployedBytecodeSize,
-        label: `${resourceToLabel(system)} system`,
+        label: `${resourceLabel(system)} system`,
       })),
-      ...config.modules.map((mod) => ({
-        bytecode: mod.prepareDeploy(deployerAddress, config.libraries).bytecode,
+      ...uniqueBy(config.modules, (mod) => getAddress(mod.address)).map((mod) => ({
+        bytecode: mod.bytecode,
         deployedBytecodeSize: mod.deployedBytecodeSize,
         label: `${mod.name} module`,
       })),
@@ -74,7 +58,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);
 
   if (!supportedStoreVersions.includes(worldDeploy.storeVersion)) {
     throw new Error(`Unsupported Store version: ${worldDeploy.storeVersion}`);
@@ -83,17 +67,12 @@ export async function deploy<configInput extends ConfigInput>({
     throw new Error(`Unsupported World version: ${worldDeploy.worldVersion}`);
   }
 
-  const namespaceTxs = await ensureNamespaceOwner({
+  await assertNamespaceOwner({
     client,
     worldDeploy,
-    resourceIds: [...tables.map((table) => table.tableId), ...config.systems.map((system) => system.systemId)],
+    resourceIds: [...tables.map((table) => table.tableId), ...systems.map((system) => system.systemId)],
   });
 
-  debug("waiting for all namespace registration transactions to confirm");
-  for (const tx of namespaceTxs) {
-    await waitForTransactionReceipt(client, { hash: tx });
-  }
-
   const tableTxs = await ensureTables({
     client,
     worldDeploy,
@@ -101,20 +80,16 @@ export async function deploy<configInput extends ConfigInput>({
   });
   const systemTxs = await ensureSystems({
     client,
-    deployerAddress,
-    libraries: config.libraries,
     worldDeploy,
-    systems: config.systems,
+    systems,
   });
   const functionTxs = await ensureFunctions({
     client,
     worldDeploy,
-    functions: config.systems.flatMap((system) => system.functions),
+    functions: systems.flatMap((system) => system.functions),
   });
   const moduleTxs = await ensureModules({
     client,
-    deployerAddress,
-    libraries: config.libraries,
     worldDeploy,
     modules: config.modules,
   });

package/src/deploy/deployWorld.ts

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

package/src/deploy/ensureContract.ts

@@ -1,5 +1,6 @@
-import { Client, Transport, Chain, Account, concatHex, getCreate2Address, Hex } from "viem";
+import { Client, Transport, Chain, Account, concatHex, getCreate2Address, Hex, size } 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";
@@ -14,19 +15,13 @@ 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[]> {
-  if (bytecode.includes("__$")) {
-    throw new Error(`Found unlinked public library in ${label} bytecode`);
-  }
-
-  const address = getCreate2Address({ from: deployerAddress, salt, bytecode });
+  const address = getCreate2Address({ from: deployer, salt, bytecode });
 
   const contractCode = await getBytecode(client, { address, blockTag: "pending" });
   if (contractCode) {
@@ -36,11 +31,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`
     );
   }
 
@@ -50,7 +45,7 @@ export async function ensureContract({
       () =>
         sendTransaction(client, {
           chain: client.chain ?? null,
-          to: deployerAddress,
+          to: deployer,
           data: concatHex([salt, bytecode]),
         }),
       {
@@ -60,7 +55,7 @@ export async function ensureContract({
           debug(`failed to deploy ${label}, retrying in ${delay}ms...`);
           await wait(delay);
         },
-      },
+      }
     ),
   ];
 }

package/src/deploy/ensureContractsDeployed.ts

@@ -2,23 +2,15 @@ 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[]> {
-  // 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();
+  const txs = (await Promise.all(contracts.map((contract) => ensureContract({ client, ...contract })))).flat();
 
   if (txs.length) {
     debug("waiting for contracts");

package/src/deploy/ensureDeployer.ts

@@ -1,75 +1,36 @@
-import { Account, Address, Chain, Client, Transport } from "viem";
-import { getBalance, getBytecode, sendRawTransaction, sendTransaction, waitForTransactionReceipt } from "viem/actions";
+import { Account, Chain, Client, Transport } from "viem";
+import { getBytecode, sendRawTransaction, sendTransaction, waitForTransactionReceipt } from "viem/actions";
 import deployment from "./create2/deployment.json";
 import { debug } from "./debug";
 
-const deployer = `0x${deployment.address}` as const;
-const deployerBytecode = `0x${deployment.bytecode}` as const;
+export const deployer = `0x${deployment.address}` as const;
 
-export async function ensureDeployer(client: Client<Transport, Chain | undefined, Account>): Promise<Address> {
+export async function ensureDeployer(client: Client<Transport, Chain | undefined, Account>): Promise<void> {
   const bytecode = await getBytecode(client, { address: deployer });
   if (bytecode) {
-    debug("found CREATE2 deployer at", deployer);
-    if (bytecode !== deployerBytecode) {
-      console.warn(
-        `\n  ⚠️ Bytecode for deployer at ${deployer} did not match the expected CREATE2 bytecode. You may have unexpected results.\n`,
-      );
-    }
-    return deployer;
+    debug("found create2 deployer at", deployer);
+    return;
   }
 
-  // There's not really a way to simulate a pre-EIP-155 (no chain ID) transaction,
-  // so we have to attempt to create the deployer first and, if it fails, fall back
-  // to a regular deploy.
-
-  // Send gas to deployment signer
-  const gasRequired = BigInt(deployment.gasLimit) * BigInt(deployment.gasPrice);
-  const currentBalance = await getBalance(client, { address: `0x${deployment.signerAddress}` });
-  const gasNeeded = gasRequired - currentBalance;
-  if (gasNeeded > 0) {
-    debug("sending gas for CREATE2 deployer to signer at", deployment.signerAddress);
-    const gasTx = await sendTransaction(client, {
-      chain: client.chain ?? null,
-      to: `0x${deployment.signerAddress}`,
-      value: gasNeeded,
-    });
-    const gasReceipt = await waitForTransactionReceipt(client, { hash: gasTx });
-    if (gasReceipt.status !== "success") {
-      console.error("failed to send gas to deployer signer", gasReceipt);
-      throw new Error("failed to send gas to deployer signer");
-    }
+  // send gas to signer
+  debug("sending gas for create2 deployer to signer at", deployment.signerAddress);
+  const gasTx = await sendTransaction(client, {
+    chain: client.chain ?? null,
+    to: `0x${deployment.signerAddress}`,
+    value: BigInt(deployment.gasLimit) * BigInt(deployment.gasPrice),
+  });
+  const gasReceipt = await waitForTransactionReceipt(client, { hash: gasTx });
+  if (gasReceipt.status !== "success") {
+    console.error("failed to send gas to deployer signer", gasReceipt);
+    throw new Error("failed to send gas to deployer signer");
   }
 
-  // Deploy the deployer
-  debug("deploying CREATE2 deployer at", deployer);
-  const deployTx = await sendRawTransaction(client, { serializedTransaction: `0x${deployment.transaction}` }).catch(
-    (error) => {
-      // Do a regular contract create if the presigned transaction doesn't work due to replay protection
-      if (String(error).includes("only replay-protected (EIP-155) transactions allowed over RPC")) {
-        console.warn(
-          // eslint-disable-next-line max-len
-          `\n  ⚠️ Your chain or RPC does not allow for non EIP-155 signed transactions, so your deploys will not be determinstic and contract addresses may change between deploys.\n\n  We recommend running your chain's node with \`--rpc.allow-unprotected-txs\` to enable determinstic deployments.\n`,
-        );
-        debug("deploying CREATE2 deployer");
-        return sendTransaction(client, {
-          chain: client.chain ?? null,
-          data: deployerBytecode,
-        });
-      }
-      throw error;
-    },
-  );
-
+  // deploy the deployer
+  debug("deploying create2 deployer at", deployer);
+  const deployTx = await sendRawTransaction(client, { serializedTransaction: `0x${deployment.transaction}` });
   const deployReceipt = await waitForTransactionReceipt(client, { hash: deployTx });
-  if (!deployReceipt.contractAddress) {
-    throw new Error("Deploy receipt did not have contract address, was the deployer not deployed?");
-  }
-
   if (deployReceipt.contractAddress !== deployer) {
-    console.warn(
-      `\n  ⚠️ CREATE2 deployer created at ${deployReceipt.contractAddress} does not match the CREATE2 determinstic deployer we expected (${deployer})`,
-    );
+    console.error("unexpected contract address for deployer", deployReceipt);
+    throw new Error("unexpected contract address for deployer");
   }
-
-  return deployReceipt.contractAddress;
 }