@aztec/archiver 0.71.0 → 0.73.0

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';
@@ -38,7 +30,10 @@ import { type L1Published } from './structs/published.js';
  * @param testName - The name of the test suite.
  * @param getStore - Returns an instance of a store that's already been initialized.
  */
-export function describeArchiverDataStore(testName: string, getStore: () => ArchiverDataStore) {
+export function describeArchiverDataStore(
+  testName: string,
+  getStore: () => ArchiverDataStore | Promise<ArchiverDataStore>,
+) {
   describe(testName, () => {
     let store: ArchiverDataStore;
     let blocks: L1Published<L2Block>[];
@@ -59,9 +54,9 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       },
     });
 
-    beforeEach(() => {
-      store = getStore();
-      blocks = times(10, i => makeL1Published(L2Block.random(i + 1), i + 10));
+    beforeEach(async () => {
+      store = await getStore();
+      blocks = await timesParallel(10, async i => makeL1Published(await L2Block.random(i + 1), i + 10));
     });
 
     describe('addBlocks', () => {
@@ -89,7 +84,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 +161,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 +176,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);
       });
     });
 
@@ -217,7 +212,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
         () => wrapInBlock(blocks[5].data.body.txEffects[2], blocks[5].data),
         () => wrapInBlock(blocks[1].data.body.txEffects[0], blocks[1].data),
       ])('retrieves a previously stored transaction', async getExpectedTx => {
-        const expectedTx = getExpectedTx();
+        const expectedTx = await getExpectedTx();
         const actualTx = await store.getTxEffect(expectedTx.data.txHash);
         expect(actualTx).toEqual(expectedTx);
       });
@@ -235,7 +230,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       ])('tries to retrieves a previously stored transaction after deleted', async getExpectedTx => {
         await store.unwindBlocks(blocks.length, blocks.length);
 
-        const expectedTx = getExpectedTx();
+        const expectedTx = await getExpectedTx();
         const actualTx = await store.getTxEffect(expectedTx.data.txHash);
         expect(actualTx).toEqual(undefined);
       });
@@ -284,7 +279,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 +289,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 () => {
@@ -307,10 +303,10 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       const blockNum = 10;
 
       beforeEach(async () => {
-        contractClass = makeContractClassPublic();
+        contractClass = await makeContractClassPublic();
         await store.addContractClasses(
           [contractClass],
-          [computePublicBytecodeCommitment(contractClass.packedBytecode)],
+          [await computePublicBytecodeCommitment(contractClass.packedBytecode)],
           blockNum,
         );
       });
@@ -327,7 +323,7 @@ export function describeArchiverDataStore(testName: string, getStore: () => Arch
       it('returns contract class if later "deployment" class was deleted', async () => {
         await store.addContractClasses(
           [contractClass],
-          [computePublicBytecodeCommitment(contractClass.packedBytecode)],
+          [await computePublicBytecodeCommitment(contractClass.packedBytecode)],
           blockNum + 1,
         );
         await store.deleteContractClasses([contractClass], blockNum + 1);
@@ -373,18 +369,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
+      // 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.
+      const makeLengthsField = (publicValuesLen: number, privateValuesLen: number) => {
+        const buf = Buffer.alloc(32);
+        buf.writeUint16BE(publicValuesLen, 27);
+        buf.writeUint16BE(privateValuesLen, 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), // 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 +405,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 +430,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 +459,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 +474,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 +486,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 +529,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), // 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), // 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 +589,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 +602,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 +622,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 +641,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 +658,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 +684,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 +725,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 +752,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

@@ -22,7 +22,7 @@ export type ArchiverConfig = {
   archiverUrl?: string;
 
   /** URL for an L1 consensus client */
-  l1ConsensusClientUrl: string;
+  l1ConsensusHostUrl?: string;
 
   /** The polling interval in ms for retrieving new L2 blocks and encrypted logs. */
   archiverPollingIntervalMS?: number;
@@ -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;
@@ -47,10 +47,10 @@ export const archiverConfigMappings: ConfigMappingsType<ArchiverConfig> = {
     description:
       'URL for an archiver service. If set, will return an archiver client as opposed to starting a new one.',
   },
-  l1ConsensusClientUrl: {
-    env: 'L1_CONSENSUS_CLIENT_URL',
+  l1ConsensusHostUrl: {
+    env: 'L1_CONSENSUS_HOST_URL',
     description: 'URL for an L1 consensus client.',
-    parseEnv: (val: string) => (val ? val : 'http://localhost:5052'),
+    parseEnv: (val: string) => val,
   },
   archiverPollingIntervalMS: {
     env: 'ARCHIVER_POLLING_INTERVAL_MS',
@@ -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,