feat(cli): save deployed contracts info

.changeset/twelve-melons-relate.md

@@ -0,0 +1,8 @@
+---
+"@latticexyz/cli": patch
+"@latticexyz/common": patch
+---
+
+The `mud deploy` command now includes the addresses of all deployed contracts and libraries in the deployment file. Previously, it only included the world address.
+
+The `mud test` command now includes an optional 'saveDeployment' flag to enable the deployment info from the test run to be saved to a file.

packages/cli/src/commands/test.ts

@@ -14,6 +14,7 @@ const testOptions = {
       "Address of an existing world contract. If provided, deployment is skipped and the RPC provided in the foundry.toml is used for fork testing.",
   },
   forgeOptions: { type: "string", description: "Options to pass to forge test" },
+  saveDeployment: { type: "boolean", desc: "Save the deployment info to a file", default: false },
 } as const satisfies Record<string, Options>;
 
 type TestOptions = InferredOptionTypes<typeof testOptions>;
@@ -45,7 +46,6 @@ const commandModule: CommandModule<typeof testOptions, TestOptions> = {
       (
         await runDeploy({
           ...opts,
-          saveDeployment: false,
           rpc: forkRpc,
         })
       ).address;

packages/cli/src/deploy/deploy.ts

@@ -71,7 +71,15 @@ export async function deploy({
   deployerAddress: initialDeployerAddress,
   indexerUrl,
   chainId,
-}: DeployOptions): Promise<WorldDeploy> {
+}: DeployOptions): Promise<
+  WorldDeploy & {
+    /** Addresses of the deployed contracts */
+    readonly contracts: readonly {
+      readonly label: string;
+      readonly address: Address;
+    }[];
+  }
+> {
   const deployerAddress = initialDeployerAddress ?? (await ensureDeployer(client));
 
   const worldDeploy = existingWorldAddress
@@ -105,7 +113,7 @@ export async function deploy({
   }
 
   const libraryMap = getLibraryMap(libraries);
-  await ensureContractsDeployed({
+  const deployedContracts = await ensureContractsDeployed({
     ...commonDeployOptions,
     deployerAddress,
     contracts: [
@@ -203,5 +211,11 @@ export async function deploy({
   });
 
   debug("deploy complete");
-  return worldDeploy;
+  return {
+    ...worldDeploy,
+    contracts: deployedContracts.map(({ contract, deployedAddress }) => ({
+      label: contract.debugLabel ?? "unknown",
+      address: deployedAddress,
+    })),
+  };
 }

packages/cli/src/runDeploy.ts

@@ -158,7 +158,7 @@ export async function runDeploy(opts: DeployOptions): Promise<WorldDeploy> {
   const automine = await enableAutomine(client);
 
   const startTime = Date.now();
-  const worldDeploy = await deploy({
+  const deployResult = await deploy({
     config,
     deployerAddress: opts.deployerAddress as Hex | undefined,
     salt,
@@ -176,7 +176,7 @@ export async function runDeploy(opts: DeployOptions): Promise<WorldDeploy> {
   if (opts.worldAddress == null || opts.alwaysRunPostDeploy) {
     await postDeploy(
       config.deploy.postDeployScript,
-      worldDeploy.address,
+      deployResult.address,
       rpc,
       profile,
       opts.forgeScriptOptions,
@@ -190,8 +190,9 @@ export async function runDeploy(opts: DeployOptions): Promise<WorldDeploy> {
   console.log(chalk.green("Deployment completed in", (Date.now() - startTime) / 1000, "seconds"));
 
   const deploymentInfo = {
-    worldAddress: worldDeploy.address,
-    blockNumber: Number(worldDeploy.deployBlock),
+    worldAddress: deployResult.address,
+    blockNumber: Number(deployResult.deployBlock),
+    contracts: deployResult.contracts,
   };
 
   if (opts.saveDeployment) {
@@ -219,9 +220,9 @@ export async function runDeploy(opts: DeployOptions): Promise<WorldDeploy> {
     );
   }
 
-  console.log(deploymentInfo);
+  console.log({ worldAddress: deploymentInfo.worldAddress, blockNumber: deploymentInfo.blockNumber });
 
-  return worldDeploy;
+  return deployResult;
 }
 
 function getWorldDeployBlock({

packages/common/src/deploy/ensureContract.ts

@@ -11,6 +11,12 @@ export type Contract = {
   salt?: Hex;
 };
 
+export type EnsureContractResult = {
+  contract: Contract;
+  deployedAddress: Hex;
+  txHash: readonly Hex[];
+};
+
 export async function ensureContract({
   client,
   deployerAddress,
@@ -21,7 +27,7 @@ export async function ensureContract({
 }: {
   readonly client: Client<Transport, Chain | undefined, Account>;
   readonly deployerAddress: Hex;
-} & Contract): Promise<readonly Hex[]> {
+} & Contract): Promise<EnsureContractResult> {
   if (bytecode.includes("__$")) {
     throw new Error(`Found unlinked public library in ${debugLabel} bytecode`);
   }
@@ -31,7 +37,11 @@ export async function ensureContract({
   const contractCode = await getCode(client, { address, blockTag: "pending" });
   if (contractCode) {
     debug("found", debugLabel, "at", address);
-    return [];
+    return {
+      contract: { bytecode, deployedBytecodeSize, debugLabel, salt },
+      deployedAddress: address,
+      txHash: [],
+    };
   }
 
   if (deployedBytecodeSize != null) {
@@ -52,11 +62,15 @@ export async function ensureContract({
   }
 
   debug("deploying", debugLabel, "at", address);
-  return [
-    await sendTransaction(client, {
-      chain: client.chain ?? null,
-      to: deployerAddress,
-      data: concatHex([salt, bytecode]),
-    }),
-  ];
+  return {
+    contract: { bytecode, deployedBytecodeSize, debugLabel, salt },
+    deployedAddress: address,
+    txHash: [
+      await sendTransaction(client, {
+        chain: client.chain ?? null,
+        to: deployerAddress,
+        data: concatHex([salt, bytecode]),
+      }),
+    ],
+  };
 }

packages/common/src/deploy/ensureContractsDeployed.ts

@@ -1,5 +1,5 @@
 import { Client, Transport, Chain, Account, Hex } from "viem";
-import { Contract, ensureContract } from "./ensureContract";
+import { Contract, ensureContract, EnsureContractResult } from "./ensureContract";
 import { waitForTransactions } from "../waitForTransactions";
 import { uniqueBy } from "../utils/uniqueBy";
 
@@ -11,19 +11,19 @@ export async function ensureContractsDeployed({
   readonly client: Client<Transport, Chain | undefined, Account>;
   readonly deployerAddress: Hex;
   readonly contracts: readonly Contract[];
-}): Promise<readonly Hex[]> {
+}): Promise<EnsureContractResult[]> {
   // Deployments assume a deterministic deployer, so we only need to deploy the unique bytecode
   const uniqueContracts = uniqueBy(contracts, (contract) => contract.bytecode);
 
-  const txs = (
+  const deployedContracts = (
     await Promise.all(uniqueContracts.map((contract) => ensureContract({ client, deployerAddress, ...contract })))
   ).flat();
 
   await waitForTransactions({
     client,
-    hashes: txs,
+    hashes: deployedContracts.map(({ txHash }) => txHash).flat(),
     debugLabel: "contract deploys",
   });
 
-  return txs;
+  return deployedContracts;
 }