@aztec/archiver 0.65.2 → 0.67.0

package/src/archiver/data_retrieval.ts

@@ -1,8 +1,9 @@
 import { Body, InboxLeaf, L2Block } from '@aztec/circuit-types';
-import { AppendOnlyTreeSnapshot, Fr, Header, Proof } from '@aztec/circuits.js';
+import { AppendOnlyTreeSnapshot, BlockHeader, Fr, Proof } from '@aztec/circuits.js';
+import { asyncPool } from '@aztec/foundation/async-pool';
 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 { type Logger, createLogger } from '@aztec/foundation/log';
 import { numToUInt32BE } from '@aztec/foundation/serialize';
 import { type InboxAbi, RollupAbi } from '@aztec/l1-artifacts';
 
@@ -25,19 +26,17 @@ import { type L1Published, type L1PublishedData } from './structs/published.js';
  * Fetches new L2 blocks.
  * @param publicClient - The viem public client to use for transaction retrieval.
  * @param rollupAddress - The address of the rollup contract.
- * @param blockUntilSynced - If true, blocks until the archiver has fully synced.
  * @param searchStartBlock - The block number to use for starting the search.
  * @param searchEndBlock - The highest block number that we should search up to.
  * @param expectedNextL2BlockNum - The next L2 block number that we expect to find.
  * @returns An array of block; as well as the next eth block to search from.
  */
-export async function retrieveBlockFromRollup(
+export async function retrieveBlocksFromRollup(
   rollup: GetContractReturnType<typeof RollupAbi, PublicClient<HttpTransport, Chain>>,
   publicClient: PublicClient,
-  blockUntilSynced: boolean,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
-  logger: DebugLogger = createDebugLogger('aztec:archiver'),
+  logger: Logger = createLogger('archiver'),
 ): Promise<L1Published<L2Block>[]> {
   const retrievedBlocks: L1Published<L2Block>[] = [];
   do {
@@ -58,13 +57,13 @@ export async function retrieveBlockFromRollup(
 
     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 ${l2BlockProposedLogs.length} L2 block processed logs for L2 blocks ${l2BlockProposedLogs[0].args.blockNumber}-${lastLog.args.blockNumber} between L1 blocks ${searchStartBlock}-${searchEndBlock}`,
     );
 
     const newBlocks = await processL2BlockProposedLogs(rollup, publicClient, l2BlockProposedLogs, logger);
     retrievedBlocks.push(...newBlocks);
     searchStartBlock = lastLog.blockNumber! + 1n;
-  } while (blockUntilSynced && searchStartBlock <= searchEndBlock);
+  } while (searchStartBlock <= searchEndBlock);
   return retrievedBlocks;
 }
 
@@ -79,17 +78,16 @@ export async function processL2BlockProposedLogs(
   rollup: GetContractReturnType<typeof RollupAbi, PublicClient<HttpTransport, Chain>>,
   publicClient: PublicClient,
   logs: GetContractEventsReturnType<typeof RollupAbi, 'L2BlockProposed'>,
-  logger: DebugLogger,
+  logger: Logger,
 ): Promise<L1Published<L2Block>[]> {
   const retrievedBlocks: L1Published<L2Block>[] = [];
-  for (const log of logs) {
+  await asyncPool(10, logs, async log => {
     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 = {
@@ -100,11 +98,12 @@ export async function processL2BlockProposedLogs(
 
       retrievedBlocks.push({ data: block, l1 });
     } else {
-      logger.warn(
-        `Archive mismatch matching, ignoring block ${l2BlockNumber} with archive: ${archive}, expected ${archiveFromChain}`,
-      );
+      logger.warn(`Ignoring L2 block ${l2BlockNumber} due to archive root mismatch`, {
+        actual: archive,
+        expected: archiveFromChain,
+      });
     }
-  }
+  });
 
   return retrievedBlocks;
 }
@@ -129,10 +128,7 @@ async function getBlockFromRollupTx(
   l2BlockNum: bigint,
 ): Promise<L2Block> {
   const { input: data } = await publicClient.getTransaction({ hash: txHash });
-  const { functionName, args } = decodeFunctionData({
-    abi: RollupAbi,
-    data,
-  });
+  const { functionName, args } = decodeFunctionData({ abi: RollupAbi, data });
 
   const allowedMethods = ['propose', 'proposeAndClaim'];
 
@@ -154,7 +150,7 @@ async function getBlockFromRollupTx(
     Hex,
   ];
 
-  const header = Header.fromBuffer(Buffer.from(hexToBytes(decodedArgs.header)));
+  const header = BlockHeader.fromBuffer(Buffer.from(hexToBytes(decodedArgs.header)));
   const blockBody = Body.fromBuffer(Buffer.from(hexToBytes(bodyHex)));
 
   const blockNumberFromHeader = header.globalVariables.blockNumber.toBigInt();
@@ -184,7 +180,6 @@ async function getBlockFromRollupTx(
  */
 export async function retrieveL1ToL2Messages(
   inbox: GetContractReturnType<typeof InboxAbi, PublicClient<HttpTransport, Chain>>,
-  blockUntilSynced: boolean,
   searchStartBlock: bigint,
   searchEndBlock: bigint,
 ): Promise<DataRetrieval<InboxLeaf>> {
@@ -208,12 +203,12 @@ export async function retrieveL1ToL2Messages(
 
     for (const log of messageSentLogs) {
       const { index, hash } = log.args;
-      retrievedL1ToL2Messages.push(new InboxLeaf(index!, Fr.fromString(hash!)));
+      retrievedL1ToL2Messages.push(new InboxLeaf(index!, Fr.fromHexString(hash!)));
     }
 
     // handles the case when there are no new messages:
     searchStartBlock = (messageSentLogs.findLast(msgLog => !!msgLog)?.blockNumber || searchStartBlock) + 1n;
-  } while (blockUntilSynced && searchStartBlock <= searchEndBlock);
+  } while (searchStartBlock <= searchEndBlock);
   return { lastProcessedL1BlockNumber: searchStartBlock - 1n, retrievedData: retrievedL1ToL2Messages };
 }
 
@@ -235,7 +230,7 @@ export async function retrieveL2ProofVerifiedEvents(
   return logs.map(log => ({
     l1BlockNumber: log.blockNumber,
     l2BlockNumber: log.args.blockNumber,
-    proverId: Fr.fromString(log.args.proverId),
+    proverId: Fr.fromHexString(log.args.proverId),
     txHash: log.transactionHash,
   }));
 }
@@ -302,8 +297,8 @@ export async function getProofFromSubmitProofTx(
     ];
 
     aggregationObject = Buffer.from(hexToBytes(decodedArgs.aggregationObject));
-    proverId = Fr.fromString(decodedArgs.args[6]);
-    archiveRoot = Fr.fromString(decodedArgs.args[1]);
+    proverId = Fr.fromHexString(decodedArgs.args[6]);
+    archiveRoot = Fr.fromHexString(decodedArgs.args[1]);
     proof = Proof.fromBuffer(Buffer.from(hexToBytes(decodedArgs.proof)));
   } else {
     throw new Error(`Unexpected proof method called ${functionName}`);

package/src/archiver/instrumentation.ts

@@ -1,29 +1,29 @@
 import { type L2Block } from '@aztec/circuit-types';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import {
   Attributes,
   type Gauge,
   type Histogram,
   LmdbMetrics,
+  type LmdbStatsCallback,
   Metrics,
   type TelemetryClient,
   type UpDownCounter,
   ValueType,
-  exponentialBuckets,
-  millisecondBuckets,
 } from '@aztec/telemetry-client';
 
 export class ArchiverInstrumentation {
   private blockHeight: Gauge;
   private blockSize: Gauge;
   private syncDuration: Histogram;
+  private l1BlocksSynced: UpDownCounter;
   private proofsSubmittedDelay: Histogram;
   private proofsSubmittedCount: UpDownCounter;
   private dbMetrics: LmdbMetrics;
 
-  private log = createDebugLogger('aztec:archiver:instrumentation');
+  private log = createLogger('archiver:instrumentation');
 
-  constructor(private telemetry: TelemetryClient) {
+  private constructor(private telemetry: TelemetryClient, lmdbStats?: LmdbStatsCallback) {
     const meter = telemetry.getMeter('Archiver');
     this.blockHeight = meter.createGauge(Metrics.ARCHIVER_BLOCK_HEIGHT, {
       description: 'The height of the latest block processed by the archiver',
@@ -39,9 +39,6 @@ export class ArchiverInstrumentation {
       unit: 'ms',
       description: 'Duration to sync a block',
       valueType: ValueType.INT,
-      advice: {
-        explicitBucketBoundaries: exponentialBuckets(1, 16),
-      },
     });
 
     this.proofsSubmittedCount = meter.createUpDownCounter(Metrics.ARCHIVER_ROLLUP_PROOF_COUNT, {
@@ -53,30 +50,30 @@ export class ArchiverInstrumentation {
       unit: 'ms',
       description: 'Time after a block is submitted until its proof is published',
       valueType: ValueType.INT,
-      advice: {
-        explicitBucketBoundaries: millisecondBuckets(1, 80), // 10ms -> ~3hs
-      },
+    });
+
+    this.l1BlocksSynced = meter.createUpDownCounter(Metrics.ARCHIVER_L1_BLOCKS_SYNCED, {
+      description: 'Number of blocks synced from L1',
+      valueType: ValueType.INT,
     });
 
     this.dbMetrics = new LmdbMetrics(
       meter,
       {
-        name: Metrics.ARCHIVER_DB_MAP_SIZE,
-        description: 'Database map size for the archiver',
-      },
-      {
-        name: Metrics.ARCHIVER_DB_USED_SIZE,
-        description: 'Database used size for the archiver',
-      },
-      {
-        name: Metrics.ARCHIVER_DB_NUM_ITEMS,
-        description: 'Num items in the archiver database',
+        [Attributes.DB_DATA_TYPE]: 'archiver',
       },
+      lmdbStats,
     );
   }
 
-  public recordDBMetrics(metrics: { mappingSize: number; numItems: number; actualSize: number }) {
-    this.dbMetrics.recordDBMetrics(metrics);
+  public static async new(telemetry: TelemetryClient, lmdbStats?: LmdbStatsCallback) {
+    const instance = new ArchiverInstrumentation(telemetry, lmdbStats);
+
+    instance.l1BlocksSynced.add(0);
+
+    await instance.telemetry.flush();
+
+    return instance;
   }
 
   public isEnabled(): boolean {
@@ -86,6 +83,7 @@ export class ArchiverInstrumentation {
   public processNewBlocks(syncTimePerBlock: number, blocks: L2Block[]) {
     this.syncDuration.record(Math.ceil(syncTimePerBlock));
     this.blockHeight.record(Math.max(...blocks.map(b => b.number)));
+    this.l1BlocksSynced.add(blocks.length);
     for (const block of blocks) {
       this.blockSize.record(block.body.txEffects.length);
     }

package/src/archiver/kv_archiver_store/block_store.ts

@@ -1,6 +1,6 @@
 import { Body, type InBlock, L2Block, L2BlockHash, 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 { AppendOnlyTreeSnapshot, type AztecAddress, BlockHeader, INITIAL_L2_BLOCK_NUM } from '@aztec/circuits.js';
+import { createLogger } 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';
@@ -38,7 +38,7 @@ export class BlockStore {
   /** Index mapping a contract's address (as a string) to its location in a block */
   #contractIndex: AztecMap<string, BlockIndexValue>;
 
-  #log = createDebugLogger('aztec:archiver:block_store');
+  #log = createLogger('archiver:block_store');
 
   constructor(private db: AztecKVStore) {
     this.#blocks = db.openMap('archiver_blocks');
@@ -147,14 +147,14 @@ export class BlockStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 block headers
    */
-  *getBlockHeaders(start: number, limit: number): IterableIterator<Header> {
+  *getBlockHeaders(start: number, limit: number): IterableIterator<BlockHeader> {
     for (const blockStorage of this.#blocks.values(this.#computeBlockRange(start, limit))) {
-      yield Header.fromBuffer(blockStorage.header);
+      yield BlockHeader.fromBuffer(blockStorage.header);
     }
   }
 
   private getBlockFromBlockStorage(blockStorage: BlockStorage) {
-    const header = Header.fromBuffer(blockStorage.header);
+    const header = BlockHeader.fromBuffer(blockStorage.header);
     const archive = AppendOnlyTreeSnapshot.fromBuffer(blockStorage.archive);
     const blockHash = header.hash().toString();
     const blockBodyBuffer = this.#blockBodies.get(blockHash);

package/src/archiver/kv_archiver_store/contract_class_store.ts

@@ -53,7 +53,7 @@ export class ContractClassStore {
   }
 
   getContractClassIds(): Fr[] {
-    return Array.from(this.#contractClasses.keys()).map(key => Fr.fromString(key));
+    return Array.from(this.#contractClasses.keys()).map(key => Fr.fromHexString(key));
   }
 
   async addFunctions(

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -1,27 +1,25 @@
 import {
-  type FromLogType,
   type GetUnencryptedLogsResponse,
   type InBlock,
   type InboxLeaf,
   type L2Block,
-  type L2BlockL2Logs,
   type LogFilter,
-  type LogType,
   type TxHash,
   type TxReceipt,
   type TxScopedL2Log,
 } from '@aztec/circuit-types';
 import {
+  type BlockHeader,
   type ContractClassPublic,
   type ContractInstanceWithAddress,
   type ExecutablePrivateFunctionWithMembershipProof,
   type Fr,
-  type Header,
+  type PrivateLog,
   type UnconstrainedFunctionWithMembershipProof,
 } from '@aztec/circuits.js';
 import { type ContractArtifact, FunctionSelector } from '@aztec/foundation/abi';
 import { type AztecAddress } from '@aztec/foundation/aztec-address';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
 import { type AztecKVStore } from '@aztec/kv-store';
 
 import { type ArchiverDataStore, type ArchiverL1SynchPoint } from '../archiver_store.js';
@@ -48,7 +46,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   #contractArtifactStore: ContractArtifactsStore;
   private functionNames = new Map<string, string>();
 
-  #log = createDebugLogger('aztec:archiver:data-store');
+  #log = createLogger('archiver:data-store');
 
   constructor(private db: AztecKVStore, logsMaxPageSize: number = 1000) {
     this.#blockStore = new BlockStore(db);
@@ -173,7 +171,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @param limit - The number of blocks to return.
    * @returns The requested L2 blocks
    */
-  getBlockHeaders(start: number, limit: number): Promise<Header[]> {
+  getBlockHeaders(start: number, limit: number): Promise<BlockHeader[]> {
     try {
       return Promise.resolve(Array.from(this.#blockStore.getBlockHeaders(start, limit)));
     } catch (err) {
@@ -266,19 +264,14 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   }
 
   /**
-   * Gets up to `limit` amount of logs starting from `from`.
-   * @param start - Number of the L2 block to which corresponds the first logs to be returned.
-   * @param limit - The number of logs to return.
-   * @param logType - Specifies whether to return encrypted or unencrypted logs.
-   * @returns The requested logs.
+   * Retrieves all private logs from up to `limit` blocks, starting from the block number `from`.
+   * @param from - The block number from which to begin retrieving logs.
+   * @param limit - The maximum number of blocks to retrieve logs from.
+   * @returns An array of private logs from the specified range of blocks.
    */
-  getLogs<TLogType extends LogType>(
-    start: number,
-    limit: number,
-    logType: TLogType,
-  ): Promise<L2BlockL2Logs<FromLogType<TLogType>>[]> {
+  getPrivateLogs(from: number, limit: number): Promise<PrivateLog[]> {
     try {
-      return Promise.resolve(Array.from(this.#logStore.getLogs(start, limit, logType)));
+      return Promise.resolve(Array.from(this.#logStore.getPrivateLogs(from, limit)));
     } catch (err) {
       return Promise.reject(err);
     }

package/src/archiver/kv_archiver_store/log_store.ts

@@ -1,23 +1,18 @@
 import {
-  type Body,
   ContractClass2BlockL2Logs,
-  EncryptedL2BlockL2Logs,
-  EncryptedNoteL2BlockL2Logs,
   ExtendedUnencryptedL2Log,
-  type FromLogType,
   type GetUnencryptedLogsResponse,
   type L2Block,
-  type L2BlockL2Logs,
   type LogFilter,
   LogId,
-  LogType,
   TxScopedL2Log,
   UnencryptedL2BlockL2Logs,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
-import { Fr } from '@aztec/circuits.js';
+import { Fr, PrivateLog } from '@aztec/circuits.js';
 import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX } from '@aztec/circuits.js/constants';
-import { createDebugLogger } from '@aztec/foundation/log';
+import { createLogger } from '@aztec/foundation/log';
+import { BufferReader } from '@aztec/foundation/serialize';
 import { type AztecKVStore, type AztecMap } from '@aztec/kv-store';
 
 import { type BlockStore } from './block_store.js';
@@ -26,72 +21,83 @@ import { type BlockStore } from './block_store.js';
  * A store for logs
  */
 export class LogStore {
-  #noteEncryptedLogsByBlock: AztecMap<number, Buffer>;
   #logsByTag: AztecMap<string, Buffer[]>;
   #logTagsByBlock: AztecMap<number, string[]>;
-  #encryptedLogsByBlock: AztecMap<number, Buffer>;
+  #privateLogsByBlock: AztecMap<number, Buffer>;
   #unencryptedLogsByBlock: AztecMap<number, Buffer>;
   #contractClassLogsByBlock: AztecMap<number, Buffer>;
   #logsMaxPageSize: number;
-  #log = createDebugLogger('aztec:archiver:log_store');
+  #log = createLogger('archiver:log_store');
 
   constructor(private db: AztecKVStore, private blockStore: BlockStore, logsMaxPageSize: number = 1000) {
-    this.#noteEncryptedLogsByBlock = db.openMap('archiver_note_encrypted_logs_by_block');
     this.#logsByTag = db.openMap('archiver_tagged_logs_by_tag');
     this.#logTagsByBlock = db.openMap('archiver_log_tags_by_block');
-    this.#encryptedLogsByBlock = db.openMap('archiver_encrypted_logs_by_block');
+    this.#privateLogsByBlock = db.openMap('archiver_private_logs_by_block');
     this.#unencryptedLogsByBlock = db.openMap('archiver_unencrypted_logs_by_block');
     this.#contractClassLogsByBlock = db.openMap('archiver_contract_class_logs_by_block');
 
     this.#logsMaxPageSize = logsMaxPageSize;
   }
 
-  #extractTaggedLogs(block: L2Block, logType: keyof Pick<Body, 'noteEncryptedLogs' | 'unencryptedLogs'>) {
+  #extractTaggedLogsFromPrivate(block: L2Block) {
     const taggedLogs = new Map<string, Buffer[]>();
     const dataStartIndexForBlock =
       block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
       block.body.numberOfTxsIncludingPadded * MAX_NOTE_HASHES_PER_TX;
-    block.body[logType].txLogs.forEach((txLogs, txIndex) => {
+    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];
+        const currentLogs = taggedLogs.get(tag.toString()) ?? [];
+        currentLogs.push(
+          new TxScopedL2Log(
+            txHash,
+            dataStartIndexForTx,
+            block.number,
+            /* isFromPublic */ false,
+            log.toBuffer(),
+          ).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.numberOfTxsIncludingPadded * MAX_NOTE_HASHES_PER_TX;
+    block.body.unencryptedLogs.txLogs.forEach((txLogs, txIndex) => {
       const txHash = block.body.txEffects[txIndex].txHash;
       const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
       const logs = txLogs.unrollLogs();
       logs.forEach(log => {
-        if (
-          (logType == 'noteEncryptedLogs' && log.data.length < 32) ||
+        if (log.data.length < 32 * 33) {
           // TODO remove when #9835 and #9836 are fixed
-          (logType === 'unencryptedLogs' && log.data.length < 32 * 33)
-        ) {
-          this.#log.warn(`Skipping log (${logType}) with invalid data length: ${log.data.length}`);
+          this.#log.warn(`Skipping unencrypted log with insufficient data length: ${log.data.length}`);
           return;
         }
         try {
-          let tag = Fr.ZERO;
           // TODO remove when #9835 and #9836 are fixed. The partial note logs are emitted as bytes, but encoded as Fields.
           // This means that for every 32 bytes of payload, we only have 1 byte of data.
           // Also, the tag is not stored in the first 32 bytes of the log, (that's the length of public fields now) but in the next 32.
-          if (logType === 'unencryptedLogs') {
-            const correctedBuffer = Buffer.alloc(32);
-            const initialOffset = 32;
-            for (let i = 0; i < 32; i++) {
-              const byte = Fr.fromBuffer(
-                log.data.subarray(i * 32 + initialOffset, i * 32 + 32 + initialOffset),
-              ).toNumber();
-              correctedBuffer.writeUInt8(byte, i);
-            }
-            tag = new Fr(correctedBuffer);
-          } else {
-            tag = new Fr(log.data.subarray(0, 32));
+          const correctedBuffer = Buffer.alloc(32);
+          const initialOffset = 32;
+          for (let i = 0; i < 32; i++) {
+            const byte = Fr.fromBuffer(
+              log.data.subarray(i * 32 + initialOffset, i * 32 + 32 + initialOffset),
+            ).toNumber();
+            correctedBuffer.writeUInt8(byte, i);
           }
-          this.#log.verbose(`Found tagged (${logType}) log with tag ${tag.toString()} in block ${block.number}`);
+          const tag = new Fr(correctedBuffer);
+
+          this.#log.debug(`Found tagged unencrypted log with tag ${tag.toString()} in block ${block.number}`);
           const currentLogs = taggedLogs.get(tag.toString()) ?? [];
           currentLogs.push(
-            new TxScopedL2Log(
-              txHash,
-              dataStartIndexForTx,
-              block.number,
-              logType === 'unencryptedLogs',
-              log.data,
-            ).toBuffer(),
+            new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, /* isFromPublic */ true, log.data).toBuffer(),
           );
           taggedLogs.set(tag.toString(), currentLogs);
         } catch (err) {
@@ -109,10 +115,7 @@ export class LogStore {
    */
   async addLogs(blocks: L2Block[]): Promise<boolean> {
     const taggedLogsToAdd = blocks
-      .flatMap(block => [
-        this.#extractTaggedLogs(block, 'noteEncryptedLogs'),
-        this.#extractTaggedLogs(block, 'unencryptedLogs'),
-      ])
+      .flatMap(block => [this.#extractTaggedLogsFromPrivate(block), this.#extractTaggedLogsFromPublic(block)])
       .reduce((acc, val) => {
         for (const [tag, logs] of val.entries()) {
           const currentLogs = acc.get(tag) ?? [];
@@ -140,8 +143,13 @@ export class LogStore {
           tagsInBlock.push(tag);
         }
         void this.#logTagsByBlock.set(block.number, tagsInBlock);
-        void this.#noteEncryptedLogsByBlock.set(block.number, block.body.noteEncryptedLogs.toBuffer());
-        void this.#encryptedLogsByBlock.set(block.number, block.body.encryptedLogs.toBuffer());
+
+        const privateLogsInBlock = block.body.txEffects
+          .map(txEffect => txEffect.privateLogs)
+          .flat()
+          .map(log => log.toBuffer());
+        void this.#privateLogsByBlock.set(block.number, Buffer.concat(privateLogsInBlock));
+
         void this.#unencryptedLogsByBlock.set(block.number, block.body.unencryptedLogs.toBuffer());
         void this.#contractClassLogsByBlock.set(block.number, block.body.contractClassLogs.toBuffer());
       });
@@ -156,8 +164,7 @@ export class LogStore {
     });
     return this.db.transaction(() => {
       blocks.forEach(block => {
-        void this.#noteEncryptedLogsByBlock.delete(block.number);
-        void this.#encryptedLogsByBlock.delete(block.number);
+        void this.#privateLogsByBlock.delete(block.number);
         void this.#unencryptedLogsByBlock.delete(block.number);
         void this.#logTagsByBlock.delete(block.number);
       });
@@ -171,43 +178,20 @@ export class LogStore {
   }
 
   /**
-   * Gets up to `limit` amount of logs starting from `from`.
-   * @param start - Number of the L2 block to which corresponds the first logs to be returned.
-   * @param limit - The number of logs to return.
-   * @param logType - Specifies whether to return encrypted or unencrypted logs.
-   * @returns The requested logs.
+   * Retrieves all private logs from up to `limit` blocks, starting from the block number `start`.
+   * @param start - The block number from which to begin retrieving logs.
+   * @param limit - The maximum number of blocks to retrieve logs from.
+   * @returns An array of private logs from the specified range of blocks.
    */
-  *getLogs<TLogType extends LogType>(
-    start: number,
-    limit: number,
-    logType: TLogType,
-  ): IterableIterator<L2BlockL2Logs<FromLogType<TLogType>>> {
-    const logMap = (() => {
-      switch (logType) {
-        case LogType.ENCRYPTED:
-          return this.#encryptedLogsByBlock;
-        case LogType.NOTEENCRYPTED:
-          return this.#noteEncryptedLogsByBlock;
-        case LogType.UNENCRYPTED:
-        default:
-          return this.#unencryptedLogsByBlock;
-      }
-    })();
-    const logTypeMap = (() => {
-      switch (logType) {
-        case LogType.ENCRYPTED:
-          return EncryptedL2BlockL2Logs;
-        case LogType.NOTEENCRYPTED:
-          return EncryptedNoteL2BlockL2Logs;
-        case LogType.UNENCRYPTED:
-        default:
-          return UnencryptedL2BlockL2Logs;
+  getPrivateLogs(start: number, limit: number) {
+    const logs = [];
+    for (const buffer of this.#privateLogsByBlock.values({ start, limit })) {
+      const reader = new BufferReader(buffer);
+      while (reader.remainingBytes() > 0) {
+        logs.push(reader.readObject(PrivateLog));
       }
-    })();
-    const L2BlockL2Logs = logTypeMap;
-    for (const buffer of logMap.values({ start, limit })) {
-      yield L2BlockL2Logs.fromBuffer(buffer) as L2BlockL2Logs<FromLogType<TLogType>>;
     }
+    return logs;
   }
 
   /**
@@ -249,7 +233,9 @@ export class LogStore {
       return { logs: [], maxLogsHit: false };
     }
 
-    const unencryptedLogsInBlock = this.#getBlockLogs(blockNumber, LogType.UNENCRYPTED);
+    const buffer = this.#unencryptedLogsByBlock.get(blockNumber) ?? Buffer.alloc(0);
+    const unencryptedLogsInBlock = UnencryptedL2BlockL2Logs.fromBuffer(buffer);
+
     const txLogs = unencryptedLogsInBlock.txLogs[txIndex].unrollLogs();
 
     const logs: ExtendedUnencryptedL2Log[] = [];
@@ -376,40 +362,4 @@ export class LogStore {
 
     return maxLogsHit;
   }
-
-  #getBlockLogs<TLogType extends LogType>(
-    blockNumber: number,
-    logType: TLogType,
-  ): L2BlockL2Logs<FromLogType<TLogType>> {
-    const logMap = (() => {
-      switch (logType) {
-        case LogType.ENCRYPTED:
-          return this.#encryptedLogsByBlock;
-        case LogType.NOTEENCRYPTED:
-          return this.#noteEncryptedLogsByBlock;
-        case LogType.UNENCRYPTED:
-        default:
-          return this.#unencryptedLogsByBlock;
-      }
-    })();
-    const logTypeMap = (() => {
-      switch (logType) {
-        case LogType.ENCRYPTED:
-          return EncryptedL2BlockL2Logs;
-        case LogType.NOTEENCRYPTED:
-          return EncryptedNoteL2BlockL2Logs;
-        case LogType.UNENCRYPTED:
-        default:
-          return UnencryptedL2BlockL2Logs;
-      }
-    })();
-    const L2BlockL2Logs = logTypeMap;
-    const buffer = logMap.get(blockNumber);
-
-    if (!buffer) {
-      return new L2BlockL2Logs([]) as L2BlockL2Logs<FromLogType<TLogType>>;
-    }
-
-    return L2BlockL2Logs.fromBuffer(buffer) as L2BlockL2Logs<FromLogType<TLogType>>;
-  }
 }