@aztec/pxe 0.24.0 → 0.26.2

package/src/kernel_prover/kernel_prover.ts

@@ -2,25 +2,20 @@ import {
   AztecAddress,
   CallRequest,
   Fr,
-  GrumpkinScalar,
-  MAX_NEW_COMMITMENTS_PER_TX,
+  MAX_NEW_NOTE_HASHES_PER_TX,
   MAX_NEW_NULLIFIERS_PER_TX,
-  MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_TX,
+  MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
   MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
-  MAX_READ_REQUESTS_PER_CALL,
-  MAX_READ_REQUESTS_PER_TX,
-  NullifierKeyValidationRequestContext,
+  NoteHashReadRequestMembershipWitness,
   PrivateCallData,
   PrivateKernelInitCircuitPrivateInputs,
   PrivateKernelInnerCircuitPrivateInputs,
   PrivateKernelInnerCircuitPublicInputs,
   PrivateKernelInnerData,
   PrivateKernelTailCircuitPrivateInputs,
-  ReadRequestMembershipWitness,
   SideEffect,
   SideEffectLinkedToNoteHash,
-  SideEffectType,
   TxRequest,
   VK_TREE_HEIGHT,
   VerificationKey,
@@ -28,10 +23,12 @@ import {
 } from '@aztec/circuits.js';
 import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Tuple, assertLength, mapTuple } from '@aztec/foundation/serialize';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { assertLength, mapTuple } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
 import { ExecutionResult, NoteAndSlot } from '@aztec/simulator';
 
+import { HintsBuilder } from './hints_builder.js';
 import { KernelProofCreator, ProofCreator, ProofOutput, ProofOutputFinal } from './proof_creator.js';
 import { ProvingDataOracle } from './proving_data_oracle.js';
 
@@ -73,7 +70,12 @@ export interface KernelProverOutput extends ProofOutputFinal {
  * constructs private call data based on the execution results.
  */
 export class KernelProver {
-  constructor(private oracle: ProvingDataOracle, private proofCreator: ProofCreator = new KernelProofCreator()) {}
+  private log = createDebugLogger('aztec:kernel-prover');
+  private hintsBuilder: HintsBuilder;
+
+  constructor(private oracle: ProvingDataOracle, private proofCreator: ProofCreator = new KernelProofCreator()) {
+    this.hintsBuilder = new HintsBuilder(oracle);
+  }
 
   /**
    * Generate a proof for a given transaction request and execution result.
@@ -100,13 +102,15 @@ export class KernelProver {
       const currentExecution = executionStack.pop()!;
       executionStack.push(...currentExecution.nestedExecutions);
 
-      const privateCallRequests = currentExecution.nestedExecutions.map(result => result.callStackItem.toCallRequest());
+      const privateCallRequests = currentExecution.nestedExecutions.map(result =>
+        result.callStackItem.toCallRequest(currentExecution.callStackItem.publicInputs.callContext),
+      );
       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++) {
+      const noteHashReadRequestMembershipWitnesses = currentExecution.noteHashReadRequestPartialWitnesses;
+      for (let rr = 0; rr < noteHashReadRequestMembershipWitnesses.length; rr++) {
         // 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) {
@@ -114,7 +118,7 @@ export class KernelProver {
         //     'Number of read requests output from Noir circuit does not match number of read request commitment indices output from simulator.',
         //   );
         // }
-        const rrWitness = readRequestMembershipWitnesses[rr];
+        const rrWitness = noteHashReadRequestMembershipWitnesses[rr];
         if (!rrWitness.isTransient) {
           // Non-transient reads must contain full membership witness with sibling path from commitment to root.
           // Get regular membership witness to fill in sibling path in the read request witness.
@@ -124,17 +128,17 @@ export class KernelProver {
       }
 
       // fill in witnesses for remaining/empty read requests
-      readRequestMembershipWitnesses.push(
-        ...Array(MAX_READ_REQUESTS_PER_CALL - readRequestMembershipWitnesses.length)
+      noteHashReadRequestMembershipWitnesses.push(
+        ...Array(MAX_NOTE_HASH_READ_REQUESTS_PER_CALL - noteHashReadRequestMembershipWitnesses.length)
           .fill(0)
-          .map(() => ReadRequestMembershipWitness.empty(BigInt(0))),
+          .map(() => NoteHashReadRequestMembershipWitness.empty(BigInt(0))),
       );
 
       const privateCallData = await this.createPrivateCallData(
         currentExecution,
         privateCallRequests,
         publicCallRequests,
-        readRequestMembershipWitnesses,
+        noteHashReadRequestMembershipWitnesses,
       );
 
       if (firstIteration) {
@@ -170,73 +174,65 @@ export class KernelProver {
       assertLength<Fr, typeof VK_TREE_HEIGHT>(previousVkMembershipWitness.siblingPath, VK_TREE_HEIGHT),
     );
 
-    const [sortedCommitments, sortedCommitmentsIndexes] = this.sortSideEffects<
+    const [sortedNoteHashes, sortedNoteHashesIndexes] = this.hintsBuilder.sortSideEffects<
       SideEffect,
-      typeof MAX_NEW_COMMITMENTS_PER_TX
-    >(output.publicInputs.end.newCommitments);
+      typeof MAX_NEW_NOTE_HASHES_PER_TX
+    >(output.publicInputs.end.newNoteHashes);
 
-    const [sortedNullifiers, sortedNullifiersIndexes] = this.sortSideEffects<
+    const [sortedNullifiers, sortedNullifiersIndexes] = this.hintsBuilder.sortSideEffects<
       SideEffectLinkedToNoteHash,
       typeof MAX_NEW_NULLIFIERS_PER_TX
     >(output.publicInputs.end.newNullifiers);
 
-    const readCommitmentHints = this.getReadRequestHints(output.publicInputs.end.readRequests, sortedCommitments);
+    const readNoteHashHints = this.hintsBuilder.getNoteHashReadRequestHints(
+      output.publicInputs.end.noteHashReadRequests,
+      sortedNoteHashes,
+    );
+
+    const nullifierReadRequestResetHints = await this.hintsBuilder.getNullifierReadRequestResetHints(
+      output.publicInputs.end.nullifierReadRequests,
+      output.publicInputs.end.newNullifiers,
+    );
 
-    const nullifierCommitmentHints = this.getNullifierHints(
+    const nullifierNoteHashHints = this.hintsBuilder.getNullifierHints(
       mapTuple(sortedNullifiers, n => n.noteHash),
-      sortedCommitments,
+      sortedNoteHashes,
     );
 
-    const masterNullifierSecretKeys = await this.getMasterNullifierSecretKeys(
+    const masterNullifierSecretKeys = await this.hintsBuilder.getMasterNullifierSecretKeys(
       output.publicInputs.end.nullifierKeyValidationRequests,
     );
 
+    this.log.debug(
+      `Calling private kernel tail with hwm ${previousKernelData.publicInputs.minRevertibleSideEffectCounter}`,
+    );
+
     const privateInputs = new PrivateKernelTailCircuitPrivateInputs(
       previousKernelData,
-      sortedCommitments,
-      sortedCommitmentsIndexes,
-      readCommitmentHints,
+      sortedNoteHashes,
+      sortedNoteHashesIndexes,
+      readNoteHashHints,
       sortedNullifiers,
       sortedNullifiersIndexes,
-      nullifierCommitmentHints,
+      nullifierReadRequestResetHints,
+      nullifierNoteHashHints,
       masterNullifierSecretKeys,
     );
     pushTestData('private-kernel-inputs-ordering', privateInputs);
     const outputFinal = await this.proofCreator.createProofTail(privateInputs);
 
     // Only return the notes whose commitment is in the commitments of the final proof.
-    const finalNewCommitments = outputFinal.publicInputs.end.newCommitments;
+    const finalNewCommitments = outputFinal.publicInputs.end.newNoteHashes;
     const outputNotes = finalNewCommitments.map(c => newNotes[c.value.toString()]).filter(c => !!c);
 
     return { ...outputFinal, outputNotes };
   }
 
-  private sortSideEffects<T extends SideEffectType, K extends number>(
-    sideEffects: Tuple<T, K>,
-  ): [Tuple<T, K>, Tuple<number, K>] {
-    const sorted = sideEffects
-      .map((sideEffect, index) => ({ sideEffect, index }))
-      .sort((a, b) => {
-        // Empty ones go to the right
-        if (a.sideEffect.isEmpty()) {
-          return 1;
-        }
-        return Number(a.sideEffect.counter.toBigInt() - b.sideEffect.counter.toBigInt());
-      });
-
-    const originalToSorted = sorted.map(() => 0);
-    sorted.forEach(({ index }, i) => {
-      originalToSorted[index] = i;
-    });
-
-    return [sorted.map(({ sideEffect }) => sideEffect) as Tuple<T, K>, originalToSorted as Tuple<number, K>];
-  }
-
   private async createPrivateCallData(
     { callStackItem, vk }: ExecutionResult,
     privateCallRequests: CallRequest[],
     publicCallRequests: CallRequest[],
-    readRequestMembershipWitnesses: ReadRequestMembershipWitness[],
+    noteHashReadRequestMembershipWitnesses: NoteHashReadRequestMembershipWitness[],
   ) {
     const { contractAddress, functionData, publicInputs } = callStackItem;
     const { portalContractAddress } = publicInputs.callContext;
@@ -277,7 +273,11 @@ export class KernelProver {
       contractClassPublicBytecodeCommitment,
       saltedInitializationHash,
       functionLeafMembershipWitness,
-      readRequestMembershipWitnesses: makeTuple(MAX_READ_REQUESTS_PER_CALL, i => readRequestMembershipWitnesses[i], 0),
+      noteHashReadRequestMembershipWitnesses: makeTuple(
+        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
+        i => noteHashReadRequestMembershipWitnesses[i],
+        0,
+      ),
       portalContractAddress: portalContractAddress.toField(),
       acirHash,
     });
@@ -299,90 +299,11 @@ export class KernelProver {
     } = executionResult;
     const contractAddress = publicInputs.callContext.storageContractAddress;
     // Assuming that for each new commitment there's an output note added to the execution result.
-    const newCommitments = await this.proofCreator.getSiloedCommitments(publicInputs);
+    const newNoteHashes = await this.proofCreator.getSiloedCommitments(publicInputs);
     return newNotes.map((data, i) => ({
       contractAddress,
       data,
-      commitment: newCommitments[i],
+      commitment: newNoteHashes[i],
     }));
   }
-
-  /**
-   * Performs the matching between an array of read request and an array of commitments. This produces
-   * hints for the private kernel ordering circuit to efficiently match a read request with the corresponding
-   * commitment.
-   *
-   * @param readRequests - The array of read requests.
-   * @param commitments - The array of commitments.
-   * @returns An array of hints where each element is the index of the commitment in commitments array
-   *  corresponding to the read request. In other words we have readRequests[i] == commitments[hints[i]].
-   */
-  private getReadRequestHints(
-    readRequests: Tuple<SideEffect, typeof MAX_READ_REQUESTS_PER_TX>,
-    commitments: Tuple<SideEffect, typeof MAX_NEW_COMMITMENTS_PER_TX>,
-  ): Tuple<Fr, typeof MAX_READ_REQUESTS_PER_TX> {
-    const hints = makeTuple(MAX_READ_REQUESTS_PER_TX, Fr.zero);
-    for (let i = 0; i < MAX_READ_REQUESTS_PER_TX && !readRequests[i].isEmpty(); i++) {
-      const equalToRR = (cmt: SideEffect) => cmt.value.equals(readRequests[i].value);
-      const result = commitments.findIndex(equalToRR);
-      if (result == -1) {
-        throw new Error(
-          `The read request at index ${i} with value ${readRequests[i].toString()} does not match to any commitment.`,
-        );
-      } else {
-        hints[i] = new Fr(result);
-      }
-    }
-    return hints;
-  }
-
-  /**
-   *  Performs the matching between an array of nullified commitments and an array of commitments. This produces
-   * hints for the private kernel ordering circuit to efficiently match a nullifier with the corresponding
-   * commitment.
-   *
-   * @param nullifiedCommitments - The array of nullified commitments.
-   * @param commitments - The array of commitments.
-   * @returns An array of hints where each element is the index of the commitment in commitments array
-   *  corresponding to the nullified commitments. In other words we have nullifiedCommitments[i] == commitments[hints[i]].
-   */
-  private getNullifierHints(
-    nullifiedCommitments: Tuple<Fr, typeof MAX_NEW_NULLIFIERS_PER_TX>,
-    commitments: Tuple<SideEffect, typeof MAX_NEW_COMMITMENTS_PER_TX>,
-  ): Tuple<Fr, typeof MAX_NEW_NULLIFIERS_PER_TX> {
-    const hints = makeTuple(MAX_NEW_NULLIFIERS_PER_TX, Fr.zero);
-    for (let i = 0; i < MAX_NEW_NULLIFIERS_PER_TX; i++) {
-      if (!nullifiedCommitments[i].isZero()) {
-        const equalToCommitment = (cmt: SideEffect) => cmt.value.equals(nullifiedCommitments[i]);
-        const result = commitments.findIndex(equalToCommitment);
-        if (result == -1) {
-          throw new Error(
-            `The nullified commitment at index ${i} with value ${nullifiedCommitments[
-              i
-            ].toString()} does not match to any commitment.`,
-          );
-        } else {
-          hints[i] = new Fr(result);
-        }
-      }
-    }
-    return hints;
-  }
-
-  private async getMasterNullifierSecretKeys(
-    nullifierKeyValidationRequests: Tuple<
-      NullifierKeyValidationRequestContext,
-      typeof MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_TX
-    >,
-  ) {
-    const keys = makeTuple(MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_TX, GrumpkinScalar.zero);
-    for (let i = 0; i < nullifierKeyValidationRequests.length; ++i) {
-      const request = nullifierKeyValidationRequests[i];
-      if (request.isEmpty()) {
-        break;
-      }
-      keys[i] = await this.oracle.getMasterNullifierSecretKey(request.publicKey);
-    }
-    return keys;
-  }
 }

package/src/kernel_prover/proof_creator.ts

@@ -9,7 +9,7 @@ import {
   Proof,
   makeEmptyProof,
 } from '@aztec/circuits.js';
-import { siloCommitment } from '@aztec/circuits.js/abis';
+import { siloNoteHash } from '@aztec/circuits.js/hash';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { elapsed } from '@aztec/foundation/timer';
@@ -53,7 +53,7 @@ export interface ProofCreator {
   /**
    * Computes the siloed commitments for a given set of public inputs.
    *
-   * @param publicInputs - The public inputs containing the contract address and new commitments to be used in generating siloed commitments.
+   * @param publicInputs - The public inputs containing the contract address and new note hashes to be used in generating siloed note hashes.
    * @returns An array of Fr (finite field) elements representing the siloed commitments.
    */
   getSiloedCommitments(publicInputs: PrivateCircuitPublicInputs): Promise<Fr[]>;
@@ -97,7 +97,7 @@ export class KernelProofCreator implements ProofCreator {
     const contractAddress = publicInputs.callContext.storageContractAddress;
 
     return Promise.resolve(
-      publicInputs.newCommitments.map(commitment => siloCommitment(contractAddress, commitment.value)),
+      publicInputs.newNoteHashes.map(commitment => siloNoteHash(contractAddress, commitment.value)),
     );
   }
 

package/src/kernel_prover/proving_data_oracle.ts

@@ -1,3 +1,4 @@
+import { NullifierMembershipWitness } from '@aztec/circuit-types';
 import {
   FUNCTION_TREE_HEIGHT,
   Fr,
@@ -59,6 +60,8 @@ export interface ProvingDataOracle {
    */
   getNoteMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>>;
 
+  getNullifierMembershipWitness(blockNumber: number, nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
+
   /**
    * Get the root of the note hash tree.
    *

package/src/note_processor/note_processor.ts

@@ -1,13 +1,6 @@
-import {
-  AztecNode,
-  INITIAL_L2_BLOCK_NUM,
-  KeyStore,
-  L1NotePayload,
-  L2BlockContext,
-  L2BlockL2Logs,
-} from '@aztec/circuit-types';
+import { AztecNode, KeyStore, L1NotePayload, L2BlockContext, L2BlockL2Logs, TaggedNote } from '@aztec/circuit-types';
 import { NoteProcessorStats } from '@aztec/circuit-types/stats';
-import { MAX_NEW_COMMITMENTS_PER_TX, PublicKey } from '@aztec/circuits.js';
+import { INITIAL_L2_BLOCK_NUM, MAX_NEW_NOTE_HASHES_PER_TX, PublicKey } from '@aztec/circuits.js';
 import { Grumpkin } from '@aztec/circuits.js/barretenberg';
 import { Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
@@ -123,20 +116,18 @@ export class NoteProcessor {
       for (let indexOfTxInABlock = 0; indexOfTxInABlock < txLogs.length; ++indexOfTxInABlock) {
         this.stats.txs++;
         const dataStartIndexForTx =
-          dataEndIndexForBlock - (txLogs.length - indexOfTxInABlock) * MAX_NEW_COMMITMENTS_PER_TX;
-        const newCommitments = block.newCommitments.slice(
-          indexOfTxInABlock * MAX_NEW_COMMITMENTS_PER_TX,
-          (indexOfTxInABlock + 1) * MAX_NEW_COMMITMENTS_PER_TX,
-        );
+          dataEndIndexForBlock - (txLogs.length - 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.
         const txFunctionLogs = txLogs[indexOfTxInABlock].functionLogs;
         const excludedIndices: Set<number> = new Set();
         for (const functionLogs of txFunctionLogs) {
-          for (const logs of functionLogs.logs) {
+          for (const log of functionLogs.logs) {
             this.stats.seen++;
-            const payload = L1NotePayload.fromEncryptedBuffer(logs, privateKey, curve);
-            if (payload) {
+            const taggedNote = TaggedNote.fromEncryptedBuffer(log, privateKey, curve);
+            if (taggedNote?.notePayload) {
+              const { notePayload: payload } = taggedNote;
               // We have successfully decrypted the data.
               const txHash = blockContext.getTxHash(indexOfTxInABlock);
               try {
@@ -145,7 +136,7 @@ export class NoteProcessor {
                   this.publicKey,
                   payload,
                   txHash,
-                  newCommitments,
+                  newNoteHashes,
                   dataStartIndexForTx,
                   excludedIndices,
                 );
@@ -162,7 +153,7 @@ export class NoteProcessor {
                     payload.storageSlot,
                     payload.noteTypeId,
                     txHash,
-                    newCommitments,
+                    newNoteHashes,
                     dataStartIndexForTx,
                   );
                   deferredNoteDaos.push(deferredNoteDao);
@@ -213,7 +204,9 @@ export class NoteProcessor {
       });
     }
 
-    const newNullifiers: Fr[] = blocksAndNotes.flatMap(b => b.blockContext.block.newNullifiers);
+    const newNullifiers: Fr[] = blocksAndNotes.flatMap(b =>
+      b.blockContext.block.body.txEffects.flatMap(txEffect => txEffect.nullifiers),
+    );
     const removedNotes = await this.db.removeNullifiedNotes(newNullifiers, this.publicKey);
     removedNotes.forEach(noteDao => {
       this.log(
@@ -255,7 +248,7 @@ export class NoteProcessor {
     const excludedIndices: Set<number> = new Set();
     const noteDaos: NoteDao[] = [];
     for (const deferredNote of deferredNoteDaos) {
-      const { note, contractAddress, storageSlot, noteTypeId, txHash, newCommitments, dataStartIndexForTx } =
+      const { note, contractAddress, storageSlot, noteTypeId, txHash, newNoteHashes, dataStartIndexForTx } =
         deferredNote;
       const payload = new L1NotePayload(note, contractAddress, storageSlot, noteTypeId);
 
@@ -265,7 +258,7 @@ export class NoteProcessor {
           this.publicKey,
           payload,
           txHash,
-          newCommitments,
+          newNoteHashes,
           dataStartIndexForTx,
           excludedIndices,
         );

package/src/note_processor/produce_note_dao.ts

@@ -1,6 +1,6 @@
 import { L1NotePayload, TxHash } from '@aztec/circuit-types';
 import { Fr, PublicKey } from '@aztec/circuits.js';
-import { computeCommitmentNonce, siloNullifier } from '@aztec/circuits.js/abis';
+import { computeCommitmentNonce, siloNullifier } from '@aztec/circuits.js/hash';
 import { AcirSimulator } from '@aztec/simulator';
 
 import { NoteDao } from '../database/note_dao.js';
@@ -14,7 +14,7 @@ import { NoteDao } from '../database/note_dao.js';
  * @param publicKey - The public counterpart to the private key to be used in note decryption.
  * @param payload - An instance of l1NotePayload.
  * @param txHash - The hash of the transaction that created the note. Equivalent to the first nullifier of the transaction.
- * @param newCommitments - New commitments in this transaction, one of which belongs to this note.
+ * @param newNoteHashes - New note hashes in this transaction, one of which belongs to this note.
  * @param dataStartIndexForTx - The next available leaf index for the note hash tree for this transaction.
  * @param excludedIndices - Indices that have been assigned a note in the same tx. Notes in a tx can have the same l1NotePayload, we need to find a different index for each replicate.
  * @param simulator - An instance of AcirSimulator.
@@ -25,13 +25,13 @@ export async function produceNoteDao(
   publicKey: PublicKey,
   payload: L1NotePayload,
   txHash: TxHash,
-  newCommitments: Fr[],
+  newNoteHashes: Fr[],
   dataStartIndexForTx: number,
   excludedIndices: Set<number>,
 ): Promise<NoteDao> {
   const { commitmentIndex, nonce, innerNoteHash, siloedNullifier } = await findNoteIndexAndNullifier(
     simulator,
-    newCommitments,
+    newNoteHashes,
     txHash,
     payload,
     excludedIndices,

package/src/pxe_http/pxe_http_server.ts

@@ -7,11 +7,12 @@ import {
   ExtendedUnencryptedL2Log,
   L2Block,
   L2BlockL2Logs,
-  L2Tx,
   LogId,
   Note,
+  NullifierMembershipWitness,
   PXE,
   Tx,
+  TxEffect,
   TxExecutionRequest,
   TxHash,
   TxReceipt,
@@ -20,7 +21,7 @@ import { FunctionSelector } from '@aztec/circuits.js';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { EthAddress } from '@aztec/foundation/eth-address';
 import { Fr, GrumpkinScalar, Point } from '@aztec/foundation/fields';
-import { JsonRpcServer } from '@aztec/foundation/json-rpc/server';
+import { JsonRpcServer, createNamespacedJsonRpcServer } from '@aztec/foundation/json-rpc/server';
 
 import http from 'http';
 
@@ -48,10 +49,10 @@ export function createPXERpcServer(pxeService: PXE): JsonRpcServer {
       ExtendedNote,
       AuthWitness,
       L2Block,
-      L2Tx,
+      TxEffect,
       LogId,
     },
-    { Tx, TxReceipt, L2BlockL2Logs },
+    { Tx, TxReceipt, L2BlockL2Logs, NullifierMembershipWitness },
     ['start', 'stop'],
   );
 }
@@ -63,7 +64,8 @@ export function createPXERpcServer(pxeService: PXE): JsonRpcServer {
  * @returns A running http server.
  */
 export function startPXEHttpServer(pxeService: PXE, port: string | number): http.Server {
-  const rpcServer = createPXERpcServer(pxeService);
+  const pxeServer = createPXERpcServer(pxeService);
+  const rpcServer = createNamespacedJsonRpcServer([{ pxe: pxeServer }]);
 
   const app = rpcServer.getApp();
   const httpServer = http.createServer(app.callback());

package/src/pxe_service/create_pxe_service.ts

@@ -4,6 +4,7 @@ import { TestKeyStore } 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';
+import { getCanonicalGasToken } from '@aztec/protocol-contracts/gas-token';
 import { getCanonicalInstanceDeployer } from '@aztec/protocol-contracts/instance-deployer';
 
 import { join } from 'path';
@@ -45,7 +46,7 @@ export async function createPXEService(
   const db = new KVPxeDatabase(await initStoreForRollup(AztecLmdbStore.open(pxeDbPath), l1Contracts.rollupAddress));
 
   const server = new PXEService(keyStore, aztecNode, db, config, logSuffix);
-  await server.addContracts([getCanonicalClassRegisterer(), getCanonicalInstanceDeployer()]);
+  await server.addContracts([getCanonicalClassRegisterer(), getCanonicalInstanceDeployer(), getCanonicalGasToken()]);
 
   await server.start();
   return server;