feat(cli): save deployed contracts info

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({ ...deploymentInfo, contracts: undefined });
 
-  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;
 }