@aztec/archiver 0.80.0 → 0.81.0

package/src/archiver/kv_archiver_store/block_store.ts

@@ -1,4 +1,5 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { Signature } from '@aztec/foundation/eth-signature';
 import { toArray } from '@aztec/foundation/iterable';
 import { createLogger } from '@aztec/foundation/log';
 import type { AztecAsyncKVStore, AztecAsyncMap, AztecAsyncSingleton, Range } from '@aztec/kv-store';
@@ -7,9 +8,9 @@ import { Body, type InBlock, L2Block, L2BlockHash } from '@aztec/stdlib/block';
 import { AppendOnlyTreeSnapshot } from '@aztec/stdlib/trees';
 import { BlockHeader, TxEffect, TxHash, TxReceipt } from '@aztec/stdlib/tx';
 
-import type { L1Published, L1PublishedData } from '../structs/published.js';
+import type { L1PublishedData, PublishedL2Block } from '../structs/published.js';
 
-export { type TxEffect, type TxHash, TxReceipt } from '@aztec/stdlib/tx';
+export { TxReceipt, type TxEffect, type TxHash } from '@aztec/stdlib/tx';
 
 type BlockIndexValue = [blockNumber: number, index: number];
 
@@ -17,6 +18,7 @@ type BlockStorage = {
   header: Buffer;
   archive: Buffer;
   l1: L1PublishedData;
+  signatures: Buffer[];
 };
 
 /**
@@ -61,25 +63,26 @@ export class BlockStore {
    * @param blocks - The L2 blocks to be added to the store.
    * @returns True if the operation is successful.
    */
-  async addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
+  async addBlocks(blocks: PublishedL2Block[]): Promise<boolean> {
     if (blocks.length === 0) {
       return true;
     }
 
     return await this.db.transactionAsync(async () => {
       for (const block of blocks) {
-        await this.#blocks.set(block.data.number, {
-          header: block.data.header.toBuffer(),
-          archive: block.data.archive.toBuffer(),
+        await this.#blocks.set(block.block.number, {
+          header: block.block.header.toBuffer(),
+          archive: block.block.archive.toBuffer(),
           l1: block.l1,
+          signatures: block.signatures.map(sig => sig.toBuffer()),
         });
 
-        for (let i = 0; i < block.data.body.txEffects.length; i++) {
-          const txEffect = block.data.body.txEffects[i];
-          await this.#txIndex.set(txEffect.txHash.toString(), [block.data.number, i]);
+        for (let i = 0; i < block.block.body.txEffects.length; i++) {
+          const txEffect = block.block.body.txEffects[i];
+          await this.#txIndex.set(txEffect.txHash.toString(), [block.block.number, i]);
         }
 
-        await this.#blockBodies.set((await block.data.hash()).toString(), block.data.body.toBuffer());
+        await this.#blockBodies.set((await block.block.hash()).toString(), block.block.body.toBuffer());
       }
 
       await this.#lastSynchedL1Block.set(blocks[blocks.length - 1].l1.blockNumber);
@@ -109,9 +112,9 @@ export class BlockStore {
           this.#log.warn(`Cannot remove block ${blockNumber} from the store since we don't have it`);
           continue;
         }
-        await this.#blocks.delete(block.data.number);
-        await Promise.all(block.data.body.txEffects.map(tx => this.#txIndex.delete(tx.txHash.toString())));
-        const blockHash = (await block.data.hash()).toString();
+        await this.#blocks.delete(block.block.number);
+        await Promise.all(block.block.body.txEffects.map(tx => this.#txIndex.delete(tx.txHash.toString())));
+        const blockHash = (await block.block.hash()).toString();
         await this.#blockBodies.delete(blockHash);
         this.#log.debug(`Unwound block ${blockNumber} ${blockHash}`);
       }
@@ -126,10 +129,9 @@ export class BlockStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  async *getBlocks(start: number, limit: number): AsyncIterableIterator<L1Published<L2Block>> {
+  async *getBlocks(start: number, limit: number): AsyncIterableIterator<PublishedL2Block> {
     for await (const blockStorage of this.#blocks.valuesAsync(this.#computeBlockRange(start, limit))) {
-      const block = await this.getBlockFromBlockStorage(blockStorage);
-      yield block;
+      yield await this.getBlockFromBlockStorage(blockStorage);
     }
   }
 
@@ -138,12 +140,11 @@ export class BlockStore {
    * @param blockNumber - The number of the block to return.
    * @returns The requested L2 block.
    */
-  async getBlock(blockNumber: number): Promise<L1Published<L2Block> | undefined> {
+  async getBlock(blockNumber: number): Promise<PublishedL2Block | undefined> {
     const blockStorage = await this.#blocks.getAsync(blockNumber);
     if (!blockStorage || !blockStorage.header) {
       return Promise.resolve(undefined);
     }
-
     return this.getBlockFromBlockStorage(blockStorage);
   }
 
@@ -170,9 +171,9 @@ export class BlockStore {
       );
     }
     const body = Body.fromBuffer(blockBodyBuffer);
-
-    const l2Block = new L2Block(archive, header, body);
-    return { data: l2Block, l1: blockStorage.l1 };
+    const block = new L2Block(archive, header, body);
+    const signatures = blockStorage.signatures.map(Signature.fromBuffer);
+    return { block, l1: blockStorage.l1, signatures };
   }
 
   /**
@@ -192,9 +193,9 @@ export class BlockStore {
     }
 
     return {
-      data: block.data.body.txEffects[txIndex],
-      l2BlockNumber: block.data.number,
-      l2BlockHash: (await block.data.hash()).toString(),
+      data: block.block.body.txEffects[txIndex],
+      l2BlockNumber: block.block.number,
+      l2BlockHash: (await block.block.hash()).toString(),
     };
   }
 
@@ -210,15 +211,15 @@ export class BlockStore {
     }
 
     const block = (await this.getBlock(blockNumber))!;
-    const tx = block.data.body.txEffects[txIndex];
+    const tx = block.block.body.txEffects[txIndex];
 
     return new TxReceipt(
       txHash,
       TxReceipt.statusFromRevertCode(tx.revertCode),
       '',
       tx.transactionFee.toBigInt(),
-      L2BlockHash.fromField(await block.data.hash()),
-      block.data.number,
+      L2BlockHash.fromField(await block.block.hash()),
+      block.block.number,
     );
   }
 

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -19,7 +19,7 @@ import type { BlockHeader, TxHash, TxReceipt } from '@aztec/stdlib/tx';
 
 import type { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
 import type { DataRetrieval } from '../structs/data_retrieval.js';
-import type { L1Published } from '../structs/published.js';
+import type { PublishedL2Block } from '../structs/published.js';
 import { BlockStore } from './block_store.js';
 import { ContractClassStore } from './contract_class_store.js';
 import { ContractInstanceStore } from './contract_instance_store.js';
@@ -78,9 +78,8 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     return this.#contractClassStore.getContractClassIds();
   }
 
-  async getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
-    const contract = this.#contractInstanceStore.getContractInstance(address, await this.getSynchedL2BlockNumber());
-    return contract;
+  getContractInstance(address: AztecAddress, blockNumber: number): Promise<ContractInstanceWithAddress | undefined> {
+    return this.#contractInstanceStore.getContractInstance(address, blockNumber);
   }
 
   async addContractClasses(
@@ -148,7 +147,7 @@ export class KVArchiverDataStore 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.
    */
-  addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
+  addBlocks(blocks: PublishedL2Block[]): Promise<boolean> {
     return this.#blockStore.addBlocks(blocks);
   }
 
@@ -170,7 +169,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  getBlocks(start: number, limit: number): Promise<L1Published<L2Block>[]> {
+  getBlocks(start: number, limit: number): Promise<PublishedL2Block[]> {
     return toArray(this.#blockStore.getBlocks(start, limit));
   }
 

package/src/archiver/kv_archiver_store/log_store.ts

@@ -1,4 +1,4 @@
-import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
+import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
 import type { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
@@ -40,7 +40,7 @@ export class LogStore {
     this.#logsMaxPageSize = logsMaxPageSize;
   }
 
-  #extractTaggedLogsFromPrivate(block: L2Block) {
+  #extractTaggedLogs(block: L2Block) {
     const taggedLogs = new Map<string, Buffer[]>();
     const dataStartIndexForBlock =
       block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
@@ -48,68 +48,22 @@ export class LogStore {
     block.body.txEffects.forEach((txEffect, txIndex) => {
       const txHash = txEffect.txHash;
       const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
+
       txEffect.privateLogs.forEach(log => {
         const tag = log.fields[0];
+        this.#log.debug(`Found private log with tag ${tag.toString()} in block ${block.number}`);
+
         const currentLogs = taggedLogs.get(tag.toString()) ?? [];
-        currentLogs.push(
-          new TxScopedL2Log(
-            txHash,
-            dataStartIndexForTx,
-            block.number,
-            /* isFromPublic */ false,
-            log.toBuffer(),
-          ).toBuffer(),
-        );
+        currentLogs.push(new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, log).toBuffer());
         taggedLogs.set(tag.toString(), currentLogs);
       });
-    });
-    return taggedLogs;
-  }
 
-  #extractTaggedLogsFromPublic(block: L2Block) {
-    const taggedLogs = new Map<string, Buffer[]>();
-    const dataStartIndexForBlock =
-      block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
-      block.body.txEffects.length * MAX_NOTE_HASHES_PER_TX;
-    block.body.txEffects.forEach((txEffect, txIndex) => {
-      const txHash = txEffect.txHash;
-      const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
       txEffect.publicLogs.forEach(log => {
-        // Check that each log stores 2 lengths in its first field. If not, it's not a tagged log:
-        const firstFieldBuf = log.log[0].toBuffer();
-        // 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.
-        if (!firstFieldBuf.subarray(0, 27).equals(Buffer.alloc(27)) || firstFieldBuf[29] !== 0) {
-          // See parseLogFromPublic - the first field of a tagged log is 5 bytes structured:
-          // [ 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(-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
-        if (totalLogLength > PUBLIC_LOG_DATA_SIZE_IN_FIELDS || log.log.slice(totalLogLength).find(f => !f.isZero())) {
-          this.#log.warn(`Skipping invalid tagged public log with first field: ${log.log[0]}`);
-          return;
-        }
-
-        // The first elt stores lengths as above => tag is in fields[1]
-        const tag = log.log[1];
+        const tag = log.log[0];
+        this.#log.debug(`Found public log with tag ${tag.toString()} in block ${block.number}`);
 
-        this.#log.debug(`Found tagged public log with tag ${tag.toString()} in block ${block.number}`);
         const currentLogs = taggedLogs.get(tag.toString()) ?? [];
-        currentLogs.push(
-          new TxScopedL2Log(
-            txHash,
-            dataStartIndexForTx,
-            block.number,
-            /* isFromPublic */ true,
-            log.toBuffer(),
-          ).toBuffer(),
-        );
+        currentLogs.push(new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, log).toBuffer());
         taggedLogs.set(tag.toString(), currentLogs);
       });
     });
@@ -123,7 +77,7 @@ export class LogStore {
    */
   addLogs(blocks: L2Block[]): Promise<boolean> {
     const taggedLogsToAdd = blocks
-      .flatMap(block => [this.#extractTaggedLogsFromPrivate(block), this.#extractTaggedLogsFromPublic(block)])
+      .map(block => this.#extractTaggedLogs(block))
       .reduce((acc, val) => {
         for (const [tag, logs] of val.entries()) {
           const currentLogs = acc.get(tag) ?? [];
@@ -238,9 +192,7 @@ export class LogStore {
    */
   async getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]> {
     const logs = await Promise.all(tags.map(tag => this.#logsByTag.getAsync(tag.toString())));
-    return logs.map(
-      noteLogBuffers => noteLogBuffers?.map(noteLogBuffer => TxScopedL2Log.fromBuffer(noteLogBuffer)) ?? [],
-    );
+    return logs.map(logBuffers => logBuffers?.map(logBuffer => TxScopedL2Log.fromBuffer(logBuffer)) ?? []);
   }
 
   /**

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -1,9 +1,4 @@
-import {
-  INITIAL_L2_BLOCK_NUM,
-  MAX_NOTE_HASHES_PER_TX,
-  MAX_NULLIFIERS_PER_TX,
-  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
-} from '@aztec/constants';
+import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX, MAX_NULLIFIERS_PER_TX } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
 import { FunctionSelector } from '@aztec/stdlib/abi';
@@ -33,7 +28,7 @@ import { type BlockHeader, TxEffect, TxHash, TxReceipt } from '@aztec/stdlib/tx'
 
 import type { ArchiverDataStore, ArchiverL1SynchPoint } from '../archiver_store.js';
 import type { DataRetrieval } from '../structs/data_retrieval.js';
-import type { L1Published } from '../structs/published.js';
+import type { PublishedL2Block } from '../structs/published.js';
 import { L1ToL2MessageStore } from './l1_to_l2_message_store.js';
 
 type StoredContractInstanceUpdate = ContractInstanceUpdateWithAddress & { blockNumber: number; logIndex: number };
@@ -45,7 +40,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   /**
    * An array containing all the L2 blocks that have been fetched so far.
    */
-  private l2Blocks: L1Published<L2Block>[] = [];
+  private l2Blocks: PublishedL2Block[] = [];
 
   /**
    * An array containing all the tx effects in the L2 blocks that have been fetched so far.
@@ -112,7 +107,10 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(Array.from(this.contractClasses.keys()).map(key => Fr.fromHexString(key)));
   }
 
-  public getContractInstance(address: AztecAddress): Promise<ContractInstanceWithAddress | undefined> {
+  public getContractInstance(
+    address: AztecAddress,
+    blockNumber: number,
+  ): Promise<ContractInstanceWithAddress | undefined> {
     const instance = this.contractInstances.get(address.toString());
     if (!instance) {
       return Promise.resolve(undefined);
@@ -120,8 +118,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     const updates = this.contractInstanceUpdates.get(address.toString()) || [];
     if (updates.length > 0) {
       const lastUpdate = updates[0];
-      const currentBlockNumber = this.getLastBlockNumber();
-      if (currentBlockNumber >= lastUpdate.blockOfChange) {
+      if (blockNumber >= lastUpdate.blockOfChange) {
         instance.currentContractClassId = lastUpdate.newContractClassId;
       } else if (!lastUpdate.prevContractClassId.isZero()) {
         instance.currentContractClassId = lastUpdate.prevContractClassId;
@@ -235,16 +232,16 @@ 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 async addBlocks(blocks: L1Published<L2Block>[]): Promise<boolean> {
+  public async addBlocks(blocks: PublishedL2Block[]): Promise<boolean> {
     if (blocks.length === 0) {
       return Promise.resolve(true);
     }
 
     this.lastL1BlockNewBlocks = blocks[blocks.length - 1].l1.blockNumber;
     this.l2Blocks.push(...blocks);
-    const flatTxEffects = blocks.flatMap(b => b.data.body.txEffects.map(txEffect => ({ block: b, txEffect })));
+    const flatTxEffects = blocks.flatMap(b => b.block.body.txEffects.map(txEffect => ({ block: b, txEffect })));
     const wrappedTxEffects = await Promise.all(
-      flatTxEffects.map(flatTxEffect => wrapInBlock(flatTxEffect.txEffect, flatTxEffect.block.data)),
+      flatTxEffects.map(flatTxEffect => wrapInBlock(flatTxEffect.txEffect, flatTxEffect.block.block)),
     );
     this.txEffects.push(...wrappedTxEffects);
 
@@ -270,68 +267,41 @@ export class MemoryArchiverStore implements ArchiverDataStore {
       if (block == undefined) {
         break;
       }
-      block.data.body.txEffects.forEach(() => this.txEffects.pop());
+      block.block.body.txEffects.forEach(() => this.txEffects.pop());
     }
 
     return Promise.resolve(true);
   }
 
-  #storeTaggedLogsFromPrivate(block: L2Block): void {
+  #storeTaggedLogs(block: L2Block): void {
     const dataStartIndexForBlock =
       block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
       block.body.txEffects.length * MAX_NOTE_HASHES_PER_TX;
     block.body.txEffects.forEach((txEffect, txIndex) => {
       const txHash = txEffect.txHash;
       const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
+
       txEffect.privateLogs.forEach(log => {
         const tag = log.fields[0];
+        this.#log.verbose(`Storing private log with tag ${tag.toString()} from block ${block.number}`);
+
         const currentLogs = this.taggedLogs.get(tag.toString()) || [];
         this.taggedLogs.set(tag.toString(), [
           ...currentLogs,
-          new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, /* isFromPublic */ false, log.toBuffer()),
+          new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, log),
         ]);
         const currentTagsInBlock = this.logTagsPerBlock.get(block.number) || [];
         this.logTagsPerBlock.set(block.number, [...currentTagsInBlock, tag]);
       });
-    });
-  }
 
-  #storeTaggedLogsFromPublic(block: L2Block): void {
-    const dataStartIndexForBlock =
-      block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
-      block.body.txEffects.length * MAX_NOTE_HASHES_PER_TX;
-    block.body.txEffects.forEach((txEffect, txIndex) => {
-      const txHash = txEffect.txHash;
-      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, 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]]
-          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(-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
-        if (totalLogLength > PUBLIC_LOG_DATA_SIZE_IN_FIELDS || log.log.slice(totalLogLength).find(f => !f.isZero())) {
-          this.#log.warn(`Skipping invalid tagged public log with first field: ${log.log[0]}`);
-          return;
-        }
+        const tag = log.log[0];
+        this.#log.verbose(`Storing public log with tag ${tag.toString()} from block ${block.number}`);
 
-        // The first elt stores lengths => tag is in fields[1]
-        const tag = log.log[1];
-        this.#log.verbose(`Storing public tagged log with tag ${tag.toString()} in block ${block.number}`);
         const currentLogs = this.taggedLogs.get(tag.toString()) || [];
         this.taggedLogs.set(tag.toString(), [
           ...currentLogs,
-          new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, /* isFromPublic */ true, log.toBuffer()),
+          new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, log),
         ]);
         const currentTagsInBlock = this.logTagsPerBlock.get(block.number) || [];
         this.logTagsPerBlock.set(block.number, [...currentTagsInBlock, tag]);
@@ -346,8 +316,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   addLogs(blocks: L2Block[]): Promise<boolean> {
     blocks.forEach(block => {
-      this.#storeTaggedLogsFromPrivate(block);
-      this.#storeTaggedLogsFromPublic(block);
+      this.#storeTaggedLogs(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(
@@ -464,7 +433,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * @returns The requested L2 blocks.
    * @remarks When "from" is smaller than genesis block number, blocks from the beginning are returned.
    */
-  public getBlocks(from: number, limit: number): Promise<L1Published<L2Block>[]> {
+  public getBlocks(from: number, limit: number): Promise<PublishedL2Block[]> {
     if (limit < 1) {
       return Promise.reject(new Error(`Invalid limit: ${limit}`));
     }
@@ -484,7 +453,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
 
   public async getBlockHeaders(from: number, limit: number): Promise<BlockHeader[]> {
     const blocks = await this.getBlocks(from, limit);
-    return blocks.map(block => block.data.header);
+    return blocks.map(block => block.block.header);
   }
 
   /**
@@ -504,15 +473,15 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   public async getSettledTxReceipt(txHash: TxHash): Promise<TxReceipt | undefined> {
     for (const block of this.l2Blocks) {
-      for (const txEffect of block.data.body.txEffects) {
+      for (const txEffect of block.block.body.txEffects) {
         if (txEffect.txHash.equals(txHash)) {
           return new TxReceipt(
             txHash,
             TxReceipt.statusFromRevertCode(txEffect.revertCode),
             '',
             txEffect.transactionFee.toBigInt(),
-            L2BlockHash.fromField(await block.data.hash()),
-            block.data.number,
+            L2BlockHash.fromField(await block.block.hash()),
+            block.block.number,
           );
         }
       }
@@ -566,8 +535,8 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    * that tag.
    */
   getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]> {
-    const noteLogs = tags.map(tag => this.taggedLogs.get(tag.toString()) || []);
-    return Promise.resolve(noteLogs);
+    const logs = tags.map(tag => this.taggedLogs.get(tag.toString()) || []);
+    return Promise.resolve(logs);
   }
 
   /**
@@ -626,8 +595,8 @@ export class MemoryArchiverStore implements ArchiverDataStore {
       if (blockLogs) {
         for (let logIndex = 0; logIndex < blockLogs.length; logIndex++) {
           const log = blockLogs[logIndex];
-          const thisTxEffect = block.data.body.txEffects.filter(effect => effect.publicLogs.includes(log))[0];
-          const thisTxIndexInBlock = block.data.body.txEffects.indexOf(thisTxEffect);
+          const thisTxEffect = block.block.body.txEffects.filter(effect => effect.publicLogs.includes(log))[0];
+          const thisTxIndexInBlock = block.block.body.txEffects.indexOf(thisTxEffect);
           const thisLogIndexInTx = thisTxEffect.publicLogs.indexOf(log);
           if (
             (!txHash || thisTxEffect.txHash.equals(txHash)) &&
@@ -635,7 +604,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
             thisTxIndexInBlock >= txIndexInBlock &&
             thisLogIndexInTx >= logIndexInTx
           ) {
-            logs.push(new ExtendedPublicLog(new LogId(block.data.number, thisTxIndexInBlock, thisLogIndexInTx), log));
+            logs.push(new ExtendedPublicLog(new LogId(block.block.number, thisTxIndexInBlock, thisLogIndexInTx), log));
             if (logs.length === this.maxLogs) {
               return Promise.resolve({
                 logs,
@@ -710,8 +679,8 @@ export class MemoryArchiverStore implements ArchiverDataStore {
       if (blockLogs) {
         for (let logIndex = 0; logIndex < blockLogs.length; logIndex++) {
           const log = blockLogs[logIndex];
-          const thisTxEffect = block.data.body.txEffects.filter(effect => effect.contractClassLogs.includes(log))[0];
-          const thisTxIndexInBlock = block.data.body.txEffects.indexOf(thisTxEffect);
+          const thisTxEffect = block.block.body.txEffects.filter(effect => effect.contractClassLogs.includes(log))[0];
+          const thisTxIndexInBlock = block.block.body.txEffects.indexOf(thisTxEffect);
           const thisLogIndexInTx = thisTxEffect.contractClassLogs.indexOf(log);
           if (
             (!txHash || thisTxEffect.txHash.equals(txHash)) &&
@@ -720,7 +689,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
             thisLogIndexInTx >= logIndexInTx
           ) {
             logs.push(
-              new ExtendedContractClassLog(new LogId(block.data.number, thisTxIndexInBlock, thisLogIndexInTx), log),
+              new ExtendedContractClassLog(new LogId(block.block.number, thisTxIndexInBlock, thisLogIndexInTx), log),
             );
             if (logs.length === this.maxLogs) {
               return Promise.resolve({
@@ -743,7 +712,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     if (this.l2Blocks.length === 0) {
       return INITIAL_L2_BLOCK_NUM - 1;
     }
-    return this.l2Blocks[this.l2Blocks.length - 1].data.number;
+    return this.l2Blocks[this.l2Blocks.length - 1].block.number;
   }
 
   /**

package/src/archiver/structs/published.ts

@@ -1,11 +1 @@
-/** Extends a type with L1 published info (block number, hash, and timestamp) */
-export type L1Published<T> = {
-  data: T;
-  l1: L1PublishedData;
-};
-
-export type L1PublishedData = {
-  blockNumber: bigint;
-  timestamp: bigint;
-  blockHash: string;
-};
+export type { PublishedL2Block, L1PublishedData } from '@aztec/stdlib/block';

package/src/test/mock_l2_block_source.ts

@@ -1,4 +1,5 @@
 import { DefaultL1ContractsConfig } from '@aztec/ethereum';
+import { Buffer32 } from '@aztec/foundation/buffer';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { createLogger } from '@aztec/foundation/log';
 import { L2Block, L2BlockHash, type L2BlockSource, type L2Tips } from '@aztec/stdlib/block';
@@ -90,6 +91,19 @@ export class MockL2BlockSource implements L2BlockSource {
     );
   }
 
+  public async getPublishedBlocks(from: number, limit: number, proven?: boolean) {
+    const blocks = await this.getBlocks(from, limit, proven);
+    return blocks.map(block => ({
+      block,
+      l1: {
+        blockNumber: BigInt(block.number),
+        blockHash: Buffer32.random().toString(),
+        timestamp: BigInt(block.number),
+      },
+      signatures: [],
+    }));
+  }
+
   getBlockHeader(number: number | 'latest'): Promise<BlockHeader | undefined> {
     return Promise.resolve(this.l2Blocks.at(typeof number === 'number' ? number - 1 : -1)?.header);
   }