@aztec/pxe 0.14.2 → 0.15.1

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.');
@@ -87,14 +84,14 @@ export class ContractTree {
       ...f,
       selector: FunctionSelector.fromNameAndParameters(f.name, f.parameters),
     }));
-    const leaves = generateFunctionLeaves(functions, wasm);
-    const root = computeFunctionTreeRoot(wasm, leaves);
+    const leaves = generateFunctionLeaves(functions);
+    const root = computeFunctionTreeRoot(leaves);
     const functionData = FunctionData.fromAbi(constructorArtifact);
-    const vkHash = hashVKStr(constructorArtifact.verificationKey, wasm);
-    const argsHash = await computeVarArgsHash(wasm, args);
-    const constructorHash = hashConstructor(wasm, functionData, argsHash, vkHash);
+    const vkHash = hashVKStr(constructorArtifact.verificationKey);
+    const argsHash = computeVarArgsHash(args);
+    const constructorHash = hashConstructor(functionData, argsHash, vkHash);
 
-    const completeAddress = computeCompleteAddress(wasm, from, contractAddressSalt, root, constructorHash);
+    const completeAddress = computeCompleteAddress(from, contractAddressSalt, root, constructorHash);
 
     const contractDao: ContractDao = {
       ...artifact,
@@ -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(
@@ -218,7 +215,7 @@ export class ContractTree {
    */
   private getFunctionLeaves() {
     if (!this.functionLeaves) {
-      this.functionLeaves = generateFunctionLeaves(this.contract.functions, this.wasm);
+      this.functionLeaves = generateFunctionLeaves(this.contract.functions);
     }
     return this.functionLeaves;
   }
@@ -228,7 +225,7 @@ export class ContractTree {
       const { completeAddress, portalContract } = this.contract;
       const root = await this.getFunctionTreeRoot();
       const newContractData = new NewContractData(completeAddress.address, portalContract, root);
-      const commitment = computeContractLeaf(this.wasm, newContractData);
+      const commitment = computeContractLeaf(newContractData);
       this.contractIndex = await this.stateInfoProvider.findLeafIndex(MerkleTreeId.CONTRACT_TREE, commitment);
       if (this.contractIndex === undefined) {
         throw new Error(

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/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/kernel_prover/proof_creator.ts

@@ -1,5 +1,4 @@
 import {
-  CircuitsWasm,
   KernelCircuitPublicInputs,
   KernelCircuitPublicInputsFinal,
   PrivateCircuitPublicInputs,
@@ -98,11 +97,10 @@ export interface ProofCreator {
 export class KernelProofCreator implements ProofCreator {
   constructor(private log = createDebugLogger('aztec:kernel_proof_creator')) {}
 
-  public async getSiloedCommitments(publicInputs: PrivateCircuitPublicInputs) {
-    const wasm = await CircuitsWasm.get();
+  public getSiloedCommitments(publicInputs: PrivateCircuitPublicInputs) {
     const contractAddress = publicInputs.callContext.storageContractAddress;
 
-    return publicInputs.newCommitments.map(commitment => siloCommitment(wasm, contractAddress, commitment));
+    return Promise.resolve(publicInputs.newCommitments.map(commitment => siloCommitment(contractAddress, commitment)));
   }
 
   public async createProofInit(privateInputs: PrivateKernelInputsInit): Promise<ProofOutput> {

package/src/note_processor/note_processor.ts

@@ -1,4 +1,4 @@
-import { CircuitsWasm, MAX_NEW_COMMITMENTS_PER_TX, MAX_NEW_NULLIFIERS_PER_TX, PublicKey } from '@aztec/circuits.js';
+import { MAX_NEW_COMMITMENTS_PER_TX, MAX_NEW_NULLIFIERS_PER_TX, PublicKey } from '@aztec/circuits.js';
 import { computeCommitmentNonce, siloNullifier } from '@aztec/circuits.js/abis';
 import { Grumpkin } from '@aztec/circuits.js/barretenberg';
 import { Fr } from '@aztec/foundation/fields';
@@ -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) {
@@ -196,7 +196,6 @@ export class NoteProcessor {
     { contractAddress, storageSlot, note }: L1NotePayload,
     excludedIndices: Set<number>,
   ) {
-    const wasm = await CircuitsWasm.get();
     let commitmentIndex = 0;
     let nonce: Fr | undefined;
     let innerNoteHash: Fr | undefined;
@@ -204,12 +203,16 @@ 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(wasm, firstNullifier, commitmentIndex);
+      const expectedNonce = computeCommitmentNonce(firstNullifier, commitmentIndex);
       ({ innerNoteHash, siloedNoteHash, uniqueSiloedNoteHash, innerNullifier } =
         await this.simulator.computeNoteHashAndNullifier(contractAddress, expectedNonce, storageSlot, note));
       if (commitment.equals(uniqueSiloedNoteHash)) {
@@ -244,7 +247,7 @@ https://github.com/AztecProtocol/aztec-packages/issues/1641`;
       commitmentIndex,
       nonce,
       innerNoteHash: innerNoteHash!,
-      siloedNullifier: siloNullifier(wasm, contractAddress, innerNullifier!),
+      siloedNullifier: siloNullifier(contractAddress, 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,7 +8,6 @@ import {
 } from '@aztec/acir-simulator';
 import {
   AztecAddress,
-  CircuitsWasm,
   CompleteAddress,
   FunctionData,
   GrumpkinPrivateKey,
@@ -120,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);
@@ -238,8 +241,7 @@ export class PXEService implements PXE {
         throw new Error('Note does not exist.');
       }
 
-      const wasm = await CircuitsWasm.get();
-      const siloedNullifier = siloNullifier(wasm, note.contractAddress, innerNullifier!);
+      const siloedNullifier = siloNullifier(note.contractAddress, innerNullifier!);
       const nullifierIndex = await this.node.findLeafIndex(MerkleTreeId.NULLIFIER_TREE, siloedNullifier);
       if (nullifierIndex !== undefined) {
         throw new Error('The note has been destroyed.');
@@ -273,16 +275,16 @@ export class PXEService implements PXE {
       throw new Error(`Unknown tx: ${note.txHash}`);
     }
 
-    const wasm = await CircuitsWasm.get();
-
     const nonces: Fr[] = [];
     const firstNullifier = tx.newNullifiers[0];
     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(wasm, firstNullifier, i);
+      const nonce = computeCommitmentNonce(firstNullifier, i);
       const { siloedNoteHash, uniqueSiloedNoteHash } = await this.simulator.computeNoteHashAndNullifier(
         note.contractAddress,
         nonce,
@@ -325,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;
@@ -626,7 +630,7 @@ export class PXEService implements PXE {
     publicInputs: KernelCircuitPublicInputsFinal,
     enqueuedPublicCalls: PublicCallRequest[],
   ) {
-    const callToHash = (call: PublicCallRequest) => call.toPublicCallStackItem().then(item => item.hash());
+    const callToHash = (call: PublicCallRequest) => call.toPublicCallStackItem().hash();
     const enqueuedPublicCallsHashes = await Promise.all(enqueuedPublicCalls.map(callToHash));
     const { publicCallStack } = publicInputs.end;
 

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();
@@ -34,7 +31,7 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
     });
 
     it('registers a recipient and returns it as a recipient only and not as an account', async () => {
-      const completeAddress = await CompleteAddress.random();
+      const completeAddress = CompleteAddress.random();
 
       await pxe.registerRecipient(completeAddress);
 
@@ -52,18 +49,15 @@ 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 () => {
-      const recipient1 = await CompleteAddress.random();
+      const recipient1 = CompleteAddress.random();
       const recipient2 = new CompleteAddress(recipient1.address, Point.random(), Fr.random());
 
       await pxe.registerRecipient(recipient1);
@@ -73,14 +67,14 @@ export const pxeTestSuite = (testName: string, pxeSetup: () => Promise<PXE>) =>
     });
 
     it('does not throw when registering the same recipient twice (just ignores the second attempt)', async () => {
-      const completeAddress = await CompleteAddress.random();
+      const completeAddress = CompleteAddress.random();
 
       await pxe.registerRecipient(completeAddress);
       await pxe.registerRecipient(completeAddress);
     });
 
     it('successfully adds a contract', async () => {
-      const contracts: DeployedContract[] = [await randomDeployedContract(), await randomDeployedContract()];
+      const contracts: DeployedContract[] = [randomDeployedContract(), randomDeployedContract()];
       await pxe.addContracts(contracts);
 
       const expectedContractAddresses = contracts.map(contract => contract.completeAddress.address);

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

@@ -1,4 +1,4 @@
-import { AztecAddress, CircuitsWasm, Fr, HistoricBlockData, PublicKey } from '@aztec/circuits.js';
+import { AztecAddress, Fr, HistoricBlockData, PublicKey } from '@aztec/circuits.js';
 import { computeGlobalsHash } from '@aztec/circuits.js/abis';
 import { DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { InterruptibleSleep } from '@aztec/foundation/sleep';
@@ -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,10 +199,11 @@ export class Synchronizer {
 
   private async setBlockDataFromBlock(latestBlock: L2BlockContext) {
     const { block } = latestBlock;
-    if (block.number < this.initialSyncBlockNumber) return;
+    if (block.number < this.initialSyncBlockNumber) {
+      return;
+    }
 
-    const wasm = await CircuitsWasm.get();
-    const globalsHash = computeGlobalsHash(wasm, latestBlock.block.globalVariables);
+    const globalsHash = computeGlobalsHash(latestBlock.block.globalVariables);
     const blockData = new HistoricBlockData(
       block.endNoteHashTreeSnapshot.root,
       block.endNullifierTreeSnapshot.root,
@@ -242,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));
   }