@aztec/archiver 0.70.0 → 0.72.1

package/src/archiver/archiver.ts

@@ -1,6 +1,7 @@
 import { type BlobSinkClientInterface } from '@aztec/blob-sink/client';
 import {
-  type GetUnencryptedLogsResponse,
+  type GetContractClassLogsResponse,
+  type GetPublicLogsResponse,
   type InBlock,
   type InboxLeaf,
   type L1RollupConstants,
@@ -381,13 +382,21 @@ export class Archiver implements ArchiveSource, Traceable {
         localBlockForDestinationProvenBlockNumber &&
         provenArchive === localBlockForDestinationProvenBlockNumber.archive.root.toString()
       ) {
-        await this.store.setProvenL2BlockNumber(Number(provenBlockNumber));
-        // if we are here then we must have a valid proven epoch number
-        await this.store.setProvenL2EpochNumber(Number(provenEpochNumber));
-        this.log.info(`Updated proven chain to block ${provenBlockNumber} (epoch ${provenEpochNumber})`, {
-          provenBlockNumber,
-          provenEpochNumber,
-        });
+        const [localProvenEpochNumber, localProvenBlockNumber] = await Promise.all([
+          this.store.getProvenL2EpochNumber(),
+          this.store.getProvenL2BlockNumber(),
+        ]);
+        if (
+          localProvenEpochNumber !== Number(provenEpochNumber) ||
+          localProvenBlockNumber !== Number(provenBlockNumber)
+        ) {
+          await this.store.setProvenL2BlockNumber(Number(provenBlockNumber));
+          await this.store.setProvenL2EpochNumber(Number(provenEpochNumber));
+          this.log.info(`Updated proven chain to block ${provenBlockNumber} (epoch ${provenEpochNumber})`, {
+            provenBlockNumber,
+            provenEpochNumber,
+          });
+        }
       }
       this.instrumentation.updateLastProvenBlock(Number(provenBlockNumber));
     };
@@ -709,12 +718,12 @@ export class Archiver implements ArchiveSource, Traceable {
   }
 
   /**
-   * Gets unencrypted logs based on the provided filter.
+   * Gets public logs based on the provided filter.
    * @param filter - The filter to apply to the logs.
    * @returns The requested logs.
    */
-  getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
-    return this.store.getUnencryptedLogs(filter);
+  getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
+    return this.store.getPublicLogs(filter);
   }
 
   /**
@@ -722,7 +731,7 @@ export class Archiver implements ArchiveSource, Traceable {
    * @param filter - The filter to apply to the logs.
    * @returns The requested logs.
    */
-  getContractClassLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+  getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
     return this.store.getContractClassLogs(filter);
   }
 
@@ -1059,10 +1068,10 @@ class ArchiverStoreHelper
   findNullifiersIndexesWithBlock(blockNumber: number, nullifiers: Fr[]): Promise<(InBlock<bigint> | undefined)[]> {
     return this.store.findNullifiersIndexesWithBlock(blockNumber, nullifiers);
   }
-  getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
-    return this.store.getUnencryptedLogs(filter);
+  getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
+    return this.store.getPublicLogs(filter);
   }
-  getContractClassLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+  getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
     return this.store.getContractClassLogs(filter);
   }
   getSynchedL2BlockNumber(): Promise<number> {

package/src/archiver/archiver_store.ts

@@ -1,5 +1,6 @@
 import {
-  type GetUnencryptedLogsResponse,
+  type GetContractClassLogsResponse,
+  type GetPublicLogsResponse,
   type InBlock,
   type InboxLeaf,
   type L2Block,
@@ -156,18 +157,18 @@ export interface ArchiverDataStore {
   getLogsByTags(tags: Fr[]): Promise<TxScopedL2Log[][]>;
 
   /**
-   * Gets unencrypted logs based on the provided filter.
+   * Gets public logs based on the provided filter.
    * @param filter - The filter to apply to the logs.
    * @returns The requested logs.
    */
-  getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse>;
+  getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse>;
 
   /**
    * 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>;
+  getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse>;
 
   /**
    * Gets the number of the latest L2 block processed.

package/src/archiver/archiver_store_test_suite.ts

@@ -1,14 +1,4 @@
-import {
-  InboxLeaf,
-  L2Block,
-  LogId,
-  TxEffect,
-  TxHash,
-  UnencryptedFunctionL2Logs,
-  UnencryptedL2Log,
-  UnencryptedTxL2Logs,
-  wrapInBlock,
-} from '@aztec/circuit-types';
+import { InboxLeaf, L2Block, LogId, TxEffect, TxHash, wrapInBlock } from '@aztec/circuit-types';
 import '@aztec/circuit-types/jest';
 import {
   AztecAddress,
@@ -19,7 +9,9 @@ import {
   L1_TO_L2_MSG_SUBTREE_HEIGHT,
   MAX_NULLIFIERS_PER_TX,
   PRIVATE_LOG_SIZE_IN_FIELDS,
+  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
   PrivateLog,
+  PublicLog,
   SerializableContractInstance,
   computePublicBytecodeCommitment,
 } from '@aztec/circuits.js';
@@ -28,7 +20,7 @@ import {
   makeExecutablePrivateFunctionWithMembershipProof,
   makeUnconstrainedFunctionWithMembershipProof,
 } from '@aztec/circuits.js/testing';
-import { times } from '@aztec/foundation/collection';
+import { times, timesParallel } from '@aztec/foundation/collection';
 import { randomInt } from '@aztec/foundation/crypto';
 
 import { type ArchiverDataStore, type ArchiverL1SynchPoint } from './archiver_store.js';
@@ -59,9 +51,9 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       },
     });
 
-    beforeEach(() => {
+    beforeEach(async () => {
       store = getStore();
-      blocks = times(10, i => makeL1Published(L2Block.random(i + 1), i + 10));
+      blocks = await timesParallel(10, async i => makeL1Published(await L2Block.random(i + 1), i + 10));
     });
 
     describe('addBlocks', () => {
@@ -89,7 +81,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       });
 
       it('can unwind multiple empty blocks', async () => {
-        const emptyBlocks = times(10, i => makeL1Published(L2Block.random(i + 1, 0), i + 10));
+        const emptyBlocks = await timesParallel(10, async i => makeL1Published(await L2Block.random(i + 1, 0), i + 10));
         await store.addBlocks(emptyBlocks);
         expect(await store.getSynchedL2BlockNumber()).toBe(10);
 
@@ -166,14 +158,14 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
     });
 
     describe('addLogs', () => {
-      it('adds private & unencrypted logs', async () => {
+      it('adds private & public logs', async () => {
         const block = blocks[0].data;
         await expect(store.addLogs([block])).resolves.toEqual(true);
       });
     });
 
     describe('deleteLogs', () => {
-      it('deletes private & unencrypted logs', async () => {
+      it('deletes private & public logs', async () => {
         const block = blocks[0].data;
         await store.addBlocks([blocks[0]]);
         await expect(store.addLogs([block])).resolves.toEqual(true);
@@ -181,15 +173,15 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         expect((await store.getPrivateLogs(1, 1)).length).toEqual(
           block.body.txEffects.map(txEffect => txEffect.privateLogs).flat().length,
         );
-        expect((await store.getUnencryptedLogs({ fromBlock: 1 })).logs.length).toEqual(
-          block.body.unencryptedLogs.getTotalLogCount(),
+        expect((await store.getPublicLogs({ fromBlock: 1 })).logs.length).toEqual(
+          block.body.txEffects.map(txEffect => txEffect.publicLogs).flat().length,
         );
 
         // This one is a pain for memory as we would never want to just delete memory in the middle.
         await store.deleteLogs([block]);
 
         expect((await store.getPrivateLogs(1, 1)).length).toEqual(0);
-        expect((await store.getUnencryptedLogs({ fromBlock: 1 })).logs.length).toEqual(0);
+        expect((await store.getPublicLogs({ fromBlock: 1 })).logs.length).toEqual(0);
       });
     });
 
@@ -284,7 +276,8 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       const blockNum = 10;
 
       beforeEach(async () => {
-        contractInstance = { ...SerializableContractInstance.random(), address: AztecAddress.random() };
+        const randomInstance = await SerializableContractInstance.random();
+        contractInstance = { ...randomInstance, address: await AztecAddress.random() };
         await store.addContractInstances([contractInstance], blockNum);
       });
 
@@ -293,7 +286,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       });
 
       it('returns undefined if contract instance is not found', async () => {
-        await expect(store.getContractInstance(AztecAddress.random())).resolves.toBeUndefined();
+        await expect(store.getContractInstance(await AztecAddress.random())).resolves.toBeUndefined();
       });
 
       it('returns undefined if previously stored contract instances was deleted', async () => {
@@ -373,18 +366,34 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       const numBlocks = 3;
       const numTxsPerBlock = 4;
       const numPrivateLogsPerTx = 3;
-      const numUnencryptedLogsPerTx = 2;
+      const numPublicLogsPerTx = 2;
 
       let blocks: L1Published<L2Block>[];
 
       const makeTag = (blockNumber: number, txIndex: number, logIndex: number, isPublic = false) =>
         new Fr((blockNumber * 100 + txIndex * 10 + logIndex) * (isPublic ? 123 : 1));
 
+      // See parseLogFromPublic
+      const makeLengthsField = (publicValuesLen: number, privateValuesLen: number, ciphertextLen: number) => {
+        const buf = Buffer.alloc(32);
+        buf.writeUint16BE(publicValuesLen, 24);
+        buf.writeUint16BE(privateValuesLen, 27);
+        buf.writeUint16BE(ciphertextLen, 30);
+        return Fr.fromBuffer(buf);
+      };
+
       const makePrivateLog = (tag: Fr) =>
         PrivateLog.fromFields([tag, ...times(PRIVATE_LOG_SIZE_IN_FIELDS - 1, i => new Fr(tag.toNumber() + i))]);
 
+      // The tag lives in field 1, not 0, of a public log
+      // See extractTaggedLogsFromPublic and noir-projects/aztec-nr/aztec/src/macros/notes/mod.nr -> emit_log
       const makePublicLog = (tag: Fr) =>
-        Buffer.concat([tag.toBuffer(), ...times(tag.toNumber() % 60, i => new Fr(tag.toNumber() + i).toBuffer())]);
+        PublicLog.fromFields([
+          AztecAddress.fromNumber(1).toField(), // log address
+          makeLengthsField(2, PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 3, 42), // field 0
+          tag, // field 1
+          ...times(PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 1, i => new Fr(tag.toNumber() + i)), // fields 2 to end
+        ]);
 
       const mockPrivateLogs = (blockNumber: number, txIndex: number) => {
         return times(numPrivateLogsPerTx, (logIndex: number) => {
@@ -393,23 +402,21 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         });
       };
 
-      const mockUnencryptedLogs = (blockNumber: number, txIndex: number) => {
-        const logs = times(numUnencryptedLogsPerTx, (logIndex: number) => {
+      const mockPublicLogs = (blockNumber: number, txIndex: number) => {
+        return times(numPublicLogsPerTx, (logIndex: number) => {
           const tag = makeTag(blockNumber, txIndex, logIndex, /* isPublic */ true);
-          const log = makePublicLog(tag);
-          return new UnencryptedL2Log(AztecAddress.fromNumber(txIndex), log);
+          return makePublicLog(tag);
         });
-        return new UnencryptedTxL2Logs([new UnencryptedFunctionL2Logs(logs)]);
       };
 
-      const mockBlockWithLogs = (blockNumber: number): L1Published<L2Block> => {
-        const block = L2Block.random(blockNumber);
+      const mockBlockWithLogs = async (blockNumber: number): Promise<L1Published<L2Block>> => {
+        const block = await L2Block.random(blockNumber);
         block.header.globalVariables.blockNumber = new Fr(blockNumber);
 
-        block.body.txEffects = times(numTxsPerBlock, (txIndex: number) => {
-          const txEffect = TxEffect.random();
+        block.body.txEffects = await timesParallel(numTxsPerBlock, async (txIndex: number) => {
+          const txEffect = await TxEffect.random();
           txEffect.privateLogs = mockPrivateLogs(blockNumber, txIndex);
-          txEffect.unencryptedLogs = mockUnencryptedLogs(blockNumber, txIndex);
+          txEffect.publicLogs = mockPublicLogs(blockNumber, txIndex);
           return txEffect;
         });
 
@@ -420,7 +427,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       };
 
       beforeEach(async () => {
-        blocks = times(numBlocks, (index: number) => mockBlockWithLogs(index));
+        blocks = await timesParallel(numBlocks, (index: number) => mockBlockWithLogs(index));
 
         await store.addBlocks(blocks);
         await store.addLogs(blocks.map(b => b.data));
@@ -449,9 +456,8 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         ]);
       });
 
-      // TODO: Allow this test when #9835 is fixed and tags can be correctly decoded
-      it.skip('is possible to batch request all logs (private and unencrypted) via tags', async () => {
-        // Tag(0, 0, 0) is shared with the first private log and the first unencrypted log.
+      it('is possible to batch request all logs (private and public) via tags', async () => {
+        // Tag(0, 0, 0) is shared with the first private log and the first public log.
         const tags = [makeTag(0, 0, 0)];
 
         const logsByTags = await store.getLogsByTags(tags);
@@ -465,7 +471,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
             }),
             expect.objectContaining({
               blockNumber: 0,
-              logData: makePublicLog(tags[0]),
+              logData: makePublicLog(tags[0]).toBuffer(),
               isFromPublic: true,
             }),
           ],
@@ -477,7 +483,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
 
         // Create a block containing logs that have the same tag as the blocks before.
         const newBlockNumber = numBlocks;
-        const newBlock = mockBlockWithLogs(newBlockNumber);
+        const newBlock = await mockBlockWithLogs(newBlockNumber);
         const newLog = newBlock.data.body.txEffects[1].privateLogs[1];
         newLog.fields[0] = tags[0];
         newBlock.data.body.txEffects[1].privateLogs[1] = newLog;
@@ -520,18 +526,48 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
           ],
         ]);
       });
+
+      it('is not possible to add public logs by tag if they are invalid', async () => {
+        const tag = makeTag(99, 88, 77);
+        const invalidLogs = [
+          PublicLog.fromFields([
+            AztecAddress.fromNumber(1).toField(),
+            makeLengthsField(2, 3, 42), // This field claims we have 5 items, but we actually have more
+            tag,
+            ...times(PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 1, i => new Fr(tag.toNumber() + i)),
+          ]),
+          PublicLog.fromFields([
+            AztecAddress.fromNumber(1).toField(),
+            makeLengthsField(2, PUBLIC_LOG_DATA_SIZE_IN_FIELDS, 42), // This field claims we have more than the max items
+            tag,
+            ...times(PUBLIC_LOG_DATA_SIZE_IN_FIELDS - 1, i => new Fr(tag.toNumber() + i)),
+          ]),
+        ];
+
+        // Create a block containing these invalid logs
+        const newBlockNumber = numBlocks;
+        const newBlock = await mockBlockWithLogs(newBlockNumber);
+        newBlock.data.body.txEffects[0].publicLogs = invalidLogs;
+        await store.addBlocks([newBlock]);
+        await store.addLogs([newBlock.data]);
+
+        const logsByTags = await store.getLogsByTags([tag]);
+
+        // Neither of the logs should have been added:
+        expect(logsByTags).toEqual([[]]);
+      });
     });
 
-    describe('getUnencryptedLogs', () => {
+    describe('getPublicLogs', () => {
       const txsPerBlock = 4;
       const numPublicFunctionCalls = 3;
-      const numUnencryptedLogs = 2;
+      const numPublicLogs = 2;
       const numBlocks = 10;
       let blocks: L1Published<L2Block>[];
 
       beforeEach(async () => {
-        blocks = times(numBlocks, (index: number) => ({
-          data: L2Block.random(index + 1, txsPerBlock, numPublicFunctionCalls, numUnencryptedLogs),
+        blocks = await timesParallel(numBlocks, async (index: number) => ({
+          data: await L2Block.random(index + 1, txsPerBlock, numPublicFunctionCalls, numPublicLogs),
           l1: { blockNumber: BigInt(index), blockHash: `0x${index}`, timestamp: BigInt(index) },
         }));
 
@@ -550,7 +586,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
           store.deleteLogs(blocks.map(b => b.data)),
         ]);
 
-        const response = await store.getUnencryptedLogs({ txHash: targetTxHash });
+        const response = await store.getPublicLogs({ txHash: targetTxHash });
         const logs = response.logs;
 
         expect(response.maxLogsHit).toBeFalsy();
@@ -563,12 +599,12 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         const targetTxIndex = randomInt(txsPerBlock);
         const targetTxHash = blocks[targetBlockIndex].data.body.txEffects[targetTxIndex].txHash;
 
-        const response = await store.getUnencryptedLogs({ txHash: targetTxHash });
+        const response = await store.getPublicLogs({ txHash: targetTxHash });
         const logs = response.logs;
 
         expect(response.maxLogsHit).toBeFalsy();
 
-        const expectedNumLogs = numPublicFunctionCalls * numUnencryptedLogs;
+        const expectedNumLogs = numPublicFunctionCalls * numPublicLogs;
         expect(logs.length).toEqual(expectedNumLogs);
 
         const targeBlockNumber = targetBlockIndex + INITIAL_L2_BLOCK_NUM;
@@ -583,12 +619,12 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         const fromBlock = 3;
         const toBlock = 7;
 
-        const response = await store.getUnencryptedLogs({ fromBlock, toBlock });
+        const response = await store.getPublicLogs({ fromBlock, toBlock });
         const logs = response.logs;
 
         expect(response.maxLogsHit).toBeFalsy();
 
-        const expectedNumLogs = txsPerBlock * numPublicFunctionCalls * numUnencryptedLogs * (toBlock - fromBlock);
+        const expectedNumLogs = txsPerBlock * numPublicFunctionCalls * numPublicLogs * (toBlock - fromBlock);
         expect(logs.length).toEqual(expectedNumLogs);
 
         for (const log of logs) {
@@ -602,14 +638,11 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         // Get a random contract address from the logs
         const targetBlockIndex = randomInt(numBlocks);
         const targetTxIndex = randomInt(txsPerBlock);
-        const targetFunctionLogIndex = randomInt(numPublicFunctionCalls);
-        const targetLogIndex = randomInt(numUnencryptedLogs);
+        const targetLogIndex = randomInt(numPublicLogs * numPublicFunctionCalls);
         const targetContractAddress =
-          blocks[targetBlockIndex].data.body.txEffects[targetTxIndex].unencryptedLogs.functionLogs[
-            targetFunctionLogIndex
-          ].logs[targetLogIndex].contractAddress;
+          blocks[targetBlockIndex].data.body.txEffects[targetTxIndex].publicLogs[targetLogIndex].contractAddress;
 
-        const response = await store.getUnencryptedLogs({ contractAddress: targetContractAddress });
+        const response = await store.getPublicLogs({ contractAddress: targetContractAddress });
 
         expect(response.maxLogsHit).toBeFalsy();
 
@@ -622,11 +655,11 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         // Get a random log as reference
         const targetBlockIndex = randomInt(numBlocks);
         const targetTxIndex = randomInt(txsPerBlock);
-        const targetLogIndex = randomInt(numUnencryptedLogs);
+        const targetLogIndex = randomInt(numPublicLogs);
 
         const afterLog = new LogId(targetBlockIndex + INITIAL_L2_BLOCK_NUM, targetTxIndex, targetLogIndex);
 
-        const response = await store.getUnencryptedLogs({ afterLog });
+        const response = await store.getPublicLogs({ afterLog });
         const logs = response.logs;
 
         expect(response.maxLogsHit).toBeFalsy();
@@ -648,40 +681,40 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         const txHash = TxHash.random();
         const afterLog = new LogId(1, 0, 0);
 
-        const response = await store.getUnencryptedLogs({ txHash, afterLog });
+        const response = await store.getPublicLogs({ txHash, afterLog });
         expect(response.logs.length).toBeGreaterThan(1);
       });
 
       it('intersecting works', async () => {
-        let logs = (await store.getUnencryptedLogs({ fromBlock: -10, toBlock: -5 })).logs;
+        let logs = (await store.getPublicLogs({ fromBlock: -10, toBlock: -5 })).logs;
         expect(logs.length).toBe(0);
 
         // "fromBlock" gets correctly trimmed to range and "toBlock" is exclusive
-        logs = (await store.getUnencryptedLogs({ fromBlock: -10, toBlock: 5 })).logs;
+        logs = (await store.getPublicLogs({ fromBlock: -10, toBlock: 5 })).logs;
         let blockNumbers = new Set(logs.map(log => log.id.blockNumber));
         expect(blockNumbers).toEqual(new Set([1, 2, 3, 4]));
 
         // "toBlock" should be exclusive
-        logs = (await store.getUnencryptedLogs({ fromBlock: 1, toBlock: 1 })).logs;
+        logs = (await store.getPublicLogs({ fromBlock: 1, toBlock: 1 })).logs;
         expect(logs.length).toBe(0);
 
-        logs = (await store.getUnencryptedLogs({ fromBlock: 10, toBlock: 5 })).logs;
+        logs = (await store.getPublicLogs({ fromBlock: 10, toBlock: 5 })).logs;
         expect(logs.length).toBe(0);
 
         // both "fromBlock" and "toBlock" get correctly capped to range and logs from all blocks are returned
-        logs = (await store.getUnencryptedLogs({ fromBlock: -100, toBlock: +100 })).logs;
+        logs = (await store.getPublicLogs({ fromBlock: -100, toBlock: +100 })).logs;
         blockNumbers = new Set(logs.map(log => log.id.blockNumber));
         expect(blockNumbers.size).toBe(numBlocks);
 
         // intersecting with "afterLog" works
-        logs = (await store.getUnencryptedLogs({ fromBlock: 2, toBlock: 5, afterLog: new LogId(4, 0, 0) })).logs;
+        logs = (await store.getPublicLogs({ fromBlock: 2, toBlock: 5, afterLog: new LogId(4, 0, 0) })).logs;
         blockNumbers = new Set(logs.map(log => log.id.blockNumber));
         expect(blockNumbers).toEqual(new Set([4]));
 
-        logs = (await store.getUnencryptedLogs({ toBlock: 5, afterLog: new LogId(5, 1, 0) })).logs;
+        logs = (await store.getPublicLogs({ toBlock: 5, afterLog: new LogId(5, 1, 0) })).logs;
         expect(logs.length).toBe(0);
 
-        logs = (await store.getUnencryptedLogs({ fromBlock: 2, toBlock: 5, afterLog: new LogId(100, 0, 0) })).logs;
+        logs = (await store.getPublicLogs({ fromBlock: 2, toBlock: 5, afterLog: new LogId(100, 0, 0) })).logs;
         expect(logs.length).toBe(0);
       });
 
@@ -689,11 +722,11 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         // Get a random log as reference
         const targetBlockIndex = randomInt(numBlocks);
         const targetTxIndex = randomInt(txsPerBlock);
-        const targetLogIndex = randomInt(numUnencryptedLogs);
+        const targetLogIndex = randomInt(numPublicLogs);
 
         const afterLog = new LogId(targetBlockIndex + INITIAL_L2_BLOCK_NUM, targetTxIndex, targetLogIndex);
 
-        const response = await store.getUnencryptedLogs({ afterLog, fromBlock: afterLog.blockNumber });
+        const response = await store.getPublicLogs({ afterLog, fromBlock: afterLog.blockNumber });
         const logs = response.logs;
 
         expect(response.maxLogsHit).toBeFalsy();
@@ -716,8 +749,8 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       const numBlocks = 10;
       const nullifiersPerBlock = new Map<number, Fr[]>();
 
-      beforeEach(() => {
-        blocks = times(numBlocks, (index: number) => L2Block.random(index + 1, 1));
+      beforeEach(async () => {
+        blocks = await timesParallel(numBlocks, (index: number) => L2Block.random(index + 1, 1));
 
         blocks.forEach((block, blockIndex) => {
           nullifiersPerBlock.set(

package/src/archiver/config.ts

@@ -36,7 +36,7 @@ export type ArchiverConfig = {
   /** The deployed L1 contract addresses */
   l1Contracts: L1ContractAddresses;
 
-  /** The max number of logs that can be obtained in 1 "getUnencryptedLogs" call. */
+  /** The max number of logs that can be obtained in 1 "getPublicLogs" call. */
   maxLogs?: number;
 } & L1ReaderConfig &
   L1ContractsConfig;
@@ -55,7 +55,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(1_000),
+    ...numberConfigHelper(500),
   },
   archiverBatchSize: {
     env: 'ARCHIVER_BATCH_SIZE',
@@ -64,7 +64,7 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
   },
   maxLogs: {
     env: 'ARCHIVER_MAX_LOGS',
-    description: 'The max number of logs that can be obtained in 1 "getUnencryptedLogs" call.',
+    description: 'The max number of logs that can be obtained in 1 "getPublicLogs" call.',
     ...numberConfigHelper(1_000),
   },
   ...l1ReaderConfigMappings,

package/src/archiver/data_retrieval.ts

@@ -165,7 +165,7 @@ async function getBlockFromRollupTx(
   // TODO(#9101): The below reconstruction is currently redundant, but once we extract blobs will be the way to construct blocks.
   // The blob source will give us blockFields, and we must construct the body from them:
   // TODO(#8954): When logs are refactored into fields, we won't need to inject them here.
-  const reconstructedBlock = Body.fromBlobFields(blockFields, blockBody.unencryptedLogs, blockBody.contractClassLogs);
+  const reconstructedBlock = Body.fromBlobFields(blockFields, blockBody.contractClassLogs);
 
   if (!reconstructedBlock.toBuffer().equals(blockBody.toBuffer())) {
     // TODO(#9101): Remove below check (without calldata there will be nothing to check against)

package/src/archiver/kv_archiver_store/kv_archiver_store.ts

@@ -1,5 +1,6 @@
 import {
-  type GetUnencryptedLogsResponse,
+  type GetContractClassLogsResponse,
+  type GetPublicLogsResponse,
   type InBlock,
   type InboxLeaf,
   type L2Block,
@@ -290,13 +291,13 @@ export class KVArchiverDataStore implements ArchiverDataStore {
   }
 
   /**
-   * Gets unencrypted logs based on the provided filter.
+   * Gets public logs based on the provided filter.
    * @param filter - The filter to apply to the logs.
    * @returns The requested logs.
    */
-  getUnencryptedLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+  getPublicLogs(filter: LogFilter): Promise<GetPublicLogsResponse> {
     try {
-      return Promise.resolve(this.#logStore.getUnencryptedLogs(filter));
+      return Promise.resolve(this.#logStore.getPublicLogs(filter));
     } catch (err) {
       return Promise.reject(err);
     }
@@ -307,7 +308,7 @@ export class KVArchiverDataStore implements ArchiverDataStore {
    * @param filter - The filter to apply to the logs.
    * @returns The requested logs.
    */
-  getContractClassLogs(filter: LogFilter): Promise<GetUnencryptedLogsResponse> {
+  getContractClassLogs(filter: LogFilter): Promise<GetContractClassLogsResponse> {
     try {
       return Promise.resolve(this.#logStore.getContractClassLogs(filter));
     } catch (err) {