Adds deployment stamp modification

packages/core/src/internal/deployment-loader/ephemeral-deployment-loader.ts

@@ -1,3 +1,5 @@
+import type { DeploymentStamp } from "../journal/types/deployment-stamp";
+
 import { Artifact, ArtifactResolver, BuildInfo } from "../../types/artifact";
 import { ExecutionEventListener } from "../../types/execution-events";
 import { JournalMessage } from "../execution/types/messages";
@@ -16,6 +18,10 @@ export class EphemeralDeploymentLoader implements DeploymentLoader {
   private _journal: Journal;
 
   private _deployedAddresses: { [key: string]: string };
+
+  private _deploymentStamps: {
+    [key: string]: DeploymentStamp;
+  };
   private _savedArtifacts: {
     [key: string]:
       | { _kind: "artifact"; artifact: Artifact }
@@ -28,6 +34,7 @@ export class EphemeralDeploymentLoader implements DeploymentLoader {
   ) {
     this._journal = new MemoryJournal(this._executionEventListener);
     this._deployedAddresses = {};
+    this._deploymentStamps = {};
     this._savedArtifacts = {};
   }
 
@@ -41,9 +48,13 @@ export class EphemeralDeploymentLoader implements DeploymentLoader {
 
   public async recordDeployedAddress(
     futureId: string,
-    contractAddress: string
+    address: string,
+    deploymentStamp?: DeploymentStamp
   ): Promise<void> {
-    this._deployedAddresses[futureId] = contractAddress;
+    this._deployedAddresses[futureId] = address;
+    if (deploymentStamp !== undefined) {
+      this._deploymentStamps[futureId] = { ...deploymentStamp };
+    }
   }
 
   public async storeBuildInfo(

packages/core/src/internal/deployment-loader/file-deployment-loader.ts

@@ -1,3 +1,5 @@
+import type { DeploymentStamp } from "../journal/types/deployment-stamp";
+
 import { ensureDir, pathExists, readFile, writeFile } from "fs-extra";
 import path from "path";
 
@@ -9,6 +11,27 @@ import { Journal } from "../journal/types";
 
 import { DeploymentLoader } from "./types";
 
+const updateJsonFile = async <T>(
+  pathToFile: string,
+  updater: (j: Record<string, T>) => Record<string, T>
+) => {
+  let fileContents: { [key: string]: T };
+  if (await pathExists(pathToFile)) {
+    const json = (await readFile(pathToFile)).toString();
+
+    fileContents = JSON.parse(json);
+  } else {
+    fileContents = {};
+  }
+
+  fileContents = updater(fileContents);
+
+  await writeFile(
+    pathToFile,
+    `${JSON.stringify(fileContents, undefined, 2)}\n`
+  );
+};
+
 export class FileDeploymentLoader implements DeploymentLoader {
   private _journal: Journal;
   private _deploymentDirsEnsured: boolean;
@@ -19,6 +42,7 @@ export class FileDeploymentLoader implements DeploymentLoader {
     buildInfoDir: string;
     journalPath: string;
     deployedAddressesPath: string;
+    deployedDeploymentStampPath: string;
   };
 
   constructor(
@@ -32,6 +56,10 @@ export class FileDeploymentLoader implements DeploymentLoader {
       this._deploymentDirPath,
       "deployed_addresses.json"
     );
+    const deployedDeploymentStampPath = path.join(
+      this._deploymentDirPath,
+      "deployment_stamps.json"
+    );
 
     this._journal = new FileJournal(journalPath, this._executionEventListener);
 
@@ -41,6 +69,7 @@ export class FileDeploymentLoader implements DeploymentLoader {
       buildInfoDir,
       journalPath,
       deployedAddressesPath,
+      deployedDeploymentStampPath,
     };
 
     this._deploymentDirsEnsured = false;
@@ -151,27 +180,27 @@ export class FileDeploymentLoader implements DeploymentLoader {
 
   public async recordDeployedAddress(
     futureId: string,
-    contractAddress: string
+    address: string,
+    deploymentStamp?: DeploymentStamp
   ): Promise<void> {
     await this._initialize();
 
-    let deployedAddresses: { [key: string]: string };
-    if (await pathExists(this._paths.deployedAddressesPath)) {
-      const json = (
-        await readFile(this._paths.deployedAddressesPath)
-      ).toString();
-
-      deployedAddresses = JSON.parse(json);
-    } else {
-      deployedAddresses = {};
-    }
-
-    deployedAddresses[futureId] = contractAddress;
-
-    await writeFile(
+    await updateJsonFile<string>(
       this._paths.deployedAddressesPath,
-      `${JSON.stringify(deployedAddresses, undefined, 2)}\n`
+      (contents) => ({
+        ...contents,
+        [futureId]: address,
+      })
     );
+    if (deploymentStamp !== undefined) {
+      await updateJsonFile<DeploymentStamp>(
+        this._paths.deployedDeploymentStampPath,
+        (contents) => ({
+          ...contents,
+          [futureId]: { ...deploymentStamp },
+        })
+      );
+    }
   }
 
   private async _initialize(): Promise<void> {

packages/core/src/internal/deployment-loader/types.ts

@@ -1,3 +1,5 @@
+import type { DeploymentStamp } from "../journal/types/deployment-stamp";
+
 import { Artifact, BuildInfo } from "../../types/artifact";
 import { JournalMessage } from "../execution/types/messages";
 
@@ -22,6 +24,7 @@ export interface DeploymentLoader {
   storeBuildInfo(futureId: string, buildInfo: BuildInfo): Promise<void>;
   recordDeployedAddress(
     futureId: string,
-    contractAddress: string
+    contractAddress: string,
+    deploymentStamp?: DeploymentStamp
   ): Promise<void>;
 }

packages/core/src/internal/execution/future-processor/future-processor.ts

@@ -18,6 +18,7 @@ import {
   StaticCallExecutionState,
 } from "../types/execution-state";
 import { ExecutionStrategy } from "../types/execution-strategy";
+import { TransactionReceiptStatus } from "../types/jsonrpc";
 import { JournalMessage, JournalMessageType } from "../types/messages";
 
 import { monitorOnchainInteraction } from "./handlers/monitor-onchain-interaction";
@@ -145,13 +146,31 @@ export class FutureProcessor {
     lastAppliedMessage: JournalMessage
   ) {
     if (
+      lastAppliedMessage.type === JournalMessageType.TRANSACTION_CONFIRM &&
+      lastAppliedMessage.receipt.status === TransactionReceiptStatus.SUCCESS
+    ) {
+      const { receipt, futureId } = lastAppliedMessage;
+      const { contractAddress, blockNumber, transactionHash } = receipt;
+      if (contractAddress !== null && contractAddress !== undefined) {
+        await this._deploymentLoader.recordDeployedAddress(
+          futureId,
+          contractAddress,
+          {
+            address: contractAddress,
+            blockNumber: Number(blockNumber),
+            transactionHash,
+          }
+        );
+      }
+    } else if (
       lastAppliedMessage.type ===
         JournalMessageType.DEPLOYMENT_EXECUTION_STATE_COMPLETE &&
       lastAppliedMessage.result.type === ExecutionResultType.SUCCESS
     ) {
       await this._deploymentLoader.recordDeployedAddress(
         lastAppliedMessage.futureId,
-        lastAppliedMessage.result.address
+        lastAppliedMessage.result.address,
+        lastAppliedMessage.result.deploymentStamp
       );
     } else if (
       lastAppliedMessage.type ===

packages/core/src/internal/execution/jsonrpc-client.ts

@@ -567,10 +567,10 @@ export class EIP1193JsonRpcClient implements JsonRpcClient {
   ): Promise<TransactionReceipt | undefined> {
     const method = "eth_getTransactionReceipt";
 
-    const response = await this._provider.request({
+    const response = (await this._provider.request({
       method,
       params: [txHash],
-    });
+    })) as TransactionReceipt | null;
 
     if (response === null) {
       return undefined;
@@ -623,6 +623,7 @@ export class EIP1193JsonRpcClient implements JsonRpcClient {
           : toChecksumFormat(contractAddress),
       status,
       logs: formatReceiptLogs(method, response),
+      transactionHash: response.transactionHash,
     };
   }
 

packages/core/src/internal/execution/types/execution-result.ts

@@ -1,4 +1,5 @@
 import { SolidityParameterType } from "../../../types/module";
+import { DeploymentStamp } from "../../journal/types/deployment-stamp";
 
 import { FailedEvmExecutionResult } from "./evm-execution";
 
@@ -76,6 +77,7 @@ export interface StrategyHeldExecutionResult {
 export interface SuccessfulDeploymentExecutionResult {
   type: ExecutionResultType.SUCCESS;
   address: string;
+  deploymentStamp?: DeploymentStamp;
 }
 
 /**

packages/core/src/internal/execution/types/jsonrpc.ts

@@ -46,6 +46,7 @@ export interface TransactionReceipt {
   contractAddress?: string;
   status: TransactionReceiptStatus;
   logs: TransactionLog[];
+  transactionHash: string;
 }
 
 /**

packages/core/src/internal/journal/types/deployment-stamp.ts

@@ -0,0 +1,8 @@
+export interface DeploymentStamp {
+  address: string;
+  blockNumber: number;
+  transactionHash: string;
+}
+
+export const zeroHash =
+  "0x0000000000000000000000000000000000000000000000000000000000000000";

packages/core/src/internal/journal/utils/emitExecutionEvent.ts

@@ -12,6 +12,7 @@ import {
   ExecutionResultType,
   SendDataExecutionResult,
   StaticCallExecutionResult,
+  SuccessfulDeploymentExecutionResult,
 } from "../../execution/types/execution-result";
 import {
   JournalMessage,
@@ -203,9 +204,10 @@ function convertExecutionResultToEventResult(
 ): ExecutionEventResult {
   switch (result.type) {
     case ExecutionResultType.SUCCESS: {
+      const res = result as SuccessfulDeploymentExecutionResult;
       return {
         type: ExecutionEventResultType.SUCCESS,
-        result: "address" in result ? result.address : undefined,
+        result: res.address,
       };
     }
     case ExecutionResultType.STATIC_CALL_ERROR:

packages/core/src/internal/views/find-address-for-contract-future-by-id.ts

@@ -1,5 +1,8 @@
 import { DeploymentState } from "../execution/types/deployment-state";
-import { ExecutionResultType } from "../execution/types/execution-result";
+import {
+  ExecutionResultType,
+  SuccessfulDeploymentExecutionResult,
+} from "../execution/types/execution-result";
 import { ExecutionSateType } from "../execution/types/execution-state";
 import { assertIgnitionInvariant } from "../utils/assertions";
 
@@ -45,5 +48,6 @@ export function findAddressForContractFuture(
     `Cannot access the result of ${futureId}, it was not a deployment success`
   );
 
-  return exState.result.address;
+  const result = exState.result as SuccessfulDeploymentExecutionResult;
+  return result.address;
 }

packages/core/src/internal/views/find-deployed-contracts.ts

@@ -1,12 +1,16 @@
 import { DeployedContract } from "../../types/deploy";
 import { DeploymentState } from "../execution/types/deployment-state";
-import { ExecutionResultType } from "../execution/types/execution-result";
+import {
+  ExecutionResultType,
+  SuccessfulDeploymentExecutionResult,
+} from "../execution/types/execution-result";
 import {
   ContractAtExecutionState,
   DeploymentExecutionState,
   ExecutionSateType,
   ExecutionStatus,
 } from "../execution/types/execution-state";
+import { zeroHash } from "../journal/types/deployment-stamp";
 import { assertIgnitionInvariant } from "../utils/assertions";
 
 export function findDeployedContracts(deploymentState: DeploymentState): {
@@ -39,17 +43,25 @@ function _toDeployedContract(
         `Deployment execution state ${des.id} should have a successful result to retrieve address`
       );
 
+      const res = des.result as SuccessfulDeploymentExecutionResult;
       return {
         id: des.id,
         contractName: des.contractName,
-        address: des.result.address,
+        address: res.address,
+        transactionHash: zeroHash,
+        blockNumber: 0,
+        ...(res.deploymentStamp !== null && res.deploymentStamp !== undefined
+          ? res.deploymentStamp
+          : {}),
       };
     }
     case ExecutionSateType.CONTRACT_AT_EXECUTION_STATE: {
       return {
         id: des.id,
         contractName: des.contractName,
         address: des.contractAddress,
+        transactionHash: zeroHash,
+        blockNumber: 0,
       };
     }
   }

packages/core/src/types/deploy.ts

@@ -181,6 +181,8 @@ export interface DeployedContract {
   id: string;
   contractName: string;
   address: string;
+  transactionHash: string;
+  blockNumber: number;
 }
 
 /**

packages/core/test/execution/future-processor/helpers/build-initialize-message-for.ts

@@ -70,6 +70,8 @@ import {
 describe("buildInitializeMessageFor", () => {
   const differentAddress = "0xBA12222222228d8Ba445958a75a0704d566BF2C8";
   const libraryAddress = "0x742d35Cc6634C0532925a3b844Bc454e4438f44e";
+  const successfulTxHash =
+    "0x0011223344556677889900112233445566778899001122334455667788990000";
   const basicStrategy = { name: "basic", config: {} } as any;
 
   let namedContractDeployment: NamedArtifactContractDeploymentFuture<string>;
@@ -319,6 +321,7 @@ describe("buildInitializeMessageFor", () => {
             ],
           },
         ],
+        transactionHash: successfulTxHash,
       },
     };
 

packages/core/test/execution/future-processor/helpers/network-interaction-execution.ts

@@ -764,14 +764,15 @@ class MockGetTransactionJsonRpcClient extends StubJsonRpcClient {
   }
 
   public async getTransactionReceipt(
-    _txHash: string
+    transactionHash: string
   ): Promise<TransactionReceipt | undefined> {
     return {
       blockHash: "0xblockhash",
       blockNumber: 34,
       contractAddress: "0xcontractaddress",
       logs: [],
       status: TransactionReceiptStatus.SUCCESS,
+      transactionHash,
     };
   }
 }