@aztec/pxe 0.15.0 → 0.16.0

package/src/contract_data_oracle/index.ts

@@ -1,4 +1,4 @@
-import { AztecAddress, CircuitsWasm, MembershipWitness, VK_TREE_HEIGHT } from '@aztec/circuits.js';
+import { AztecAddress, MembershipWitness, VK_TREE_HEIGHT } from '@aztec/circuits.js';
 import { FunctionDebugMetadata, FunctionSelector, getFunctionDebugMetadata } from '@aztec/foundation/abi';
 import { ContractDatabase, StateInfoProvider } from '@aztec/types';
 
@@ -155,8 +155,7 @@ export class ContractDataOracle {
         throw new Error(`Unknown contract: ${contractAddress}`);
       }
 
-      const wasm = await CircuitsWasm.get();
-      tree = new ContractTree(contract, this.stateProvider, wasm);
+      tree = new ContractTree(contract, this.stateProvider);
       this.trees.push(tree);
     }
     return tree;

package/src/contract_tree/index.ts

@@ -1,6 +1,5 @@
 import {
   CONTRACT_TREE_HEIGHT,
-  CircuitsWasm,
   EthAddress,
   FUNCTION_TREE_HEIGHT,
   Fr,
@@ -8,7 +7,6 @@ import {
   MembershipWitness,
   NewContractConstructor,
   NewContractData,
-  computeFunctionTree,
   computeFunctionTreeData,
   generateFunctionLeaves,
   hashVKStr,
@@ -18,6 +16,7 @@ import {
 import {
   computeCompleteAddress,
   computeContractLeaf,
+  computeFunctionTree,
   computeFunctionTreeRoot,
   computeVarArgsHash,
   hashConstructor,
@@ -44,7 +43,6 @@ export class ContractTree {
      */
     public readonly contract: ContractDao,
     private stateInfoProvider: StateInfoProvider,
-    private wasm: CircuitsWasm,
     /**
      * Data associated with the contract constructor for a new contract.
      */
@@ -66,7 +64,7 @@ export class ContractTree {
    * @param node - An instance of the AztecNode class representing the current node.
    * @returns A new ContractTree instance containing the contract data and computed values.
    */
-  public static async new(
+  public static new(
     artifact: ContractArtifact,
     args: Fr[],
     portalContract: EthAddress,
@@ -74,7 +72,6 @@ export class ContractTree {
     from: PublicKey,
     node: AztecNode,
   ) {
-    const wasm = await CircuitsWasm.get();
     const constructorArtifact = artifact.functions.find(isConstructor);
     if (!constructorArtifact) {
       throw new Error('Constructor not found.');
@@ -88,9 +85,9 @@ export class ContractTree {
       selector: FunctionSelector.fromNameAndParameters(f.name, f.parameters),
     }));
     const leaves = generateFunctionLeaves(functions);
-    const root = computeFunctionTreeRoot(wasm, leaves);
+    const root = computeFunctionTreeRoot(leaves);
     const functionData = FunctionData.fromAbi(constructorArtifact);
-    const vkHash = hashVKStr(constructorArtifact.verificationKey, wasm);
+    const vkHash = hashVKStr(constructorArtifact.verificationKey);
     const argsHash = computeVarArgsHash(args);
     const constructorHash = hashConstructor(functionData, argsHash, vkHash);
 
@@ -106,7 +103,7 @@ export class ContractTree {
       functionData,
       vkHash,
     };
-    return new ContractTree(contractDao, node, wasm, NewContractConstructor);
+    return new ContractTree(contractDao, node, NewContractConstructor);
   }
 
   /**
@@ -172,7 +169,7 @@ export class ContractTree {
   public getFunctionTreeRoot() {
     if (!this.functionTreeRoot) {
       const leaves = this.getFunctionLeaves();
-      this.functionTreeRoot = computeFunctionTreeRoot(this.wasm, leaves);
+      this.functionTreeRoot = computeFunctionTreeRoot(leaves);
     }
     return Promise.resolve(this.functionTreeRoot);
   }
@@ -197,7 +194,7 @@ export class ContractTree {
 
     if (!this.functionTree) {
       const leaves = this.getFunctionLeaves();
-      this.functionTree = computeFunctionTree(this.wasm, leaves);
+      this.functionTree = computeFunctionTree(leaves);
     }
     const functionTreeData = computeFunctionTreeData(this.functionTree, functionIndex);
     return Promise.resolve(

package/src/database/database.ts

@@ -24,6 +24,20 @@ export interface Database extends ContractDatabase {
    */
   getAuthWitness(messageHash: Fr): Promise<Fr[]>;
 
+  /**
+   * Adding a capsule to the capsule dispenser.
+   * @remarks A capsule is a "blob" of data that is passed to the contract through an oracle.
+   * @param capsule - An array of field elements representing the capsule.
+   */
+  addCapsule(capsule: Fr[]): Promise<void>;
+
+  /**
+   * Get the next capsule from the capsule dispenser.
+   * @remarks A capsule is a "blob" of data that is passed to the contract through an oracle.
+   * @returns A promise that resolves to an array of field elements representing the capsule.
+   */
+  popCapsule(): Promise<Fr[] | undefined>;
+
   /**
    * Gets notes based on the provided filter.
    * @param filter - The filter to apply to the notes.

package/src/database/memory_db.ts

@@ -20,6 +20,9 @@ export class MemoryDB extends MemoryContractDatabase implements Database {
   private globalVariablesHash: Fr | undefined;
   private addresses: CompleteAddress[] = [];
   private authWitnesses: Record<string, Fr[]> = {};
+  // A capsule is a "blob" of data that is passed to the contract through an oracle.
+  // We are using a stack to keep track of the capsules that are passed to the contract.
+  private capsuleStack: Fr[][] = [];
 
   constructor(logSuffix?: string) {
     super(createDebugLogger(logSuffix ? 'aztec:memory_db_' + logSuffix : 'aztec:memory_db'));
@@ -44,11 +47,20 @@ export class MemoryDB extends MemoryContractDatabase implements Database {
     return Promise.resolve(this.authWitnesses[messageHash.toString()]);
   }
 
-  public addNote(note: NoteDao) {
+  public addNote(note: NoteDao): Promise<void> {
     this.notesTable.push(note);
     return Promise.resolve();
   }
 
+  public addCapsule(capsule: Fr[]): Promise<void> {
+    this.capsuleStack.push(capsule);
+    return Promise.resolve();
+  }
+
+  public popCapsule(): Promise<Fr[] | undefined> {
+    return Promise.resolve(this.capsuleStack.pop());
+  }
+
   public addNotes(notes: NoteDao[]) {
     this.notesTable.push(...notes);
     return Promise.resolve();
@@ -95,7 +107,9 @@ export class MemoryDB extends MemoryContractDatabase implements Database {
 
   public getTreeRoots(): Record<MerkleTreeId, Fr> {
     const roots = this.treeRoots;
-    if (!roots) throw new Error(`Tree roots not set in memory database`);
+    if (!roots) {
+      throw new Error(`Tree roots not set in memory database`);
+    }
     return roots;
   }
 
@@ -106,7 +120,9 @@ export class MemoryDB extends MemoryContractDatabase implements Database {
 
   public getHistoricBlockData(): HistoricBlockData {
     const roots = this.getTreeRoots();
-    if (!this.globalVariablesHash) throw new Error(`Global variables hash not set in memory database`);
+    if (!this.globalVariablesHash) {
+      throw new Error(`Global variables hash not set in memory database`);
+    }
     return new HistoricBlockData(
       roots[MerkleTreeId.NOTE_HASH_TREE],
       roots[MerkleTreeId.NULLIFIER_TREE],

package/src/index.ts

@@ -4,7 +4,7 @@ export * from './config/index.js';
 
 export { Tx, TxHash } from '@aztec/types';
 
-export { TxRequest, CircuitsWasm, PartialAddress } from '@aztec/circuits.js';
+export { TxRequest, PartialAddress } from '@aztec/circuits.js';
 export * from '@aztec/foundation/fields';
 export * from '@aztec/foundation/eth-address';
 export * from '@aztec/foundation/aztec-address';

package/src/kernel_prover/kernel_prover.ts

@@ -2,17 +2,18 @@ import { ExecutionResult, NoteAndSlot } from '@aztec/acir-simulator';
 import {
   AztecAddress,
   CONTRACT_TREE_HEIGHT,
+  CallRequest,
   EMPTY_NULLIFIED_COMMITMENT,
   Fr,
   MAX_NEW_COMMITMENTS_PER_TX,
   MAX_NEW_NULLIFIERS_PER_TX,
   MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,
+  MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
   MAX_READ_REQUESTS_PER_CALL,
   MAX_READ_REQUESTS_PER_TX,
   MembershipWitness,
   PreviousKernelData,
   PrivateCallData,
-  PrivateCallStackItem,
   PrivateKernelInputsInit,
   PrivateKernelInputsInner,
   PrivateKernelInputsOrdering,
@@ -24,6 +25,7 @@ import {
   makeEmptyProof,
   makeTuple,
 } from '@aztec/circuits.js';
+import { padArrayEnd } from '@aztec/foundation/collection';
 import { Tuple, assertLength } from '@aztec/foundation/serialize';
 
 import { KernelProofCreator, ProofCreator, ProofOutput, ProofOutputFinal } from './proof_creator.js';
@@ -93,28 +95,21 @@ export class KernelProver {
     while (executionStack.length) {
       const currentExecution = executionStack.pop()!;
       executionStack.push(...currentExecution.nestedExecutions);
-      const privateCallStackPreimages = currentExecution.nestedExecutions.map(result => result.callStackItem);
-      if (privateCallStackPreimages.length > MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL) {
-        throw new Error(
-          `Too many items in the call stack. Maximum amount is ${MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL}. Got ${privateCallStackPreimages.length}.`,
-        );
-      }
-      // Pad with empty items to reach max/const length expected by circuit.
-      privateCallStackPreimages.push(
-        ...Array(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL - privateCallStackPreimages.length)
-          .fill(0)
-          .map(() => PrivateCallStackItem.empty()),
-      );
+
+      const privateCallRequests = currentExecution.nestedExecutions.map(result => result.callStackItem.toCallRequest());
+      const publicCallRequests = currentExecution.enqueuedPublicFunctionCalls.map(result => result.toCallRequest());
 
       // Start with the partially filled in read request witnesses from the simulator
       // and fill the non-transient ones in with sibling paths via oracle.
       const readRequestMembershipWitnesses = currentExecution.readRequestPartialWitnesses;
       for (let rr = 0; rr < readRequestMembershipWitnesses.length; rr++) {
-        if (currentExecution.callStackItem.publicInputs.readRequests[rr] == Fr.zero()) {
-          throw new Error(
-            'Number of read requests output from Noir circuit does not match number of read request commitment indices output from simulator.',
-          );
-        }
+        // Pretty sure this check was forever broken. I made some changes to Fr and this started triggering.
+        // The conditional makes no sense to me anyway.
+        // if (currentExecution.callStackItem.publicInputs.readRequests[rr] == Fr.ZERO) {
+        //   throw new Error(
+        //     'Number of read requests output from Noir circuit does not match number of read request commitment indices output from simulator.',
+        //   );
+        // }
         const rrWitness = readRequestMembershipWitnesses[rr];
         if (!rrWitness.isTransient) {
           // Non-transient reads must contain full membership witness with sibling path from commitment to root.
@@ -133,8 +128,9 @@ export class KernelProver {
 
       const privateCallData = await this.createPrivateCallData(
         currentExecution,
+        privateCallRequests,
+        publicCallRequests,
         readRequestMembershipWitnesses,
-        makeTuple(MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL, i => privateCallStackPreimages[i], 0),
       );
 
       if (firstIteration) {
@@ -194,12 +190,21 @@ export class KernelProver {
 
   private async createPrivateCallData(
     { callStackItem, vk }: ExecutionResult,
+    privateCallRequests: CallRequest[],
+    publicCallRequests: CallRequest[],
     readRequestMembershipWitnesses: ReadRequestMembershipWitness[],
-    privateCallStackPreimages: Tuple<PrivateCallStackItem, typeof MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL>,
   ) {
     const { contractAddress, functionData, publicInputs } = callStackItem;
     const { portalContractAddress } = publicInputs.callContext;
 
+    // Pad with empty items to reach max/const length expected by circuit.
+    const privateCallStack = padArrayEnd(
+      privateCallRequests,
+      CallRequest.empty(),
+      MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,
+    );
+    const publicCallStack = padArrayEnd(publicCallRequests, CallRequest.empty(), MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL);
+
     const contractLeafMembershipWitness = functionData.isConstructor
       ? MembershipWitness.random(CONTRACT_TREE_HEIGHT)
       : await this.oracle.getContractMembershipWitness(contractAddress);
@@ -218,7 +223,8 @@ export class KernelProver {
 
     return new PrivateCallData(
       callStackItem,
-      privateCallStackPreimages,
+      privateCallStack,
+      publicCallStack,
       proof,
       VerificationKey.fromBuffer(vk),
       functionLeafMembershipWitness,

package/src/kernel_prover/proof_creator.ts

@@ -22,8 +22,6 @@ import { CircuitSimulationStats } from '@aztec/types/stats';
 export interface ProofOutput {
   /**
    * The public inputs required for the proof generation process.
-   * Note: C++ side does not define the specific data structure PrivateKernelPublicInputs and therefore
-   * would not generate a binding in circuits.gen.ts.
    */
   publicInputs: KernelCircuitPublicInputs;
   /**
@@ -39,8 +37,6 @@ export interface ProofOutput {
 export interface ProofOutputFinal {
   /**
    * The public inputs required for the proof generation process.
-   * Note: C++ side does not define the specific data structure PrivateKernelPublicInputsFinal and therefore
-   * would not generate a binding in circuits.gen.ts.
    */
   publicInputs: KernelCircuitPublicInputsFinal;
   /**
@@ -89,10 +85,10 @@ export interface ProofCreator {
 
 /**
  * The KernelProofCreator class is responsible for generating siloed commitments and zero-knowledge proofs
- * for private kernel circuit. It leverages Barretenberg and Circuits Wasm libraries
- * to perform cryptographic operations and proof creation. The class provides methods to compute commitments
- * based on the given public inputs and to generate proofs based on signed transaction requests, previous kernel
- * data, private call data, and a flag indicating whether it's the first iteration or not.
+ * for private kernel circuit. It leverages Barretenberg to perform cryptographic operations and proof creation.
+ * The class provides methods to compute commitments based on the given public inputs and to generate proofs based on
+ * signed transaction requests, previous kernel data, private call data, and a flag indicating whether it's the first
+ * iteration or not.
  */
 export class KernelProofCreator implements ProofCreator {
   constructor(private log = createDebugLogger('aztec:kernel_proof_creator')) {}

package/src/note_processor/note_processor.ts

@@ -94,7 +94,7 @@ export class NoteProcessor {
     }
 
     const blocksAndNotes: ProcessedData[] = [];
-    const curve = await Grumpkin.new();
+    const curve = new Grumpkin();
 
     // Iterate over both blocks and encrypted logs.
     for (let blockIndex = 0; blockIndex < encryptedL2BlockLogs.length; ++blockIndex) {
@@ -203,10 +203,14 @@ export class NoteProcessor {
     let uniqueSiloedNoteHash: Fr | undefined;
     let innerNullifier: Fr | undefined;
     for (; commitmentIndex < commitments.length; ++commitmentIndex) {
-      if (excludedIndices.has(commitmentIndex)) continue;
+      if (excludedIndices.has(commitmentIndex)) {
+        continue;
+      }
 
       const commitment = commitments[commitmentIndex];
-      if (commitment.equals(Fr.ZERO)) break;
+      if (commitment.equals(Fr.ZERO)) {
+        break;
+      }
 
       const expectedNonce = computeCommitmentNonce(firstNullifier, commitmentIndex);
       ({ innerNoteHash, siloedNoteHash, uniqueSiloedNoteHash, innerNullifier } =

package/src/pxe_service/create_pxe_service.ts

@@ -43,7 +43,7 @@ export async function createPXEService(
         : undefined
       : useLogSuffix;
 
-  keyStore = keyStore || new TestKeyStore(await Grumpkin.new());
+  keyStore = keyStore || new TestKeyStore(new Grumpkin());
   db = db || new MemoryDB(logSuffix);
 
   const server = new PXEService(keyStore, aztecNode, db, config, logSuffix);

package/src/pxe_service/pxe_service.ts

@@ -8,6 +8,7 @@ import {
 } from '@aztec/acir-simulator';
 import {
   AztecAddress,
+  CallRequest,
   CompleteAddress,
   FunctionData,
   GrumpkinPrivateKey,
@@ -119,8 +120,12 @@ export class PXEService implements PXE {
     return this.db.addAuthWitness(witness.requestHash, witness.witness);
   }
 
+  public addCapsule(capsule: Fr[]) {
+    return this.db.addCapsule(capsule);
+  }
+
   public async registerAccount(privKey: GrumpkinPrivateKey, partialAddress: PartialAddress): Promise<CompleteAddress> {
-    const completeAddress = await CompleteAddress.fromPrivateKeyAndPartialAddress(privKey, partialAddress);
+    const completeAddress = CompleteAddress.fromPrivateKeyAndPartialAddress(privKey, partialAddress);
     const wasAdded = await this.db.addCompleteAddress(completeAddress);
     if (wasAdded) {
       const pubKey = this.keyStore.addAccount(privKey);
@@ -276,7 +281,9 @@ export class PXEService implements PXE {
     const commitments = tx.newCommitments;
     for (let i = 0; i < commitments.length; ++i) {
       const commitment = commitments[i];
-      if (commitment.equals(Fr.ZERO)) break;
+      if (commitment.equals(Fr.ZERO)) {
+        break;
+      }
 
       const nonce = computeCommitmentNonce(firstNullifier, i);
       const { siloedNoteHash, uniqueSiloedNoteHash } = await this.simulator.computeNoteHashAndNullifier(
@@ -321,7 +328,9 @@ export class PXEService implements PXE {
     const newContract = deployedContractAddress ? await this.db.getContract(deployedContractAddress) : undefined;
 
     const tx = await this.#simulateAndProve(txRequest, newContract);
-    if (simulatePublic) await this.#simulatePublicCalls(tx);
+    if (simulatePublic) {
+      await this.#simulatePublicCalls(tx);
+    }
     this.log.info(`Executed local simulation for ${await tx.getTxHash()}`);
 
     return tx;
@@ -347,13 +356,23 @@ export class PXEService implements PXE {
   }
 
   public async getTxReceipt(txHash: TxHash): Promise<TxReceipt> {
+    let txReceipt = new TxReceipt(txHash, TxStatus.DROPPED, 'Tx dropped by P2P node.');
+
+    // We first check if the tx is in pending (instead of first checking if it is mined) because if we first check
+    // for mined and then for pending there could be a race condition where the tx is mined between the two checks
+    // and we would incorrectly return a TxReceipt with status DROPPED
+    const pendingTx = await this.node.getPendingTxByHash(txHash);
+    if (pendingTx) {
+      txReceipt = new TxReceipt(txHash, TxStatus.PENDING, '');
+    }
+
     const settledTx = await this.node.getTx(txHash);
     if (settledTx) {
       const deployedContractAddress = settledTx.newContractData.find(
         c => !c.contractAddress.equals(AztecAddress.ZERO),
       )?.contractAddress;
 
-      return new TxReceipt(
+      txReceipt = new TxReceipt(
         txHash,
         TxStatus.MINED,
         '',
@@ -363,12 +382,7 @@ export class PXEService implements PXE {
       );
     }
 
-    const pendingTx = await this.node.getPendingTxByHash(txHash);
-    if (pendingTx) {
-      return new TxReceipt(txHash, TxStatus.PENDING, '');
-    }
-
-    return new TxReceipt(txHash, TxStatus.DROPPED, 'Tx dropped by P2P node.');
+    return txReceipt;
   }
 
   public async getTx(txHash: TxHash): Promise<L2Tx | undefined> {
@@ -622,28 +636,27 @@ export class PXEService implements PXE {
     publicInputs: KernelCircuitPublicInputsFinal,
     enqueuedPublicCalls: PublicCallRequest[],
   ) {
-    const callToHash = (call: PublicCallRequest) => call.toPublicCallStackItem().hash();
-    const enqueuedPublicCallsHashes = await Promise.all(enqueuedPublicCalls.map(callToHash));
+    const enqueuedPublicCallStackItems = await Promise.all(enqueuedPublicCalls.map(c => c.toCallRequest()));
     const { publicCallStack } = publicInputs.end;
 
     // Validate all items in enqueued public calls are in the kernel emitted stack
-    const areEqual = enqueuedPublicCallsHashes.reduce(
+    const areEqual = enqueuedPublicCallStackItems.reduce(
       (accum, enqueued) => accum && !!publicCallStack.find(item => item.equals(enqueued)),
       true,
     );
 
     if (!areEqual) {
       throw new Error(
-        `Enqueued public function calls and public call stack do not match.\nEnqueued calls: ${enqueuedPublicCallsHashes
-          .map(h => h.toString())
+        `Enqueued public function calls and public call stack do not match.\nEnqueued calls: ${enqueuedPublicCallStackItems
+          .map(h => h.hash.toString())
           .join(', ')}\nPublic call stack: ${publicCallStack.map(i => i.toString()).join(', ')}`,
       );
     }
 
     // Override kernel output
     publicInputs.end.publicCallStack = padArrayEnd(
-      enqueuedPublicCallsHashes,
-      Fr.ZERO,
+      enqueuedPublicCallStackItems,
+      CallRequest.empty(),
       MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
     );
   }

package/src/pxe_service/test/pxe_test_suite.ts

@@ -12,13 +12,10 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
     }, 120_000);
 
     it('registers an account and returns it as an account only and not as a recipient', async () => {
-      const keyPair = ConstantKeyPair.random(await Grumpkin.new());
-      const completeAddress = await CompleteAddress.fromPrivateKeyAndPartialAddress(
-        await keyPair.getPrivateKey(),
-        Fr.random(),
-      );
+      const keyPair = ConstantKeyPair.random(new Grumpkin());
+      const completeAddress = CompleteAddress.fromPrivateKeyAndPartialAddress(keyPair.getPrivateKey(), Fr.random());
 
-      await pxe.registerAccount(await keyPair.getPrivateKey(), completeAddress.partialAddress);
+      await pxe.registerAccount(keyPair.getPrivateKey(), completeAddress.partialAddress);
 
       // Check that the account is correctly registered using the getAccounts and getRecipients methods
       const accounts = await pxe.getRegisteredAccounts();
@@ -52,14 +49,11 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
     });
 
     it('does not throw when registering the same account twice (just ignores the second attempt)', async () => {
-      const keyPair = ConstantKeyPair.random(await Grumpkin.new());
-      const completeAddress = await CompleteAddress.fromPrivateKeyAndPartialAddress(
-        await keyPair.getPrivateKey(),
-        Fr.random(),
-      );
+      const keyPair = ConstantKeyPair.random(new Grumpkin());
+      const completeAddress = CompleteAddress.fromPrivateKeyAndPartialAddress(keyPair.getPrivateKey(), Fr.random());
 
-      await pxe.registerAccount(await keyPair.getPrivateKey(), completeAddress.partialAddress);
-      await pxe.registerAccount(await keyPair.getPrivateKey(), completeAddress.partialAddress);
+      await pxe.registerAccount(keyPair.getPrivateKey(), completeAddress.partialAddress);
+      await pxe.registerAccount(keyPair.getPrivateKey(), completeAddress.partialAddress);
     });
 
     it('cannot register a recipient with the same aztec address but different pub key or partial address', async () => {

package/src/simulator_oracle/index.ts

@@ -31,19 +31,30 @@ export class SimulatorOracle implements DBOracle {
 
   async getCompleteAddress(address: AztecAddress): Promise<CompleteAddress> {
     const completeAddress = await this.db.getCompleteAddress(address);
-    if (!completeAddress)
+    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/dev_docs/contracts/common_errors#no-public-key-registered-error`,
       );
+    }
     return completeAddress;
   }
 
   async getAuthWitness(messageHash: Fr): Promise<Fr[]> {
     const witness = await this.db.getAuthWitness(messageHash);
-    if (!witness) throw new Error(`Unknown auth witness for message hash ${messageHash.toString(true)}`);
+    if (!witness) {
+      throw new Error(`Unknown auth witness for message hash ${messageHash.toString()}`);
+    }
     return witness;
   }
 
+  async popCapsule(): Promise<Fr[]> {
+    const capsule = await this.db.popCapsule();
+    if (!capsule) {
+      throw new Error(`No capsules available`);
+    }
+    return capsule;
+  }
+
   async getNotes(contractAddress: AztecAddress, storageSlot: Fr) {
     const noteDaos = await this.db.getNotes({ contractAddress, storageSlot });
     return noteDaos.map(({ contractAddress, storageSlot, nonce, note, innerNoteHash, siloedNullifier, index }) => ({

package/src/synchronizer/synchronizer.ts

@@ -39,7 +39,9 @@ export class Synchronizer {
    * @param retryInterval - The time interval (in ms) to wait before retrying if no data is available.
    */
   public async start(from = INITIAL_L2_BLOCK_NUM, limit = 1, retryInterval = 1000) {
-    if (this.running) return;
+    if (this.running) {
+      return;
+    }
     this.running = true;
 
     if (from < this.synchedToBlock + 1) {
@@ -197,7 +199,9 @@ export class Synchronizer {
 
   private async setBlockDataFromBlock(latestBlock: L2BlockContext) {
     const { block } = latestBlock;
-    if (block.number < this.initialSyncBlockNumber) return;
+    if (block.number < this.initialSyncBlockNumber) {
+      return;
+    }
 
     const globalsHash = computeGlobalsHash(latestBlock.block.globalVariables);
     const blockData = new HistoricBlockData(
@@ -241,7 +245,9 @@ export class Synchronizer {
   public addAccount(publicKey: PublicKey, keyStore: KeyStore, startingBlock: number) {
     const predicate = (x: NoteProcessor) => x.publicKey.equals(publicKey);
     const processor = this.noteProcessors.find(predicate) ?? this.noteProcessorsToCatchUp.find(predicate);
-    if (processor) return;
+    if (processor) {
+      return;
+    }
 
     this.noteProcessorsToCatchUp.push(new NoteProcessor(publicKey, keyStore, this.db, this.node, startingBlock));
   }