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

package/src/deploy/debug.ts

@@ -0,0 +1,10 @@
+import { debug as parentDebug } from "../debug";
+
+export const debug = parentDebug.extend("deploy");
+export const error = parentDebug.extend("deploy");
+
+// Pipe debug output to stdout instead of stderr
+debug.log = console.debug.bind(console);
+
+// Pipe error output to stderr
+error.log = console.error.bind(console);

package/src/deploy/deploy.ts

@@ -0,0 +1,133 @@
+import { Account, Address, Chain, Client, Hex, Transport } from "viem";
+import { ensureDeployer } from "./ensureDeployer";
+import { deployWorld } from "./deployWorld";
+import { ensureTables } from "./ensureTables";
+import { Config, ConfigInput, WorldDeploy, supportedStoreVersions, supportedWorldVersions } from "./common";
+import { ensureSystems } from "./ensureSystems";
+import { waitForTransactionReceipt } from "viem/actions";
+import { getWorldDeploy } from "./getWorldDeploy";
+import { ensureFunctions } from "./ensureFunctions";
+import { ensureModules } from "./ensureModules";
+import { Table } from "./configToTables";
+import { ensureNamespaceOwner } from "./ensureNamespaceOwner";
+import { debug } from "./debug";
+import { resourceToLabel } from "@latticexyz/common";
+import { ensureContractsDeployed } from "./ensureContractsDeployed";
+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;
+};
+
+/**
+ * Given a viem client and MUD config, we attempt to introspect the world
+ * (or deploy a new one if no world address is provided) and do the minimal
+ * amount of work to make the world match the config (e.g. deploy new tables,
+ * replace systems, etc.)
+ */
+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 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: [
+      ...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: `${resourceToLabel(system)} system`,
+      })),
+      ...config.modules.map((mod) => ({
+        bytecode: mod.prepareDeploy(deployerAddress, config.libraries).bytecode,
+        deployedBytecodeSize: mod.deployedBytecodeSize,
+        label: `${mod.name} module`,
+      })),
+    ],
+  });
+
+  const worldDeploy = existingWorldAddress
+    ? await getWorldDeploy(client, existingWorldAddress)
+    : await deployWorld(client, deployerAddress, salt ?? `0x${randomBytes(32).toString("hex")}`);
+
+  if (!supportedStoreVersions.includes(worldDeploy.storeVersion)) {
+    throw new Error(`Unsupported Store version: ${worldDeploy.storeVersion}`);
+  }
+  if (!supportedWorldVersions.includes(worldDeploy.worldVersion)) {
+    throw new Error(`Unsupported World version: ${worldDeploy.worldVersion}`);
+  }
+
+  const namespaceTxs = await ensureNamespaceOwner({
+    client,
+    worldDeploy,
+    resourceIds: [...tables.map((table) => table.tableId), ...config.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,
+    tables,
+  });
+  const systemTxs = await ensureSystems({
+    client,
+    deployerAddress,
+    libraries: config.libraries,
+    worldDeploy,
+    systems: config.systems,
+  });
+  const functionTxs = await ensureFunctions({
+    client,
+    worldDeploy,
+    functions: config.systems.flatMap((system) => system.functions),
+  });
+  const moduleTxs = await ensureModules({
+    client,
+    deployerAddress,
+    libraries: config.libraries,
+    worldDeploy,
+    modules: config.modules,
+  });
+
+  const txs = [...tableTxs, ...systemTxs, ...functionTxs, ...moduleTxs];
+
+  // wait for each tx separately/serially, because parallelizing results in RPC errors
+  debug("waiting for all transactions to confirm");
+  for (const tx of txs) {
+    await waitForTransactionReceipt(client, { hash: tx });
+    // TODO: throw if there was a revert?
+  }
+
+  debug("deploy complete");
+  return worldDeploy;
+}

package/src/deploy/deployWorld.ts

@@ -0,0 +1,38 @@
+import { Account, Chain, Client, Hex, Log, Transport } from "viem";
+import { waitForTransactionReceipt } from "viem/actions";
+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>,
+  deployerAddress: Hex,
+  salt: Hex,
+): Promise<WorldDeploy> {
+  const worldFactory = await ensureWorldFactory(client, deployerAddress);
+
+  debug("deploying world");
+  const tx = await writeContract(client, {
+    chain: client.chain ?? null,
+    address: worldFactory,
+    abi: WorldFactoryAbi,
+    functionName: "deployWorld",
+    args: [salt],
+  });
+
+  debug("waiting for world deploy");
+  const receipt = await waitForTransactionReceipt(client, { hash: tx });
+  if (receipt.status !== "success") {
+    console.error("world deploy failed", receipt);
+    throw new Error("world deploy failed");
+  }
+
+  // TODO: remove type casting once https://github.com/wagmi-dev/viem/pull/1330 is merged
+  const deploy = logsToWorldDeploy(receipt.logs.map((log) => log as Log<bigint, number, false>));
+  debug("deployed world to", deploy.address, "at block", deploy.deployBlock);
+
+  return { ...deploy, stateBlock: deploy.deployBlock };
+}

package/src/deploy/ensureContract.ts

@@ -0,0 +1,66 @@
+import { Client, Transport, Chain, Account, concatHex, getCreate2Address, Hex } from "viem";
+import { getBytecode } from "viem/actions";
+import { contractSizeLimit, salt } from "./common";
+import { sendTransaction } from "@latticexyz/common";
+import { debug } from "./debug";
+import pRetry from "p-retry";
+import { wait } from "@latticexyz/common/utils";
+
+export type Contract = {
+  bytecode: Hex;
+  deployedBytecodeSize: number;
+  label?: string;
+};
+
+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 contractCode = await getBytecode(client, { address, blockTag: "pending" });
+  if (contractCode) {
+    debug("found", label, "at", address);
+    return [];
+  }
+
+  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`,
+    );
+  } 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`,
+    );
+  }
+
+  debug("deploying", label, "at", address);
+  return [
+    await pRetry(
+      () =>
+        sendTransaction(client, {
+          chain: client.chain ?? null,
+          to: deployerAddress,
+          data: concatHex([salt, bytecode]),
+        }),
+      {
+        retries: 3,
+        onFailedAttempt: async (error) => {
+          const delay = error.attemptNumber * 500;
+          debug(`failed to deploy ${label}, retrying in ${delay}ms...`);
+          await wait(delay);
+        },
+      },
+    ),
+  ];
+}

package/src/deploy/ensureContractsDeployed.ts

@@ -0,0 +1,33 @@
+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();
+
+  if (txs.length) {
+    debug("waiting for contracts");
+    // wait for each tx separately/serially, because parallelizing results in RPC errors
+    for (const tx of txs) {
+      await waitForTransactionReceipt(client, { hash: tx });
+      // TODO: throw if there was a revert?
+    }
+  }
+
+  return txs;
+}

package/src/deploy/ensureDeployer.ts

@@ -0,0 +1,75 @@
+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";
+
+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<Address> {
+  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;
+  }
+
+  // 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}` }).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.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

@@ -0,0 +1,86 @@
+import { Client, Transport, Chain, Account, Hex } from "viem";
+import { hexToResource, writeContract } from "@latticexyz/common";
+import { WorldDeploy, WorldFunction, worldAbi } from "./common";
+import { debug } from "./debug";
+import { getFunctions } from "./getFunctions";
+import pRetry from "p-retry";
+import { wait } from "@latticexyz/common/utils";
+
+export async function ensureFunctions({
+  client,
+  worldDeploy,
+  functions,
+}: {
+  readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly worldDeploy: WorldDeploy;
+  readonly functions: readonly WorldFunction[];
+}): Promise<readonly Hex[]> {
+  const worldFunctions = await getFunctions({ client, worldDeploy });
+  const worldSelectorToFunction = Object.fromEntries(worldFunctions.map((func) => [func.selector, func]));
+
+  const toSkip = functions.filter((func) => worldSelectorToFunction[func.selector]);
+  const toAdd = functions.filter((func) => !toSkip.includes(func));
+
+  if (toSkip.length) {
+    debug("functions already registered:", toSkip.map((func) => func.signature).join(", "));
+    const wrongSystem = toSkip.filter((func) => func.systemId !== worldSelectorToFunction[func.selector]?.systemId);
+    if (wrongSystem.length) {
+      console.warn(
+        "found",
+        wrongSystem.length,
+        "functions already registered but pointing at a different system ID:",
+        wrongSystem.map((func) => func.signature).join(", "),
+      );
+    }
+  }
+
+  if (!toAdd.length) return [];
+
+  debug("registering functions:", toAdd.map((func) => func.signature).join(", "));
+
+  return Promise.all(
+    toAdd.map((func) => {
+      const { namespace } = hexToResource(func.systemId);
+      if (namespace === "") {
+        return pRetry(
+          () =>
+            writeContract(client, {
+              chain: client.chain ?? null,
+              address: worldDeploy.address,
+              abi: worldAbi,
+              // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+              functionName: "registerRootFunctionSelector",
+              args: [func.systemId, func.systemFunctionSignature, func.systemFunctionSignature],
+            }),
+          {
+            retries: 3,
+            onFailedAttempt: async (error) => {
+              const delay = error.attemptNumber * 500;
+              debug(`failed to register function ${func.signature}, retrying in ${delay}ms...`);
+              await wait(delay);
+            },
+          },
+        );
+      }
+      return pRetry(
+        () =>
+          writeContract(client, {
+            chain: client.chain ?? null,
+            address: worldDeploy.address,
+            abi: worldAbi,
+            // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+            functionName: "registerFunctionSelector",
+            args: [func.systemId, func.systemFunctionSignature],
+          }),
+        {
+          retries: 3,
+          onFailedAttempt: async (error) => {
+            const delay = error.attemptNumber * 500;
+            debug(`failed to register function ${func.signature}, retrying in ${delay}ms...`);
+            await wait(delay);
+          },
+        },
+      );
+    }),
+  );
+}

package/src/deploy/ensureModules.ts

@@ -0,0 +1,79 @@
+import { Client, Transport, Chain, Account, Hex, BaseError } from "viem";
+import { writeContract } from "@latticexyz/common";
+import { Library, Module, WorldDeploy, worldAbi } from "./common";
+import { debug } from "./debug";
+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[]> {
+  if (!modules.length) return [];
+
+  await ensureContractsDeployed({
+    client,
+    deployerAddress,
+    contracts: modules.map((mod) => ({
+      bytecode: mod.prepareDeploy(deployerAddress, libraries).bytecode,
+      deployedBytecodeSize: mod.deployedBytecodeSize,
+      label: `${mod.name} module`,
+    })),
+  });
+
+  debug("installing modules:", modules.map((mod) => mod.name).join(", "));
+  return (
+    await Promise.all(
+      modules.map((mod) =>
+        pRetry(
+          async () => {
+            try {
+              const moduleAddress = mod.prepareDeploy(deployerAddress, libraries).address;
+              return mod.installAsRoot
+                ? await writeContract(client, {
+                    chain: client.chain ?? null,
+                    address: worldDeploy.address,
+                    abi: worldAbi,
+                    // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+                    functionName: "installRootModule",
+                    args: [moduleAddress, mod.installData],
+                  })
+                : await writeContract(client, {
+                    chain: client.chain ?? null,
+                    address: worldDeploy.address,
+                    abi: worldAbi,
+                    // TODO: replace with batchCall (https://github.com/latticexyz/mud/issues/1645)
+                    functionName: "installModule",
+                    args: [moduleAddress, mod.installData],
+                  });
+            } catch (error) {
+              if (error instanceof BaseError && error.message.includes("Module_AlreadyInstalled")) {
+                debug(`module ${mod.name} already installed`);
+                return;
+              }
+              throw error;
+            }
+          },
+          {
+            retries: 3,
+            onFailedAttempt: async (error) => {
+              const delay = error.attemptNumber * 500;
+              debug(`failed to install module ${mod.name}, retrying in ${delay}ms...`);
+              await wait(delay);
+            },
+          },
+        ),
+      ),
+    )
+  ).filter(isDefined);
+}

package/src/deploy/ensureNamespaceOwner.ts

@@ -0,0 +1,71 @@
+import { Account, Chain, Client, Hex, Transport, getAddress } from "viem";
+import { WorldDeploy, worldAbi, worldTables } from "./common";
+import { hexToResource, resourceToHex, writeContract } from "@latticexyz/common";
+import { getResourceIds } from "./getResourceIds";
+import { getTableValue } from "./getTableValue";
+import { debug } from "./debug";
+
+export async function ensureNamespaceOwner({
+  client,
+  worldDeploy,
+  resourceIds,
+}: {
+  readonly client: Client<Transport, Chain | undefined, Account>;
+  readonly worldDeploy: WorldDeploy;
+  readonly resourceIds: readonly Hex[];
+}): Promise<readonly Hex[]> {
+  const desiredNamespaces = Array.from(new Set(resourceIds.map((resourceId) => hexToResource(resourceId).namespace)));
+  const existingResourceIds = await getResourceIds({ client, worldDeploy });
+  const existingNamespaces = new Set(existingResourceIds.map((resourceId) => hexToResource(resourceId).namespace));
+  if (existingNamespaces.size) {
+    debug(
+      "found",
+      existingNamespaces.size,
+      "existing namespaces:",
+      Array.from(existingNamespaces)
+        .map((namespace) => (namespace === "" ? "<root>" : namespace))
+        .join(", "),
+    );
+  }
+
+  // Assert ownership of existing namespaces
+  const existingDesiredNamespaces = desiredNamespaces.filter((namespace) => existingNamespaces.has(namespace));
+  const namespaceOwners = await Promise.all(
+    existingDesiredNamespaces.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(", ")}`);
+  }
+
+  // Register missing namespaces
+  const missingNamespaces = desiredNamespaces.filter((namespace) => !existingNamespaces.has(namespace));
+  if (missingNamespaces.length > 0) {
+    debug("registering namespaces", Array.from(missingNamespaces).join(", "));
+  }
+  const registrationTxs = Promise.all(
+    missingNamespaces.map((namespace) =>
+      writeContract(client, {
+        chain: client.chain ?? null,
+        address: worldDeploy.address,
+        abi: worldAbi,
+        functionName: "registerNamespace",
+        args: [resourceToHex({ namespace, type: "namespace", name: "" })],
+      }),
+    ),
+  );
+
+  return registrationTxs;
+}