@aztec/pxe 0.32.1 → 0.34.0

package/src/note_processor/note_processor.ts

@@ -3,7 +3,7 @@ import {
   type EncryptedL2BlockL2Logs,
   type KeyStore,
   L1NotePayload,
-  type L2BlockContext,
+  type L2Block,
   TaggedNote,
 } from '@aztec/circuit-types';
 import { type NoteProcessorStats } from '@aztec/circuit-types/stats';
@@ -25,9 +25,9 @@ import { produceNoteDao } from './produce_note_dao.js';
  */
 interface ProcessedData {
   /**
-   * Holds L2 block and a cache of already requested tx hashes.
+   * Holds L2 block.
    */
-  blockContext: L2BlockContext;
+  block: L2Block;
   /**
    * DAOs of processed notes.
    */
@@ -82,25 +82,20 @@ export class NoteProcessor {
   }
 
   /**
-   * Process the given L2 block contexts and encrypted logs to update the note processor.
-   * It synchronizes the user's account by decrypting the encrypted logs and processing
-   * the transactions and auxiliary data associated with them.
-   * Throws an error if the number of block contexts and encrypted logs do not match.
+   * Extracts new user-relevant notes from the information contained in the provided L2 blocks and encrypted logs.
    *
-   * @param l2BlockContexts - An array of L2 block contexts to be processed.
-   * @param encryptedL2BlockLogs - An array of encrypted logs associated with the L2 block contexts.
+   * @throws If the number of blocks and encrypted logs do not match.
+   * @param l2Blocks - L2 blocks to be processed.
+   * @param encryptedL2BlockLogs - Encrypted logs associated with the L2 blocks.
    * @returns A promise that resolves once the processing is completed.
    */
-  public async process(
-    l2BlockContexts: L2BlockContext[],
-    encryptedL2BlockLogs: EncryptedL2BlockL2Logs[],
-  ): Promise<void> {
-    if (l2BlockContexts.length !== encryptedL2BlockLogs.length) {
+  public async process(l2Blocks: L2Block[], encryptedL2BlockLogs: EncryptedL2BlockL2Logs[]): Promise<void> {
+    if (l2Blocks.length !== encryptedL2BlockLogs.length) {
       throw new Error(
-        `Number of blocks and EncryptedLogs is not equal. Received ${l2BlockContexts.length} blocks, ${encryptedL2BlockLogs.length} encrypted logs.`,
+        `Number of blocks and EncryptedLogs is not equal. Received ${l2Blocks.length} blocks, ${encryptedL2BlockLogs.length} encrypted logs.`,
       );
     }
-    if (!l2BlockContexts.length) {
+    if (l2Blocks.length === 0) {
       return;
     }
 
@@ -113,9 +108,10 @@ export class NoteProcessor {
     for (let blockIndex = 0; blockIndex < encryptedL2BlockLogs.length; ++blockIndex) {
       this.stats.blocks++;
       const { txLogs } = encryptedL2BlockLogs[blockIndex];
-      const blockContext = l2BlockContexts[blockIndex];
-      const block = blockContext.block;
-      const dataEndIndexForBlock = block.header.state.partial.noteHashTree.nextAvailableLeafIndex;
+      const block = l2Blocks[blockIndex];
+      const dataStartIndexForBlock =
+        block.header.state.partial.noteHashTree.nextAvailableLeafIndex -
+        block.body.numberOfTxsIncludingPadded * MAX_NEW_NOTE_HASHES_PER_TX;
 
       // We are using set for `userPertainingTxIndices` to avoid duplicates. This would happen in case there were
       // multiple encrypted logs in a tx pertaining to a user.
@@ -125,8 +121,7 @@ export class NoteProcessor {
       // Iterate over all the encrypted logs and try decrypting them. If successful, store the note.
       for (let indexOfTxInABlock = 0; indexOfTxInABlock < txLogs.length; ++indexOfTxInABlock) {
         this.stats.txs++;
-        const dataStartIndexForTx =
-          dataEndIndexForBlock - (txLogs.length - indexOfTxInABlock) * MAX_NEW_NOTE_HASHES_PER_TX;
+        const dataStartIndexForTx = dataStartIndexForBlock + indexOfTxInABlock * MAX_NEW_NOTE_HASHES_PER_TX;
         const newNoteHashes = block.body.txEffects[indexOfTxInABlock].noteHashes;
         // Note: Each tx generates a `TxL2Logs` object and for this reason we can rely on its index corresponding
         //       to the index of a tx in a block.
@@ -139,7 +134,7 @@ export class NoteProcessor {
             if (taggedNote?.notePayload) {
               const { notePayload: payload } = taggedNote;
               // We have successfully decrypted the data.
-              const txHash = blockContext.getTxHash(indexOfTxInABlock);
+              const txHash = block.body.txEffects[indexOfTxInABlock].txHash;
               try {
                 const noteDao = await produceNoteDao(
                   this.simulator,
@@ -178,7 +173,7 @@ export class NoteProcessor {
       }
 
       blocksAndNotes.push({
-        blockContext: l2BlockContexts[blockIndex],
+        block: l2Blocks[blockIndex],
         noteDaos,
       });
     }
@@ -186,10 +181,10 @@ export class NoteProcessor {
     await this.processBlocksAndNotes(blocksAndNotes);
     await this.processDeferredNotes(deferredNoteDaos);
 
-    const syncedToBlock = l2BlockContexts[l2BlockContexts.length - 1].block.number;
+    const syncedToBlock = l2Blocks[l2Blocks.length - 1].number;
     await this.db.setSynchedBlockNumberForPublicKey(this.publicKey, syncedToBlock);
 
-    this.log(`Synched block ${syncedToBlock}`);
+    this.log.debug(`Synched block ${syncedToBlock}`);
   }
 
   /**
@@ -199,14 +194,14 @@ export class NoteProcessor {
    * transaction auxiliary data from the database. This function keeps track of new nullifiers
    * and ensures all other transactions are updated with newly settled block information.
    *
-   * @param blocksAndNotes - Array of objects containing L2BlockContexts, user-pertaining transaction indices, and NoteDaos.
+   * @param blocksAndNotes - Array of objects containing L2 blocks, user-pertaining transaction indices, and NoteDaos.
    */
   private async processBlocksAndNotes(blocksAndNotes: ProcessedData[]) {
     const noteDaos = blocksAndNotes.flatMap(b => b.noteDaos);
     if (noteDaos.length) {
       await this.db.addNotes(noteDaos);
       noteDaos.forEach(noteDao => {
-        this.log(
+        this.log.verbose(
           `Added note for contract ${noteDao.contractAddress} at slot ${
             noteDao.storageSlot
           } with nullifier ${noteDao.siloedNullifier.toString()}`,
@@ -215,11 +210,11 @@ export class NoteProcessor {
     }
 
     const newNullifiers: Fr[] = blocksAndNotes.flatMap(b =>
-      b.blockContext.block.body.txEffects.flatMap(txEffect => txEffect.nullifiers),
+      b.block.body.txEffects.flatMap(txEffect => txEffect.nullifiers),
     );
     const removedNotes = await this.db.removeNullifiedNotes(newNullifiers, this.publicKey);
     removedNotes.forEach(noteDao => {
-      this.log(
+      this.log.verbose(
         `Removed note for contract ${noteDao.contractAddress} at slot ${
           noteDao.storageSlot
         } with nullifier ${noteDao.siloedNullifier.toString()}`,
@@ -236,7 +231,7 @@ export class NoteProcessor {
     if (deferredNoteDaos.length) {
       await this.db.addDeferredNotes(deferredNoteDaos);
       deferredNoteDaos.forEach(noteDao => {
-        this.log(
+        this.log.verbose(
           `Deferred note for contract ${noteDao.contractAddress} at slot ${
             noteDao.storageSlot
           } in tx ${noteDao.txHash.toString()}`,

package/src/pxe_http/pxe_http_server.ts

@@ -9,6 +9,7 @@ import {
   Note,
   NullifierMembershipWitness,
   type PXE,
+  SimulatedTx,
   Tx,
   TxEffect,
   TxExecutionRequest,
@@ -49,7 +50,7 @@ export function createPXERpcServer(pxeService: PXE): JsonRpcServer {
       TxEffect,
       LogId,
     },
-    { Tx, TxReceipt, EncryptedL2BlockL2Logs, UnencryptedL2BlockL2Logs, NullifierMembershipWitness },
+    { SimulatedTx, Tx, TxReceipt, EncryptedL2BlockL2Logs, UnencryptedL2BlockL2Logs, NullifierMembershipWitness },
     ['start', 'stop'],
   );
 }

package/src/pxe_service/pxe_service.ts

@@ -11,6 +11,7 @@ import {
   MerkleTreeId,
   type NoteFilter,
   type PXE,
+  SimulatedTx,
   SimulationError,
   Tx,
   type TxEffect,
@@ -27,8 +28,7 @@ import {
   CompleteAddress,
   FunctionData,
   type GrumpkinPrivateKey,
-  MAX_NON_REVERTIBLE_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-  MAX_REVERTIBLE_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+  MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
   type PartialAddress,
   type PrivateKernelTailCircuitPublicInputs,
   type PublicCallRequest,
@@ -71,7 +71,7 @@ export class PXEService implements PXE {
   private simulator: AcirSimulator;
   private log: DebugLogger;
   private nodeVersion: string;
-  // serialize synchronizer and calls to simulateTx.
+  // serialize synchronizer and calls to proveTx.
   // ensures that state is not changed while simulating
   private jobQueue = new SerialQueue();
 
@@ -121,7 +121,7 @@ export class PXEService implements PXE {
     }
 
     if (count > 0) {
-      this.log(`Restored ${count} accounts`);
+      this.log.info(`Restored ${count} accounts`);
     }
   }
 
@@ -388,26 +388,43 @@ export class PXEService implements PXE {
     return await this.node.getBlock(blockNumber);
   }
 
-  public async simulateTx(txRequest: TxExecutionRequest, simulatePublic: boolean) {
+  public async proveTx(txRequest: TxExecutionRequest, simulatePublic: boolean) {
+    return (await this.simulateTx(txRequest, simulatePublic)).tx;
+  }
+
+  public async simulateTx(
+    txRequest: TxExecutionRequest,
+    simulatePublic: boolean,
+    msgSender: AztecAddress | undefined = undefined,
+  ) {
     if (!txRequest.functionData.isPrivate) {
       throw new Error(`Public entrypoints are not allowed`);
     }
-
-    // all simulations must be serialized w.r.t. the synchronizer
     return await this.jobQueue.put(async () => {
       const timer = new Timer();
-      const tx = await this.#simulateAndProve(txRequest);
-      this.log(`Processed private part of ${tx.getTxHash()}`, {
-        eventName: 'tx-pxe-processing',
-        duration: timer.ms(),
-        ...tx.getStats(),
-      } satisfies TxPXEProcessingStats);
+      const simulatedTx = await this.#simulateAndProve(txRequest, msgSender);
+      // We log only if the msgSender is undefined, as simulating with a different msgSender
+      // is unlikely to be a real transaction, and likely to be only used to read data.
+      // Meaning that it will not necessarily have produced a nullifier (and thus have no TxHash)
+      // If we log, the `getTxHash` function will throw.
+
+      if (!msgSender) {
+        this.log.debug(`Processed private part of ${simulatedTx.tx.getTxHash()}`, {
+          eventName: 'tx-pxe-processing',
+          duration: timer.ms(),
+          ...simulatedTx.tx.getStats(),
+        } satisfies TxPXEProcessingStats);
+      }
+
       if (simulatePublic) {
-        await this.#simulatePublicCalls(tx);
+        // Only one transaction, so we can take index 0.
+        simulatedTx.publicReturnValues = (await this.#simulatePublicCalls(simulatedTx.tx))[0];
       }
-      this.log.info(`Executed local simulation for ${tx.getTxHash()}`);
 
-      return tx;
+      if (!msgSender) {
+        this.log.info(`Executed local simulation for ${simulatedTx.tx.getTxHash()}`);
+      }
+      return simulatedTx;
     });
   }
 
@@ -524,15 +541,15 @@ export class PXEService implements PXE {
     };
   }
 
-  async #simulate(txRequest: TxExecutionRequest): Promise<ExecutionResult> {
+  async #simulate(txRequest: TxExecutionRequest, msgSender?: AztecAddress): Promise<ExecutionResult> {
     // TODO - Pause syncing while simulating.
 
     const { contractAddress, functionArtifact, portalContract } = await this.#getSimulationParameters(txRequest);
 
-    this.log('Executing simulator...');
+    this.log.debug('Executing simulator...');
     try {
-      const result = await this.simulator.run(txRequest, functionArtifact, contractAddress, portalContract);
-      this.log('Simulation completed!');
+      const result = await this.simulator.run(txRequest, functionArtifact, contractAddress, portalContract, msgSender);
+      this.log.verbose(`Simulation completed for ${contractAddress.toString()}:${functionArtifact.name}`);
       return result;
     } catch (err) {
       if (err instanceof SimulationError) {
@@ -553,10 +570,10 @@ export class PXEService implements PXE {
   async #simulateUnconstrained(execRequest: FunctionCall) {
     const { contractAddress, functionArtifact } = await this.#getSimulationParameters(execRequest);
 
-    this.log('Executing unconstrained simulator...');
+    this.log.debug('Executing unconstrained simulator...');
     try {
       const result = await this.simulator.runUnconstrained(execRequest, functionArtifact, contractAddress);
-      this.log('Unconstrained simulation completed!');
+      this.log.verbose(`Unconstrained simulation for ${contractAddress}.${functionArtifact.name} completed`);
 
       return result;
     } catch (err) {
@@ -575,7 +592,7 @@ export class PXEService implements PXE {
    */
   async #simulatePublicCalls(tx: Tx) {
     try {
-      await this.node.simulatePublicCalls(tx);
+      return await this.node.simulatePublicCalls(tx);
     } catch (err) {
       // Try to fill in the noir call stack since the PXE may have access to the debug metadata
       if (err instanceof SimulationError) {
@@ -599,28 +616,26 @@ export class PXEService implements PXE {
 
   /**
    * Simulate a transaction, generate a kernel proof, and create a private transaction object.
-   * The function takes in a transaction request and an ECDSA signature. It simulates the transaction,
-   * then generates a kernel proof using the simulation result. Finally, it creates a private
+   * The function takes in a transaction request, simulates it, and then generates a kernel proof
+   * using the simulation result. Finally, it creates a private
    * transaction object with the generated proof and public inputs. If a new contract address is provided,
    * the function will also include the new contract's public functions in the transaction object.
    *
    * @param txExecutionRequest - The transaction request to be simulated and proved.
    * @param signature - The ECDSA signature for the transaction request.
-   * @returns A private transaction object containing the proof, public inputs, and encrypted logs.
+   * @param msgSender - (Optional) The message sender to use for the simulation.
+   * @returns An object tract contains:
+   * A private transaction object containing the proof, public inputs, and encrypted logs.
+   * The return values of the private execution
    */
-  async #simulateAndProve(txExecutionRequest: TxExecutionRequest) {
-    // TODO - Pause syncing while simulating.
-
+  async #simulateAndProve(txExecutionRequest: TxExecutionRequest, msgSender?: AztecAddress) {
     // Get values that allow us to reconstruct the block hash
-    const executionResult = await this.#simulate(txExecutionRequest);
+    const executionResult = await this.#simulate(txExecutionRequest, msgSender);
 
     const kernelOracle = new KernelOracle(this.contractDataOracle, this.keyStore, this.node);
     const kernelProver = new KernelProver(kernelOracle);
-    this.log(`Executing kernel prover...`);
+    this.log.debug(`Executing kernel prover...`);
     const { proof, publicInputs } = await kernelProver.prove(txExecutionRequest.toTxRequest(), executionResult);
-    this.log(
-      `Needs setup: ${publicInputs.needsSetup}, needs app logic: ${publicInputs.needsAppLogic}, needs teardown: ${publicInputs.needsTeardown}`,
-    );
 
     const encryptedLogs = new EncryptedTxL2Logs(collectEncryptedLogs(executionResult));
     const unencryptedLogs = new UnencryptedTxL2Logs(collectUnencryptedLogs(executionResult));
@@ -630,7 +645,8 @@ export class PXEService implements PXE {
     // TODO(#757): Enforce proper ordering of enqueued public calls
     await this.patchPublicCallStackOrdering(publicInputs, enqueuedPublicFunctions);
 
-    return new Tx(publicInputs, proof, encryptedLogs, unencryptedLogs, enqueuedPublicFunctions);
+    const tx = new Tx(publicInputs, proof, encryptedLogs, unencryptedLogs, enqueuedPublicFunctions);
+    return new SimulatedTx(tx, [executionResult.returnValues]);
   }
 
   /**
@@ -681,55 +697,62 @@ export class PXEService implements PXE {
     publicInputs: PrivateKernelTailCircuitPublicInputs,
     enqueuedPublicCalls: PublicCallRequest[],
   ) {
+    if (!publicInputs.forPublic) {
+      return;
+    }
+
     const enqueuedPublicCallStackItems = await Promise.all(enqueuedPublicCalls.map(c => c.toCallRequest()));
 
     // Validate all items in enqueued public calls are in the kernel emitted stack
     const enqueuedRevertiblePublicCallStackItems = enqueuedPublicCallStackItems.filter(enqueued =>
-      publicInputs.end.publicCallStack.find(item => item.equals(enqueued)),
+      publicInputs.forPublic!.end.publicCallStack.find(item => item.equals(enqueued)),
     );
 
-    const revertibleStackSize = arrayNonEmptyLength(publicInputs.end.publicCallStack, item => item.isEmpty());
+    const revertibleStackSize = arrayNonEmptyLength(publicInputs.forPublic.end.publicCallStack, item => item.isEmpty());
 
     if (enqueuedRevertiblePublicCallStackItems.length !== revertibleStackSize) {
       throw new Error(
         `Enqueued revertible public function calls and revertible public call stack do not match.\nEnqueued calls: ${enqueuedRevertiblePublicCallStackItems
           .map(h => h.hash.toString())
-          .join(', ')}\nPublic call stack: ${publicInputs.end.publicCallStack.map(i => i.toString()).join(', ')}`,
+          .join(', ')}\nPublic call stack: ${publicInputs.forPublic.end.publicCallStack
+          .map(i => i.toString())
+          .join(', ')}`,
       );
     }
 
     // Override kernel output
-    publicInputs.end.publicCallStack = padArrayEnd(
+    publicInputs.forPublic.end.publicCallStack = padArrayEnd(
       enqueuedRevertiblePublicCallStackItems,
       CallRequest.empty(),
-      MAX_REVERTIBLE_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+      MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
     );
 
     // Do the same for non-revertible
 
     const enqueuedNonRevertiblePublicCallStackItems = enqueuedPublicCallStackItems.filter(enqueued =>
-      publicInputs.endNonRevertibleData.publicCallStack.find(item => item.equals(enqueued)),
+      publicInputs.forPublic!.endNonRevertibleData.publicCallStack.find(item => item.equals(enqueued)),
     );
 
-    const nonRevertibleStackSize = arrayNonEmptyLength(publicInputs.endNonRevertibleData.publicCallStack, item =>
-      item.isEmpty(),
+    const nonRevertibleStackSize = arrayNonEmptyLength(
+      publicInputs.forPublic.endNonRevertibleData.publicCallStack,
+      item => item.isEmpty(),
     );
 
     if (enqueuedNonRevertiblePublicCallStackItems.length !== nonRevertibleStackSize) {
       throw new Error(
         `Enqueued non-revertible public function calls and non-revertible public call stack do not match.\nEnqueued calls: ${enqueuedNonRevertiblePublicCallStackItems
           .map(h => h.hash.toString())
-          .join(', ')}\nPublic call stack: ${publicInputs.endNonRevertibleData.publicCallStack
+          .join(', ')}\nPublic call stack: ${publicInputs.forPublic.endNonRevertibleData.publicCallStack
           .map(i => i.toString())
           .join(', ')}`,
       );
     }
 
     // Override kernel output
-    publicInputs.endNonRevertibleData.publicCallStack = padArrayEnd(
+    publicInputs.forPublic.endNonRevertibleData.publicCallStack = padArrayEnd(
       enqueuedNonRevertiblePublicCallStackItems,
       CallRequest.empty(),
-      MAX_NON_REVERTIBLE_PUBLIC_CALL_STACK_LENGTH_PER_TX,
+      MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
     );
   }
 

package/src/pxe_service/test/pxe_test_suite.ts

@@ -135,12 +135,12 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
         authWitnesses: [],
       });
 
-      await expect(async () => await pxe.simulateTx(txExecutionRequest, false)).rejects.toThrow(
+      await expect(async () => await pxe.proveTx(txExecutionRequest, false)).rejects.toThrow(
         'Public entrypoints are not allowed',
       );
     });
 
-    // Note: Not testing a successful run of `simulateTx`, `sendTx`, `getTxReceipt` and `viewTx` here as it requires
+    // Note: Not testing a successful run of `proveTx`, `sendTx`, `getTxReceipt` and `viewTx` here as it requires
     //       a larger setup and it's sufficiently tested in the e2e tests.
 
     it('throws when getting public storage for non-existent contract', async () => {

package/src/synchronizer/synchronizer.ts

@@ -1,7 +1,7 @@
 import {
   type AztecNode,
   type KeyStore,
-  L2BlockContext,
+  type L2Block,
   L2BlockL2Logs,
   MerkleTreeId,
   type TxHash,
@@ -51,10 +51,10 @@ export class Synchronizer {
     this.running = true;
 
     await this.jobQueue.put(() => this.initialSync());
-    this.log('Initial sync complete');
+    this.log.info('Initial sync complete');
     this.runningPromise = new RunningPromise(() => this.sync(limit), retryInterval);
     this.runningPromise.start();
-    this.log('Started loop');
+    this.log.debug('Started loop');
   }
 
   protected async initialSync() {
@@ -107,17 +107,16 @@ export class Synchronizer {
 
       const encryptedLogs = blocks.flatMap(block => block.body.encryptedLogs);
 
-      // Wrap blocks in block contexts & only keep those that match our query
-      const blockContexts = blocks.filter(block => block.number >= from).map(block => new L2BlockContext(block));
-
       // Update latest tree roots from the most recent block
-      const latestBlock = blockContexts[blockContexts.length - 1];
+      const latestBlock = blocks[blocks.length - 1];
       await this.setHeaderFromBlock(latestBlock);
 
       const logCount = L2BlockL2Logs.getTotalLogCount(encryptedLogs);
-      this.log(`Forwarding ${logCount} encrypted logs and blocks to ${this.noteProcessors.length} note processors`);
+      this.log.debug(
+        `Forwarding ${logCount} encrypted logs and blocks to ${this.noteProcessors.length} note processors`,
+      );
       for (const noteProcessor of this.noteProcessors) {
-        await noteProcessor.process(blockContexts, encryptedLogs);
+        await noteProcessor.process(blocks, encryptedLogs);
       }
       return true;
     } catch (err) {
@@ -185,14 +184,12 @@ export class Synchronizer {
 
       const encryptedLogs = blocks.flatMap(block => block.body.encryptedLogs);
 
-      const blockContexts = blocks.map(block => new L2BlockContext(block));
-
       const logCount = L2BlockL2Logs.getTotalLogCount(encryptedLogs);
-      this.log(`Forwarding ${logCount} encrypted logs and blocks to note processors in catch up mode`);
+      this.log.debug(`Forwarding ${logCount} encrypted logs and blocks to note processors in catch up mode`);
 
       for (const noteProcessor of catchUpGroup) {
         // find the index of the first block that the note processor is not yet synced to
-        const index = blockContexts.findIndex(block => block.block.number > noteProcessor.status.syncedToBlock);
+        const index = blocks.findIndex(block => block.number > noteProcessor.status.syncedToBlock);
         if (index === -1) {
           // Due to the limit, we might not have fetched a new enough block for the note processor.
           // And since the group is sorted, we break as soon as we find a note processor
@@ -202,14 +199,14 @@ export class Synchronizer {
 
         this.log.debug(
           `Catching up note processor ${noteProcessor.publicKey.toString()} by processing ${
-            blockContexts.length - index
+            blocks.length - index
           } blocks`,
         );
-        await noteProcessor.process(blockContexts.slice(index), encryptedLogs.slice(index));
+        await noteProcessor.process(blocks.slice(index), encryptedLogs.slice(index));
 
         if (noteProcessor.status.syncedToBlock === toBlockNumber) {
           // Note processor caught up, move it to `noteProcessors` from `noteProcessorsToCatchUp`.
-          this.log(`Note processor for ${noteProcessor.publicKey.toString()} has caught up`, {
+          this.log.debug(`Note processor for ${noteProcessor.publicKey.toString()} has caught up`, {
             eventName: 'note-processor-caught-up',
             publicKey: noteProcessor.publicKey.toString(),
             duration: noteProcessor.timer.ms(),
@@ -231,13 +228,12 @@ export class Synchronizer {
     }
   }
 
-  private async setHeaderFromBlock(latestBlock: L2BlockContext) {
-    const { block } = latestBlock;
-    if (block.number < this.initialSyncBlockNumber) {
+  private async setHeaderFromBlock(latestBlock: L2Block) {
+    if (latestBlock.number < this.initialSyncBlockNumber) {
       return;
     }
 
-    await this.db.setHeader(block.header);
+    await this.db.setHeader(latestBlock.header);
   }
 
   /**
@@ -250,7 +246,7 @@ export class Synchronizer {
   public async stop() {
     this.running = false;
     await this.runningPromise?.stop();
-    this.log('Stopped');
+    this.log.info('Stopped');
   }
 
   /**
@@ -360,7 +356,7 @@ export class Synchronizer {
     await this.db.addNotes(newNotes);
 
     newNotes.forEach(noteDao => {
-      this.log(
+      this.log.debug(
         `Decoded deferred note for contract ${noteDao.contractAddress} at slot ${
           noteDao.storageSlot
         } with nullifier ${noteDao.siloedNullifier.toString()}`,