@aztec/pxe 0.40.1 → 0.42.0

package/src/pxe_service/create_pxe_service.ts

@@ -1,7 +1,8 @@
 import { BBNativeProofCreator } from '@aztec/bb-prover';
 import { type AztecNode, type ProofCreator } from '@aztec/circuit-types';
 import { randomBytes } from '@aztec/foundation/crypto';
-import { TestKeyStore } from '@aztec/key-store';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { KeyStore } from '@aztec/key-store';
 import { AztecLmdbStore } from '@aztec/kv-store/lmdb';
 import { initStoreForRollup } from '@aztec/kv-store/utils';
 import { getCanonicalClassRegisterer } from '@aztec/protocol-contracts/class-registerer';
@@ -19,7 +20,7 @@ import { PXEService } from './pxe_service.js';
 
 /**
  * Create and start an PXEService instance with the given AztecNode.
- * If no keyStore or database is provided, it will use TestKeyStore and MemoryDB as default values.
+ * If no keyStore or database is provided, it will use KeyStore and MemoryDB as default values.
  * Returns a Promise that resolves to the started PXEService instance.
  *
  * @param aztecNode - The AztecNode instance to be used by the server.
@@ -41,9 +42,7 @@ export async function createPXEService(
   const keyStorePath = config.dataDirectory ? join(config.dataDirectory, 'pxe_key_store') : undefined;
   const l1Contracts = await aztecNode.getL1ContractAddresses();
 
-  const keyStore = new TestKeyStore(
-    await initStoreForRollup(AztecLmdbStore.open(keyStorePath), l1Contracts.rollupAddress),
-  );
+  const keyStore = new KeyStore(await initStoreForRollup(AztecLmdbStore.open(keyStorePath), l1Contracts.rollupAddress));
   const db = new KVPxeDatabase(await initStoreForRollup(AztecLmdbStore.open(pxeDbPath), l1Contracts.rollupAddress));
 
   // (@PhilWindle) Temporary validation until WASM is implemented
@@ -54,7 +53,11 @@ export async function createPXEService(
     }
     prover = !config.proverEnabled
       ? new TestProofCreator()
-      : new BBNativeProofCreator(config.bbBinaryPath!, config.bbWorkingDirectory!);
+      : new BBNativeProofCreator(
+          config.bbBinaryPath!,
+          config.bbWorkingDirectory!,
+          createDebugLogger('aztec:pxe:bb-native-prover' + (logSuffix ? `:${logSuffix}` : '')),
+        );
   }
 
   const server = new PXEService(keyStore, aztecNode, db, prover, config, logSuffix);
@@ -62,7 +65,7 @@ export async function createPXEService(
     getCanonicalClassRegisterer(),
     getCanonicalInstanceDeployer(),
     getCanonicalMultiCallEntrypointContract(),
-    getCanonicalGasToken(l1Contracts.gasPortalAddress),
+    getCanonicalGasToken(),
     getCanonicalKeyRegistry(),
   ]) {
     await server.registerContract(contract);

package/src/pxe_service/pxe_service.ts

@@ -1,16 +1,17 @@
 import {
   type AuthWitness,
   type AztecNode,
+  EncryptedNoteTxL2Logs,
   EncryptedTxL2Logs,
   ExtendedNote,
   type FunctionCall,
   type GetUnencryptedLogsResponse,
-  type KeyStore,
   type L2Block,
   type LogFilter,
   MerkleTreeId,
   type NoteFilter,
   type PXE,
+  type PXEInfo,
   type ProofCreator,
   SimulatedTx,
   SimulationError,
@@ -22,32 +23,32 @@ import {
   UnencryptedTxL2Logs,
   isNoirCallStackUnresolved,
 } from '@aztec/circuit-types';
-import { type TxPXEProcessingStats } from '@aztec/circuit-types/stats';
 import {
   AztecAddress,
-  CallRequest,
   type CompleteAddress,
-  FunctionData,
-  MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
   type PartialAddress,
-  type PrivateKernelTailCircuitPublicInputs,
-  type PublicCallRequest,
   computeContractClassId,
   getContractClassFromArtifact,
 } from '@aztec/circuits.js';
 import { computeNoteHashNonce, siloNullifier } from '@aztec/circuits.js/hash';
 import { type ContractArtifact, type DecodedReturn, FunctionSelector, encodeArguments } from '@aztec/foundation/abi';
-import { arrayNonEmptyLength, padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { type Fq, Fr } from '@aztec/foundation/fields';
 import { SerialQueue } from '@aztec/foundation/fifo';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
-import { Timer } from '@aztec/foundation/timer';
+import { type KeyStore } from '@aztec/key-store';
+import { getCanonicalClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
+import { getCanonicalGasToken } from '@aztec/protocol-contracts/gas-token';
+import { getCanonicalInstanceDeployer } from '@aztec/protocol-contracts/instance-deployer';
+import { getCanonicalKeyRegistryAddress } from '@aztec/protocol-contracts/key-registry';
+import { getCanonicalMultiCallEntrypointAddress } from '@aztec/protocol-contracts/multi-call-entrypoint';
 import {
   type AcirSimulator,
   type ExecutionResult,
+  accumulateReturnValues,
   collectEnqueuedPublicFunctionCalls,
   collectPublicTeardownFunctionCall,
   collectSortedEncryptedLogs,
+  collectSortedNoteEncryptedLogs,
   collectSortedUnencryptedLogs,
   resolveOpcodeLocations,
 } from '@aztec/simulator';
@@ -71,7 +72,7 @@ export class PXEService implements PXE {
   private contractDataOracle: ContractDataOracle;
   private simulator: AcirSimulator;
   private log: DebugLogger;
-  private nodeVersion: string;
+  private packageVersion: string;
   // serialize synchronizer and calls to proveTx.
   // ensures that state is not changed while simulating
   private jobQueue = new SerialQueue();
@@ -88,7 +89,7 @@ export class PXEService implements PXE {
     this.synchronizer = new Synchronizer(node, db, this.jobQueue, logSuffix);
     this.contractDataOracle = new ContractDataOracle(db);
     this.simulator = getAcirSimulator(db, node, keyStore, this.contractDataOracle);
-    this.nodeVersion = getPackageInfo().version;
+    this.packageVersion = getPackageInfo().version;
 
     this.jobQueue.start();
   }
@@ -159,6 +160,10 @@ export class PXEService implements PXE {
     return this.db.getAuthWitness(messageHash);
   }
 
+  async rotateNskM(account: AztecAddress, secretKey: Fq): Promise<void> {
+    await this.keyStore.rotateMasterNullifierKey(account, secretKey);
+  }
+
   public addCapsule(capsule: Fr[]) {
     return this.db.addCapsule(capsule);
   }
@@ -207,14 +212,6 @@ export class PXEService implements PXE {
     return Promise.resolve(account);
   }
 
-  public async getRegisteredAccountPublicKeysHash(address: AztecAddress): Promise<Fr | undefined> {
-    const accounts = await this.keyStore.getAccounts();
-    if (!accounts.some(account => account.equals(address))) {
-      return undefined;
-    }
-    return this.keyStore.getPublicKeysHash(address);
-  }
-
   public async registerRecipient(recipient: CompleteAddress): Promise<void> {
     const wasAdded = await this.db.addCompleteAddress(recipient);
 
@@ -428,25 +425,13 @@ export class PXEService implements PXE {
     simulatePublic: boolean,
     msgSender: AztecAddress | undefined = undefined,
   ): Promise<SimulatedTx> {
-    if (!txRequest.functionData.isPrivate) {
-      throw new Error(`Public entrypoints are not allowed`);
-    }
     return await this.jobQueue.put(async () => {
-      const timer = new Timer();
       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) {
         simulatedTx.publicOutput = await this.#simulatePublicCalls(simulatedTx.tx);
       }
@@ -468,7 +453,7 @@ export class PXEService implements PXE {
     return txHash;
   }
 
-  public async viewTx(
+  public async simulateUnconstrained(
     functionName: string,
     args: any[],
     to: AztecAddress,
@@ -520,28 +505,49 @@ export class PXEService implements PXE {
     }
 
     return {
+      name: functionDao.name,
       args: encodeArguments(functionDao, args),
-      functionData: FunctionData.fromAbi(functionDao),
+      selector: FunctionSelector.fromNameAndParameters(functionDao.name, functionDao.parameters),
+      type: functionDao.functionType,
       to,
+      isStatic: functionDao.isStatic,
+      returnTypes: functionDao.returnTypes,
     };
   }
 
   public async getNodeInfo(): Promise<NodeInfo> {
-    const [version, chainId, contractAddresses] = await Promise.all([
+    const [nodeVersion, protocolVersion, chainId, contractAddresses, protocolContractAddresses] = await Promise.all([
+      this.node.getNodeVersion(),
       this.node.getVersion(),
       this.node.getChainId(),
       this.node.getL1ContractAddresses(),
+      this.node.getProtocolContractAddresses(),
     ]);
 
     const nodeInfo: NodeInfo = {
-      nodeVersion: this.nodeVersion,
+      nodeVersion,
       chainId,
-      protocolVersion: version,
+      protocolVersion,
       l1ContractAddresses: contractAddresses,
+      protocolContractAddresses: protocolContractAddresses,
     };
+
     return nodeInfo;
   }
 
+  public getPXEInfo(): Promise<PXEInfo> {
+    return Promise.resolve({
+      pxeVersion: this.packageVersion,
+      protocolContractAddresses: {
+        classRegisterer: getCanonicalClassRegistererAddress(),
+        gasToken: getCanonicalGasToken().address,
+        instanceDeployer: getCanonicalInstanceDeployer().address,
+        keyRegistry: getCanonicalKeyRegistryAddress(),
+        multiCallEntrypoint: getCanonicalMultiCallEntrypointAddress(),
+      },
+    });
+  }
+
   /**
    * Retrieves the simulation parameters required to run an ACIR simulation.
    * This includes the contract address, function artifact, and historical tree roots.
@@ -551,14 +557,10 @@ export class PXEService implements PXE {
    */
   async #getSimulationParameters(execRequest: FunctionCall | TxExecutionRequest) {
     const contractAddress = (execRequest as FunctionCall).to ?? (execRequest as TxExecutionRequest).origin;
-    const functionArtifact = await this.contractDataOracle.getFunctionArtifact(
-      contractAddress,
-      execRequest.functionData.selector,
-    );
-    const debug = await this.contractDataOracle.getFunctionDebugMetadata(
-      contractAddress,
-      execRequest.functionData.selector,
-    );
+    const functionSelector =
+      (execRequest as FunctionCall).selector ?? (execRequest as TxExecutionRequest).functionSelector;
+    const functionArtifact = await this.contractDataOracle.getFunctionArtifact(contractAddress, functionSelector);
+    const debug = await this.contractDataOracle.getFunctionDebugMetadata(contractAddress, functionSelector);
 
     return {
       contractAddress,
@@ -665,24 +667,23 @@ export class PXEService implements PXE {
     this.log.debug(`Executing kernel prover...`);
     const { proof, publicInputs } = await kernelProver.prove(txExecutionRequest.toTxRequest(), executionResult);
 
+    const noteEncryptedLogs = new EncryptedNoteTxL2Logs([collectSortedNoteEncryptedLogs(executionResult)]);
     const unencryptedLogs = new UnencryptedTxL2Logs([collectSortedUnencryptedLogs(executionResult)]);
     const encryptedLogs = new EncryptedTxL2Logs([collectSortedEncryptedLogs(executionResult)]);
     const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(executionResult);
     const teardownPublicFunction = collectPublicTeardownFunctionCall(executionResult);
 
-    // HACK(#1639): Manually patches the ordering of the public call stack
-    // TODO(#757): Enforce proper ordering of enqueued public calls
-    await this.patchPublicCallStackOrdering(publicInputs, enqueuedPublicFunctions);
-
     const tx = new Tx(
       publicInputs,
       proof.binaryProof,
+      noteEncryptedLogs,
       encryptedLogs,
       unencryptedLogs,
       enqueuedPublicFunctions,
       teardownPublicFunction,
     );
-    return new SimulatedTx(tx, executionResult.returnValues);
+
+    return new SimulatedTx(tx, accumulateReturnValues(executionResult));
   }
 
   /**
@@ -722,76 +723,6 @@ export class PXEService implements PXE {
     );
   }
 
-  // HACK(#1639): this is a hack to fix ordering of public calls enqueued in the call stack. Since the private kernel
-  // cannot keep track of side effects that happen after or before a nested call, we override the public call stack
-  // it emits with whatever we got from the simulator collected enqueued calls. As a sanity check, we at least verify
-  // that the elements are the same, so we are only tweaking their ordering.
-  // See yarn-project/end-to-end/src/e2e_ordering.test.ts
-  // See https://github.com/AztecProtocol/aztec-packages/issues/1615
-  // TODO(#757): Enforce proper ordering of enqueued public calls
-  private async patchPublicCallStackOrdering(
-    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.forPublic!.end.publicCallStack.find(item => item.equals(enqueued)),
-    );
-
-    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.forPublic.end.publicCallStack
-          .map(i => i.toString())
-          .join(', ')}`,
-      );
-    }
-
-    // Override kernel output
-    publicInputs.forPublic.end.publicCallStack = padArrayEnd(
-      enqueuedRevertiblePublicCallStackItems,
-      CallRequest.empty(),
-      MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-    );
-
-    // Do the same for non-revertible
-
-    const enqueuedNonRevertiblePublicCallStackItems = enqueuedPublicCallStackItems.filter(enqueued =>
-      publicInputs.forPublic!.endNonRevertibleData.publicCallStack.find(item => item.equals(enqueued)),
-    );
-
-    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.forPublic.endNonRevertibleData.publicCallStack
-          .map(i => i.toString())
-          .join(', ')}`,
-      );
-    }
-
-    // Override kernel output
-    publicInputs.forPublic.endNonRevertibleData.publicCallStack = padArrayEnd(
-      enqueuedNonRevertiblePublicCallStackItems,
-      CallRequest.empty(),
-      MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
-    );
-  }
-
   public async isGlobalStateSynchronized() {
     return await this.synchronizer.isGlobalStateSynchronized();
   }
@@ -804,6 +735,10 @@ export class PXEService implements PXE {
     return Promise.resolve(this.synchronizer.getSyncStatus());
   }
 
+  public getSyncStats() {
+    return Promise.resolve(this.synchronizer.getSyncStats());
+  }
+
   public async isContractClassPubliclyRegistered(id: Fr): Promise<boolean> {
     return !!(await this.node.getContractClass(id));
   }

package/src/pxe_service/test/pxe_test_suite.ts

@@ -1,6 +1,5 @@
 import {
   type PXE,
-  TxExecutionRequest,
   randomContractArtifact,
   randomContractInstanceWithAddress,
   randomDeployedContract,
@@ -9,11 +8,9 @@ import {
   AztecAddress,
   CompleteAddress,
   Fr,
-  FunctionData,
   INITIAL_L2_BLOCK_NUM,
   Point,
   PublicKeys,
-  TxContext,
   getContractClassFromArtifact,
 } from '@aztec/circuits.js';
 
@@ -126,24 +123,7 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
       await expect(pxe.registerContract({ instance, artifact })).rejects.toThrow(/Artifact does not match/i);
     });
 
-    it('throws when simulating a tx targeting public entrypoint', async () => {
-      const functionData = FunctionData.empty();
-      functionData.isPrivate = false;
-      const txExecutionRequest = TxExecutionRequest.from({
-        origin: AztecAddress.random(),
-        firstCallArgsHash: new Fr(0),
-        functionData,
-        txContext: TxContext.empty(),
-        argsOfCalls: [],
-        authWitnesses: [],
-      });
-
-      await expect(async () => await pxe.proveTx(txExecutionRequest, false)).rejects.toThrow(
-        'Public entrypoints are not allowed',
-      );
-    });
-
-    // Note: Not testing a successful run of `proveTx`, `sendTx`, `getTxReceipt` and `viewTx` here as it requires
+    // Note: Not testing a successful run of `proveTx`, `sendTx`, `getTxReceipt` and `simulateUnconstrained` 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/simulator/index.ts

@@ -1,4 +1,5 @@
-import { type AztecNode, type KeyStore } from '@aztec/circuit-types';
+import { type AztecNode } from '@aztec/circuit-types';
+import { type KeyStore } from '@aztec/key-store';
 import { AcirSimulator } from '@aztec/simulator';
 
 import { ContractDataOracle } from '../contract_data_oracle/index.js';

package/src/simulator_oracle/index.ts

@@ -1,6 +1,5 @@
 import {
   type AztecNode,
-  type KeyStore,
   type L2Block,
   MerkleTreeId,
   type NoteStatus,
@@ -14,12 +13,14 @@ import {
   type Fr,
   type FunctionSelector,
   type Header,
+  type KeyValidationRequest,
   type L1_TO_L2_MSG_TREE_HEIGHT,
 } from '@aztec/circuits.js';
 import { computeL1ToL2MessageNullifier } from '@aztec/circuits.js/hash';
 import { type FunctionArtifact, getFunctionArtifact } from '@aztec/foundation/abi';
 import { createDebugLogger } from '@aztec/foundation/log';
-import { type DBOracle, MessageLoadOracleInputs, type NullifierKeys } from '@aztec/simulator';
+import { type KeyStore } from '@aztec/key-store';
+import { type DBOracle, MessageLoadOracleInputs } from '@aztec/simulator';
 import { type ContractInstance } from '@aztec/types/contracts';
 
 import { type ContractDataOracle } from '../contract_data_oracle/index.js';
@@ -37,17 +38,16 @@ export class SimulatorOracle implements DBOracle {
     private log = createDebugLogger('aztec:pxe:simulator_oracle'),
   ) {}
 
-  async getNullifierKeys(accountAddress: AztecAddress, contractAddress: AztecAddress): Promise<NullifierKeys> {
-    const masterNullifierPublicKey = await this.keyStore.getMasterNullifierPublicKey(accountAddress);
-    const appNullifierSecretKey = await this.keyStore.getAppNullifierSecretKey(accountAddress, contractAddress);
-    return { masterNullifierPublicKey, appNullifierSecretKey };
+  getKeyValidationRequest(pkMHash: Fr, contractAddress: AztecAddress): Promise<KeyValidationRequest> {
+    return this.keyStore.getKeyValidationRequest(pkMHash, contractAddress);
   }
 
-  async getCompleteAddress(address: AztecAddress): Promise<CompleteAddress> {
-    const completeAddress = await this.db.getCompleteAddress(address);
+  async getCompleteAddress(account: AztecAddress): Promise<CompleteAddress> {
+    const completeAddress = await this.db.getCompleteAddress(account);
     if (!completeAddress) {
       throw new Error(
-        `No public key registered for address ${address.toString()}. Register it by calling pxe.registerRecipient(...) or pxe.registerAccount(...).\nSee docs for context: https://docs.aztec.network/developers/debugging/aztecnr-errors#simulation-error-No-public-key-registered-for-address-0x0-Register-it-by-calling-pxeregisterRecipient-or-pxeregisterAccount`,
+        `No public key registered for address ${account}.
+        Register it by calling pxe.registerRecipient(...) or pxe.registerAccount(...).\nSee docs for context: https://docs.aztec.network/developers/debugging/aztecnr-errors#simulation-error-No-public-key-registered-for-address-0x0-Register-it-by-calling-pxeregisterRecipient-or-pxeregisterAccount`,
       );
     }
     return completeAddress;
@@ -230,4 +230,8 @@ export class SimulatorOracle implements DBOracle {
   public async getBlockNumber(): Promise<number> {
     return await this.aztecNode.getBlockNumber();
   }
+
+  public getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string> {
+    return this.contractDataOracle.getDebugFunctionName(contractAddress, selector);
+  }
 }

package/src/synchronizer/synchronizer.ts

@@ -1,16 +1,10 @@
-import {
-  type AztecNode,
-  type KeyStore,
-  type L2Block,
-  L2BlockL2Logs,
-  MerkleTreeId,
-  type TxHash,
-} from '@aztec/circuit-types';
+import { type AztecNode, type L2Block, L2BlockL2Logs, MerkleTreeId, type TxHash } from '@aztec/circuit-types';
 import { type NoteProcessorCaughtUpStats } from '@aztec/circuit-types/stats';
 import { type AztecAddress, type Fr, INITIAL_L2_BLOCK_NUM, type PublicKey } from '@aztec/circuits.js';
 import { type SerialQueue } from '@aztec/foundation/fifo';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { RunningPromise } from '@aztec/foundation/running-promise';
+import { type KeyStore } from '@aztec/key-store';
 
 import { type DeferredNoteDao } from '../database/deferred_note_dao.js';
 import { type PxeDatabase } from '../database/index.js';
@@ -105,18 +99,19 @@ export class Synchronizer {
         return false;
       }
 
-      const encryptedLogs = blocks.flatMap(block => block.body.encryptedLogs);
+      const noteEncryptedLogs = blocks.flatMap(block => block.body.noteEncryptedLogs);
 
       // Update latest tree roots from the most recent block
       const latestBlock = blocks[blocks.length - 1];
       await this.setHeaderFromBlock(latestBlock);
 
-      const logCount = L2BlockL2Logs.getTotalLogCount(encryptedLogs);
+      const logCount = L2BlockL2Logs.getTotalLogCount(noteEncryptedLogs);
       this.log.debug(
         `Forwarding ${logCount} encrypted logs and blocks to ${this.noteProcessors.length} note processors`,
       );
       for (const noteProcessor of this.noteProcessors) {
-        await noteProcessor.process(blocks, encryptedLogs);
+        // TODO(#6830): pass in only the blocks
+        await noteProcessor.process(blocks, noteEncryptedLogs);
       }
       return true;
     } catch (err) {
@@ -182,9 +177,9 @@ export class Synchronizer {
         throw new Error('No blocks in processor catch up mode');
       }
 
-      const encryptedLogs = blocks.flatMap(block => block.body.encryptedLogs);
+      const noteEncryptedLogs = blocks.flatMap(block => block.body.noteEncryptedLogs);
 
-      const logCount = L2BlockL2Logs.getTotalLogCount(encryptedLogs);
+      const logCount = L2BlockL2Logs.getTotalLogCount(noteEncryptedLogs);
       this.log.debug(`Forwarding ${logCount} encrypted logs and blocks to note processors in catch up mode`);
 
       for (const noteProcessor of catchUpGroup) {
@@ -202,7 +197,7 @@ export class Synchronizer {
             blocks.length - index
           } blocks`,
         );
-        await noteProcessor.process(blocks.slice(index), encryptedLogs.slice(index));
+        await noteProcessor.process(blocks.slice(index), noteEncryptedLogs.slice(index));
 
         if (noteProcessor.status.syncedToBlock === toBlockNumber) {
           // Note processor caught up, move it to `noteProcessors` from `noteProcessorsToCatchUp`.
@@ -325,6 +320,14 @@ export class Synchronizer {
     };
   }
 
+  /**
+   * Returns the note processor stats.
+   * @returns The note processor stats for notes for each public key being tracked.
+   */
+  public getSyncStats() {
+    return Object.fromEntries(this.noteProcessors.map(n => [n.masterIncomingViewingPublicKey.toString(), n.stats]));
+  }
+
   /**
    * Retry decoding any deferred notes for the specified contract address.
    * @param contractAddress - the contract address that has just been added

package/dest/kernel_prover/private_inputs_builders/build_private_kernel_tail_outputs.d.ts

@@ -1,4 +0,0 @@
-import { MAX_NEW_NOTE_HASHES_PER_TX, MAX_NEW_NULLIFIERS_PER_TX, PrivateKernelTailOutputs, ScopedNoteHash, ScopedNullifier } from '@aztec/circuits.js';
-import { type Tuple } from '@aztec/foundation/serialize';
-export declare function buildPrivateKernelTailOutputs(prevNoteHashes: Tuple<ScopedNoteHash, typeof MAX_NEW_NOTE_HASHES_PER_TX>, prevNullifiers: Tuple<ScopedNullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>): PrivateKernelTailOutputs;
-//# sourceMappingURL=build_private_kernel_tail_outputs.d.ts.map

package/dest/kernel_prover/private_inputs_builders/build_private_kernel_tail_outputs.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"build_private_kernel_tail_outputs.d.ts","sourceRoot":"","sources":["../../../src/kernel_prover/private_inputs_builders/build_private_kernel_tail_outputs.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,0BAA0B,EAC1B,yBAAyB,EACzB,wBAAwB,EACxB,cAAc,EACd,eAAe,EAChB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,KAAK,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD,wBAAgB,6BAA6B,CAC3C,cAAc,EAAE,KAAK,CAAC,cAAc,EAAE,OAAO,0BAA0B,CAAC,EACxE,cAAc,EAAE,KAAK,CAAC,eAAe,EAAE,OAAO,yBAAyB,CAAC,4BAiBzE"}

package/dest/kernel_prover/private_inputs_builders/build_private_kernel_tail_outputs.js

@@ -1,10 +0,0 @@
-import { MAX_NEW_NOTE_HASHES_PER_TX, MAX_NEW_NULLIFIERS_PER_TX, PrivateKernelTailOutputs, ScopedNoteHash, ScopedNullifier, } from '@aztec/circuits.js';
-import { padArrayEnd } from '@aztec/foundation/collection';
-export function buildPrivateKernelTailOutputs(prevNoteHashes, prevNullifiers) {
-    // Propagate note hashes that are not linked to a nullifier.
-    // Note that note hashes can't link to the first nullifier (counter == 0).
-    const noteHashes = padArrayEnd(prevNoteHashes.filter(n => !n.nullifierCounter), ScopedNoteHash.empty(), MAX_NEW_NOTE_HASHES_PER_TX);
-    const nullifiers = padArrayEnd(prevNullifiers.filter(n => n.nullifiedNoteHash.isZero()), ScopedNullifier.empty(), MAX_NEW_NULLIFIERS_PER_TX);
-    return new PrivateKernelTailOutputs(noteHashes, nullifiers);
-}
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbGRfcHJpdmF0ZV9rZXJuZWxfdGFpbF9vdXRwdXRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2tlcm5lbF9wcm92ZXIvcHJpdmF0ZV9pbnB1dHNfYnVpbGRlcnMvYnVpbGRfcHJpdmF0ZV9rZXJuZWxfdGFpbF9vdXRwdXRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCwwQkFBMEIsRUFDMUIseUJBQXlCLEVBQ3pCLHdCQUF3QixFQUN4QixjQUFjLEVBQ2QsZUFBZSxHQUNoQixNQUFNLG9CQUFvQixDQUFDO0FBQzVCLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSw4QkFBOEIsQ0FBQztBQUczRCxNQUFNLFVBQVUsNkJBQTZCLENBQzNDLGNBQXdFLEVBQ3hFLGNBQXdFO0lBRXhFLDREQUE0RDtJQUM1RCwwRUFBMEU7SUFDMUUsTUFBTSxVQUFVLEdBQUcsV0FBVyxDQUM1QixjQUFjLENBQUMsTUFBTSxDQUFDLENBQUMsQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDLENBQUMsZ0JBQWdCLENBQUMsRUFDL0MsY0FBYyxDQUFDLEtBQUssRUFBRSxFQUN0QiwwQkFBMEIsQ0FDM0IsQ0FBQztJQUVGLE1BQU0sVUFBVSxHQUFHLFdBQVcsQ0FDNUIsY0FBYyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FBQyxpQkFBaUIsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxFQUN4RCxlQUFlLENBQUMsS0FBSyxFQUFFLEVBQ3ZCLHlCQUF5QixDQUMxQixDQUFDO0lBRUYsT0FBTyxJQUFJLHdCQUF3QixDQUFDLFVBQVUsRUFBRSxVQUFVLENBQUMsQ0FBQztBQUM5RCxDQUFDIn0=

package/src/kernel_prover/private_inputs_builders/build_private_kernel_tail_outputs.ts

@@ -1,30 +0,0 @@
-import {
-  MAX_NEW_NOTE_HASHES_PER_TX,
-  MAX_NEW_NULLIFIERS_PER_TX,
-  PrivateKernelTailOutputs,
-  ScopedNoteHash,
-  ScopedNullifier,
-} from '@aztec/circuits.js';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { type Tuple } from '@aztec/foundation/serialize';
-
-export function buildPrivateKernelTailOutputs(
-  prevNoteHashes: Tuple<ScopedNoteHash, typeof MAX_NEW_NOTE_HASHES_PER_TX>,
-  prevNullifiers: Tuple<ScopedNullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
-) {
-  // Propagate note hashes that are not linked to a nullifier.
-  // Note that note hashes can't link to the first nullifier (counter == 0).
-  const noteHashes = padArrayEnd(
-    prevNoteHashes.filter(n => !n.nullifierCounter),
-    ScopedNoteHash.empty(),
-    MAX_NEW_NOTE_HASHES_PER_TX,
-  );
-
-  const nullifiers = padArrayEnd(
-    prevNullifiers.filter(n => n.nullifiedNoteHash.isZero()),
-    ScopedNullifier.empty(),
-    MAX_NEW_NULLIFIERS_PER_TX,
-  );
-
-  return new PrivateKernelTailOutputs(noteHashes, nullifiers);
-}