@aztec/archiver 0.62.0 → 0.63.0

package/src/archiver/archiver.ts

@@ -1,5 +1,5 @@
 import {
-  type EncryptedL2NoteLog,
+  type EncryptedL2Log,
   type FromLogType,
   type GetUnencryptedLogsResponse,
   type InboxLeaf,
@@ -15,6 +15,7 @@ import {
   type TxEffect,
   type TxHash,
   type TxReceipt,
+  type TxScopedL2Log,
   type UnencryptedL2Log,
 } from '@aztec/circuit-types';
 import {
@@ -160,6 +161,8 @@ export class Archiver implements ArchiveSource {
       rollup.read.GENESIS_TIME(),
     ] as const);
 
+    const { aztecEpochDuration: epochDuration, aztecSlotDuration: slotDuration, ethereumSlotDuration } = config;
+
     const archiver = new Archiver(
       publicClient,
       config.l1Contracts.rollupAddress,
@@ -168,7 +171,7 @@ export class Archiver implements ArchiveSource {
       archiverStore,
       config.archiverPollingIntervalMS ?? 10_000,
       new ArchiverInstrumentation(telemetry),
-      { l1StartBlock, l1GenesisTime },
+      { l1StartBlock, l1GenesisTime, epochDuration, slotDuration, ethereumSlotDuration },
     );
     await archiver.start(blockUntilSynced);
     return archiver;
@@ -246,6 +249,12 @@ export class Archiver implements ArchiveSource {
     // ********** Events that are processed per L1 block **********
     await this.handleL1ToL2Messages(blockUntilSynced, messagesSynchedTo, currentL1BlockNumber);
 
+    // Store latest l1 block number and timestamp seen. Used for epoch and slots calculations.
+    if (!this.l1BlockNumber || this.l1BlockNumber < currentL1BlockNumber) {
+      this.l1Timestamp = (await this.publicClient.getBlock({ blockNumber: currentL1BlockNumber })).timestamp;
+      this.l1BlockNumber = currentL1BlockNumber;
+    }
+
     // ********** Events that are processed per L2 block **********
     if (currentL1BlockNumber > blocksSynchedTo) {
       // First we retrieve new L2 blocks
@@ -257,21 +266,17 @@ export class Archiver implements ArchiveSource {
       // up to which point we're pruning, and then requesting L2 blocks up to that point only.
       await this.handleEpochPrune(provenBlockNumber, currentL1BlockNumber);
     }
-
-    // Store latest l1 block number and timestamp seen. Used for epoch and slots calculations.
-    if (!this.l1BlockNumber || this.l1BlockNumber < currentL1BlockNumber) {
-      this.l1Timestamp = await this.publicClient.getBlock({ blockNumber: currentL1BlockNumber }).then(b => b.timestamp);
-      this.l1BlockNumber = currentL1BlockNumber;
-    }
   }
 
   /** Checks if there'd be a reorg for the next block submission and start pruning now. */
   private async handleEpochPrune(provenBlockNumber: bigint, currentL1BlockNumber: bigint) {
     const localPendingBlockNumber = BigInt(await this.getBlockNumber());
 
+    const time = (this.l1Timestamp ?? 0n) + BigInt(this.l1constants.ethereumSlotDuration);
+
     const canPrune =
       localPendingBlockNumber > provenBlockNumber &&
-      (await this.rollup.read.canPrune({ blockNumber: currentL1BlockNumber }));
+      (await this.rollup.read.canPruneAtTime([time], { blockNumber: currentL1BlockNumber }));
 
     if (canPrune) {
       this.log.verbose(`L2 prune will occur on next submission. Rolling back to last proven block.`);
@@ -499,7 +504,7 @@ export class Archiver implements ArchiveSource {
   }
 
   public async getBlocksForEpoch(epochNumber: bigint): Promise<L2Block[]> {
-    const [start, end] = getSlotRangeForEpoch(epochNumber);
+    const [start, end] = getSlotRangeForEpoch(epochNumber, this.l1constants);
     const blocks: L2Block[] = [];
 
     // Walk the list of blocks backwards and filter by slots matching the requested epoch.
@@ -520,7 +525,7 @@ export class Archiver implements ArchiveSource {
     // The epoch is complete if the current L2 block is the last one in the epoch (or later)
     const header = await this.getBlockHeader('latest');
     const slot = header?.globalVariables.slotNumber.toBigInt();
-    const [_startSlot, endSlot] = getSlotRangeForEpoch(epochNumber);
+    const [_startSlot, endSlot] = getSlotRangeForEpoch(epochNumber, this.l1constants);
     if (slot && slot >= endSlot) {
       return true;
     }
@@ -634,7 +639,7 @@ export class Archiver implements ArchiveSource {
    * @returns For each received tag, an array of matching logs is returned. An empty array implies no logs match
    * that tag.
    */
-  getLogsByTags(tags: Fr[]): Promise<EncryptedL2NoteLog[][]> {
+  getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]> {
     return this.store.getLogsByTags(tags);
   }
 
@@ -647,6 +652,15 @@ export class Archiver implements ArchiveSource {
     return this.store.getUnencryptedLogs(filter);
   }
 
+  /**
+   * Gets contract class logs based on the provided filter.
+   * @param filter - The filter to apply to the logs.
+   * @returns The requested logs.
+   */
+  getContractClassLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+    return this.store.getContractClassLogs(filter);
+  }
+
   /**
    * Gets the number of the latest L2 block processed by the block source implementation.
    * @returns The number of the latest L2 block processed by the block source implementation.
@@ -785,7 +799,7 @@ class ArchiverStoreHelper
    * Extracts and stores contract instances out of ContractInstanceDeployed events emitted by the canonical deployer contract.
    * @param allLogs - All logs emitted in a bunch of blocks.
    */
-  async #updateDeployedContractInstances(allLogs: UnencryptedL2Log[], blockNum: number, operation: Operation) {
+  async #updateDeployedContractInstances(allLogs: EncryptedL2Log[], blockNum: number, operation: Operation) {
     const contractInstances = ContractInstanceDeployedEvent.fromLogs(allLogs).map(e => e.toContractInstance());
     if (contractInstances.length > 0) {
       contractInstances.forEach(c =>
@@ -864,15 +878,18 @@ class ArchiverStoreHelper
       // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
       ...(await Promise.all(
         blocks.map(async block => {
-          const blockLogs = block.data.body.txEffects
-            .flatMap(txEffect => (txEffect ? [txEffect.unencryptedLogs] : []))
+          const contractClassLogs = block.data.body.txEffects
+            .flatMap(txEffect => (txEffect ? [txEffect.contractClassLogs] : []))
+            .flatMap(txLog => txLog.unrollLogs());
+          // ContractInstanceDeployed event logs are now broadcast in .encryptedLogs
+          const allEncryptedLogs = block.data.body.txEffects
+            .flatMap(txEffect => (txEffect ? [txEffect.encryptedLogs] : []))
             .flatMap(txLog => txLog.unrollLogs());
-
           return (
             await Promise.all([
-              this.#updateRegisteredContractClasses(blockLogs, block.data.number, Operation.Store),
-              this.#updateDeployedContractInstances(blockLogs, block.data.number, Operation.Store),
-              this.#storeBroadcastedIndividualFunctions(blockLogs, block.data.number),
+              this.#updateRegisteredContractClasses(contractClassLogs, block.data.number, Operation.Store),
+              this.#updateDeployedContractInstances(allEncryptedLogs, block.data.number, Operation.Store),
+              this.#storeBroadcastedIndividualFunctions(contractClassLogs, block.data.number),
             ])
           ).every(Boolean);
         }),
@@ -894,11 +911,15 @@ class ArchiverStoreHelper
       // Unroll all logs emitted during the retrieved blocks and extract any contract classes and instances from them
       ...(await Promise.all(
         blocks.map(async block => {
-          const blockLogs = block.data.body.txEffects
-            .flatMap(txEffect => (txEffect ? [txEffect.unencryptedLogs] : []))
+          const contractClassLogs = block.data.body.txEffects
+            .flatMap(txEffect => (txEffect ? [txEffect.contractClassLogs] : []))
             .flatMap(txLog => txLog.unrollLogs());
-          await this.#updateRegisteredContractClasses(blockLogs, block.data.number, Operation.Delete);
-          await this.#updateDeployedContractInstances(blockLogs, block.data.number, Operation.Delete);
+          // ContractInstanceDeployed event logs are now broadcast in .encryptedLogs
+          const allEncryptedLogs = block.data.body.txEffects
+            .flatMap(txEffect => (txEffect ? [txEffect.encryptedLogs] : []))
+            .flatMap(txLog => txLog.unrollLogs());
+          await this.#updateRegisteredContractClasses(contractClassLogs, block.data.number, Operation.Delete);
+          await this.#updateDeployedContractInstances(allEncryptedLogs, block.data.number, Operation.Delete);
         }),
       )),
       this.store.deleteLogs(blocks.map(b => b.data)),
@@ -934,12 +955,15 @@ class ArchiverStoreHelper
   ): Promise<L2BlockL2Logs<FromLogType<TLogType>>[]> {
     return this.store.getLogs(from, limit, logType);
   }
-  getLogsByTags(tags: Fr[]): Promise<EncryptedL2NoteLog[][]> {
+  getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]> {
     return this.store.getLogsByTags(tags);
   }
   getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
     return this.store.getUnencryptedLogs(filter);
   }
+  getContractClassLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+    return this.store.getContractClassLogs(filter);
+  }
   getSynchedL2BlockNumber(): Promise<number> {
     return this.store.getSynchedL2BlockNumber();
   }
@@ -987,9 +1011,15 @@ class ArchiverStoreHelper
 type L1RollupConstants = {
   l1StartBlock: bigint;
   l1GenesisTime: bigint;
+  slotDuration: number;
+  epochDuration: number;
+  ethereumSlotDuration: number;
 };
 
 const EmptyL1RollupConstants: L1RollupConstants = {
   l1StartBlock: 0n,
   l1GenesisTime: 0n,
+  epochDuration: 0,
+  slotDuration: 0,
+  ethereumSlotDuration: 0,
 };

package/src/archiver/archiver_store.ts

@@ -1,5 +1,4 @@
 import {
-  type EncryptedL2NoteLog,
   type FromLogType,
   type GetUnencryptedLogsResponse,
   type InboxLeaf,
@@ -10,6 +9,7 @@ import {
   type TxEffect,
   type TxHash,
   type TxReceipt,
+  type TxScopedL2Log,
 } from '@aztec/circuit-types';
 import {
   type ContractClassPublic,
@@ -142,7 +142,7 @@ export interface ArchiverDataStore {
    * @returns For each received tag, an array of matching logs is returned. An empty array implies no logs match
    * that tag.
    */
-  getLogsByTags(tags: Fr[]): Promise<EncryptedL2NoteLog[][]>;
+  getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]>;
 
   /**
    * Gets unencrypted logs based on the provided filter.
@@ -151,6 +151,13 @@ export interface ArchiverDataStore {
    */
   getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse>;
 
+  /**
+   * Gets contract class logs based on the provided filter.
+   * @param filter - The filter to apply to the logs.
+   * @returns The requested logs.
+   */
+  getContractClassLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse>;
+
   /**
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.

package/src/archiver/archiver_store_test_suite.ts

@@ -344,14 +344,24 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
     describe('getLogsByTags', () => {
       const txsPerBlock = 4;
       const numPrivateFunctionCalls = 3;
-      const numNoteEncryptedLogs = 2;
+      const numPublicFunctionCalls = 1;
+      const numEncryptedLogsPerFn = 2;
+      const numUnencryptedLogsPerFn = 1;
       const numBlocks = 10;
       let blocks: L1Published<L2Block>[];
-      let tags: { [i: number]: { [j: number]: Buffer[] } } = {};
+      let encryptedLogTags: { [i: number]: { [j: number]: Buffer[] } } = {};
+      let unencryptedLogTags: { [i: number]: { [j: number]: Buffer[] } } = {};
 
       beforeEach(async () => {
         blocks = times(numBlocks, (index: number) => ({
-          data: L2Block.random(index + 1, txsPerBlock, numPrivateFunctionCalls, 2, numNoteEncryptedLogs, 2),
+          data: L2Block.random(
+            index + 1,
+            txsPerBlock,
+            numPrivateFunctionCalls,
+            numPublicFunctionCalls,
+            numEncryptedLogsPerFn,
+            numUnencryptedLogsPerFn,
+          ),
           l1: { blockNumber: BigInt(index), blockHash: `0x${index}`, timestamp: BigInt(index) },
         }));
         // Last block has the note encrypted log tags of the first tx copied from the previous block
@@ -373,46 +383,94 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         await store.addBlocks(blocks);
         await store.addLogs(blocks.map(b => b.data));
 
-        tags = {};
+        encryptedLogTags = {};
+        unencryptedLogTags = {};
         blocks.forEach((b, blockIndex) => {
-          if (!tags[blockIndex]) {
-            tags[blockIndex] = {};
+          if (!encryptedLogTags[blockIndex]) {
+            encryptedLogTags[blockIndex] = {};
+          }
+          if (!unencryptedLogTags[blockIndex]) {
+            unencryptedLogTags[blockIndex] = {};
           }
           b.data.body.noteEncryptedLogs.txLogs.forEach((txLogs, txIndex) => {
-            if (!tags[blockIndex][txIndex]) {
-              tags[blockIndex][txIndex] = [];
+            if (!encryptedLogTags[blockIndex][txIndex]) {
+              encryptedLogTags[blockIndex][txIndex] = [];
+            }
+            encryptedLogTags[blockIndex][txIndex].push(...txLogs.unrollLogs().map(log => log.data.subarray(0, 32)));
+          });
+          b.data.body.unencryptedLogs.txLogs.forEach((txLogs, txIndex) => {
+            if (!unencryptedLogTags[blockIndex][txIndex]) {
+              unencryptedLogTags[blockIndex][txIndex] = [];
             }
-            tags[blockIndex][txIndex].push(...txLogs.unrollLogs().map(log => log.data.subarray(0, 32)));
+            unencryptedLogTags[blockIndex][txIndex].push(...txLogs.unrollLogs().map(log => log.data.subarray(0, 32)));
           });
         });
       });
 
-      it('is possible to batch request all logs of a tx via tags', async () => {
+      it('is possible to batch request encrypted logs of a tx via tags', async () => {
         // get random tx from any block that's not the last one
         const targetBlockIndex = randomInt(numBlocks - 2);
         const targetTxIndex = randomInt(txsPerBlock);
 
         const logsByTags = await store.getLogsByTags(
-          tags[targetBlockIndex][targetTxIndex].map(buffer => new Fr(buffer)),
+          encryptedLogTags[targetBlockIndex][targetTxIndex].map(buffer => new Fr(buffer)),
         );
 
-        const expectedResponseSize = numPrivateFunctionCalls * numNoteEncryptedLogs;
+        const expectedResponseSize = numPrivateFunctionCalls * numEncryptedLogsPerFn;
         expect(logsByTags.length).toEqual(expectedResponseSize);
 
         logsByTags.forEach((logsByTag, logIndex) => {
           expect(logsByTag).toHaveLength(1);
-          const [log] = logsByTag;
-          expect(log).toEqual(
-            blocks[targetBlockIndex].data.body.noteEncryptedLogs.txLogs[targetTxIndex].unrollLogs()[logIndex],
+          const [scopedLog] = logsByTag;
+          expect(scopedLog.txHash).toEqual(blocks[targetBlockIndex].data.body.txEffects[targetTxIndex].txHash);
+          expect(scopedLog.logData).toEqual(
+            blocks[targetBlockIndex].data.body.noteEncryptedLogs.txLogs[targetTxIndex].unrollLogs()[logIndex].data,
+          );
+        });
+      });
+
+      // TODO: Allow this test when #9835 is fixed and tags can be correctly decoded
+      it.skip('is possible to batch request all logs (encrypted and unencrypted) of a tx via tags', async () => {
+        // get random tx from any block that's not the last one
+        const targetBlockIndex = randomInt(numBlocks - 2);
+        const targetTxIndex = randomInt(txsPerBlock);
+
+        const logsByTags = await store.getLogsByTags(
+          encryptedLogTags[targetBlockIndex][targetTxIndex]
+            .concat(unencryptedLogTags[targetBlockIndex][targetTxIndex])
+            .map(buffer => new Fr(buffer)),
+        );
+
+        const expectedResponseSize =
+          numPrivateFunctionCalls * numEncryptedLogsPerFn + numPublicFunctionCalls * numUnencryptedLogsPerFn;
+        expect(logsByTags.length).toEqual(expectedResponseSize);
+
+        const encryptedLogsByTags = logsByTags.slice(0, numPrivateFunctionCalls * numEncryptedLogsPerFn);
+        const unencryptedLogsByTags = logsByTags.slice(numPrivateFunctionCalls * numEncryptedLogsPerFn);
+        encryptedLogsByTags.forEach((logsByTag, logIndex) => {
+          expect(logsByTag).toHaveLength(1);
+          const [scopedLog] = logsByTag;
+          expect(scopedLog.txHash).toEqual(blocks[targetBlockIndex].data.body.txEffects[targetTxIndex].txHash);
+          expect(scopedLog.logData).toEqual(
+            blocks[targetBlockIndex].data.body.noteEncryptedLogs.txLogs[targetTxIndex].unrollLogs()[logIndex].data,
+          );
+        });
+        unencryptedLogsByTags.forEach((logsByTag, logIndex) => {
+          expect(logsByTag).toHaveLength(1);
+          const [scopedLog] = logsByTag;
+          expect(scopedLog.logData).toEqual(
+            blocks[targetBlockIndex].data.body.unencryptedLogs.txLogs[targetTxIndex].unrollLogs()[logIndex].data,
           );
         });
       });
 
-      it('is possible to batch request all logs of different blocks via tags', async () => {
+      it('is possible to batch request logs of different blocks via tags', async () => {
         // get first tx of first block and second tx of second block
-        const logsByTags = await store.getLogsByTags([...tags[0][0], ...tags[1][1]].map(buffer => new Fr(buffer)));
+        const logsByTags = await store.getLogsByTags(
+          [...encryptedLogTags[0][0], ...encryptedLogTags[1][1]].map(buffer => new Fr(buffer)),
+        );
 
-        const expectedResponseSize = 2 * numPrivateFunctionCalls * numNoteEncryptedLogs;
+        const expectedResponseSize = 2 * numPrivateFunctionCalls * numEncryptedLogsPerFn;
         expect(logsByTags.length).toEqual(expectedResponseSize);
 
         logsByTags.forEach(logsByTag => expect(logsByTag).toHaveLength(1));
@@ -420,14 +478,14 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
 
       it('is possible to batch request logs that have the same tag but different content', async () => {
         // get first tx of last block
-        const logsByTags = await store.getLogsByTags(tags[numBlocks - 1][0].map(buffer => new Fr(buffer)));
+        const logsByTags = await store.getLogsByTags(encryptedLogTags[numBlocks - 1][0].map(buffer => new Fr(buffer)));
 
-        const expectedResponseSize = numPrivateFunctionCalls * numNoteEncryptedLogs;
+        const expectedResponseSize = numPrivateFunctionCalls * numEncryptedLogsPerFn;
         expect(logsByTags.length).toEqual(expectedResponseSize);
 
         logsByTags.forEach(logsByTag => {
           expect(logsByTag).toHaveLength(2);
-          const [tag0, tag1] = logsByTag.map(log => new Fr(log.data.subarray(0, 32)));
+          const [tag0, tag1] = logsByTag.map(scopedLog => new Fr(scopedLog.logData.subarray(0, 32)));
           expect(tag0).toEqual(tag1);
         });
       });
@@ -439,10 +497,10 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
 
         const logsByTags = await store.getLogsByTags([
           Fr.random(),
-          ...tags[targetBlockIndex][targetTxIndex].slice(1).map(buffer => new Fr(buffer)),
+          ...encryptedLogTags[targetBlockIndex][targetTxIndex].slice(1).map(buffer => new Fr(buffer)),
         ]);
 
-        const expectedResponseSize = numPrivateFunctionCalls * numNoteEncryptedLogs;
+        const expectedResponseSize = numPrivateFunctionCalls * numEncryptedLogsPerFn;
         expect(logsByTags.length).toEqual(expectedResponseSize);
 
         const [emptyLogsByTag, ...populatedLogsByTags] = logsByTags;
@@ -450,9 +508,10 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
 
         populatedLogsByTags.forEach((logsByTag, logIndex) => {
           expect(logsByTag).toHaveLength(1);
-          const [log] = logsByTag;
-          expect(log).toEqual(
-            blocks[targetBlockIndex].data.body.noteEncryptedLogs.txLogs[targetTxIndex].unrollLogs()[logIndex + 1],
+          const [scopedLog] = logsByTag;
+          expect(scopedLog.txHash).toEqual(blocks[targetBlockIndex].data.body.txEffects[targetTxIndex].txHash);
+          expect(scopedLog.logData).toEqual(
+            blocks[targetBlockIndex].data.body.noteEncryptedLogs.txLogs[targetTxIndex].unrollLogs()[logIndex + 1].data,
           );
         });
       });

package/src/archiver/config.ts

@@ -1,4 +1,10 @@
-import { type L1ContractAddresses, type L1ReaderConfig, l1ReaderConfigMappings } from '@aztec/ethereum';
+import {
+  type L1ContractAddresses,
+  type L1ContractsConfig,
+  type L1ReaderConfig,
+  l1ContractsConfigMappings,
+  l1ReaderConfigMappings,
+} from '@aztec/ethereum';
 import { type ConfigMappingsType, getConfigFromMappings, numberConfigHelper } from '@aztec/foundation/config';
 
 /**
@@ -32,14 +38,10 @@ export type ArchiverConfig = {
    */
   l1Contracts: L1ContractAddresses;
 
-  /**
-   * Optional dir to store data. If omitted will store in memory.
-   */
-  dataDirectory: string | undefined;
-
   /** The max number of logs that can be obtained in 1 "getUnencryptedLogs" call. */
   maxLogs?: number;
-} & L1ReaderConfig;
+} & L1ReaderConfig &
+  L1ContractsConfig;
 
 export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
   archiverUrl: {
@@ -50,11 +52,7 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
   archiverPollingIntervalMS: {
     env: 'ARCHIVER_POLLING_INTERVAL_MS',
     description: 'The polling interval in ms for retrieving new L2 blocks and encrypted logs.',
-    ...numberConfigHelper(1000),
-  },
-  dataDirectory: {
-    env: 'DATA_DIRECTORY',
-    description: 'Optional dir to store data. If omitted will store in memory.',
+    ...numberConfigHelper(1_000),
   },
   maxLogs: {
     env: 'ARCHIVER_MAX_LOGS',
@@ -67,6 +65,7 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     description: 'The polling interval viem uses in ms',
     ...numberConfigHelper(1000),
   },
+  ...l1ContractsConfigMappings,
 };
 
 /**

package/src/archiver/epoch_helpers.ts

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

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -1,5 +1,4 @@
 import {
-  type EncryptedL2NoteLog,
   type FromLogType,
   type GetUnencryptedLogsResponse,
   type InboxLeaf,
@@ -10,6 +9,7 @@ import {
   type TxEffect,
   type TxHash,
   type TxReceipt,
+  type TxScopedL2Log,
 } from '@aztec/circuit-types';
 import {
   type ContractClassPublic,
@@ -245,7 +245,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @returns For each received tag, an array of matching logs is returned. An empty array implies no logs match
    * that tag.
    */
-  getLogsByTags(tags: Fr[]): Promise<EncryptedL2NoteLog[][]> {
+  getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]> {
     try {
       return this.#logStore.getLogsByTags(tags);
     } catch (err) {
@@ -266,6 +266,19 @@ export class KVArchiverDataStore implements ArchiverDataStore {
     }
   }
 
+  /**
+   * Gets contract class logs based on the provided filter.
+   * @param filter - The filter to apply to the logs.
+   * @returns The requested logs.
+   */
+  getContractClassLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+    try {
+      return Promise.resolve(this.#logStore.getContractClassLogs(filter));
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+
   /**
    * Gets the number of the latest L2 block processed.
    * @returns The number of the latest L2 block processed.