@aztec/archiver 0.72.1 → 0.74.0

package/src/archiver/kv_archiver_store/message_store.ts

@@ -1,7 +1,7 @@
 import { InboxLeaf } from '@aztec/circuit-types';
 import { Fr, L1_TO_L2_MSG_SUBTREE_HEIGHT } from '@aztec/circuits.js';
 import { createLogger } from '@aztec/foundation/log';
-import { type AztecKVStore, type AztecMap, type AztecSingleton } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncSingleton } from '@aztec/kv-store';
 
 import { type DataRetrieval } from '../structs/data_retrieval.js';
 
@@ -9,36 +9,36 @@ import { type DataRetrieval } from '../structs/data_retrieval.js';
  * LMDB implementation of the ArchiverDataStore interface.
  */
 export class MessageStore {
-  #l1ToL2Messages: AztecMap<string, Buffer>;
-  #l1ToL2MessageIndices: AztecMap<string, bigint>;
-  #lastSynchedL1Block: AztecSingleton<bigint>;
-  #totalMessageCount: AztecSingleton<bigint>;
+  #l1ToL2Messages: AztecAsyncMap<string, Buffer>;
+  #l1ToL2MessageIndices: AztecAsyncMap<string, bigint>;
+  #lastSynchedL1Block: AztecAsyncSingleton<bigint>;
+  #totalMessageCount: AztecAsyncSingleton<bigint>;
 
   #log = createLogger('archiver:message_store');
 
   #l1ToL2MessagesSubtreeSize = 2 ** L1_TO_L2_MSG_SUBTREE_HEIGHT;
 
-  constructor(private db: AztecKVStore) {
+  constructor(private db: AztecAsyncKVStore) {
     this.#l1ToL2Messages = db.openMap('archiver_l1_to_l2_messages');
     this.#l1ToL2MessageIndices = db.openMap('archiver_l1_to_l2_message_indices');
     this.#lastSynchedL1Block = db.openSingleton('archiver_last_l1_block_new_messages');
     this.#totalMessageCount = db.openSingleton('archiver_l1_to_l2_message_count');
   }
 
-  getTotalL1ToL2MessageCount(): bigint {
-    return this.#totalMessageCount.get() ?? 0n;
+  async getTotalL1ToL2MessageCount(): Promise<bigint> {
+    return (await this.#totalMessageCount.getAsync()) ?? 0n;
   }
 
   /**
    * Gets the last L1 block number that emitted new messages.
    * @returns The last L1 block number processed
    */
-  getSynchedL1BlockNumber(): bigint | undefined {
-    return this.#lastSynchedL1Block.get();
+  getSynchedL1BlockNumber(): Promise<bigint | undefined> {
+    return this.#lastSynchedL1Block.getAsync();
   }
 
-  setSynchedL1BlockNumber(l1BlockNumber: bigint) {
-    void this.#lastSynchedL1Block.set(l1BlockNumber);
+  async setSynchedL1BlockNumber(l1BlockNumber: bigint): Promise<void> {
+    await this.#lastSynchedL1Block.set(l1BlockNumber);
   }
 
   /**
@@ -47,22 +47,22 @@ export class MessageStore {
    * @returns True if the operation is successful.
    */
   addL1ToL2Messages(messages: DataRetrieval<InboxLeaf>): Promise<boolean> {
-    return this.db.transaction(() => {
-      const lastL1BlockNumber = this.#lastSynchedL1Block.get() ?? 0n;
+    return this.db.transactionAsync(async () => {
+      const lastL1BlockNumber = (await this.#lastSynchedL1Block.getAsync()) ?? 0n;
       if (lastL1BlockNumber >= messages.lastProcessedL1BlockNumber) {
         return false;
       }
 
-      void this.#lastSynchedL1Block.set(messages.lastProcessedL1BlockNumber);
+      await this.#lastSynchedL1Block.set(messages.lastProcessedL1BlockNumber);
 
       for (const message of messages.retrievedData) {
         const key = `${message.index}`;
-        void this.#l1ToL2Messages.set(key, message.leaf.toBuffer());
-        void this.#l1ToL2MessageIndices.set(message.leaf.toString(), message.index);
+        await this.#l1ToL2Messages.set(key, message.leaf.toBuffer());
+        await this.#l1ToL2MessageIndices.set(message.leaf.toString(), message.index);
       }
 
-      const lastTotalMessageCount = this.getTotalL1ToL2MessageCount();
-      void this.#totalMessageCount.set(lastTotalMessageCount + BigInt(messages.retrievedData.length));
+      const lastTotalMessageCount = await this.getTotalL1ToL2MessageCount();
+      await this.#totalMessageCount.set(lastTotalMessageCount + BigInt(messages.retrievedData.length));
 
       return true;
     });
@@ -74,17 +74,17 @@ export class MessageStore {
    * @returns The index of the L1 to L2 message in the L1 to L2 message tree (undefined if not found).
    */
   getL1ToL2MessageIndex(l1ToL2Message: Fr): Promise<bigint | undefined> {
-    return Promise.resolve(this.#l1ToL2MessageIndices.get(l1ToL2Message.toString()));
+    return this.#l1ToL2MessageIndices.getAsync(l1ToL2Message.toString());
   }
 
-  getL1ToL2Messages(blockNumber: bigint): Fr[] {
+  async getL1ToL2Messages(blockNumber: bigint): Promise<Fr[]> {
     const messages: Fr[] = [];
     let undefinedMessageFound = false;
     const startIndex = Number(InboxLeaf.smallestIndexFromL2Block(blockNumber));
     for (let i = startIndex; i < startIndex + this.#l1ToL2MessagesSubtreeSize; i++) {
       // This is inefficient but probably fine for now.
       const key = `${i}`;
-      const message = this.#l1ToL2Messages.get(key);
+      const message = await this.#l1ToL2Messages.getAsync(key);
       if (message) {
         if (undefinedMessageFound) {
           throw new Error(`L1 to L2 message gap found in block ${blockNumber}`);

package/src/archiver/kv_archiver_store/nullifier_store.ts

@@ -1,46 +1,55 @@
 import { type InBlock, type L2Block } from '@aztec/circuit-types';
 import { type Fr, MAX_NULLIFIERS_PER_TX } from '@aztec/circuits.js';
 import { createLogger } from '@aztec/foundation/log';
-import { type AztecKVStore, type AztecMap } from '@aztec/kv-store';
+import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
 
 export class NullifierStore {
-  #nullifiersToBlockNumber: AztecMap<string, number>;
-  #nullifiersToBlockHash: AztecMap<string, string>;
-  #nullifiersToIndex: AztecMap<string, number>;
+  #nullifiersToBlockNumber: AztecAsyncMap<string, number>;
+  #nullifiersToBlockHash: AztecAsyncMap<string, string>;
+  #nullifiersToIndex: AztecAsyncMap<string, number>;
   #log = createLogger('archiver:log_store');
 
-  constructor(private db: AztecKVStore) {
+  constructor(private db: AztecAsyncKVStore) {
     this.#nullifiersToBlockNumber = db.openMap('archiver_nullifiers_to_block_number');
     this.#nullifiersToBlockHash = db.openMap('archiver_nullifiers_to_block_hash');
     this.#nullifiersToIndex = db.openMap('archiver_nullifiers_to_index');
   }
 
   async addNullifiers(blocks: L2Block[]): Promise<boolean> {
-    await this.db.transaction(() => {
-      blocks.forEach(block => {
-        const dataStartIndexForBlock =
-          block.header.state.partial.nullifierTree.nextAvailableLeafIndex -
-          block.body.txEffects.length * MAX_NULLIFIERS_PER_TX;
-        block.body.txEffects.forEach((txEffects, txIndex) => {
-          const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NULLIFIERS_PER_TX;
-          txEffects.nullifiers.forEach((nullifier, nullifierIndex) => {
-            void this.#nullifiersToBlockNumber.set(nullifier.toString(), block.number);
-            void this.#nullifiersToBlockHash.set(nullifier.toString(), block.hash().toString());
-            void this.#nullifiersToIndex.set(nullifier.toString(), dataStartIndexForTx + nullifierIndex);
-          });
-        });
-      });
+    const blockHashes = await Promise.all(blocks.map(block => block.hash()));
+    await this.db.transactionAsync(async () => {
+      await Promise.all(
+        blocks.map((block, i) => {
+          const dataStartIndexForBlock =
+            block.header.state.partial.nullifierTree.nextAvailableLeafIndex -
+            block.body.txEffects.length * MAX_NULLIFIERS_PER_TX;
+          return Promise.all(
+            block.body.txEffects.map((txEffects, txIndex) => {
+              const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NULLIFIERS_PER_TX;
+              return Promise.all(
+                txEffects.nullifiers.map(async (nullifier, nullifierIndex) => {
+                  await this.#nullifiersToBlockNumber.set(nullifier.toString(), block.number);
+                  await this.#nullifiersToBlockHash.set(nullifier.toString(), blockHashes[i].toString());
+                  await this.#nullifiersToIndex.set(nullifier.toString(), dataStartIndexForTx + nullifierIndex);
+                }),
+              );
+            }),
+          );
+        }),
+      );
     });
     return true;
   }
 
   async deleteNullifiers(blocks: L2Block[]): Promise<boolean> {
-    await this.db.transaction(() => {
+    await this.db.transactionAsync(async () => {
       for (const block of blocks) {
         for (const nullifier of block.body.txEffects.flatMap(tx => tx.nullifiers)) {
-          void this.#nullifiersToBlockNumber.delete(nullifier.toString());
-          void this.#nullifiersToBlockHash.delete(nullifier.toString());
-          void this.#nullifiersToIndex.delete(nullifier.toString());
+          await Promise.all([
+            this.#nullifiersToBlockNumber.delete(nullifier.toString()),
+            this.#nullifiersToBlockHash.delete(nullifier.toString()),
+            this.#nullifiersToIndex.delete(nullifier.toString()),
+          ]);
         }
       }
     });
@@ -51,13 +60,22 @@ export class NullifierStore {
     blockNumber: number,
     nullifiers: Fr[],
   ): Promise<(InBlock<bigint> | undefined)[]> {
-    const maybeNullifiers = await this.db.transaction(() => {
-      return nullifiers.map(nullifier => ({
-        data: this.#nullifiersToIndex.get(nullifier.toString()),
-        l2BlockNumber: this.#nullifiersToBlockNumber.get(nullifier.toString()),
-        l2BlockHash: this.#nullifiersToBlockHash.get(nullifier.toString()),
-      }));
-    });
+    const asStrings = nullifiers.map(x => x.toString());
+
+    const maybeNullifiers = await Promise.all(
+      asStrings.map(async nullifier => {
+        const [data, l2BlockNumber, l2BlockHash] = await Promise.all([
+          this.#nullifiersToIndex.getAsync(nullifier),
+          this.#nullifiersToBlockNumber.getAsync(nullifier),
+          this.#nullifiersToBlockHash.getAsync(nullifier),
+        ]);
+        return {
+          data,
+          l2BlockNumber,
+          l2BlockHash,
+        };
+      }),
+    );
     return maybeNullifiers.map(({ data, l2BlockNumber, l2BlockHash }) => {
       if (
         data === undefined ||

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -191,14 +191,18 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @param blocks - The L2 blocks to be added to the store and the last processed L1 block.
    * @returns True if the operation is successful.
    */
-  public addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
+  public async addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
     if (blocks.length === 0) {
       return Promise.resolve(true);
     }
 
     this.lastL1BlockNewBlocks = blocks[blocks.length - 1].l1.blockNumber;
     this.l2Blocks.push(...blocks);
-    this.txEffects.push(...blocks.flatMap(b => b.data.body.txEffects.map(txEffect => wrapInBlock(txEffect, b.data))));
+    const flatTxEffects = blocks.flatMap(b => b.data.body.txEffects.map(txEffect => ({ block: b, txEffect })));
+    const wrappedTxEffects = await Promise.all(
+      flatTxEffects.map(flatTxEffect => wrapInBlock(flatTxEffect.txEffect, flatTxEffect.block.data)),
+    );
+    this.txEffects.push(...wrappedTxEffects);
 
     return Promise.resolve(true);
   }
@@ -257,20 +261,18 @@ export class MemoryArchiverStore implements ArchiverDataStore {
       const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
       txEffect.publicLogs.forEach(log => {
         // Check that each log stores 3 lengths in its first field. If not, it's not a tagged log:
+        // See macros/note/mod/ and see how finalization_log[0] is constructed, to understand this monstrosity. (It wasn't me).
+        // Search the codebase for "disgusting encoding" to see other hardcoded instances of this encoding, that you might need to change if you ever find yourself here.
         const firstFieldBuf = log.log[0].toBuffer();
-        if (
-          !firstFieldBuf.subarray(0, 24).equals(Buffer.alloc(24)) ||
-          firstFieldBuf[26] !== 0 ||
-          firstFieldBuf[29] !== 0
-        ) {
+        if (!firstFieldBuf.subarray(0, 27).equals(Buffer.alloc(27)) || firstFieldBuf[29] !== 0) {
           // See parseLogFromPublic - the first field of a tagged log is 8 bytes structured:
-          // [ publicLen[0], publicLen[1], 0, privateLen[0], privateLen[1], 0, ciphertextLen[0], ciphertextLen[1]]
+          // [ publicLen[0], publicLen[1], 0, privateLen[0], privateLen[1]]
           this.#log.warn(`Skipping public log with invalid first field: ${log.log[0]}`);
           return;
         }
         // Check that the length values line up with the log contents
-        const publicValuesLength = firstFieldBuf.subarray(-8).readUint16BE();
-        const privateValuesLength = firstFieldBuf.subarray(-8).readUint16BE(3);
+        const publicValuesLength = firstFieldBuf.subarray(-5).readUint16BE();
+        const privateValuesLength = firstFieldBuf.subarray(-5).readUint16BE(3);
         // Add 1 for the first field holding lengths
         const totalLogLength = 1 + publicValuesLength + privateValuesLength;
         // Note that zeroes can be valid log values, so we can only assert that we do not go over the given length
@@ -300,8 +302,8 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   addLogs(blocks: L2Block[]): Promise<boolean> {
     blocks.forEach(block => {
-      void this.#storeTaggedLogsFromPrivate(block);
-      void this.#storeTaggedLogsFromPublic(block);
+      this.#storeTaggedLogsFromPrivate(block);
+      this.#storeTaggedLogsFromPublic(block);
       this.privateLogsPerBlock.set(block.number, block.body.txEffects.map(txEffect => txEffect.privateLogs).flat());
       this.publicLogsPerBlock.set(block.number, block.body.txEffects.map(txEffect => txEffect.publicLogs).flat());
       this.contractClassLogsPerBlock.set(block.number, block.body.contractClassLogs);
@@ -327,22 +329,25 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(true);
   }
 
-  addNullifiers(blocks: L2Block[]): Promise<boolean> {
-    blocks.forEach(block => {
-      const dataStartIndexForBlock =
-        block.header.state.partial.nullifierTree.nextAvailableLeafIndex -
-        block.body.txEffects.length * MAX_NULLIFIERS_PER_TX;
-      block.body.txEffects.forEach((txEffects, txIndex) => {
-        const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NULLIFIERS_PER_TX;
-        txEffects.nullifiers.forEach((nullifier, nullifierIndex) => {
-          this.blockScopedNullifiers.set(nullifier.toString(), {
-            index: BigInt(dataStartIndexForTx + nullifierIndex),
-            blockNumber: block.number,
-            blockHash: block.hash().toString(),
+  async addNullifiers(blocks: L2Block[]): Promise<boolean> {
+    await Promise.all(
+      blocks.map(async block => {
+        const dataStartIndexForBlock =
+          block.header.state.partial.nullifierTree.nextAvailableLeafIndex -
+          block.body.txEffects.length * MAX_NULLIFIERS_PER_TX;
+        const blockHash = await block.hash();
+        block.body.txEffects.forEach((txEffects, txIndex) => {
+          const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NULLIFIERS_PER_TX;
+          txEffects.nullifiers.forEach((nullifier, nullifierIndex) => {
+            this.blockScopedNullifiers.set(nullifier.toString(), {
+              index: BigInt(dataStartIndexForTx + nullifierIndex),
+              blockNumber: block.number,
+              blockHash: blockHash.toString(),
+            });
           });
         });
-      });
-    });
+      }),
+    );
     return Promise.resolve(true);
   }
 
@@ -450,24 +455,22 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @param txHash - The hash of a tx we try to get the receipt for.
    * @returns The requested tx receipt (or undefined if not found).
    */
-  public getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
+  public async getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
     for (const block of this.l2Blocks) {
       for (const txEffect of block.data.body.txEffects) {
         if (txEffect.txHash.equals(txHash)) {
-          return Promise.resolve(
-            new TxReceipt(
-              txHash,
-              TxReceipt.statusFromRevertCode(txEffect.revertCode),
-              '',
-              txEffect.transactionFee.toBigInt(),
-              L2BlockHash.fromField(block.data.hash()),
-              block.data.number,
-            ),
+          return new TxReceipt(
+            txHash,
+            TxReceipt.statusFromRevertCode(txEffect.revertCode),
+            '',
+            txEffect.transactionFee.toBigInt(),
+            L2BlockHash.fromField(await block.data.hash()),
+            block.data.number,
           );
         }
       }
     }
-    return Promise.resolve(undefined);
+    return undefined;
   }
 
   /**
@@ -737,20 +740,18 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(this.functionNames.get(selector.toString()));
   }
 
-  public registerContractFunctionSignatures(_address: AztecAddress, signatures: string[]): Promise<void> {
+  public async registerContractFunctionSignatures(_address: AztecAddress, signatures: string[]): Promise<void> {
     for (const sig of signatures) {
       try {
-        const selector = FunctionSelector.fromSignature(sig);
+        const selector = await FunctionSelector.fromSignature(sig);
         this.functionNames.set(selector.toString(), sig.slice(0, sig.indexOf('(')));
       } catch {
         this.#log.warn(`Failed to parse signature: ${sig}. Ignoring`);
       }
     }
-
-    return Promise.resolve();
   }
 
-  public estimateSize(): { mappingSize: number; actualSize: number; numItems: number } {
-    return { mappingSize: 0, actualSize: 0, numItems: 0 };
+  public estimateSize(): Promise<{ mappingSize: number; actualSize: number; numItems: number }> {
+    return Promise.resolve({ mappingSize: 0, actualSize: 0, numItems: 0 });
   }
 }

package/src/factory.ts

@@ -9,7 +9,7 @@ import { FunctionType, decodeFunctionSignature } from '@aztec/foundation/abi';
 import { createLogger } from '@aztec/foundation/log';
 import { type Maybe } from '@aztec/foundation/types';
 import { type DataStoreConfig } from '@aztec/kv-store/config';
-import { createStore } from '@aztec/kv-store/lmdb';
+import { createStore } from '@aztec/kv-store/lmdb-v2';
 import { TokenContractArtifact } from '@aztec/noir-contracts.js/Token';
 import { TokenBridgeContractArtifact } from '@aztec/noir-contracts.js/TokenBridge';
 import { protocolContractNames } from '@aztec/protocol-contracts';
@@ -53,7 +53,7 @@ async function registerProtocolContracts(store: KVArchiverDataStore) {
       .map(fn => decodeFunctionSignature(fn.name, fn.parameters));
 
     await store.registerContractFunctionSignatures(contract.address, publicFunctionSignatures);
-    const bytecodeCommitment = computePublicBytecodeCommitment(contractClassPublic.packedBytecode);
+    const bytecodeCommitment = await computePublicBytecodeCommitment(contractClassPublic.packedBytecode);
     await store.addContractClasses([contractClassPublic], [bytecodeCommitment], blockNumber);
     await store.addContractInstances([contract.instance], blockNumber);
   }
@@ -67,11 +67,13 @@ async function registerProtocolContracts(store: KVArchiverDataStore) {
 async function registerCommonContracts(store: KVArchiverDataStore) {
   const blockNumber = 0;
   const artifacts = [TokenBridgeContractArtifact, TokenContractArtifact];
-  const classes = artifacts.map(artifact => ({
-    ...getContractClassFromArtifact(artifact),
-    privateFunctions: [],
-    unconstrainedFunctions: [],
-  }));
-  const bytecodeCommitments = classes.map(x => computePublicBytecodeCommitment(x.packedBytecode));
+  const classes = await Promise.all(
+    artifacts.map(async artifact => ({
+      ...(await getContractClassFromArtifact(artifact)),
+      privateFunctions: [],
+      unconstrainedFunctions: [],
+    })),
+  );
+  const bytecodeCommitments = await Promise.all(classes.map(x => computePublicBytecodeCommitment(x.packedBytecode)));
   await store.addContractClasses(classes, bytecodeCommitments, blockNumber);
 }

package/src/test/mock_l2_block_source.ts

@@ -126,7 +126,7 @@ export class MockL2BlockSource implements L2BlockSource {
    * @param txHash - The hash of a transaction which resulted in the returned tx effect.
    * @returns The requested tx effect.
    */
-  public getTxEffect(txHash: TxHash) {
+  public async getTxEffect(txHash: TxHash) {
     const match = this.l2Blocks
       .flatMap(b => b.body.txEffects.map(tx => [tx, b] as const))
       .find(([tx]) => tx.txHash.equals(txHash));
@@ -134,7 +134,7 @@ export class MockL2BlockSource implements L2BlockSource {
       return Promise.resolve(undefined);
     }
     const [txEffect, block] = match;
-    return Promise.resolve({ data: txEffect, l2BlockNumber: block.number, l2BlockHash: block.hash().toString() });
+    return { data: txEffect, l2BlockNumber: block.number, l2BlockHash: (await block.hash()).toString() };
   }
 
   /**
@@ -142,24 +142,22 @@ export class MockL2BlockSource implements L2BlockSource {
    * @param txHash - The hash of a tx we try to get the receipt for.
    * @returns The requested tx receipt (or undefined if not found).
    */
-  public getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
+  public async getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
     for (const block of this.l2Blocks) {
       for (const txEffect of block.body.txEffects) {
         if (txEffect.txHash.equals(txHash)) {
-          return Promise.resolve(
-            new TxReceipt(
-              txHash,
-              TxStatus.SUCCESS,
-              '',
-              txEffect.transactionFee.toBigInt(),
-              L2BlockHash.fromField(block.hash()),
-              block.number,
-            ),
+          return new TxReceipt(
+            txHash,
+            TxStatus.SUCCESS,
+            '',
+            txEffect.transactionFee.toBigInt(),
+            L2BlockHash.fromField(await block.hash()),
+            block.number,
           );
         }
       }
     }
-    return Promise.resolve(undefined);
+    return undefined;
   }
 
   async getL2Tips(): Promise<L2Tips> {
@@ -169,10 +167,14 @@ export class MockL2BlockSource implements L2BlockSource {
       await this.getProvenBlockNumber(),
     ] as const;
 
+    const latestBlock = this.l2Blocks[latest - 1];
+    const provenBlock = this.l2Blocks[proven - 1];
+    const finalizedBlock = this.l2Blocks[finalized - 1];
+
     return {
-      latest: { number: latest, hash: this.l2Blocks[latest - 1]?.hash().toString() },
-      proven: { number: proven, hash: this.l2Blocks[proven - 1]?.hash().toString() },
-      finalized: { number: finalized, hash: this.l2Blocks[finalized - 1]?.hash().toString() },
+      latest: { number: latest, hash: (await latestBlock?.hash())?.toString() },
+      proven: { number: proven, hash: (await provenBlock?.hash())?.toString() },
+      finalized: { number: finalized, hash: (await finalizedBlock?.hash())?.toString() },
     };
   }