@aztec/archiver 0.55.1 → 0.57.0

package/src/archiver/data_retrieval.ts

@@ -1,20 +1,25 @@
-import { type InboxLeaf, type L2Block } from '@aztec/circuit-types';
-import { Fr, type Proof } from '@aztec/circuits.js';
+import { Body, InboxLeaf, L2Block } from '@aztec/circuit-types';
+import { AppendOnlyTreeSnapshot, Fr, Header, Proof } from '@aztec/circuits.js';
 import { type EthAddress } from '@aztec/foundation/eth-address';
+import { type ViemSignature } from '@aztec/foundation/eth-signature';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
-import { RollupAbi } from '@aztec/l1-artifacts';
-
-import { type Hex, type PublicClient, getAbiItem } from 'viem';
+import { numToUInt32BE } from '@aztec/foundation/serialize';
+import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
 
 import {
-  getBlockProofFromSubmitProofTx,
-  getL2BlockProposedLogs,
-  getMessageSentLogs,
-  processL2BlockProposedLogs,
-  processMessageSentLogs,
-} from './eth_log_handlers.js';
+  type Chain,
+  type GetContractEventsReturnType,
+  type GetContractReturnType,
+  type Hex,
+  type HttpTransport,
+  type PublicClient,
+  decodeFunctionData,
+  getAbiItem,
+  hexToBytes,
+} from 'viem';
+
 import { type DataRetrieval } from './structs/data_retrieval.js';
-import { type L1Published } from './structs/published.js';
+import { type L1Published, type L1PublishedData } from './structs/published.js';
 
 /**
  * Fetches new L2 blocks.
@@ -27,12 +32,11 @@ import { type L1Published } from './structs/published.js';
  * @returns An array of block; as well as the next eth block to search from.
  */
 export async function retrieveBlockFromRollup(
+  rollup: GetContractReturnType<typeof RollupAbi, PublicClient<HttpTransport, Chain>>,
   publicClient: PublicClient,
-  rollupAddress: EthAddress,
   blockUntilSynced: boolean,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
-  expectedNextL2BlockNum: bigint,
   logger: DebugLogger = createDebugLogger('aztec:archiver'),
 ): Promise<L1Published<L2Block>[]> {
   const retrievedBlocks: L1Published<L2Block>[] = [];
@@ -40,29 +44,122 @@ export async function retrieveBlockFromRollup(
     if (searchStartBlock > searchEndBlock) {
       break;
     }
-    const L2BlockProposedLogs = await getL2BlockProposedLogs(
-      publicClient,
-      rollupAddress,
-      searchStartBlock,
-      searchEndBlock,
+    const l2BlockProposedLogs = await rollup.getEvents.L2BlockProposed(
+      {},
+      {
+        fromBlock: searchStartBlock,
+        toBlock: searchEndBlock + 1n,
+      },
     );
-    if (L2BlockProposedLogs.length === 0) {
+
+    if (l2BlockProposedLogs.length === 0) {
       break;
     }
 
-    const lastLog = L2BlockProposedLogs[L2BlockProposedLogs.length - 1];
+    const lastLog = l2BlockProposedLogs[l2BlockProposedLogs.length - 1];
     logger.debug(
-      `Got L2 block processed logs for ${L2BlockProposedLogs[0].blockNumber}-${lastLog.blockNumber} between ${searchStartBlock}-${searchEndBlock} L1 blocks`,
+      `Got L2 block processed logs for ${l2BlockProposedLogs[0].blockNumber}-${lastLog.blockNumber} between ${searchStartBlock}-${searchEndBlock} L1 blocks`,
     );
 
-    const newBlocks = await processL2BlockProposedLogs(publicClient, expectedNextL2BlockNum, L2BlockProposedLogs);
+    const newBlocks = await processL2BlockProposedLogs(rollup, publicClient, l2BlockProposedLogs, logger);
     retrievedBlocks.push(...newBlocks);
     searchStartBlock = lastLog.blockNumber! + 1n;
-    expectedNextL2BlockNum += BigInt(newBlocks.length);
   } while (blockUntilSynced && searchStartBlock <= searchEndBlock);
   return retrievedBlocks;
 }
 
+/**
+ * Processes newly received L2BlockProposed logs.
+ * @param rollup - The rollup contract
+ * @param publicClient - The viem public client to use for transaction retrieval.
+ * @param logs - L2BlockProposed logs.
+ * @returns - An array blocks.
+ */
+export async function processL2BlockProposedLogs(
+  rollup: GetContractReturnType<typeof RollupAbi, PublicClient<HttpTransport, Chain>>,
+  publicClient: PublicClient,
+  logs: GetContractEventsReturnType<typeof RollupAbi, 'L2BlockProposed'>,
+  logger: DebugLogger,
+): Promise<L1Published<L2Block>[]> {
+  const retrievedBlocks: L1Published<L2Block>[] = [];
+  for (const log of logs) {
+    const l2BlockNumber = log.args.blockNumber!;
+    const archive = log.args.archive!;
+    const archiveFromChain = await rollup.read.archiveAt([l2BlockNumber]);
+
+    // The value from the event and contract will match only if the block is in the chain.
+    if (archive === archiveFromChain) {
+      // TODO: Fetch blocks from calldata in parallel
+      const block = await getBlockFromRollupTx(publicClient, log.transactionHash!, l2BlockNumber);
+
+      const l1: L1PublishedData = {
+        blockNumber: log.blockNumber,
+        blockHash: log.blockHash,
+        timestamp: await getL1BlockTime(publicClient, log.blockNumber),
+      };
+
+      retrievedBlocks.push({ data: block, l1 });
+    } else {
+      logger.warn(
+        `Archive mismatch matching, ignoring block ${l2BlockNumber} with archive: ${archive}, expected ${archiveFromChain}`,
+      );
+    }
+  }
+
+  return retrievedBlocks;
+}
+
+export async function getL1BlockTime(publicClient: PublicClient, blockNumber: bigint): Promise<bigint> {
+  const block = await publicClient.getBlock({ blockNumber, includeTransactions: false });
+  return block.timestamp;
+}
+
+/**
+ * Gets block from the calldata of an L1 transaction.
+ * Assumes that the block was published from an EOA.
+ * TODO: Add retries and error management.
+ * @param publicClient - The viem public client to use for transaction retrieval.
+ * @param txHash - Hash of the tx that published it.
+ * @param l2BlockNum - L2 block number.
+ * @returns L2 block from the calldata, deserialized
+ */
+async function getBlockFromRollupTx(
+  publicClient: PublicClient,
+  txHash: `0x${string}`,
+  l2BlockNum: bigint,
+): Promise<L2Block> {
+  const { input: data } = await publicClient.getTransaction({ hash: txHash });
+  const { functionName, args } = decodeFunctionData({
+    abi: RollupAbi,
+    data,
+  });
+
+  const allowedMethods = ['propose', 'proposeAndClaim'];
+
+  if (!allowedMethods.includes(functionName)) {
+    throw new Error(`Unexpected method called ${functionName}`);
+  }
+  const [headerHex, archiveRootHex, , , , bodyHex] = args! as readonly [Hex, Hex, Hex, Hex[], ViemSignature[], Hex];
+
+  const header = Header.fromBuffer(Buffer.from(hexToBytes(headerHex)));
+  const blockBody = Body.fromBuffer(Buffer.from(hexToBytes(bodyHex)));
+
+  const blockNumberFromHeader = header.globalVariables.blockNumber.toBigInt();
+
+  if (blockNumberFromHeader !== l2BlockNum) {
+    throw new Error(`Block number mismatch: expected ${l2BlockNum} but got ${blockNumberFromHeader}`);
+  }
+
+  const archive = AppendOnlyTreeSnapshot.fromBuffer(
+    Buffer.concat([
+      Buffer.from(hexToBytes(archiveRootHex)), // L2Block.archive.root
+      numToUInt32BE(Number(l2BlockNum + 1n)), // L2Block.archive.nextAvailableLeafIndex
+    ]),
+  );
+
+  return new L2Block(archive, header, blockBody);
+}
+
 /**
  * Fetch L1 to L2 messages.
  * @param publicClient - The viem public client to use for transaction retrieval.
@@ -73,8 +170,7 @@ export async function retrieveBlockFromRollup(
  * @returns An array of InboxLeaf and next eth block to search from.
  */
 export async function retrieveL1ToL2Messages(
-  publicClient: PublicClient,
-  inboxAddress: EthAddress,
+  inbox: GetContractReturnType<typeof InboxAbi, PublicClient<HttpTransport, Chain>>,
   blockUntilSynced: boolean,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
@@ -84,12 +180,24 @@ export async function retrieveL1ToL2Messages(
     if (searchStartBlock > searchEndBlock) {
       break;
     }
-    const messageSentLogs = await getMessageSentLogs(publicClient, inboxAddress, searchStartBlock, searchEndBlock);
+
+    const messageSentLogs = await inbox.getEvents.MessageSent(
+      {},
+      {
+        fromBlock: searchStartBlock,
+        toBlock: searchEndBlock + 1n,
+      },
+    );
+
     if (messageSentLogs.length === 0) {
       break;
     }
-    const l1ToL2Messages = processMessageSentLogs(messageSentLogs);
-    retrievedL1ToL2Messages.push(...l1ToL2Messages);
+
+    for (const log of messageSentLogs) {
+      const { l2BlockNumber, index, hash } = log.args;
+      retrievedL1ToL2Messages.push(new InboxLeaf(l2BlockNumber!, index!, Fr.fromString(hash!)));
+    }
+
     // handles the case when there are no new messages:
     searchStartBlock = (messageSentLogs.findLast(msgLog => !!msgLog)?.blockNumber || searchStartBlock) + 1n;
   } while (blockUntilSynced && searchStartBlock <= searchEndBlock);
@@ -131,7 +239,7 @@ export async function retrieveL2ProofsFromRollup(
   const lastProcessedL1BlockNumber = logs.length > 0 ? logs.at(-1)!.l1BlockNumber : searchStartBlock - 1n;
 
   for (const { txHash, proverId, l2BlockNumber } of logs) {
-    const proofData = await getBlockProofFromSubmitProofTx(publicClient, txHash, l2BlockNumber, proverId);
+    const proofData = await getProofFromSubmitProofTx(publicClient, txHash, proverId);
     retrievedData.push({ proof: proofData.proof, proverId: proofData.proverId, l2BlockNumber, txHash });
   }
   return {
@@ -139,3 +247,54 @@ export async function retrieveL2ProofsFromRollup(
     lastProcessedL1BlockNumber,
   };
 }
+
+export type SubmitBlockProof = {
+  archiveRoot: Fr;
+  proverId: Fr;
+  aggregationObject: Buffer;
+  proof: Proof;
+};
+
+/**
+ * Gets block metadata (header and archive snapshot) from the calldata of an L1 transaction.
+ * Assumes that the block was published from an EOA.
+ * TODO: Add retries and error management.
+ * @param publicClient - The viem public client to use for transaction retrieval.
+ * @param txHash - Hash of the tx that published it.
+ * @param l2BlockNum - L2 block number.
+ * @returns L2 block metadata (header and archive) from the calldata, deserialized
+ */
+export async function getProofFromSubmitProofTx(
+  publicClient: PublicClient,
+  txHash: `0x${string}`,
+  expectedProverId: Fr,
+): Promise<SubmitBlockProof> {
+  const { input: data } = await publicClient.getTransaction({ hash: txHash });
+  const { functionName, args } = decodeFunctionData({ abi: RollupAbi, data });
+
+  let proverId: Fr;
+  let archiveRoot: Fr;
+  let aggregationObject: Buffer;
+  let proof: Proof;
+
+  if (functionName === 'submitEpochRootProof') {
+    const [_epochSize, nestedArgs, _fees, aggregationObjectHex, proofHex] = args!;
+    aggregationObject = Buffer.from(hexToBytes(aggregationObjectHex));
+    proverId = Fr.fromString(nestedArgs[6]);
+    archiveRoot = Fr.fromString(nestedArgs[1]);
+    proof = Proof.fromBuffer(Buffer.from(hexToBytes(proofHex)));
+  } else {
+    throw new Error(`Unexpected proof method called ${functionName}`);
+  }
+
+  if (!proverId.equals(expectedProverId)) {
+    throw new Error(`Prover ID mismatch: expected ${expectedProverId} but got ${proverId}`);
+  }
+
+  return {
+    proverId,
+    aggregationObject,
+    archiveRoot,
+    proof,
+  };
+}

package/src/archiver/epoch_helpers.ts

@@ -0,0 +1,26 @@
+import { AZTEC_EPOCH_DURATION, AZTEC_SLOT_DURATION } from '@aztec/circuits.js';
+
+/** Returns the slot number for a given timestamp. */
+export function getSlotAtTimestamp(ts: bigint, constants: { l1GenesisTime: bigint }) {
+  return ts < constants.l1GenesisTime ? 0n : (ts - constants.l1GenesisTime) / BigInt(AZTEC_SLOT_DURATION);
+}
+
+/** Returns the epoch number for a given timestamp. */
+export function getEpochNumberAtTimestamp(ts: bigint, constants: { l1GenesisTime: bigint }) {
+  return getSlotAtTimestamp(ts, constants) / BigInt(AZTEC_EPOCH_DURATION);
+}
+
+/** Returns the range of slots (inclusive) for a given epoch number. */
+export function getSlotRangeForEpoch(epochNumber: bigint) {
+  const startSlot = epochNumber * BigInt(AZTEC_EPOCH_DURATION);
+  return [startSlot, startSlot + BigInt(AZTEC_EPOCH_DURATION) - 1n];
+}
+
+/** Returns the range of L1 timestamps (inclusive) for a given epoch number. */
+export function getTimestampRangeForEpoch(epochNumber: bigint, constants: { l1GenesisTime: bigint }) {
+  const [startSlot, endSlot] = getSlotRangeForEpoch(epochNumber);
+  return [
+    constants.l1GenesisTime + startSlot * BigInt(AZTEC_SLOT_DURATION),
+    constants.l1GenesisTime + endSlot * BigInt(AZTEC_SLOT_DURATION),
+  ];
+}

package/src/archiver/kv_archiver_store/block_store.ts

@@ -1,10 +1,9 @@
-import { L2Block, type TxEffect, type TxHash, TxReceipt } from '@aztec/circuit-types';
+import { Body, L2Block, type TxEffect, type TxHash, TxReceipt } from '@aztec/circuit-types';
 import { AppendOnlyTreeSnapshot, type AztecAddress, Header, INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { type AztecKVStore, type AztecMap, type AztecSingleton, type Range } from '@aztec/kv-store';
 
 import { type L1Published, type L1PublishedData } from '../structs/published.js';
-import { type BlockBodyStore } from './block_body_store.js';
 
 type BlockIndexValue = [blockNumber: number, index: number];
 
@@ -20,9 +19,19 @@ type BlockStorage = {
 export class BlockStore {
   /** Map block number to block data */
   #blocks: AztecMap<number, BlockStorage>;
+
+  /** Map block body hash to block body */
+  #blockBodies: AztecMap<string, Buffer>;
+
   /** Stores L1 block number in which the last processed L2 block was included */
   #lastSynchedL1Block: AztecSingleton<bigint>;
 
+  /** Stores l2 block number of the last proven block */
+  #lastProvenL2Block: AztecSingleton<number>;
+
+  /** Stores l2 epoch number of the last proven epoch */
+  #lastProvenL2Epoch: AztecSingleton<number>;
+
   /** Index mapping transaction hash (as a string) to its location in a block */
   #txIndex: AztecMap<string, BlockIndexValue>;
 
@@ -31,15 +40,14 @@ export class BlockStore {
 
   #log = createDebugLogger('aztec:archiver:block_store');
 
-  #blockBodyStore: BlockBodyStore;
-
-  constructor(private db: AztecKVStore, blockBodyStore: BlockBodyStore) {
-    this.#blockBodyStore = blockBodyStore;
-
+  constructor(private db: AztecKVStore) {
     this.#blocks = db.openMap('archiver_blocks');
+    this.#blockBodies = db.openMap('archiver_block_bodies');
     this.#txIndex = db.openMap('archiver_tx_index');
     this.#contractIndex = db.openMap('archiver_contract_index');
     this.#lastSynchedL1Block = db.openSingleton('archiver_last_synched_l1_block');
+    this.#lastProvenL2Block = db.openSingleton('archiver_last_proven_l2_block');
+    this.#lastProvenL2Epoch = db.openSingleton('archiver_last_proven_l2_epoch');
   }
 
   /**
@@ -63,6 +71,8 @@ export class BlockStore {
         block.data.body.txEffects.forEach((tx, i) => {
           void this.#txIndex.set(tx.txHash.toString(), [block.data.number, i]);
         });
+
+        void this.#blockBodies.set(block.data.body.getTxsEffectsHash().toString('hex'), block.data.body.toBuffer());
       }
 
       void this.#lastSynchedL1Block.set(blocks[blocks.length - 1].l1.blockNumber);
@@ -71,6 +81,38 @@ export class BlockStore {
     });
   }
 
+  /**
+   * Unwinds blocks from the database
+   * @param from -  The tip of the chain, passed for verification purposes,
+   *                ensuring that we don't end up deleting something we did not intend
+   * @param blocksToUnwind - The number of blocks we are to unwind
+   * @returns True if the operation is successful
+   */
+  unwindBlocks(from: number, blocksToUnwind: number) {
+    return this.db.transaction(() => {
+      const last = this.getSynchedL2BlockNumber();
+      if (from != last) {
+        throw new Error(`Can only remove from the tip`);
+      }
+
+      for (let i = 0; i < blocksToUnwind; i++) {
+        const blockNumber = from - i;
+        const block = this.getBlock(blockNumber);
+
+        if (block === undefined) {
+          throw new Error(`Cannot remove block ${blockNumber} from the store, we don't have it`);
+        }
+        void this.#blocks.delete(block.data.number);
+        block.data.body.txEffects.forEach(tx => {
+          void this.#txIndex.delete(tx.txHash.toString());
+        });
+        void this.#blockBodies.delete(block.data.body.getTxsEffectsHash().toString('hex'));
+      }
+
+      return true;
+    });
+  }
+
   /**
    * Gets up to `limit` amount of L2 blocks starting from `from`.
    * @param start - Number of the first block to return (inclusive).
@@ -97,16 +139,29 @@ export class BlockStore {
     return this.getBlockFromBlockStorage(blockStorage);
   }
 
+  /**
+   * Gets the headers for a sequence of L2 blocks.
+   * @param start - Number of the first block to return (inclusive).
+   * @param limit - The number of blocks to return.
+   * @returns The requested L2 block headers
+   */
+  *getBlockHeaders(start: number, limit: number): IterableIterator<Header> {
+    for (const blockStorage of this.#blocks.values(this.#computeBlockRange(start, limit))) {
+      yield Header.fromBuffer(blockStorage.header);
+    }
+  }
+
   private getBlockFromBlockStorage(blockStorage: BlockStorage) {
     const header = Header.fromBuffer(blockStorage.header);
     const archive = AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive);
-    const body = this.#blockBodyStore.getBlockBody(header.contentCommitment.txsEffectsHash);
 
-    if (body === undefined) {
-      throw new Error('Body is not able to be retrieved from BodyStore');
+    const blockBodyBuffer = this.#blockBodies.get(header.contentCommitment.txsEffectsHash.toString('hex'));
+    if (blockBodyBuffer === undefined) {
+      throw new Error('Body could not be retrieved');
     }
+    const body = Body.fromBuffer(blockBodyBuffer);
 
-    const l2Block = L2Block.fromFields({ header, archive, body });
+    const l2Block = new L2Block(archive, header, body);
     return { data: l2Block, l1: blockStorage.l1 };
   }
 
@@ -184,13 +239,33 @@ export class BlockStore {
     return this.#lastSynchedL1Block.get();
   }
 
+  setSynchedL1BlockNumber(l1BlockNumber: bigint) {
+    void this.#lastSynchedL1Block.set(l1BlockNumber);
+  }
+
+  getProvenL2BlockNumber(): number {
+    return this.#lastProvenL2Block.get() ?? 0;
+  }
+
+  setProvenL2BlockNumber(blockNumber: number) {
+    void this.#lastProvenL2Block.set(blockNumber);
+  }
+
+  getProvenL2EpochNumber(): number | undefined {
+    return this.#lastProvenL2Epoch.get();
+  }
+
+  setProvenL2EpochNumber(epochNumber: number) {
+    void this.#lastProvenL2Epoch.set(epochNumber);
+  }
+
   #computeBlockRange(start: number, limit: number): Required<Pick<Range<number>, 'start' | 'end'>> {
     if (limit < 1) {
       throw new Error(`Invalid limit: ${limit}`);
     }
 
     if (start < INITIAL_L2_BLOCK_NUM) {
-      start = INITIAL_L2_BLOCK_NUM;
+      throw new Error(`Invalid start: ${start}`);
     }
 
     const end = start + limit;

package/src/archiver/kv_archiver_store/contract_class_store.ts

@@ -3,6 +3,7 @@ import { BufferReader, numToUInt8, serializeToBuffer } from '@aztec/foundation/s
 import { type AztecKVStore, type AztecMap } from '@aztec/kv-store';
 import {
   type ContractClassPublic,
+  type ContractClassPublicWithBlockNumber,
   type ExecutablePrivateFunctionWithMembershipProof,
   type UnconstrainedFunctionWithMembershipProof,
 } from '@aztec/types/contracts';
@@ -17,8 +18,18 @@ export class ContractClassStore {
     this.#contractClasses = db.openMap('archiver_contract_classes');
   }
 
-  addContractClass(contractClass: ContractClassPublic): Promise<void> {
-    return this.#contractClasses.set(contractClass.id.toString(), serializeContractClassPublic(contractClass));
+  async addContractClass(contractClass: ContractClassPublic, blockNumber: number): Promise<void> {
+    await this.#contractClasses.setIfNotExists(
+      contractClass.id.toString(),
+      serializeContractClassPublic({ ...contractClass, l2BlockNumber: blockNumber }),
+    );
+  }
+
+  async deleteContractClasses(contractClass: ContractClassPublic, blockNumber: number): Promise<void> {
+    const restoredContractClass = this.#contractClasses.get(contractClass.id.toString());
+    if (restoredContractClass && deserializeContractClassPublic(restoredContractClass).l2BlockNumber >= blockNumber) {
+      await this.#contractClasses.delete(contractClass.id.toString());
+    }
   }
 
   getContractClass(id: Fr): ContractClassPublic | undefined {
@@ -44,7 +55,7 @@ export class ContractClassStore {
       const existingClass = deserializeContractClassPublic(existingClassBuffer);
       const { privateFunctions: existingPrivateFns, unconstrainedFunctions: existingUnconstrainedFns } = existingClass;
 
-      const updatedClass: Omit<ContractClassPublic, 'id'> = {
+      const updatedClass: Omit<ContractClassPublicWithBlockNumber, 'id'> = {
         ...existingClass,
         privateFunctions: [
           ...existingPrivateFns,
@@ -63,8 +74,9 @@ export class ContractClassStore {
   }
 }
 
-function serializeContractClassPublic(contractClass: Omit<ContractClassPublic, 'id'>): Buffer {
+function serializeContractClassPublic(contractClass: Omit<ContractClassPublicWithBlockNumber, 'id'>): Buffer {
   return serializeToBuffer(
+    contractClass.l2BlockNumber,
     numToUInt8(contractClass.version),
     contractClass.artifactHash,
     contractClass.publicFunctions.length,
@@ -108,9 +120,10 @@ function serializeUnconstrainedFunction(fn: UnconstrainedFunctionWithMembershipP
   );
 }
 
-function deserializeContractClassPublic(buffer: Buffer): Omit<ContractClassPublic, 'id'> {
+function deserializeContractClassPublic(buffer: Buffer): Omit<ContractClassPublicWithBlockNumber, 'id'> {
   const reader = BufferReader.asReader(buffer);
   return {
+    l2BlockNumber: reader.readNumber(),
     version: reader.readUInt8() as 1,
     artifactHash: reader.readObject(Fr),
     publicFunctions: reader.readVector({

package/src/archiver/kv_archiver_store/contract_instance_store.ts

@@ -19,6 +19,10 @@ export class ContractInstanceStore {
     );
   }
 
+  deleteContractInstance(contractInstance: ContractInstanceWithAddress): Promise<void> {
+    return this.#contractInstances.delete(contractInstance.address.toString());
+  }
+
   getContractInstance(address: AztecAddress): ContractInstanceWithAddress | undefined {
     const contractInstance = this.#contractInstances.get(address.toString());
     return contractInstance && SerializableContractInstance.fromBuffer(contractInstance).withAddress(address);