@aztec/archiver 0.0.0-test.1 → 0.0.1-commit.1142ef1

package/src/archiver/kv_archiver_store/log_store.ts

@@ -1,9 +1,11 @@
-import { INITIAL_L2_BLOCK_NUM, MAX_NOTE_HASHES_PER_TX, PUBLIC_LOG_DATA_SIZE_IN_FIELDS } from '@aztec/constants';
-import type { Fr } from '@aztec/foundation/fields';
+import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
+import { BlockNumber } from '@aztec/foundation/branded-types';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import { BufferReader, numToUInt32BE } from '@aztec/foundation/serialize';
 import type { AztecAsyncKVStore, AztecAsyncMap } from '@aztec/kv-store';
-import type { L2Block } from '@aztec/stdlib/block';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { L2BlockHash, L2BlockNew } from '@aztec/stdlib/block';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
 import {
   ContractClassLog,
@@ -11,8 +13,9 @@ import {
   ExtendedPublicLog,
   type LogFilter,
   LogId,
-  PrivateLog,
   PublicLog,
+  type SiloedTag,
+  Tag,
   TxScopedL2Log,
 } from '@aztec/stdlib/logs';
 
@@ -22,98 +25,123 @@ import type { BlockStore } from './block_store.js';
  * A store for logs
  */
 export class LogStore {
-  #logsByTag: AztecAsyncMap<string, Buffer[]>;
-  #logTagsByBlock: AztecAsyncMap<number, string[]>;
-  #privateLogsByBlock: AztecAsyncMap<number, Buffer>;
+  // `tag` --> private logs
+  #privateLogsByTag: AztecAsyncMap<string, Buffer[]>;
+  // `{contractAddress}_${tag}` --> public logs
+  #publicLogsByContractAndTag: AztecAsyncMap<string, Buffer[]>;
+  #privateLogKeysByBlock: AztecAsyncMap<number, string[]>;
+  #publicLogKeysByBlock: AztecAsyncMap<number, string[]>;
   #publicLogsByBlock: AztecAsyncMap<number, Buffer>;
   #contractClassLogsByBlock: AztecAsyncMap<number, Buffer>;
   #logsMaxPageSize: number;
   #log = createLogger('archiver:log_store');
 
-  constructor(private db: AztecAsyncKVStore, private blockStore: BlockStore, logsMaxPageSize: number = 1000) {
-    this.#logsByTag = db.openMap('archiver_tagged_logs_by_tag');
-    this.#logTagsByBlock = db.openMap('archiver_log_tags_by_block');
-    this.#privateLogsByBlock = db.openMap('archiver_private_logs_by_block');
+  constructor(
+    private db: AztecAsyncKVStore,
+    private blockStore: BlockStore,
+    logsMaxPageSize: number = 1000,
+  ) {
+    this.#privateLogsByTag = db.openMap('archiver_private_tagged_logs_by_tag');
+    this.#publicLogsByContractAndTag = db.openMap('archiver_public_tagged_logs_by_tag');
+    this.#privateLogKeysByBlock = db.openMap('archiver_private_log_keys_by_block');
+    this.#publicLogKeysByBlock = db.openMap('archiver_public_log_keys_by_block');
     this.#publicLogsByBlock = db.openMap('archiver_public_logs_by_block');
     this.#contractClassLogsByBlock = db.openMap('archiver_contract_class_logs_by_block');
 
     this.#logsMaxPageSize = logsMaxPageSize;
   }
 
-  #extractTaggedLogsFromPrivate(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) => {
+  /**
+   * Extracts tagged logs from a single block, grouping them into private and public maps.
+   *
+   * @param block - The L2 block to extract logs from.
+   * @returns An object containing the private and public tagged logs for the block.
+   */
+  #extractTaggedLogsFromBlock(block: L2BlockNew) {
+    // SiloedTag (as string) -> array of log buffers.
+    const privateTaggedLogs = new Map<string, Buffer[]>();
+    // "{contractAddress}_{tag}" (as string) -> array of log buffers.
+    const publicTaggedLogs = new Map<string, Buffer[]>();
+
+    block.body.txEffects.forEach(txEffect => {
       const txHash = txEffect.txHash;
-      const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
+
       txEffect.privateLogs.forEach(log => {
+        // Private logs use SiloedTag (already siloed by kernel)
         const tag = log.fields[0];
-        const currentLogs = taggedLogs.get(tag.toString()) ?? [];
+        this.#log.debug(`Found private log with tag ${tag.toString()} in block ${block.number}`);
+
+        const currentLogs = privateTaggedLogs.get(tag.toString()) ?? [];
         currentLogs.push(
           new TxScopedL2Log(
             txHash,
-            dataStartIndexForTx,
             block.number,
-            /* isFromPublic */ false,
-            log.toBuffer(),
+            block.timestamp,
+            log.getEmittedFields(),
+            txEffect.noteHashes,
+            txEffect.nullifiers[0],
           ).toBuffer(),
         );
-        taggedLogs.set(tag.toString(), currentLogs);
+        privateTaggedLogs.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];
+        // Public logs use Tag directly (not siloed) and are stored with contract address
+        const tag = log.fields[0];
+        const contractAddress = log.contractAddress;
+        const key = `${contractAddress.toString()}_${tag.toString()}`;
+        this.#log.debug(
+          `Found public log with tag ${tag.toString()} from contract ${contractAddress.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()) ?? [];
+        const currentLogs = publicTaggedLogs.get(key) ?? [];
         currentLogs.push(
           new TxScopedL2Log(
             txHash,
-            dataStartIndexForTx,
             block.number,
-            /* isFromPublic */ true,
-            log.toBuffer(),
+            block.timestamp,
+            log.getEmittedFields(),
+            txEffect.noteHashes,
+            txEffect.nullifiers[0],
           ).toBuffer(),
         );
-        taggedLogs.set(tag.toString(), currentLogs);
+        publicTaggedLogs.set(key, currentLogs);
       });
     });
-    return taggedLogs;
+
+    return { privateTaggedLogs, publicTaggedLogs };
+  }
+
+  /**
+   * Extracts and aggregates tagged logs from a list of blocks.
+   * @param blocks - The blocks to extract logs from.
+   * @returns A map from tag (as string) to an array of serialized private logs belonging to that tag, and a map from
+   * "{contractAddress}_{tag}" (as string) to an array of serialized public logs belonging to that key.
+   */
+  #extractTaggedLogs(blocks: L2BlockNew[]): {
+    privateTaggedLogs: Map<string, Buffer[]>;
+    publicTaggedLogs: Map<string, Buffer[]>;
+  } {
+    const taggedLogsInBlocks = blocks.map(block => this.#extractTaggedLogsFromBlock(block));
+
+    // Now we merge the maps from each block into a single map.
+    const privateTaggedLogs = taggedLogsInBlocks.reduce((acc, { privateTaggedLogs }) => {
+      for (const [tag, logs] of privateTaggedLogs.entries()) {
+        const currentLogs = acc.get(tag) ?? [];
+        acc.set(tag, currentLogs.concat(logs));
+      }
+      return acc;
+    }, new Map<string, Buffer[]>());
+
+    const publicTaggedLogs = taggedLogsInBlocks.reduce((acc, { publicTaggedLogs }) => {
+      for (const [key, logs] of publicTaggedLogs.entries()) {
+        const currentLogs = acc.get(key) ?? [];
+        acc.set(key, currentLogs.concat(logs));
+      }
+      return acc;
+    }, new Map<string, Buffer[]>());
+
+    return { privateTaggedLogs, publicTaggedLogs };
   }
 
   /**
@@ -121,43 +149,59 @@ export class LogStore {
    * @param blocks - The blocks for which to add the logs.
    * @returns True if the operation is successful.
    */
-  addLogs(blocks: L2Block[]): Promise<boolean> {
-    const taggedLogsToAdd = blocks
-      .flatMap(block => [this.#extractTaggedLogsFromPrivate(block), this.#extractTaggedLogsFromPublic(block)])
-      .reduce((acc, val) => {
-        for (const [tag, logs] of val.entries()) {
-          const currentLogs = acc.get(tag) ?? [];
-          acc.set(tag, currentLogs.concat(logs));
-        }
-        return acc;
-      });
-    const tagsToUpdate = Array.from(taggedLogsToAdd.keys());
+  addLogs(blocks: L2BlockNew[]): Promise<boolean> {
+    const { privateTaggedLogs, publicTaggedLogs } = this.#extractTaggedLogs(blocks);
+
+    const keysOfPrivateLogsToUpdate = Array.from(privateTaggedLogs.keys());
+    const keysOfPublicLogsToUpdate = Array.from(publicTaggedLogs.keys());
 
     return this.db.transactionAsync(async () => {
-      const currentTaggedLogs = await Promise.all(
-        tagsToUpdate.map(async tag => ({ tag, logBuffers: await this.#logsByTag.getAsync(tag) })),
+      const currentPrivateTaggedLogs = await Promise.all(
+        keysOfPrivateLogsToUpdate.map(async key => ({
+          tag: key,
+          logBuffers: await this.#privateLogsByTag.getAsync(key),
+        })),
       );
-      currentTaggedLogs.forEach(taggedLogBuffer => {
+      currentPrivateTaggedLogs.forEach(taggedLogBuffer => {
         if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
-          taggedLogsToAdd.set(
+          privateTaggedLogs.set(
             taggedLogBuffer.tag,
-            taggedLogBuffer.logBuffers!.concat(taggedLogsToAdd.get(taggedLogBuffer.tag)!),
+            taggedLogBuffer.logBuffers!.concat(privateTaggedLogs.get(taggedLogBuffer.tag)!),
+          );
+        }
+      });
+
+      const currentPublicTaggedLogs = await Promise.all(
+        keysOfPublicLogsToUpdate.map(async key => ({
+          key,
+          logBuffers: await this.#publicLogsByContractAndTag.getAsync(key),
+        })),
+      );
+      currentPublicTaggedLogs.forEach(taggedLogBuffer => {
+        if (taggedLogBuffer.logBuffers && taggedLogBuffer.logBuffers.length > 0) {
+          publicTaggedLogs.set(
+            taggedLogBuffer.key,
+            taggedLogBuffer.logBuffers!.concat(publicTaggedLogs.get(taggedLogBuffer.key)!),
           );
         }
       });
+
       for (const block of blocks) {
-        const tagsInBlock = [];
-        for (const [tag, logs] of taggedLogsToAdd.entries()) {
-          await this.#logsByTag.set(tag, logs);
-          tagsInBlock.push(tag);
+        const blockHash = await block.hash();
+
+        const privateTagsInBlock: string[] = [];
+        for (const [tag, logs] of privateTaggedLogs.entries()) {
+          await this.#privateLogsByTag.set(tag, logs);
+          privateTagsInBlock.push(tag);
         }
-        await this.#logTagsByBlock.set(block.number, tagsInBlock);
+        await this.#privateLogKeysByBlock.set(block.number, privateTagsInBlock);
 
-        const privateLogsInBlock = block.body.txEffects
-          .map(txEffect => txEffect.privateLogs)
-          .flat()
-          .map(log => log.toBuffer());
-        await this.#privateLogsByBlock.set(block.number, Buffer.concat(privateLogsInBlock));
+        const publicKeysInBlock: string[] = [];
+        for (const [key, logs] of publicTaggedLogs.entries()) {
+          await this.#publicLogsByContractAndTag.set(key, logs);
+          publicKeysInBlock.push(key);
+        }
+        await this.#publicLogKeysByBlock.set(block.number, publicKeysInBlock);
 
         const publicLogsInBlock = block.body.txEffects
           .map((txEffect, txIndex) =>
@@ -179,68 +223,82 @@ export class LogStore {
           )
           .flat();
 
-        await this.#publicLogsByBlock.set(block.number, Buffer.concat(publicLogsInBlock));
-        await this.#contractClassLogsByBlock.set(block.number, Buffer.concat(contractClassLogsInBlock));
+        await this.#publicLogsByBlock.set(block.number, this.#packWithBlockHash(blockHash, publicLogsInBlock));
+        await this.#contractClassLogsByBlock.set(
+          block.number,
+          this.#packWithBlockHash(blockHash, contractClassLogsInBlock),
+        );
       }
 
       return true;
     });
   }
 
-  deleteLogs(blocks: L2Block[]): Promise<boolean> {
+  #packWithBlockHash(blockHash: Fr, data: Buffer<ArrayBufferLike>[]): Buffer<ArrayBufferLike> {
+    return Buffer.concat([blockHash.toBuffer(), ...data]);
+  }
+
+  #unpackBlockHash(reader: BufferReader): L2BlockHash {
+    const blockHash = reader.remainingBytes() > 0 ? reader.readObject(Fr) : undefined;
+
+    if (!blockHash) {
+      throw new Error('Failed to read block hash from log entry buffer');
+    }
+
+    return L2BlockHash.fromField(blockHash);
+  }
+
+  deleteLogs(blocks: L2BlockNew[]): Promise<boolean> {
     return this.db.transactionAsync(async () => {
-      const tagsToDelete = (
-        await Promise.all(
-          blocks.map(async block => {
-            const tags = await this.#logTagsByBlock.getAsync(block.number);
-            return tags ?? [];
-          }),
-        )
-      ).flat();
+      await Promise.all(
+        blocks.map(async block => {
+          // Delete private logs
+          const privateKeys = (await this.#privateLogKeysByBlock.getAsync(block.number)) ?? [];
+          await Promise.all(privateKeys.map(tag => this.#privateLogsByTag.delete(tag)));
+
+          // Delete public logs
+          const publicKeys = (await this.#publicLogKeysByBlock.getAsync(block.number)) ?? [];
+          await Promise.all(publicKeys.map(key => this.#publicLogsByContractAndTag.delete(key)));
+        }),
+      );
 
       await Promise.all(
         blocks.map(block =>
           Promise.all([
-            this.#privateLogsByBlock.delete(block.number),
             this.#publicLogsByBlock.delete(block.number),
-            this.#logTagsByBlock.delete(block.number),
+            this.#privateLogKeysByBlock.delete(block.number),
+            this.#publicLogKeysByBlock.delete(block.number),
+            this.#contractClassLogsByBlock.delete(block.number),
           ]),
         ),
       );
 
-      await Promise.all(tagsToDelete.map(tag => this.#logsByTag.delete(tag.toString())));
       return true;
     });
   }
 
   /**
-   * 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.
+   * Gets all private logs that match any of the `tags`. For each tag, an array of matching logs is returned. An empty
+   * array implies no logs match that tag.
    */
-  async getPrivateLogs(start: number, limit: number): Promise<PrivateLog[]> {
-    const logs = [];
-    for await (const buffer of this.#privateLogsByBlock.valuesAsync({ start, limit })) {
-      const reader = new BufferReader(buffer);
-      while (reader.remainingBytes() > 0) {
-        logs.push(reader.readObject(PrivateLog));
-      }
-    }
-    return logs;
+  async getPrivateLogsByTags(tags: SiloedTag[]): Promise<TxScopedL2Log[][]> {
+    const logs = await Promise.all(tags.map(tag => this.#privateLogsByTag.getAsync(tag.toString())));
+
+    return logs.map(logBuffers => logBuffers?.map(logBuffer => TxScopedL2Log.fromBuffer(logBuffer)) ?? []);
   }
 
   /**
-   * Gets all logs that match any of the received tags (i.e. logs with their first field equal to a tag).
-   * @param tags - The tags to filter the logs by.
-   * @returns For each received tag, an array of matching logs is returned. An empty array implies no logs match
-   * that tag.
+   * Gets all public logs that match any of the `tags` from the specified contract. For each tag, an array of matching
+   * logs is returned. An empty array implies no logs match that tag.
    */
-  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)) ?? [],
+  async getPublicLogsByTagsFromContract(contractAddress: AztecAddress, tags: Tag[]): Promise<TxScopedL2Log[][]> {
+    const logs = await Promise.all(
+      tags.map(tag => {
+        const key = `${contractAddress.toString()}_${tag.value.toString()}`;
+        return this.#publicLogsByContractAndTag.getAsync(key);
+      }),
     );
+    return logs.map(logBuffers => logBuffers?.map(logBuffer => TxScopedL2Log.fromBuffer(logBuffer)) ?? []);
   }
 
   /**
@@ -271,6 +329,9 @@ export class LogStore {
     const buffer = (await this.#publicLogsByBlock.getAsync(blockNumber)) ?? Buffer.alloc(0);
     const publicLogsInBlock: [PublicLog[]] = [[]];
     const reader = new BufferReader(buffer);
+
+    const blockHash = this.#unpackBlockHash(reader);
+
     while (reader.remainingBytes() > 0) {
       const indexOfTx = reader.readNumber();
       const numLogsInTx = reader.readNumber();
@@ -283,7 +344,7 @@ export class LogStore {
     const txLogs = publicLogsInBlock[txIndex];
 
     const logs: ExtendedPublicLog[] = [];
-    const maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+    const maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
 
     return { logs, maxLogsHit };
   }
@@ -306,6 +367,9 @@ export class LogStore {
     loopOverBlocks: for await (const [blockNumber, logBuffer] of this.#publicLogsByBlock.entriesAsync({ start, end })) {
       const publicLogsInBlock: [PublicLog[]] = [[]];
       const reader = new BufferReader(logBuffer);
+
+      const blockHash = this.#unpackBlockHash(reader);
+
       while (reader.remainingBytes() > 0) {
         const indexOfTx = reader.readNumber();
         const numLogsInTx = reader.readNumber();
@@ -316,7 +380,7 @@ export class LogStore {
       }
       for (let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < publicLogsInBlock.length; txIndex++) {
         const txLogs = publicLogsInBlock[txIndex];
-        maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+        maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
         if (maxLogsHit) {
           this.#log.debug(`Max logs hit at block ${blockNumber}`);
           break loopOverBlocks;
@@ -355,6 +419,8 @@ export class LogStore {
     const contractClassLogsInBlock: [ContractClassLog[]] = [[]];
 
     const reader = new BufferReader(contractClassLogsBuffer);
+    const blockHash = this.#unpackBlockHash(reader);
+
     while (reader.remainingBytes() > 0) {
       const indexOfTx = reader.readNumber();
       const numLogsInTx = reader.readNumber();
@@ -367,7 +433,7 @@ export class LogStore {
     const txLogs = contractClassLogsInBlock[txIndex];
 
     const logs: ExtendedContractClassLog[] = [];
-    const maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+    const maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
 
     return { logs, maxLogsHit };
   }
@@ -393,6 +459,7 @@ export class LogStore {
     })) {
       const contractClassLogsInBlock: [ContractClassLog[]] = [[]];
       const reader = new BufferReader(logBuffer);
+      const blockHash = this.#unpackBlockHash(reader);
       while (reader.remainingBytes() > 0) {
         const indexOfTx = reader.readNumber();
         const numLogsInTx = reader.readNumber();
@@ -403,7 +470,7 @@ export class LogStore {
       }
       for (let txIndex = filter.afterLog?.txIndex ?? 0; txIndex < contractClassLogsInBlock.length; txIndex++) {
         const txLogs = contractClassLogsInBlock[txIndex];
-        maxLogsHit = this.#accumulateLogs(logs, blockNumber, txIndex, txLogs, filter);
+        maxLogsHit = this.#accumulateLogs(logs, blockNumber, blockHash, txIndex, txLogs, filter);
         if (maxLogsHit) {
           this.#log.debug(`Max logs hit at block ${blockNumber}`);
           break loopOverBlocks;
@@ -417,9 +484,10 @@ export class LogStore {
   #accumulateLogs(
     results: (ExtendedContractClassLog | ExtendedPublicLog)[],
     blockNumber: number,
+    blockHash: L2BlockHash,
     txIndex: number,
     txLogs: (ContractClassLog | PublicLog)[],
-    filter: LogFilter,
+    filter: LogFilter = {},
   ): boolean {
     let maxLogsHit = false;
     let logIndex = typeof filter.afterLog?.logIndex === 'number' ? filter.afterLog.logIndex + 1 : 0;
@@ -427,9 +495,13 @@ export class LogStore {
       const log = txLogs[logIndex];
       if (!filter.contractAddress || log.contractAddress.equals(filter.contractAddress)) {
         if (log instanceof ContractClassLog) {
-          results.push(new ExtendedContractClassLog(new LogId(blockNumber, txIndex, logIndex), log));
+          results.push(
+            new ExtendedContractClassLog(new LogId(BlockNumber(blockNumber), blockHash, txIndex, logIndex), log),
+          );
+        } else if (log instanceof PublicLog) {
+          results.push(new ExtendedPublicLog(new LogId(BlockNumber(blockNumber), blockHash, txIndex, logIndex), log));
         } else {
-          results.push(new ExtendedPublicLog(new LogId(blockNumber, txIndex, logIndex), log));
+          throw new Error('Unknown log type');
         }
 
         if (results.length >= this.#logsMaxPageSize) {