@aztec/archiver 3.0.0-nightly.20251223 → 3.0.0-nightly.20251224

package/src/archiver/archiver_store_test_suite.ts

@@ -30,7 +30,7 @@ import {
   SerializableContractInstance,
   computePublicBytecodeCommitment,
 } from '@aztec/stdlib/contract';
-import { ContractClassLog, LogId, PrivateLog, PublicLog } from '@aztec/stdlib/logs';
+import { ContractClassLog, LogId, PrivateLog, PublicLog, SiloedTag, Tag } from '@aztec/stdlib/logs';
 import { InboxLeaf } from '@aztec/stdlib/messaging';
 import { CheckpointHeader } from '@aztec/stdlib/rollup';
 import {
@@ -2198,46 +2198,35 @@ export function describeArchiverDataStore(
       });
     });
 
-    describe('getLogsByTags', () => {
+    describe('getPrivateLogsByTags', () => {
       const numBlocksForLogs = 3;
       const numTxsPerBlock = 4;
       const numPrivateLogsPerTx = 3;
-      const numPublicLogsPerTx = 2;
 
       let logsCheckpoints: PublishedCheckpoint[];
 
-      const makeTag = (blockNumber: number, txIndex: number, logIndex: number, isPublic = false) =>
-        blockNumber === 1 && txIndex === 0 && logIndex === 0
-          ? Fr.ZERO // Shared tag
-          : new Fr((blockNumber * 100 + txIndex * 10 + logIndex) * (isPublic ? 123 : 1));
+      const makePrivateLogTag = (blockNumber: number, txIndex: number, logIndex: number): SiloedTag =>
+        new SiloedTag(
+          blockNumber === 1 && txIndex === 0 && logIndex === 0
+            ? Fr.ZERO // Shared tag
+            : new Fr(blockNumber * 100 + txIndex * 10 + logIndex),
+        );
 
-      const makePrivateLog = (tag: Fr) =>
+      const makePrivateLog = (tag: SiloedTag) =>
         PrivateLog.from({
-          fields: makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, i => (!i ? tag : new Fr(tag.toNumber() + i))),
+          fields: makeTuple(PRIVATE_LOG_SIZE_IN_FIELDS, i =>
+            !i ? tag.value : new Fr(tag.value.toBigInt() + BigInt(i)),
+          ),
           emittedLength: PRIVATE_LOG_SIZE_IN_FIELDS,
         });
 
-      const makePublicLog = (tag: Fr) =>
-        PublicLog.from({
-          contractAddress: AztecAddress.fromNumber(1),
-          // Arbitrary length
-          fields: new Array(10).fill(null).map((_, i) => (!i ? tag : new Fr(tag.toNumber() + i))),
-        });
-
       const mockPrivateLogs = (blockNumber: number, txIndex: number) => {
         return times(numPrivateLogsPerTx, (logIndex: number) => {
-          const tag = makeTag(blockNumber, txIndex, logIndex);
+          const tag = makePrivateLogTag(blockNumber, txIndex, logIndex);
           return makePrivateLog(tag);
         });
       };
 
-      const mockPublicLogs = (blockNumber: number, txIndex: number) => {
-        return times(numPublicLogsPerTx, (logIndex: number) => {
-          const tag = makeTag(blockNumber, txIndex, logIndex, /* isPublic */ true);
-          return makePublicLog(tag);
-        });
-      };
-
       const mockCheckpointWithLogs = async (
         blockNumber: number,
         previousArchive?: AppendOnlyTreeSnapshot,
@@ -2253,7 +2242,7 @@ export function describeArchiverDataStore(
         block.body.txEffects = await timesParallel(numTxsPerBlock, async (txIndex: number) => {
           const txEffect = await TxEffect.random();
           txEffect.privateLogs = mockPrivateLogs(blockNumber, txIndex);
-          txEffect.publicLogs = mockPublicLogs(blockNumber, txIndex);
+          txEffect.publicLogs = []; // No public logs needed for private log tests
           return txEffect;
         });
 
@@ -2279,9 +2268,9 @@ export function describeArchiverDataStore(
       });
 
       it('is possible to batch request private logs via tags', async () => {
-        const tags = [makeTag(2, 1, 2), makeTag(1, 2, 0)];
+        const tags = [makePrivateLogTag(2, 1, 2), makePrivateLogTag(1, 2, 0)];
 
-        const logsByTags = await store.getLogsByTags(tags);
+        const logsByTags = await store.getPrivateLogsByTags(tags);
 
         expect(logsByTags).toEqual([
           [
@@ -2303,11 +2292,21 @@ export function describeArchiverDataStore(
         ]);
       });
 
-      it('is possible to batch request all logs (private and public) via tags', async () => {
-        // Tag(1, 0, 0) is shared with the first private log and the first public log.
-        const tags = [makeTag(1, 0, 0)];
+      it('is possible to batch request logs that have the same tag but different content', async () => {
+        const tags = [makePrivateLogTag(1, 2, 1)];
 
-        const logsByTags = await store.getLogsByTags(tags);
+        // Create a checkpoint containing logs that have the same tag as the checkpoints before.
+        // Chain from the last checkpoint's archive
+        const newBlockNumber = numBlocksForLogs + 1;
+        const previousArchive = logsCheckpoints[logsCheckpoints.length - 1].checkpoint.blocks[0].archive;
+        const newCheckpoint = await mockCheckpointWithLogs(newBlockNumber, previousArchive);
+        const newLog = newCheckpoint.checkpoint.blocks[0].body.txEffects[1].privateLogs[1];
+        newLog.fields[0] = tags[0].value;
+        newCheckpoint.checkpoint.blocks[0].body.txEffects[1].privateLogs[1] = newLog;
+        await store.addCheckpoints([newCheckpoint]);
+        await store.addLogs([newCheckpoint.checkpoint.blocks[0]]);
+
+        const logsByTags = await store.getPrivateLogsByTags(tags);
 
         expect(logsByTags).toEqual([
           [
@@ -2317,54 +2316,169 @@ export function describeArchiverDataStore(
               log: makePrivateLog(tags[0]),
               isFromPublic: false,
             }),
+            expect.objectContaining({
+              blockNumber: newBlockNumber,
+              blockHash: L2BlockHash.fromField(await newCheckpoint.checkpoint.blocks[0].header.hash()),
+              log: newLog,
+              isFromPublic: false,
+            }),
+          ],
+        ]);
+      });
+
+      it('is possible to request logs for non-existing tags and determine their position', async () => {
+        const tags = [makePrivateLogTag(99, 88, 77), makePrivateLogTag(1, 1, 1)];
+
+        const logsByTags = await store.getPrivateLogsByTags(tags);
+
+        expect(logsByTags).toEqual([
+          [
+            // No logs for the first tag.
+          ],
+          [
             expect.objectContaining({
               blockNumber: 1,
               blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
+              log: makePrivateLog(tags[1]),
+              isFromPublic: false,
+            }),
+          ],
+        ]);
+      });
+    });
+
+    describe('getPublicLogsByTagsFromContract', () => {
+      const numBlocksForLogs = 3;
+      const numTxsPerBlock = 4;
+      const numPublicLogsPerTx = 2;
+      const contractAddress = AztecAddress.fromNumber(543254);
+
+      let logsCheckpoints: PublishedCheckpoint[];
+
+      const makePublicLogTag = (blockNumber: number, txIndex: number, logIndex: number): Tag =>
+        new Tag(
+          blockNumber === 1 && txIndex === 0 && logIndex === 0
+            ? Fr.ZERO // Shared tag
+            : new Fr((blockNumber * 100 + txIndex * 10 + logIndex) * 123),
+        );
+
+      const makePublicLog = (tag: Tag) =>
+        PublicLog.from({
+          contractAddress: contractAddress,
+          // Arbitrary length
+          fields: new Array(10).fill(null).map((_, i) => (!i ? tag.value : new Fr(tag.value.toBigInt() + BigInt(i)))),
+        });
+
+      const mockPublicLogs = (blockNumber: number, txIndex: number) => {
+        return times(numPublicLogsPerTx, (logIndex: number) => {
+          const tag = makePublicLogTag(blockNumber, txIndex, logIndex);
+          return makePublicLog(tag);
+        });
+      };
+
+      const mockCheckpointWithLogs = async (
+        blockNumber: number,
+        previousArchive?: AppendOnlyTreeSnapshot,
+      ): Promise<PublishedCheckpoint> => {
+        const block = await L2BlockNew.random(BlockNumber(blockNumber), {
+          checkpointNumber: CheckpointNumber(blockNumber),
+          indexWithinCheckpoint: 0,
+          state: makeStateForBlock(blockNumber, numTxsPerBlock),
+          ...(previousArchive ? { lastArchive: previousArchive } : {}),
+        });
+        block.header.globalVariables.blockNumber = BlockNumber(blockNumber);
+
+        block.body.txEffects = await timesParallel(numTxsPerBlock, async (txIndex: number) => {
+          const txEffect = await TxEffect.random();
+          txEffect.privateLogs = []; // No private logs needed for public log tests
+          txEffect.publicLogs = mockPublicLogs(blockNumber, txIndex);
+          return txEffect;
+        });
+
+        const checkpoint = new Checkpoint(
+          AppendOnlyTreeSnapshot.random(),
+          CheckpointHeader.random(),
+          [block],
+          CheckpointNumber(blockNumber),
+        );
+        return makePublishedCheckpoint(checkpoint, blockNumber);
+      };
+
+      beforeEach(async () => {
+        // Create checkpoints sequentially to chain archive roots
+        logsCheckpoints = [];
+        for (let i = 0; i < numBlocksForLogs; i++) {
+          const previousArchive = i > 0 ? logsCheckpoints[i - 1].checkpoint.blocks[0].archive : undefined;
+          logsCheckpoints.push(await mockCheckpointWithLogs(i + 1, previousArchive));
+        }
+
+        await store.addCheckpoints(logsCheckpoints);
+        await store.addLogs(logsCheckpoints.flatMap(p => p.checkpoint.blocks));
+      });
+
+      it('is possible to batch request public logs via tags', async () => {
+        const tags = [makePublicLogTag(2, 1, 1), makePublicLogTag(1, 2, 0)];
+
+        const logsByTags = await store.getPublicLogsByTagsFromContract(contractAddress, tags);
+
+        expect(logsByTags).toEqual([
+          [
+            expect.objectContaining({
+              blockNumber: 2,
+              blockHash: L2BlockHash.fromField(await logsCheckpoints[2 - 1].checkpoint.blocks[0].header.hash()),
               log: makePublicLog(tags[0]),
               isFromPublic: true,
             }),
           ],
+          [
+            expect.objectContaining({
+              blockNumber: 1,
+              blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
+              log: makePublicLog(tags[1]),
+              isFromPublic: true,
+            }),
+          ],
         ]);
       });
 
       it('is possible to batch request logs that have the same tag but different content', async () => {
-        const tags = [makeTag(1, 2, 1)];
+        const tags = [makePublicLogTag(1, 2, 1)];
 
         // Create a checkpoint containing logs that have the same tag as the checkpoints before.
         // Chain from the last checkpoint's archive
         const newBlockNumber = numBlocksForLogs + 1;
         const previousArchive = logsCheckpoints[logsCheckpoints.length - 1].checkpoint.blocks[0].archive;
         const newCheckpoint = await mockCheckpointWithLogs(newBlockNumber, previousArchive);
-        const newLog = newCheckpoint.checkpoint.blocks[0].body.txEffects[1].privateLogs[1];
-        newLog.fields[0] = tags[0];
-        newCheckpoint.checkpoint.blocks[0].body.txEffects[1].privateLogs[1] = newLog;
+        const newLog = newCheckpoint.checkpoint.blocks[0].body.txEffects[1].publicLogs[1];
+        newLog.fields[0] = tags[0].value;
+        newCheckpoint.checkpoint.blocks[0].body.txEffects[1].publicLogs[1] = newLog;
         await store.addCheckpoints([newCheckpoint]);
         await store.addLogs([newCheckpoint.checkpoint.blocks[0]]);
 
-        const logsByTags = await store.getLogsByTags(tags);
+        const logsByTags = await store.getPublicLogsByTagsFromContract(contractAddress, tags);
 
         expect(logsByTags).toEqual([
           [
             expect.objectContaining({
               blockNumber: 1,
               blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
-              log: makePrivateLog(tags[0]),
-              isFromPublic: false,
+              log: makePublicLog(tags[0]),
+              isFromPublic: true,
             }),
             expect.objectContaining({
               blockNumber: newBlockNumber,
               blockHash: L2BlockHash.fromField(await newCheckpoint.checkpoint.blocks[0].header.hash()),
               log: newLog,
-              isFromPublic: false,
+              isFromPublic: true,
             }),
           ],
         ]);
       });
 
       it('is possible to request logs for non-existing tags and determine their position', async () => {
-        const tags = [makeTag(99, 88, 77), makeTag(1, 1, 1)];
+        const tags = [makePublicLogTag(99, 88, 77), makePublicLogTag(1, 1, 0)];
 
-        const logsByTags = await store.getLogsByTags(tags);
+        const logsByTags = await store.getPublicLogsByTagsFromContract(contractAddress, tags);
 
         expect(logsByTags).toEqual([
           [
@@ -2374,8 +2488,8 @@ export function describeArchiverDataStore(
             expect.objectContaining({
               blockNumber: 1,
               blockHash: L2BlockHash.fromField(await logsCheckpoints[1 - 1].checkpoint.blocks[0].header.hash()),
-              log: makePrivateLog(tags[1]),
-              isFromPublic: false,
+              log: makePublicLog(tags[1]),
+              isFromPublic: true,
             }),
           ],
         ]);

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -17,7 +17,7 @@ import type {
   UtilityFunctionWithMembershipProof,
 } from '@aztec/stdlib/contract';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
-import type { LogFilter, TxScopedL2Log } from '@aztec/stdlib/logs';
+import type { LogFilter, SiloedTag, Tag, TxScopedL2Log } from '@aztec/stdlib/logs';
 import type { BlockHeader, TxHash, TxReceipt } from '@aztec/stdlib/tx';
 import type { UInt64 } from '@aztec/stdlib/types';
 
@@ -318,16 +318,17 @@ export class KVArchiverDataStore implements ArchiverDataStore, ContractDataSourc
     return this.#messageStore.getL1ToL2Messages(checkpointNumber);
   }
 
-  /**
-   * 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.
-   * @param logsPerTag - How many logs to return per tag. Default returns everything
-   * @returns For each received tag, an array of matching logs is returned. An empty array implies no logs match
-   * that tag.
-   */
-  getLogsByTags(tags: Fr[], logsPerTag?: number): Promise<TxScopedL2Log[][]> {
+  getPrivateLogsByTags(tags: SiloedTag[]): Promise<TxScopedL2Log[][]> {
+    try {
+      return this.#logStore.getPrivateLogsByTags(tags);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+  }
+
+  getPublicLogsByTagsFromContract(contractAddress: AztecAddress, tags: Tag[]): Promise<TxScopedL2Log[][]> {
     try {
-      return this.#logStore.getLogsByTags(tags, logsPerTag);
+      return this.#logStore.getPublicLogsByTagsFromContract(contractAddress, tags);
     } catch (err) {
       return Promise.reject(err);
     }

package/src/archiver/kv_archiver_store/log_store.ts

@@ -4,6 +4,7 @@ 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 { AztecAddress } from '@aztec/stdlib/aztec-address';
 import { L2BlockHash, L2BlockNew } from '@aztec/stdlib/block';
 import type { GetContractClassLogsResponse, GetPublicLogsResponse } from '@aztec/stdlib/interfaces/client';
 import {
@@ -13,6 +14,8 @@ import {
   type LogFilter,
   LogId,
   PublicLog,
+  type SiloedTag,
+  Tag,
   TxScopedL2Log,
 } from '@aztec/stdlib/logs';
 
@@ -22,8 +25,12 @@ import type { BlockStore } from './block_store.js';
  * A store for logs
  */
 export class LogStore {
-  #logsByTag: AztecAsyncMap<string, Buffer[]>;
-  #logTagsByBlock: AztecAsyncMap<number, string[]>;
+  // `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;
@@ -34,29 +41,42 @@ export class LogStore {
     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.#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;
   }
 
-  async #extractTaggedLogs(block: L2BlockNew) {
+  /**
+   * 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.
+   */
+  async #extractTaggedLogsFromBlock(block: L2BlockNew) {
     const blockHash = L2BlockHash.fromField(await block.hash());
-    const taggedLogs = new Map<string, Buffer[]>();
+    // 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[]>();
     const dataStartIndexForBlock =
       block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
       block.body.txEffects.length * MAX_NOTE_HASHES_PER_TX;
+
     block.body.txEffects.forEach((txEffect, txIndex) => {
       const txHash = txEffect.txHash;
       const dataStartIndexForTx = dataStartIndexForBlock + txIndex * MAX_NOTE_HASHES_PER_TX;
 
       txEffect.privateLogs.forEach((log, logIndex) => {
+        // Private logs use SiloedTag (already siloed by kernel)
         const tag = log.fields[0];
         this.#log.debug(`Found private log with tag ${tag.toString()} in block ${block.number}`);
 
-        const currentLogs = taggedLogs.get(tag.toString()) ?? [];
+        const currentLogs = privateTaggedLogs.get(tag.toString()) ?? [];
         currentLogs.push(
           new TxScopedL2Log(
             txHash,
@@ -68,14 +88,19 @@ export class LogStore {
             log,
           ).toBuffer(),
         );
-        taggedLogs.set(tag.toString(), currentLogs);
+        privateTaggedLogs.set(tag.toString(), currentLogs);
       });
 
       txEffect.publicLogs.forEach((log, logIndex) => {
+        // Public logs use Tag directly (not siloed) and are stored with contract address
         const tag = log.fields[0];
-        this.#log.debug(`Found public log with tag ${tag.toString()} in block ${block.number}`);
+        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}`,
+        );
 
-        const currentLogs = taggedLogs.get(tag.toString()) ?? [];
+        const currentLogs = publicTaggedLogs.get(key) ?? [];
         currentLogs.push(
           new TxScopedL2Log(
             txHash,
@@ -87,49 +112,102 @@ export class LogStore {
             log,
           ).toBuffer(),
         );
-        taggedLogs.set(tag.toString(), currentLogs);
+        publicTaggedLogs.set(key, currentLogs);
       });
     });
-    return taggedLogs;
+
+    return { privateTaggedLogs, publicTaggedLogs };
   }
 
   /**
-   * Append new logs to the store's list.
-   * @param blocks - The blocks for which to add the logs.
-   * @returns True if the operation is successful.
+   * 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.
    */
-  async addLogs(blocks: L2BlockNew[]): Promise<boolean> {
-    const taggedLogsInBlocks = await Promise.all(blocks.map(block => this.#extractTaggedLogs(block)));
-    const taggedLogsToAdd = taggedLogsInBlocks.reduce((acc, taggedLogs) => {
-      for (const [tag, logs] of taggedLogs.entries()) {
+  async #extractTaggedLogs(
+    blocks: L2BlockNew[],
+  ): Promise<{ privateTaggedLogs: Map<string, Buffer[]>; publicTaggedLogs: Map<string, Buffer[]> }> {
+    const taggedLogsInBlocks = await Promise.all(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 tagsToUpdate = Array.from(taggedLogsToAdd.keys());
+
+    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 };
+  }
+
+  /**
+   * Append new logs to the store's list.
+   * @param blocks - The blocks for which to add the logs.
+   * @returns True if the operation is successful.
+   */
+  async addLogs(blocks: L2BlockNew[]): Promise<boolean> {
+    const { privateTaggedLogs, publicTaggedLogs } = await 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 blockHash = await block.hash();
 
-        const tagsInBlock = [];
-        for (const [tag, logs] of taggedLogsToAdd.entries()) {
-          await this.#logsByTag.set(tag, logs);
-          tagsInBlock.push(tag);
+        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 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) =>
@@ -178,44 +256,55 @@ export class LogStore {
 
   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.#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;
     });
   }
 
   /**
-   * 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 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 getLogsByTags(tags: Fr[], limitPerTag?: number): Promise<TxScopedL2Log[][]> {
-    if (limitPerTag !== undefined && limitPerTag <= 0) {
-      throw new TypeError('limitPerTag needs to be greater than 0');
-    }
-    const logs = await Promise.all(tags.map(tag => this.#logsByTag.getAsync(tag.toString())));
-    return logs.map(
-      logBuffers => logBuffers?.slice(0, limitPerTag).map(logBuffer => TxScopedL2Log.fromBuffer(logBuffer)) ?? [],
+  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 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 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)) ?? []);
   }
 
   /**

package/src/archiver/l1/data_retrieval.ts

@@ -331,7 +331,7 @@ export async function getCheckpointBlobDataFromBlobs(
   logger: Logger,
   isHistoricalSync: boolean,
 ): Promise<CheckpointBlobData> {
-  const blobBodies = await blobClient.getBlobSidecar(blockHash, blobHashes, undefined, { isHistoricalSync });
+  const blobBodies = await blobClient.getBlobSidecar(blockHash, blobHashes, { isHistoricalSync });
   if (blobBodies.length === 0) {
     throw new NoBlobBodiesFoundError(checkpointNumber);
   }
@@ -339,7 +339,7 @@ export async function getCheckpointBlobDataFromBlobs(
   let checkpointBlobData: CheckpointBlobData;
   try {
     // Attempt to decode the checkpoint blob data.
-    checkpointBlobData = decodeCheckpointBlobDataFromBlobs(blobBodies.map(b => b.blob));
+    checkpointBlobData = decodeCheckpointBlobDataFromBlobs(blobBodies);
   } catch (err: any) {
     if (err instanceof BlobDeserializationError) {
       logger.fatal(err.message);