@aztec/pxe 0.36.0 → 0.38.0

package/src/kernel_prover/interface/proof_creator.ts

@@ -0,0 +1,79 @@
+import {
+  type PrivateCircuitPublicInputs,
+  type PrivateKernelCircuitPublicInputs,
+  type PrivateKernelInitCircuitPrivateInputs,
+  type PrivateKernelInnerCircuitPrivateInputs,
+  type PrivateKernelTailCircuitPrivateInputs,
+  type PrivateKernelTailCircuitPublicInputs,
+  type Proof,
+} from '@aztec/circuits.js';
+import { type Fr } from '@aztec/foundation/fields';
+import { type ACVMField } from '@aztec/simulator';
+
+/**
+ * Represents the output of the proof creation process for init and inner private kernel circuit.
+ * Contains the public inputs required for the init and inner private kernel circuit and the generated proof.
+ */
+export type ProofOutput<PublicInputsType> = {
+  /**
+   * The public inputs required for the proof generation process.
+   */
+  publicInputs: PublicInputsType;
+  /**
+   * The zk-SNARK proof for the kernel execution.
+   */
+  proof: Proof;
+};
+
+/**
+ * ProofCreator provides functionality to create and validate proofs, and retrieve
+ * siloed commitments necessary for maintaining transaction privacy and security on the network.
+ */
+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 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[]>;
+
+  /**
+   * Creates a proof output for a given signed transaction request and private call data for the first iteration.
+   *
+   * @param privateKernelInputsInit - The private data structure for the initial iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  createProofInit(
+    privateKernelInputsInit: PrivateKernelInitCircuitPrivateInputs,
+  ): Promise<ProofOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Creates a proof output for a given previous kernel data and private call data for an inner iteration.
+   *
+   * @param privateKernelInputsInner - The private input data structure for the inner iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  createProofInner(
+    privateKernelInputsInner: PrivateKernelInnerCircuitPrivateInputs,
+  ): Promise<ProofOutput<PrivateKernelCircuitPublicInputs>>;
+
+  /**
+   * Creates a proof output based on the last inner kernel iteration kernel data for the final ordering iteration.
+   *
+   * @param privateKernelInputsTail - The private input data structure for the final ordering iteration.
+   * @returns A Promise resolving to a ProofOutput object containing public inputs and the kernel proof.
+   */
+  createProofTail(
+    privateKernelInputsTail: PrivateKernelTailCircuitPrivateInputs,
+  ): Promise<ProofOutput<PrivateKernelTailCircuitPublicInputs>>;
+
+  /**
+   * Creates a proof for an app circuit.
+   *
+   * @param partialWitness - The witness produced via circuit simulation
+   * @param bytecode - The circuit bytecode in gzipped bincode format
+   * @returns A Promise resolving to a Proof object
+   */
+  createAppCircuitProof(partialWitness: Map<number, ACVMField>, bytecode: Buffer): Promise<Proof>;
+}

package/src/kernel_prover/kernel_prover.ts

@@ -1,34 +1,33 @@
 import {
   CallRequest,
   Fr,
-  MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
   MAX_PRIVATE_CALL_STACK_LENGTH_PER_CALL,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_CALL,
-  NoteHashReadRequestMembershipWitness,
   PrivateCallData,
   PrivateKernelCircuitPublicInputs,
   PrivateKernelData,
   PrivateKernelInitCircuitPrivateInputs,
   PrivateKernelInnerCircuitPrivateInputs,
   PrivateKernelTailCircuitPrivateInputs,
+  type PrivateKernelTailCircuitPublicInputs,
+  type Proof,
   type TxRequest,
   VK_TREE_HEIGHT,
   VerificationKey,
   makeEmptyProof,
 } from '@aztec/circuits.js';
-import { makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { assertLength } from '@aztec/foundation/serialize';
 import { pushTestData } from '@aztec/foundation/testing';
-import { type ExecutionResult, collectNullifiedNoteHashCounters } from '@aztec/simulator';
+import { type ExecutionResult, collectNoteHashLeafIndexMap, collectNullifiedNoteHashCounters } from '@aztec/simulator';
 
+import { type ProofCreator, type ProofOutput } from './interface/proof_creator.js';
 import {
   buildPrivateKernelInnerHints,
   buildPrivateKernelTailHints,
   buildPrivateKernelTailOutputs,
 } from './private_inputs_builders/index.js';
-import { KernelProofCreator, type ProofCreator, type ProofOutput, type ProofOutputFinal } from './proof_creator.js';
 import { type ProvingDataOracle } from './proving_data_oracle.js';
 
 /**
@@ -39,7 +38,8 @@ import { type ProvingDataOracle } from './proving_data_oracle.js';
  */
 export class KernelProver {
   private log = createDebugLogger('aztec:kernel-prover');
-  constructor(private oracle: ProvingDataOracle, private proofCreator: ProofCreator = new KernelProofCreator()) {}
+
+  constructor(private oracle: ProvingDataOracle, private proofCreator: ProofCreator) {}
 
   /**
    * Generate a proof for a given transaction request and execution result.
@@ -51,20 +51,21 @@ export class KernelProver {
    * @param executionResult - The execution result object containing nested executions and preimages.
    * @returns A Promise that resolves to a KernelProverOutput object containing proof, public inputs, and output notes.
    */
-  async prove(txRequest: TxRequest, executionResult: ExecutionResult): Promise<ProofOutputFinal> {
+  async prove(
+    txRequest: TxRequest,
+    executionResult: ExecutionResult,
+  ): Promise<ProofOutput<PrivateKernelTailCircuitPublicInputs>> {
     const executionStack = [executionResult];
     let firstIteration = true;
     let previousVerificationKey = VerificationKey.makeFake();
 
-    let output: ProofOutput = {
+    let output: ProofOutput<PrivateKernelCircuitPublicInputs> = {
       publicInputs: PrivateKernelCircuitPublicInputs.empty(),
       proof: makeEmptyProof(),
     };
 
-    const noteHashNullifierCounterMap = new Map();
-    collectNullifiedNoteHashCounters(executionResult).forEach(({ noteHashCounter, nullifierCounter }) =>
-      noteHashNullifierCounterMap.set(noteHashCounter, nullifierCounter),
-    );
+    const noteHashLeafIndexMap = collectNoteHashLeafIndexMap(executionResult);
+    const noteHashNullifierCounterMap = collectNullifiedNoteHashCounters(executionResult);
 
     while (executionStack.length) {
       const currentExecution = executionStack.pop()!;
@@ -75,38 +76,16 @@ export class KernelProver {
       );
       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 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) {
-        //   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 = 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.
-          const membershipWitness = await this.oracle.getNoteMembershipWitness(rrWitness.leafIndex.toBigInt());
-          rrWitness.siblingPath = membershipWitness.siblingPath;
-        }
-      }
-
-      // fill in witnesses for remaining/empty read requests
-      noteHashReadRequestMembershipWitnesses.push(
-        ...Array(MAX_NOTE_HASH_READ_REQUESTS_PER_CALL - noteHashReadRequestMembershipWitnesses.length)
-          .fill(0)
-          .map(() => NoteHashReadRequestMembershipWitness.empty(BigInt(0))),
+      const proof = await this.proofCreator.createAppCircuitProof(
+        currentExecution.partialWitness,
+        currentExecution.acir,
       );
 
       const privateCallData = await this.createPrivateCallData(
         currentExecution,
         privateCallRequests,
         publicCallRequests,
-        noteHashReadRequestMembershipWitnesses,
+        proof,
       );
 
       const hints = buildPrivateKernelInnerHints(
@@ -148,7 +127,7 @@ export class KernelProver {
       `Calling private kernel tail with hwm ${previousKernelData.publicInputs.minRevertibleSideEffectCounter}`,
     );
 
-    const hints = await buildPrivateKernelTailHints(output.publicInputs, this.oracle);
+    const hints = await buildPrivateKernelTailHints(output.publicInputs, noteHashLeafIndexMap, this.oracle);
 
     const expectedOutputs = buildPrivateKernelTailOutputs(hints.sortedNewNoteHashes, hints.sortedNewNullifiers);
 
@@ -162,7 +141,7 @@ export class KernelProver {
     { callStackItem, vk }: ExecutionResult,
     privateCallRequests: CallRequest[],
     publicCallRequests: CallRequest[],
-    noteHashReadRequestMembershipWitnesses: NoteHashReadRequestMembershipWitness[],
+    proof: Proof,
   ) {
     const { contractAddress, functionData } = callStackItem;
 
@@ -188,9 +167,6 @@ export class KernelProver {
     // const acirHash = keccak256(Buffer.from(bytecode, 'hex'));
     const acirHash = Fr.fromBuffer(Buffer.alloc(32, 0));
 
-    // TODO
-    const proof = makeEmptyProof();
-
     return PrivateCallData.from({
       callStackItem,
       privateCallStack,
@@ -202,11 +178,6 @@ export class KernelProver {
       contractClassPublicBytecodeCommitment,
       saltedInitializationHash,
       functionLeafMembershipWitness,
-      noteHashReadRequestMembershipWitnesses: makeTuple(
-        MAX_NOTE_HASH_READ_REQUESTS_PER_CALL,
-        i => noteHashReadRequestMembershipWitnesses[i],
-        0,
-      ),
       acirHash,
     });
   }

package/src/kernel_prover/private_inputs_builders/build_private_kernel_tail_hints.ts

@@ -4,13 +4,11 @@ import {
   type MAX_ENCRYPTED_LOGS_PER_TX,
   MAX_NEW_NOTE_HASHES_PER_TX,
   MAX_NEW_NULLIFIERS_PER_TX,
-  MAX_NOTE_HASH_READ_REQUESTS_PER_TX,
   MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_TX,
   type MAX_NULLIFIER_READ_REQUESTS_PER_TX,
   type MAX_UNENCRYPTED_LOGS_PER_TX,
   MembershipWitness,
   NULLIFIER_TREE_HEIGHT,
-  type NoteHashContext,
   type Nullifier,
   type NullifierKeyValidationRequestContext,
   type PrivateKernelCircuitPublicInputs,
@@ -18,9 +16,9 @@ import {
   type ReadRequestContext,
   type SideEffect,
   type SideEffectType,
+  buildNoteHashReadRequestHints,
   buildNullifierReadRequestHints,
   buildTransientDataHints,
-  countAccumulatedItems,
   sortByCounterGetSortedHints,
 } from '@aztec/circuits.js';
 import { makeTuple } from '@aztec/foundation/array';
@@ -50,42 +48,6 @@ function sortSideEffects<T extends SideEffectType, K extends number>(
   return [sorted.map(({ sideEffect }) => sideEffect) as Tuple<T, K>, originalToSorted as Tuple<number, K>];
 }
 
-function isValidNoteHashReadRequest(readRequest: SideEffect, noteHash: NoteHashContext) {
-  return (
-    noteHash.value.equals(readRequest.value) &&
-    noteHash.counter < readRequest.counter.toNumber() &&
-    (noteHash.nullifierCounter === 0 || noteHash.nullifierCounter > readRequest.counter.toNumber())
-  );
-}
-
-/**
- * Performs the matching between an array of read request and an array of note hashes. This produces
- * hints for the private kernel tail circuit to efficiently match a read request with the corresponding
- * note hash. Several read requests might be pointing to the same note hash. It is therefore valid
- * to return more than one hint with the same index.
- *
- * @param noteHashReadRequests - The array of read requests.
- * @param noteHashes - The array of note hashes.
- * @returns An array of hints where each element is the index of the note hash in note hashes array
- *  corresponding to the read request. In other words we have readRequests[i] == noteHashes[hints[i]].
- */
-function getNoteHashReadRequestHints(
-  noteHashReadRequests: Tuple<SideEffect, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX>,
-  noteHashes: Tuple<NoteHashContext, typeof MAX_NEW_NOTE_HASHES_PER_TX>,
-): Tuple<number, typeof MAX_NOTE_HASH_READ_REQUESTS_PER_TX> {
-  const hints = makeTuple(MAX_NOTE_HASH_READ_REQUESTS_PER_TX, () => 0);
-  const numReadRequests = countAccumulatedItems(noteHashReadRequests);
-  for (let i = 0; i < numReadRequests; i++) {
-    const readRequest = noteHashReadRequests[i];
-    const noteHashIndex = noteHashes.findIndex((n: NoteHashContext) => isValidNoteHashReadRequest(readRequest, n));
-    if (noteHashIndex === -1) {
-      throw new Error(`The read request at index ${i} ${readRequest} does not match to any note hash.`);
-    }
-    hints[i] = noteHashIndex;
-  }
-  return hints;
-}
-
 function getNullifierReadRequestHints(
   nullifierReadRequests: Tuple<ReadRequestContext, typeof MAX_NULLIFIER_READ_REQUESTS_PER_TX>,
   nullifiers: Tuple<Nullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
@@ -131,11 +93,14 @@ async function getMasterNullifierSecretKeys(
 
 export async function buildPrivateKernelTailHints(
   publicInputs: PrivateKernelCircuitPublicInputs,
+  noteHashLeafIndexMap: Map<bigint, bigint>,
   oracle: ProvingDataOracle,
 ) {
-  const noteHashReadRequestHints = getNoteHashReadRequestHints(
+  const noteHashReadRequestHints = await buildNoteHashReadRequestHints(
+    oracle,
     publicInputs.validationRequests.noteHashReadRequests,
     publicInputs.end.newNoteHashes,
+    noteHashLeafIndexMap,
   );
 
   const nullifierReadRequestHints = await getNullifierReadRequestHints(

package/src/kernel_prover/proving_data_oracle.ts

@@ -58,7 +58,7 @@ export interface ProvingDataOracle {
    * @param leafIndex - The leaf index of the note in the note hash tree.
    * @returns the MembershipWitness for the note.
    */
-  getNoteMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>>;
+  getNoteHashMembershipWitness(leafIndex: bigint): Promise<MembershipWitness<typeof NOTE_HASH_TREE_HEIGHT>>;
 
   getNullifierMembershipWitness(nullifier: Fr): Promise<NullifierMembershipWitness | undefined>;
 

package/src/kernel_prover/test/test_circuit_prover.ts

@@ -0,0 +1,96 @@
+import { type CircuitSimulationStats } from '@aztec/circuit-types/stats';
+import {
+  type PrivateCircuitPublicInputs,
+  type PrivateKernelCircuitPublicInputs,
+  type PrivateKernelInitCircuitPrivateInputs,
+  type PrivateKernelInnerCircuitPrivateInputs,
+  type PrivateKernelTailCircuitPrivateInputs,
+  type PrivateKernelTailCircuitPublicInputs,
+  Proof,
+  makeEmptyProof,
+} from '@aztec/circuits.js';
+import { siloNoteHash } from '@aztec/circuits.js/hash';
+import { createDebugLogger } from '@aztec/foundation/log';
+import { elapsed } from '@aztec/foundation/timer';
+import { executeInit, executeInner, executeTail, executeTailForPublic } from '@aztec/noir-protocol-circuits-types';
+
+import { type ProofCreator, type ProofOutput } from '../interface/proof_creator.js';
+
+/**
+ * Test Proof Creator executes circuit simulations and provides fake proofs.
+ */
+export class TestProofCreator implements ProofCreator {
+  constructor(private log = createDebugLogger('aztec:test_proof_creator')) {}
+
+  public getSiloedCommitments(publicInputs: PrivateCircuitPublicInputs) {
+    const contractAddress = publicInputs.callContext.storageContractAddress;
+
+    return Promise.resolve(
+      publicInputs.newNoteHashes.map(commitment => siloNoteHash(contractAddress, commitment.value)),
+    );
+  }
+
+  public async createProofInit(
+    privateInputs: PrivateKernelInitCircuitPrivateInputs,
+  ): Promise<ProofOutput<PrivateKernelCircuitPublicInputs>> {
+    const [duration, result] = await elapsed(() => executeInit(privateInputs));
+    this.log.debug(`Simulated private kernel init`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'private-kernel-init',
+      duration,
+      inputSize: privateInputs.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+    const proof = makeEmptyProof();
+
+    return {
+      publicInputs: result,
+      proof: proof,
+    };
+  }
+
+  public async createProofInner(
+    privateInputs: PrivateKernelInnerCircuitPrivateInputs,
+  ): Promise<ProofOutput<PrivateKernelCircuitPublicInputs>> {
+    const [duration, result] = await elapsed(() => executeInner(privateInputs));
+    this.log.debug(`Simulated private kernel inner`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'private-kernel-inner',
+      duration,
+      inputSize: privateInputs.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+    const proof = makeEmptyProof();
+
+    return {
+      publicInputs: result,
+      proof: proof,
+    };
+  }
+
+  public async createProofTail(
+    privateInputs: PrivateKernelTailCircuitPrivateInputs,
+  ): Promise<ProofOutput<PrivateKernelTailCircuitPublicInputs>> {
+    const isForPublic = privateInputs.isForPublic();
+    const [duration, result] = await elapsed(() =>
+      isForPublic ? executeTailForPublic(privateInputs) : executeTail(privateInputs),
+    );
+    this.log.debug(`Simulated private kernel ordering`, {
+      eventName: 'circuit-simulation',
+      circuitName: 'private-kernel-ordering',
+      duration,
+      inputSize: privateInputs.toBuffer().length,
+      outputSize: result.toBuffer().length,
+    } satisfies CircuitSimulationStats);
+    const proof = makeEmptyProof();
+
+    return {
+      publicInputs: result,
+      proof: proof,
+    };
+  }
+
+  createAppCircuitProof(_1: Map<number, string>, _2: Buffer): Promise<Proof> {
+    return Promise.resolve(new Proof(Buffer.alloc(0)));
+  }
+}

package/src/pxe_service/create_pxe_service.ts

@@ -13,6 +13,9 @@ import { join } from 'path';
 
 import { type PXEServiceConfig } from '../config/index.js';
 import { KVPxeDatabase } from '../database/kv_pxe_database.js';
+import { BBNativeProofCreator } from '../kernel_prover/bb_prover/bb_native_proof_creator.js';
+import { type ProofCreator } from '../kernel_prover/interface/proof_creator.js';
+import { TestProofCreator } from '../kernel_prover/test/test_circuit_prover.js';
 import { PXEService } from './pxe_service.js';
 
 /**
@@ -23,12 +26,14 @@ import { PXEService } from './pxe_service.js';
  * @param aztecNode - The AztecNode instance to be used by the server.
  * @param config - The PXE Service Config to use
  * @param options - (Optional) Optional information for creating an PXEService.
+ * @param proofCreator - An optional proof creator to use in place of any other configuration
  * @returns A Promise that resolves to the started PXEService instance.
  */
 export async function createPXEService(
   aztecNode: AztecNode,
   config: PXEServiceConfig,
   useLogSuffix: string | boolean | undefined = undefined,
+  proofCreator?: ProofCreator,
 ) {
   const logSuffix =
     typeof useLogSuffix === 'boolean' ? (useLogSuffix ? randomBytes(3).toString('hex') : undefined) : useLogSuffix;
@@ -42,7 +47,18 @@ export async function createPXEService(
   );
   const db = new KVPxeDatabase(await initStoreForRollup(AztecLmdbStore.open(pxeDbPath), l1Contracts.rollupAddress));
 
-  const server = new PXEService(keyStore, aztecNode, db, config, logSuffix);
+  // (@PhilWindle) Temporary validation until WASM is implemented
+  let prover: ProofCreator | undefined = proofCreator;
+  if (!prover) {
+    if (config.proverEnabled && (!config.bbBinaryPath || !config.bbWorkingDirectory)) {
+      throw new Error(`Prover must be configured with binary path and working directory`);
+    }
+    prover = !config.proverEnabled
+      ? new TestProofCreator()
+      : new BBNativeProofCreator(config.bbBinaryPath!, config.bbWorkingDirectory!);
+  }
+
+  const server = new PXEService(keyStore, aztecNode, db, prover, config, logSuffix);
   for (const contract of [
     getCanonicalClassRegisterer(),
     getCanonicalInstanceDeployer(),

package/src/pxe_service/pxe_service.ts

@@ -1,8 +1,6 @@
 import {
   type AuthWitness,
   type AztecNode,
-  EncryptedFunctionL2Logs,
-  type EncryptedL2Log,
   EncryptedTxL2Logs,
   ExtendedNote,
   type FunctionCall,
@@ -20,8 +18,6 @@ import {
   type TxExecutionRequest,
   type TxHash,
   type TxReceipt,
-  UnencryptedFunctionL2Logs,
-  type UnencryptedL2Log,
   UnencryptedTxL2Logs,
   isNoirCallStackUnresolved,
 } from '@aztec/circuit-types';
@@ -34,24 +30,23 @@ import {
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
   type PartialAddress,
   type PrivateKernelTailCircuitPublicInputs,
-  type PublicCallRequest,
-  type SideEffect,
+  PublicCallRequest,
   computeContractClassId,
   getContractClassFromArtifact,
 } from '@aztec/circuits.js';
 import { computeCommitmentNonce, 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 { Fr, type Point } 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 AcirSimulator,
   type ExecutionResult,
-  collectEncryptedLogs,
   collectEnqueuedPublicFunctionCalls,
-  collectUnencryptedLogs,
+  collectSortedEncryptedLogs,
+  collectSortedUnencryptedLogs,
   resolveOpcodeLocations,
 } from '@aztec/simulator';
 import { type ContractClassWithId, type ContractInstanceWithAddress } from '@aztec/types/contracts';
@@ -62,6 +57,7 @@ import { ContractDataOracle } from '../contract_data_oracle/index.js';
 import { type PxeDatabase } from '../database/index.js';
 import { NoteDao } from '../database/note_dao.js';
 import { KernelOracle } from '../kernel_oracle/index.js';
+import { type ProofCreator } from '../kernel_prover/interface/proof_creator.js';
 import { KernelProver } from '../kernel_prover/kernel_prover.js';
 import { getAcirSimulator } from '../simulator/index.js';
 import { Synchronizer } from '../synchronizer/index.js';
@@ -83,6 +79,7 @@ export class PXEService implements PXE {
     private keyStore: KeyStore,
     private node: AztecNode,
     private db: PxeDatabase,
+    private proofCreator: ProofCreator,
     private config: PXEServiceConfig,
     logSuffix?: string,
   ) {
@@ -216,8 +213,20 @@ export class PXEService implements PXE {
     return this.keyStore.getPublicKeysHash(address);
   }
 
-  public async registerRecipient(recipient: CompleteAddress): Promise<void> {
+  public async registerRecipient(recipient: CompleteAddress, publicKeys: Point[] = []): Promise<void> {
     const wasAdded = await this.db.addCompleteAddress(recipient);
+
+    // TODO #5834: This should be refactored to be okay with only adding complete address
+    if (publicKeys.length !== 0) {
+      await this.keyStore.addPublicKeysForAccount(
+        recipient.address,
+        publicKeys[0],
+        publicKeys[1],
+        publicKeys[2],
+        publicKeys[3],
+      );
+    }
+
     if (wasAdded) {
       this.log.info(`Added recipient:\n ${recipient.toReadableString()}`);
     } else {
@@ -654,18 +663,27 @@ export class PXEService implements PXE {
     const executionResult = await this.#simulate(txExecutionRequest, msgSender);
 
     const kernelOracle = new KernelOracle(this.contractDataOracle, this.keyStore, this.node);
-    const kernelProver = new KernelProver(kernelOracle);
+    const kernelProver = new KernelProver(kernelOracle, this.proofCreator);
     this.log.debug(`Executing kernel prover...`);
     const { proof, publicInputs } = await kernelProver.prove(txExecutionRequest.toTxRequest(), executionResult);
 
-    const { encryptedLogs, unencryptedLogs } = this.patchLogsOrdering(executionResult);
+    const unencryptedLogs = new UnencryptedTxL2Logs([collectSortedUnencryptedLogs(executionResult)]);
+    const encryptedLogs = new EncryptedTxL2Logs([collectSortedEncryptedLogs(executionResult)]);
     const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(executionResult);
+    const teardownPublicFunction = PublicCallRequest.empty();
 
     // 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, encryptedLogs, unencryptedLogs, enqueuedPublicFunctions);
+    const tx = new Tx(
+      publicInputs,
+      proof,
+      encryptedLogs,
+      unencryptedLogs,
+      enqueuedPublicFunctions,
+      teardownPublicFunction,
+    );
     return new SimulatedTx(tx, executionResult.returnValues);
   }
 
@@ -776,61 +794,6 @@ export class PXEService implements PXE {
     );
   }
 
-  // As above, this is a hack for encrypted/unencrypted logs ordering, now they are sorted. Since the private kernel
-  // cannot keep track of side effects that happen after or before a nested call, we override the gathered logs.
-  // 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/1641
-  // Added as part of resolving #5017
-  private patchLogsOrdering(execResult: ExecutionResult) {
-    const encLogs = collectEncryptedLogs(execResult).flatMap(l => l.logs);
-    const unencLogs = collectUnencryptedLogs(execResult).flatMap(l => l.logs);
-    const getLogs = (res: ExecutionResult, enc: boolean) => {
-      const logs: SideEffect[] = enc
-        ? res.callStackItem.publicInputs.encryptedLogsHashes.concat(res.nestedExecutions.flatMap(e => getLogs(e, true)))
-        : res.callStackItem.publicInputs.unencryptedLogsHashes.concat(
-            res.nestedExecutions.flatMap(e => getLogs(e, false)),
-          );
-
-      return logs;
-    };
-
-    const sortSEs = (a: SideEffect, b: SideEffect) => {
-      if (a.isEmpty()) {
-        return 1;
-      } else if (b.isEmpty()) {
-        return -1;
-      } else {
-        return Number(a.counter.toBigInt() - b.counter.toBigInt());
-      }
-    };
-
-    const sortedEncLogs = getLogs(execResult, true).sort(sortSEs);
-    const sortedUnencLogs = getLogs(execResult, false).sort(sortSEs);
-
-    const finalEncLogs: EncryptedL2Log[] = [];
-    sortedEncLogs.forEach((sideEffect: SideEffect) => {
-      if (!sideEffect.isEmpty()) {
-        const isLog = (log: EncryptedL2Log) => Fr.fromBuffer(log.hash()).equals(sideEffect.value);
-        const thisLogIndex = encLogs.findIndex(isLog);
-        finalEncLogs.push(encLogs[thisLogIndex]);
-      }
-    });
-
-    const finalUnencLogs: UnencryptedL2Log[] = [];
-    sortedUnencLogs.forEach((sideEffect: SideEffect) => {
-      if (!sideEffect.isEmpty()) {
-        const isLog = (log: UnencryptedL2Log) => Fr.fromBuffer(log.hash()).equals(sideEffect.value);
-        const thisLogIndex = unencLogs.findIndex(isLog);
-        finalUnencLogs.push(unencLogs[thisLogIndex]);
-      }
-    });
-
-    const encryptedLogs = new EncryptedTxL2Logs([new EncryptedFunctionL2Logs(finalEncLogs)]);
-    const unencryptedLogs = new UnencryptedTxL2Logs([new UnencryptedFunctionL2Logs(finalUnencLogs)]);
-    return { encryptedLogs, unencryptedLogs };
-  }
-
   public async isGlobalStateSynchronized() {
     return await this.synchronizer.isGlobalStateSynchronized();
   }