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

package/src/deploy/ensureDeployer.ts

@@ -1,36 +1,75 @@
-import { Account, Chain, Client, Transport } from "viem";
-import { getBytecode, sendRawTransaction, sendTransaction, waitForTransactionReceipt } from "viem/actions";
+import { Account, Address, Chain, Client, Transport } from "viem";
+import { getBalance, getBytecode, sendRawTransaction, sendTransaction, waitForTransactionReceipt } from "viem/actions";
 import deployment from "./create2/deployment.json";
 import { debug } from "./debug";
 
-export const deployer = `0x${deployment.address}` as const;
+const deployer = `0x${deployment.address}` as const;
+const deployerBytecode = `0x${deployment.bytecode}` as const;
 
-export async function ensureDeployer(client: Client<Transport, Chain | undefined, Account>): Promise<void> {
+export async function ensureDeployer(client: Client<Transport, Chain | undefined, Account>): Promise<Address> {
   const bytecode = await getBytecode(client, { address: deployer });
   if (bytecode) {
-    debug("found create2 deployer at", deployer);
-    return;
+    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;
   }
 
-  // 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");
+  // 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");
+    }
   }
 
-  // deploy the deployer
-  debug("deploying create2 deployer at", deployer);
-  const deployTx = await sendRawTransaction(client, { serializedTransaction: `0x${deployment.transaction}` });
+  // 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;
+    },
+  );
+
   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.error("unexpected contract address for deployer", deployReceipt);
-    throw new Error("unexpected contract address for deployer");
+    console.warn(
+      `\n  ⚠️ CREATE2 deployer created at ${deployReceipt.contractAddress} does not match the CREATE2 determinstic deployer we expected (${deployer})`,
+    );
   }
+
+  return deployReceipt.contractAddress;
 }

package/src/deploy/ensureFunctions.ts

@@ -29,7 +29,7 @@ export async function ensureFunctions({
         "found",
         wrongSystem.length,
         "functions already registered but pointing at a different system ID:",
-        wrongSystem.map((func) => func.signature).join(", ")
+        wrongSystem.map((func) => func.signature).join(", "),
       );
     }
   }
@@ -50,7 +50,7 @@ export async function ensureFunctions({
               abi: worldAbi,
               // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
               functionName: "registerRootFunctionSelector",
-              args: [func.systemId, func.systemFunctionSignature, func.systemFunctionSelector],
+              args: [func.systemId, func.systemFunctionSignature, func.systemFunctionSignature],
             }),
           {
             retries: 3,
@@ -59,7 +59,7 @@ export async function ensureFunctions({
               debug(`failed to register function ${func.signature}, retrying in ${delay}ms...`);
               await wait(delay);
             },
-          }
+          },
         );
       }
       return pRetry(
@@ -79,8 +79,8 @@ export async function ensureFunctions({
             debug(`failed to register function ${func.signature}, retrying in ${delay}ms...`);
             await wait(delay);
           },
-        }
+        },
       );
-    })
+    }),
   );
 }

package/src/deploy/ensureModules.ts

@@ -1,17 +1,21 @@
-import { Client, Transport, Chain, Account, Hex, BaseError, getAddress } from "viem";
+import { Client, Transport, Chain, Account, Hex, BaseError } from "viem";
 import { writeContract } from "@latticexyz/common";
-import { Module, WorldDeploy, worldAbi } from "./common";
+import { Library, Module, WorldDeploy, worldAbi } from "./common";
 import { debug } from "./debug";
-import { isDefined, uniqueBy, wait } from "@latticexyz/common/utils";
+import { isDefined, wait } from "@latticexyz/common/utils";
 import pRetry from "p-retry";
 import { ensureContractsDeployed } from "./ensureContractsDeployed";
 
 export async function ensureModules({
   client,
+  deployerAddress,
+  libraries,
   worldDeploy,
   modules,
 }: {
   readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly deployerAddress: Hex;
+  readonly libraries: readonly Library[];
   readonly worldDeploy: WorldDeploy;
   readonly modules: readonly Module[];
 }): Promise<readonly Hex[]> {
@@ -19,8 +23,9 @@ export async function ensureModules({
 
   await ensureContractsDeployed({
     client,
-    contracts: uniqueBy(modules, (mod) => getAddress(mod.address)).map((mod) => ({
-      bytecode: mod.bytecode,
+    deployerAddress,
+    contracts: modules.map((mod) => ({
+      bytecode: mod.prepareDeploy(deployerAddress, libraries).bytecode,
       deployedBytecodeSize: mod.deployedBytecodeSize,
       label: `${mod.name} module`,
     })),
@@ -33,6 +38,7 @@ export async function ensureModules({
         pRetry(
           async () => {
             try {
+              const moduleAddress = mod.prepareDeploy(deployerAddress, libraries).address;
               return mod.installAsRoot
                 ? await writeContract(client, {
                     chain: client.chain ?? null,
@@ -40,7 +46,7 @@ export async function ensureModules({
                     abi: worldAbi,
                     // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
                     functionName: "installRootModule",
-                    args: [mod.address, mod.installData],
+                    args: [moduleAddress, mod.installData],
                   })
                 : await writeContract(client, {
                     chain: client.chain ?? null,
@@ -48,7 +54,7 @@ export async function ensureModules({
                     abi: worldAbi,
                     // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
                     functionName: "installModule",
-                    args: [mod.address, mod.installData],
+                    args: [moduleAddress, mod.installData],
                   });
             } catch (error) {
               if (error instanceof BaseError && error.message.includes("Module_AlreadyInstalled")) {
@@ -65,9 +71,9 @@ export async function ensureModules({
               debug(`failed to install module ${mod.name}, retrying in ${delay}ms...`);
               await wait(delay);
             },
-          }
-        )
-      )
+          },
+        ),
+      ),
     )
   ).filter(isDefined);
 }

package/src/deploy/ensureNamespaceOwner.ts

@@ -24,7 +24,7 @@ export async function ensureNamespaceOwner({
       "existing namespaces:",
       Array.from(existingNamespaces)
         .map((namespace) => (namespace === "" ? "<root>" : namespace))
-        .join(", ")
+        .join(", "),
     );
   }
 
@@ -39,7 +39,7 @@ export async function ensureNamespaceOwner({
         key: { namespaceId: resourceToHex({ type: "namespace", namespace, name: "" }) },
       });
       return [namespace, owner];
-    })
+    }),
   );
 
   const unauthorizedNamespaces = namespaceOwners
@@ -63,8 +63,8 @@ export async function ensureNamespaceOwner({
         abi: worldAbi,
         functionName: "registerNamespace",
         args: [resourceToHex({ namespace, type: "namespace", name: "" })],
-      })
-    )
+      }),
+    ),
   );
 
   return registrationTxs;

package/src/deploy/ensureSystems.ts

@@ -1,20 +1,25 @@
-import { Client, Transport, Chain, Account, Hex, getAddress } from "viem";
-import { writeContract } from "@latticexyz/common";
-import { System, WorldDeploy, worldAbi } from "./common";
+import { Client, Transport, Chain, Account, Hex, getAddress, Address } from "viem";
+import { writeContract, resourceToLabel } from "@latticexyz/common";
+import { Library, System, WorldDeploy, worldAbi } from "./common";
 import { debug } from "./debug";
-import { resourceLabel } from "./resourceLabel";
 import { getSystems } from "./getSystems";
 import { getResourceAccess } from "./getResourceAccess";
-import { uniqueBy, wait } from "@latticexyz/common/utils";
+import { wait } from "@latticexyz/common/utils";
 import pRetry from "p-retry";
 import { ensureContractsDeployed } from "./ensureContractsDeployed";
 
+// TODO: move each system registration+access to batch call to be atomic
+
 export async function ensureSystems({
   client,
+  deployerAddress,
+  libraries,
   worldDeploy,
   systems,
 }: {
   readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly deployerAddress: Hex;
+  readonly libraries: readonly Library[];
   readonly worldDeploy: WorldDeploy;
   readonly systems: readonly System[];
 }): Promise<readonly Hex[]> {
@@ -22,30 +27,112 @@ export async function ensureSystems({
     getSystems({ client, worldDeploy }),
     getResourceAccess({ client, worldDeploy }),
   ]);
+
+  // Register or replace systems
+
+  const existingSystems = systems.filter((system) =>
+    worldSystems.some(
+      (worldSystem) =>
+        worldSystem.systemId === system.systemId &&
+        getAddress(worldSystem.address) === getAddress(system.prepareDeploy(deployerAddress, libraries).address),
+    ),
+  );
+  if (existingSystems.length) {
+    debug("existing systems", existingSystems.map(resourceToLabel).join(", "));
+  }
+  const existingSystemIds = existingSystems.map((system) => system.systemId);
+
+  const missingSystems = systems.filter((system) => !existingSystemIds.includes(system.systemId));
+  if (!missingSystems.length) return [];
+
+  const systemsToUpgrade = missingSystems.filter((system) =>
+    worldSystems.some(
+      (worldSystem) =>
+        worldSystem.systemId === system.systemId &&
+        getAddress(worldSystem.address) !== getAddress(system.prepareDeploy(deployerAddress, libraries).address),
+    ),
+  );
+  if (systemsToUpgrade.length) {
+    debug("upgrading systems", systemsToUpgrade.map(resourceToLabel).join(", "));
+  }
+
+  const systemsToAdd = missingSystems.filter(
+    (system) => !worldSystems.some((worldSystem) => worldSystem.systemId === system.systemId),
+  );
+  if (systemsToAdd.length) {
+    debug("registering new systems", systemsToAdd.map(resourceToLabel).join(", "));
+  }
+
+  await ensureContractsDeployed({
+    client,
+    deployerAddress,
+    contracts: missingSystems.map((system) => ({
+      bytecode: system.prepareDeploy(deployerAddress, libraries).bytecode,
+      deployedBytecodeSize: system.deployedBytecodeSize,
+      label: `${resourceToLabel(system)} system`,
+    })),
+  });
+
+  const registerTxs = await Promise.all(
+    missingSystems.map((system) =>
+      pRetry(
+        () =>
+          writeContract(client, {
+            chain: client.chain ?? null,
+            address: worldDeploy.address,
+            abi: worldAbi,
+            // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+            functionName: "registerSystem",
+            args: [system.systemId, system.prepareDeploy(deployerAddress, libraries).address, system.allowAll],
+          }),
+        {
+          retries: 3,
+          onFailedAttempt: async (error) => {
+            const delay = error.attemptNumber * 500;
+            debug(`failed to register system ${resourceToLabel(system)}, retrying in ${delay}ms...`);
+            await wait(delay);
+          },
+        },
+      ),
+    ),
+  );
+
+  // Adjust system access
+
   const systemIds = systems.map((system) => system.systemId);
   const currentAccess = worldAccess.filter(({ resourceId }) => systemIds.includes(resourceId));
-  const desiredAccess = systems.flatMap((system) =>
-    system.allowedAddresses.map((address) => ({ resourceId: system.systemId, address }))
-  );
+  const desiredAccess = [
+    ...systems.flatMap((system) =>
+      system.allowedAddresses.map((address) => ({ resourceId: system.systemId, address })),
+    ),
+    ...systems.flatMap((system) =>
+      system.allowedSystemIds
+        .map((systemId) => ({
+          resourceId: system.systemId,
+          address:
+            worldSystems.find((s) => s.systemId === systemId)?.address ??
+            systems.find((s) => s.systemId === systemId)?.prepareDeploy(deployerAddress, libraries).address,
+        }))
+        .filter((access): access is typeof access & { address: Address } => access.address != null),
+    ),
+  ];
 
   const accessToAdd = desiredAccess.filter(
     (access) =>
       !currentAccess.some(
         ({ resourceId, address }) =>
-          resourceId === access.resourceId && getAddress(address) === getAddress(access.address)
-      )
+          resourceId === access.resourceId && getAddress(address) === getAddress(access.address),
+      ),
   );
 
   const accessToRemove = currentAccess.filter(
     (access) =>
       !desiredAccess.some(
         ({ resourceId, address }) =>
-          resourceId === access.resourceId && getAddress(address) === getAddress(access.address)
-      )
+          resourceId === access.resourceId && getAddress(address) === getAddress(access.address),
+      ),
   );
 
-  // TODO: move each system access+registration to batch call to be atomic
-
   if (accessToRemove.length) {
     debug("revoking", accessToRemove.length, "access grants");
   }
@@ -53,7 +140,7 @@ export async function ensureSystems({
     debug("adding", accessToAdd.length, "access grants");
   }
 
-  const accessTxs = [
+  const accessTxs = await Promise.all([
     ...accessToRemove.map((access) =>
       pRetry(
         () =>
@@ -71,8 +158,8 @@ export async function ensureSystems({
             debug(`failed to revoke access, retrying in ${delay}ms...`);
             await wait(delay);
           },
-        }
-      )
+        },
+      ),
     ),
     ...accessToAdd.map((access) =>
       pRetry(
@@ -91,72 +178,10 @@ export async function ensureSystems({
             debug(`failed to grant access, retrying in ${delay}ms...`);
             await wait(delay);
           },
-        }
-      )
-    ),
-  ];
-
-  const existingSystems = systems.filter((system) =>
-    worldSystems.some(
-      (worldSystem) =>
-        worldSystem.systemId === system.systemId && getAddress(worldSystem.address) === getAddress(system.address)
-    )
-  );
-  if (existingSystems.length) {
-    debug("existing systems", existingSystems.map(resourceLabel).join(", "));
-  }
-  const existingSystemIds = existingSystems.map((system) => system.systemId);
-
-  const missingSystems = systems.filter((system) => !existingSystemIds.includes(system.systemId));
-  if (!missingSystems.length) return [];
-
-  const systemsToUpgrade = missingSystems.filter((system) =>
-    worldSystems.some(
-      (worldSystem) =>
-        worldSystem.systemId === system.systemId && getAddress(worldSystem.address) !== getAddress(system.address)
-    )
-  );
-  if (systemsToUpgrade.length) {
-    debug("upgrading systems", systemsToUpgrade.map(resourceLabel).join(", "));
-  }
-
-  const systemsToAdd = missingSystems.filter(
-    (system) => !worldSystems.some((worldSystem) => worldSystem.systemId === system.systemId)
-  );
-  if (systemsToAdd.length) {
-    debug("registering new systems", systemsToAdd.map(resourceLabel).join(", "));
-  }
-
-  await ensureContractsDeployed({
-    client,
-    contracts: uniqueBy(missingSystems, (system) => getAddress(system.address)).map((system) => ({
-      bytecode: system.bytecode,
-      deployedBytecodeSize: system.deployedBytecodeSize,
-      label: `${resourceLabel(system)} system`,
-    })),
-  });
-
-  const registerTxs = missingSystems.map((system) =>
-    pRetry(
-      () =>
-        writeContract(client, {
-          chain: client.chain ?? null,
-          address: worldDeploy.address,
-          abi: worldAbi,
-          // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
-          functionName: "registerSystem",
-          args: [system.systemId, system.address, system.allowAll],
-        }),
-      {
-        retries: 3,
-        onFailedAttempt: async (error) => {
-          const delay = error.attemptNumber * 500;
-          debug(`failed to register system ${resourceLabel(system)}, retrying in ${delay}ms...`);
-          await wait(delay);
         },
-      }
-    )
-  );
+      ),
+    ),
+  ]);
 
-  return await Promise.all([...accessTxs, ...registerTxs]);
+  return [...registerTxs, ...accessTxs];
 }

package/src/deploy/ensureTables.ts

@@ -1,10 +1,9 @@
 import { Client, Transport, Chain, Account, Hex } from "viem";
 import { Table } from "./configToTables";
-import { writeContract } from "@latticexyz/common";
+import { resourceToLabel, writeContract } from "@latticexyz/common";
 import { WorldDeploy, worldAbi } from "./common";
-import { valueSchemaToFieldLayoutHex, keySchemaToHex, valueSchemaToHex } from "@latticexyz/protocol-parser";
+import { valueSchemaToFieldLayoutHex, keySchemaToHex, valueSchemaToHex } from "@latticexyz/protocol-parser/internal";
 import { debug } from "./debug";
-import { resourceLabel } from "./resourceLabel";
 import { getTables } from "./getTables";
 import pRetry from "p-retry";
 import { wait } from "@latticexyz/common/utils";
@@ -23,12 +22,12 @@ export async function ensureTables({
 
   const existingTables = tables.filter((table) => worldTableIds.includes(table.tableId));
   if (existingTables.length) {
-    debug("existing tables", existingTables.map(resourceLabel).join(", "));
+    debug("existing tables", existingTables.map(resourceToLabel).join(", "));
   }
 
   const missingTables = tables.filter((table) => !worldTableIds.includes(table.tableId));
   if (missingTables.length) {
-    debug("registering tables", missingTables.map(resourceLabel).join(", "));
+    debug("registering tables", missingTables.map(resourceToLabel).join(", "));
     return await Promise.all(
       missingTables.map((table) =>
         pRetry(
@@ -52,12 +51,12 @@ export async function ensureTables({
             retries: 3,
             onFailedAttempt: async (error) => {
               const delay = error.attemptNumber * 500;
-              debug(`failed to register table ${resourceLabel(table)}, retrying in ${delay}ms...`);
+              debug(`failed to register table ${resourceToLabel(table)}, retrying in ${delay}ms...`);
               await wait(delay);
             },
-          }
-        )
-      )
+          },
+        ),
+      ),
     );
   }