@aztec/archiver 0.65.2 → 0.66.0

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -1,12 +1,9 @@
 import {
-  type FromLogType,
   type GetUnencryptedLogsResponse,
   type InBlock,
   type InboxLeaf,
   type L2Block,
-  type L2BlockL2Logs,
   type LogFilter,
-  type LogType,
   type TxHash,
   type TxReceipt,
   type TxScopedL2Log,
@@ -17,6 +14,7 @@ import {
   type ExecutablePrivateFunctionWithMembershipProof,
   type Fr,
   type Header,
+  type PrivateLog,
   type UnconstrainedFunctionWithMembershipProof,
 } from '@aztec/circuits.js';
 import { type ContractArtifact, FunctionSelector } from '@aztec/foundation/abi';
@@ -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 { 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');
 
   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>>;
-  }
 }

package/src/archiver/memory_archiver_store/memory_archiver_store.ts

@@ -1,19 +1,13 @@
 import {
-  type Body,
   type ContractClass2BlockL2Logs,
-  type EncryptedL2BlockL2Logs,
-  type EncryptedNoteL2BlockL2Logs,
   ExtendedUnencryptedL2Log,
-  type FromLogType,
   type GetUnencryptedLogsResponse,
   type InBlock,
   type InboxLeaf,
   type L2Block,
   L2BlockHash,
-  type L2BlockL2Logs,
   type LogFilter,
   LogId,
-  LogType,
   type TxEffect,
   type TxHash,
   TxReceipt,
@@ -31,6 +25,7 @@ import {
   INITIAL_L2_BLOCK_NUM,
   MAX_NOTE_HASHES_PER_TX,
   MAX_NULLIFIERS_PER_TX,
+  type PrivateLog,
   type UnconstrainedFunctionWithMembershipProof,
 } from '@aztec/circuits.js';
 import { type ContractArtifact, FunctionSelector } from '@aztec/foundation/abi';
@@ -56,13 +51,11 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   private txEffects: InBlock<TxEffect>[] = [];
 
-  private noteEncryptedLogsPerBlock: Map<number, EncryptedNoteL2BlockL2Logs> = new Map();
-
   private taggedLogs: Map<string, TxScopedL2Log[]> = new Map();
 
   private logTagsPerBlock: Map<number, Fr[]> = new Map();
 
-  private encryptedLogsPerBlock: Map<number, EncryptedL2BlockL2Logs> = new Map();
+  private privateLogsPerBlock: Map<number, PrivateLog[]> = new Map();
 
   private unencryptedLogsPerBlock: Map<number, UnencryptedL2BlockL2Logs> = new Map();
 
@@ -232,46 +225,61 @@ export class MemoryArchiverStore implements ArchiverDataStore {
     return Promise.resolve(true);
   }
 
-  #storeTaggedLogs(block: L2Block, logType: keyof Pick<Body, 'noteEncryptedLogs' | 'unencryptedLogs'>): void {
+  #storeTaggedLogsFromPrivate(block: L2Block): void {
+    const dataStartIndexForBlock =
+      block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
+      block.body.numberOfTxsIncludingPadded * 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];
+        const currentLogs = this.taggedLogs.get(tag.toString()) || [];
+        this.taggedLogs.set(tag.toString(), [
+          ...currentLogs,
+          new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, /* isFromPublic */ false, log.toBuffer()),
+        ]);
+        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.numberOfTxsIncludingPadded * MAX_NOTE_HASHES_PER_TX;
-    block.body[logType].txLogs.forEach((txLogs, txIndex) => {
+    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) ||
           // TODO remove when #9835 and #9836 are fixed
-          (logType === 'unencryptedLogs' && log.data.length < 32 * 33)
+          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 invalid 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(`Storing tagged (${logType}) log with tag ${tag.toString()} in block ${block.number}`);
+          const tag = new Fr(correctedBuffer);
+          this.#log.verbose(`Storing unencrypted 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, logType === 'unencryptedLogs', log.data),
+            new TxScopedL2Log(txHash, dataStartIndexForTx, block.number, /* isFromPublic */ true, log.data),
           ]);
           const currentTagsInBlock = this.logTagsPerBlock.get(block.number) || [];
           this.logTagsPerBlock.set(block.number, [...currentTagsInBlock, tag]);
@@ -289,10 +297,9 @@ export class MemoryArchiverStore implements ArchiverDataStore {
    */
   addLogs(blocks: L2Block[]): Promise<boolean> {
     blocks.forEach(block => {
-      void this.#storeTaggedLogs(block, 'noteEncryptedLogs');
-      void this.#storeTaggedLogs(block, 'unencryptedLogs');
-      this.noteEncryptedLogsPerBlock.set(block.number, block.body.noteEncryptedLogs);
-      this.encryptedLogsPerBlock.set(block.number, block.body.encryptedLogs);
+      void this.#storeTaggedLogsFromPrivate(block);
+      void this.#storeTaggedLogsFromPublic(block);
+      this.privateLogsPerBlock.set(block.number, block.body.txEffects.map(txEffect => txEffect.privateLogs).flat());
       this.unencryptedLogsPerBlock.set(block.number, block.body.unencryptedLogs);
       this.contractClassLogsPerBlock.set(block.number, block.body.contractClassLogs);
     });
@@ -308,8 +315,7 @@ export class MemoryArchiverStore implements ArchiverDataStore {
       });
 
     blocks.forEach(block => {
-      this.encryptedLogsPerBlock.delete(block.number);
-      this.noteEncryptedLogsPerBlock.delete(block.number);
+      this.privateLogsPerBlock.delete(block.number);
       this.unencryptedLogsPerBlock.delete(block.number);
       this.logTagsPerBlock.delete(block.number);
       this.contractClassLogsPerBlock.delete(block.number);
@@ -471,17 +477,12 @@ export class MemoryArchiverStore implements ArchiverDataStore {
   }
 
   /**
-   * Gets up to `limit` amount of logs starting from `from`.
-   * @param from - 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>(
-    from: number,
-    limit: number,
-    logType: TLogType,
-  ): Promise<L2BlockL2Logs<FromLogType<TLogType>>[]> {
+  getPrivateLogs(from: number, limit: number): Promise<PrivateLog[]> {
     if (from < INITIAL_L2_BLOCK_NUM || limit < 1) {
       return Promise.resolve([]);
     }
@@ -490,34 +491,19 @@ export class MemoryArchiverStore implements ArchiverDataStore {
       return Promise.resolve([]);
     }
 
-    const logMap = (() => {
-      switch (logType) {
-        case LogType.ENCRYPTED:
-          return this.encryptedLogsPerBlock;
-        case LogType.NOTEENCRYPTED:
-          return this.noteEncryptedLogsPerBlock;
-        case LogType.UNENCRYPTED:
-        default:
-          return this.unencryptedLogsPerBlock;
-      }
-    })() as Map<number, L2BlockL2Logs<FromLogType<TLogType>>>;
-
     const startIndex = from;
     const endIndex = startIndex + limit;
     const upper = Math.min(endIndex, this.l2Blocks.length + INITIAL_L2_BLOCK_NUM);
 
-    const l = [];
+    const logsInBlocks = [];
     for (let i = startIndex; i < upper; i++) {
-      const log = logMap.get(i);
-      if (log) {
-        l.push(log);
-      } else {
-        // I hate typescript sometimes
-        l.push(undefined as unknown as L2BlockL2Logs<FromLogType<TLogType>>);
+      const logs = this.privateLogsPerBlock.get(i);
+      if (logs) {
+        logsInBlocks.push(logs);
       }
     }
 
-    return Promise.resolve(l);
+    return Promise.resolve(logsInBlocks.flat());
   }
 
   /**

package/src/index.ts

@@ -1,62 +1,8 @@
-import { jsonStringify } from '@aztec/foundation/json-rpc';
-import { createDebugLogger } from '@aztec/foundation/log';
-import { fileURLToPath } from '@aztec/foundation/url';
-import { NoopTelemetryClient } from '@aztec/telemetry-client/noop';
-
-import { createPublicClient, http } from 'viem';
-import { localhost } from 'viem/chains';
-
-import { Archiver, getArchiverConfigFromEnv } from './archiver/index.js';
-import { ArchiverInstrumentation } from './archiver/instrumentation.js';
-import { MemoryArchiverStore } from './archiver/memory_archiver_store/memory_archiver_store.js';
-
 export * from './archiver/index.js';
-export * from './rpc/index.js';
 export * from './factory.js';
+export * from './rpc/index.js';
 
-export { retrieveL2ProofVerifiedEvents, retrieveBlockFromRollup } from './archiver/data_retrieval.js';
-
-const log = createDebugLogger('aztec:archiver');
-
-/**
- * A function which instantiates and starts Archiver.
- */
-// eslint-disable-next-line require-await
-async function main() {
-  const config = getArchiverConfigFromEnv();
-  const { l1RpcUrl: rpcUrl, l1Contracts } = config;
-
-  log.info(`Starting archiver in main(): ${jsonStringify(config)}`);
-  const publicClient = createPublicClient({
-    chain: localhost,
-    transport: http(rpcUrl),
-  });
-
-  const archiverStore = new MemoryArchiverStore(1000);
-
-  const archiver = new Archiver(
-    publicClient,
-    l1Contracts.rollupAddress,
-    l1Contracts.inboxAddress,
-    l1Contracts.registryAddress,
-    archiverStore,
-    1000,
-    new ArchiverInstrumentation(new NoopTelemetryClient()),
-  );
-
-  const shutdown = async () => {
-    await archiver.stop();
-    process.exit(0);
-  };
-  process.once('SIGINT', shutdown);
-  process.once('SIGTERM', shutdown);
-}
-
-// See https://twitter.com/Rich_Harris/status/1355289863130673153
-if (process.argv[1] === fileURLToPath(import.meta.url).replace(/\/index\.js$/, '')) {
-  // eslint-disable-next-line @typescript-eslint/no-floating-promises
-  main().catch(err => {
-    log.error(err);
-    process.exit(1);
-  });
-}
+export {
+  retrieveBlocksFromRollup as retrieveBlockFromRollup,
+  retrieveL2ProofVerifiedEvents,
+} from './archiver/data_retrieval.js';

package/src/test/mock_l2_block_source.ts

@@ -7,12 +7,11 @@ import {
   TxReceipt,
   TxStatus,
 } from '@aztec/circuit-types';
+import { getSlotRangeForEpoch } from '@aztec/circuit-types';
 import { EthAddress, type Header } from '@aztec/circuits.js';
 import { DefaultL1ContractsConfig } from '@aztec/ethereum';
 import { createDebugLogger } from '@aztec/foundation/log';
 
-import { getSlotRangeForEpoch } from '../archiver/epoch_helpers.js';
-
 /**
  * A mocked implementation of L2BlockSource to be used in tests.
  */

package/dest/archiver/epoch_helpers.d.ts

@@ -1,20 +0,0 @@
-export type EpochConstants = {
-    l1GenesisBlock: bigint;
-    l1GenesisTime: bigint;
-    epochDuration: number;
-    slotDuration: number;
-};
-/** Returns the slot number for a given timestamp. */
-export declare function getSlotAtTimestamp(ts: bigint, constants: Pick<EpochConstants, 'l1GenesisTime' | 'slotDuration'>): bigint;
-/** Returns the epoch number for a given timestamp. */
-export declare function getEpochNumberAtTimestamp(ts: bigint, constants: Pick<EpochConstants, 'epochDuration' | 'slotDuration' | 'l1GenesisTime'>): bigint;
-/** Returns the range of L2 slots (inclusive) for a given epoch number. */
-export declare function getSlotRangeForEpoch(epochNumber: bigint, constants: Pick<EpochConstants, 'epochDuration'>): bigint[];
-/** Returns the range of L1 timestamps (inclusive) for a given epoch number. */
-export declare function getTimestampRangeForEpoch(epochNumber: bigint, constants: Pick<EpochConstants, 'l1GenesisTime' | 'slotDuration' | 'epochDuration'>): bigint[];
-/**
- * Returns the range of L1 blocks (inclusive) for a given epoch number.
- * @remarks This assumes no time warp has happened.
- */
-export declare function getL1BlockRangeForEpoch(epochNumber: bigint, constants: Pick<EpochConstants, 'l1GenesisBlock' | 'epochDuration' | 'slotDuration'>): bigint[];
-//# sourceMappingURL=epoch_helpers.d.ts.map

package/dest/archiver/epoch_helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"epoch_helpers.d.ts","sourceRoot":"","sources":["../../src/archiver/epoch_helpers.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,cAAc,GAAG;IAC3B,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,qDAAqD;AACrD,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,cAAc,EAAE,eAAe,GAAG,cAAc,CAAC,UAE/G;AAED,sDAAsD;AACtD,wBAAgB,yBAAyB,CACvC,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,IAAI,CAAC,cAAc,EAAE,eAAe,GAAG,cAAc,GAAG,eAAe,CAAC,UAGpF;AAED,0EAA0E;AAC1E,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,EAAE,SAAS,EAAE,IAAI,CAAC,cAAc,EAAE,eAAe,CAAC,YAGzG;AAED,+EAA+E;AAC/E,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,IAAI,CAAC,cAAc,EAAE,eAAe,GAAG,cAAc,GAAG,eAAe,CAAC,YAOpF;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,IAAI,CAAC,cAAc,EAAE,gBAAgB,GAAG,eAAe,GAAG,cAAc,CAAC,YAOrF"}