@aztec/pxe 0.15.0 → 0.15.1

package/src/kernel_prover/kernel_prover.ts

@@ -110,11 +110,13 @@ export class KernelProver {
       // 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.

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

@@ -119,8 +119,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 +280,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 +327,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;

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));
   }