@aztec/pxe 0.56.0 → 0.58.0

package/src/note_processor/utils/produce_note_daos.ts

@@ -0,0 +1,114 @@
+import { type L1NotePayload, type PublicKey, type TxHash, type UnencryptedTxL2Logs } from '@aztec/circuit-types';
+import { type Fr } from '@aztec/foundation/fields';
+import { type Logger } from '@aztec/foundation/log';
+import { type AcirSimulator } from '@aztec/simulator';
+
+import { type DeferredNoteDao } from '../../database/deferred_note_dao.js';
+import { IncomingNoteDao } from '../../database/incoming_note_dao.js';
+import { OutgoingNoteDao } from '../../database/outgoing_note_dao.js';
+import { type PxeDatabase } from '../../database/pxe_database.js';
+import { produceNoteDaosForKey } from './produce_note_daos_for_key.js';
+
+/**
+ * Decodes a note from a transaction that we know was intended for us.
+ * Throws if we do not yet have the contract corresponding to the note in our database.
+ * Accepts a set of excluded indices, which are indices that have been assigned a note in the same tx.
+ * Inserts the index of the note into the excludedIndices set if the note is successfully decoded.
+ *
+ * @param simulator - An instance of AcirSimulator.
+ * @param db - An instance of PxeDatabase.
+ * @param ivpkM - The public counterpart to the secret key to be used in the decryption of incoming note logs.
+ * @param ovpkM - The public counterpart to the secret key to be used in the decryption of outgoing note logs.
+ * @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 noteHashes - 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 logger - An instance of Logger.
+ * @param unencryptedLogs - Unencrypted logs for the transaction (used to complete partial notes).
+ * @returns An object containing the incoming, outgoing, and deferred notes.
+ */
+export async function produceNoteDaos(
+  simulator: AcirSimulator,
+  db: PxeDatabase,
+  ivpkM: PublicKey | undefined,
+  ovpkM: PublicKey | undefined,
+  payload: L1NotePayload,
+  txHash: TxHash,
+  noteHashes: Fr[],
+  dataStartIndexForTx: number,
+  excludedIndices: Set<number>,
+  logger: Logger,
+  unencryptedLogs: UnencryptedTxL2Logs,
+): Promise<{
+  incomingNote: IncomingNoteDao | undefined;
+  outgoingNote: OutgoingNoteDao | undefined;
+  incomingDeferredNote: DeferredNoteDao | undefined;
+  outgoingDeferredNote: DeferredNoteDao | undefined;
+}> {
+  // WARNING: This code is full of tech debt and will be refactored once we have final design of partial notes
+  // delivery.
+  if (!ivpkM && !ovpkM) {
+    throw new Error('Both ivpkM and ovpkM are undefined. Cannot create note.');
+  }
+
+  let incomingNote: IncomingNoteDao | undefined;
+  let outgoingNote: OutgoingNoteDao | undefined;
+  let incomingDeferredNote: DeferredNoteDao | undefined;
+  let outgoingDeferredNote: DeferredNoteDao | undefined;
+
+  if (ivpkM) {
+    [incomingNote, incomingDeferredNote] = await produceNoteDaosForKey(
+      simulator,
+      db,
+      ivpkM,
+      payload,
+      txHash,
+      noteHashes,
+      dataStartIndexForTx,
+      excludedIndices,
+      logger,
+      unencryptedLogs,
+      IncomingNoteDao.fromPayloadAndNoteInfo,
+    );
+  }
+
+  if (ovpkM) {
+    if (incomingNote) {
+      // Incoming note is defined meaning that this PXE has both the incoming and outgoing keys. We can skip computing
+      // note hash and note index since we already have them in the incoming note.
+      outgoingNote = new OutgoingNoteDao(
+        payload.note,
+        payload.contractAddress,
+        payload.storageSlot,
+        payload.noteTypeId,
+        txHash,
+        incomingNote.nonce,
+        incomingNote.noteHash,
+        incomingNote.index,
+        ovpkM,
+      );
+    } else {
+      [outgoingNote, outgoingDeferredNote] = await produceNoteDaosForKey(
+        simulator,
+        db,
+        ovpkM,
+        payload,
+        txHash,
+        noteHashes,
+        dataStartIndexForTx,
+        excludedIndices,
+        logger,
+        unencryptedLogs,
+        OutgoingNoteDao.fromPayloadAndNoteInfo,
+      );
+    }
+  }
+
+  return {
+    incomingNote,
+    outgoingNote,
+    incomingDeferredNote,
+    outgoingDeferredNote,
+  };
+}

package/src/note_processor/utils/produce_note_daos_for_key.ts

@@ -0,0 +1,157 @@
+import { type L1NotePayload, type TxHash, UnencryptedTxL2Logs } from '@aztec/circuit-types';
+import { Fr, type PublicKey } from '@aztec/circuits.js';
+import { type Logger } from '@aztec/foundation/log';
+import { type AcirSimulator, ContractNotFoundError } from '@aztec/simulator';
+
+import { DeferredNoteDao } from '../../database/deferred_note_dao.js';
+import { type PxeDatabase } from '../../database/pxe_database.js';
+import { addNullableFieldsToPayload } from './add_nullable_field_to_payload.js';
+import { type NoteInfo, bruteForceNoteInfo } from './brute_force_note_info.js';
+
+export async function produceNoteDaosForKey<T>(
+  simulator: AcirSimulator,
+  db: PxeDatabase,
+  pkM: PublicKey,
+  payload: L1NotePayload,
+  txHash: TxHash,
+  noteHashes: Fr[],
+  dataStartIndexForTx: number,
+  excludedIndices: Set<number>,
+  logger: Logger,
+  unencryptedLogs: UnencryptedTxL2Logs,
+  daoConstructor: (payload: L1NotePayload, noteInfo: NoteInfo, dataStartIndexForTx: number, pkM: PublicKey) => T,
+): Promise<[T | undefined, DeferredNoteDao | undefined]> {
+  let noteDao: T | undefined;
+  let deferredNoteDao: DeferredNoteDao | undefined;
+
+  try {
+    const noteInfo = await bruteForceNoteInfo(
+      simulator,
+      noteHashes,
+      txHash,
+      payload,
+      excludedIndices,
+      true, // For incoming we compute a nullifier (recipient of incoming is the party that nullifies).
+    );
+    excludedIndices?.add(noteInfo.noteHashIndex);
+
+    noteDao = daoConstructor(payload, noteInfo, dataStartIndexForTx, pkM);
+  } catch (e) {
+    if (e instanceof ContractNotFoundError) {
+      logger.warn(e.message);
+
+      deferredNoteDao = new DeferredNoteDao(
+        pkM,
+        payload.note,
+        payload.contractAddress,
+        payload.storageSlot,
+        payload.noteTypeId,
+        txHash,
+        noteHashes,
+        dataStartIndexForTx,
+        unencryptedLogs,
+      );
+    } else if (
+      (e as any).message.includes('failed to solve blackbox function: embedded_curve_add') ||
+      (e as any).message.includes('Could not find key prefix.')
+    ) {
+      // TODO(#8769): This branch is a temporary partial notes delivery solution that should be eventually replaced.
+      // Both error messages above occur only when we are dealing with a partial note and are thrown when calling
+      // `note.compute_note_hash()` or `note.compute_nullifier_without_context()`
+      // in `compute_note_hash_and_optionally_a_nullifier` function. It occurs with partial notes because in the
+      // partial flow we receive a note log of a note that is missing some fields here and then we try to compute
+      // the note hash with MSM while some of the fields are zeroed out (or get a nsk for zero npk_m_hash).
+      noteDao = await handlePartialNote(
+        simulator,
+        db,
+        pkM,
+        payload,
+        txHash,
+        noteHashes,
+        dataStartIndexForTx,
+        excludedIndices,
+        logger,
+        unencryptedLogs,
+        daoConstructor,
+      );
+    } else {
+      logger.error(`Could not process note because of "${e}". Discarding note...`);
+    }
+  }
+
+  return [noteDao, deferredNoteDao];
+}
+
+async function handlePartialNote<T>(
+  simulator: AcirSimulator,
+  db: PxeDatabase,
+  pkM: PublicKey,
+  payload: L1NotePayload,
+  txHash: TxHash,
+  noteHashes: Fr[],
+  dataStartIndexForTx: number,
+  excludedIndices: Set<number>,
+  logger: Logger,
+  unencryptedLogs: UnencryptedTxL2Logs,
+  daoConstructor: (payload: L1NotePayload, noteInfo: NoteInfo, dataStartIndexForTx: number, pkM: PublicKey) => T,
+): Promise<T | undefined> {
+  let noteDao: T | undefined;
+
+  for (const functionLogs of unencryptedLogs.functionLogs) {
+    for (const log of functionLogs.logs) {
+      const { data } = log;
+      // It is the expectation that partial notes will have the corresponding unencrypted log be multiple
+      // of Fr.SIZE_IN_BYTES as the nullable fields should be simply concatenated.
+      if (data.length % Fr.SIZE_IN_BYTES === 0) {
+        const nullableFields = [];
+        for (let i = 0; i < data.length; i += Fr.SIZE_IN_BYTES) {
+          const chunk = data.subarray(i, i + Fr.SIZE_IN_BYTES);
+          nullableFields.push(Fr.fromBuffer(chunk));
+        }
+
+        // We insert the nullable fields into the note and then we try to produce the note dao again
+        const payloadWithNullableFields = await addNullableFieldsToPayload(db, payload, nullableFields);
+
+        let deferredNoteDao: DeferredNoteDao | undefined;
+        try {
+          [noteDao, deferredNoteDao] = await produceNoteDaosForKey(
+            simulator,
+            db,
+            pkM,
+            payloadWithNullableFields,
+            txHash,
+            noteHashes,
+            dataStartIndexForTx,
+            excludedIndices,
+            logger,
+            UnencryptedTxL2Logs.empty(), // We set unencrypted logs to empty to prevent infinite recursion.
+            daoConstructor,
+          );
+        } catch (e) {
+          // We ignore the key prefix error because that is expected to be triggered when an incorrect value
+          // is inserted at the position of `npk_m_hash`. This happens commonly because we are brute forcing
+          // the unencrypted logs.
+          if (!(e as any).message.includes('Could not find key prefix.')) {
+            throw e;
+          }
+        }
+
+        if (deferredNoteDao) {
+          // This should not happen as we should first get contract not found error before the blackbox func error.
+          throw new Error('Partial notes should never be deferred.');
+        }
+
+        if (noteDao) {
+          // We managed to complete the partial note so we terminate the search.
+          break;
+        }
+      }
+    }
+  }
+
+  if (!noteDao) {
+    logger.error(`Partial note note found. Discarding note...`);
+  }
+
+  return noteDao;
+}

package/src/pxe_http/pxe_http_server.ts

@@ -1,6 +1,10 @@
 import {
   AuthWitness,
   CompleteAddress,
+  CountedNoteLog,
+  CountedPublicExecutionRequest,
+  EncryptedL2Log,
+  EncryptedL2NoteLog,
   EncryptedNoteL2BlockL2Logs,
   ExtendedNote,
   ExtendedUnencryptedL2Log,
@@ -9,17 +13,20 @@ import {
   Note,
   NullifierMembershipWitness,
   type PXE,
+  PrivateExecutionResult,
   SiblingPath,
-  SimulatedTx,
   Tx,
   TxEffect,
   TxExecutionRequest,
   TxHash,
+  TxProvingResult,
   TxReceipt,
+  TxSimulationResult,
   UnencryptedL2BlockL2Logs,
+  UnencryptedL2Log,
   UniqueNote,
 } from '@aztec/circuit-types';
-import { FunctionSelector } from '@aztec/circuits.js';
+import { FunctionSelector, PrivateCallStackItem, PublicKeys } from '@aztec/circuits.js';
 import { NoteSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Buffer32 } from '@aztec/foundation/buffer';
@@ -50,6 +57,7 @@ export function createPXERpcServer(pxeService: PXE): JsonRpcServer {
       GrumpkinScalar,
       Note,
       ExtendedNote,
+      PublicKeys,
       UniqueNote,
       SiblingPath,
       AuthWitness,
@@ -59,9 +67,17 @@ export function createPXERpcServer(pxeService: PXE): JsonRpcServer {
     },
     {
       EncryptedNoteL2BlockL2Logs,
+      EncryptedL2NoteLog,
+      EncryptedL2Log,
+      UnencryptedL2Log,
       NoteSelector,
       NullifierMembershipWitness,
-      SimulatedTx,
+      TxSimulationResult,
+      TxProvingResult,
+      PrivateExecutionResult,
+      PrivateCallStackItem,
+      CountedPublicExecutionRequest,
+      CountedNoteLog,
       Tx,
       TxReceipt,
       UnencryptedL2BlockL2Logs,

package/src/pxe_service/create_pxe_service.ts

@@ -4,12 +4,6 @@ import { randomBytes } from '@aztec/foundation/crypto';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { KeyStore } from '@aztec/key-store';
 import { createStore } from '@aztec/kv-store/utils';
-import { getCanonicalAuthRegistry } from '@aztec/protocol-contracts/auth-registry';
-import { getCanonicalClassRegisterer } from '@aztec/protocol-contracts/class-registerer';
-import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
-import { getCanonicalInstanceDeployer } from '@aztec/protocol-contracts/instance-deployer';
-import { getCanonicalMultiCallEntrypointContract } from '@aztec/protocol-contracts/multi-call-entrypoint';
-import { getCanonicalRouter } from '@aztec/protocol-contracts/router';
 
 import { type PXEServiceConfig } from '../config/index.js';
 import { KVPxeDatabase } from '../database/kv_pxe_database.js';
@@ -45,17 +39,6 @@ export async function createPXEService(
 
   const prover = proofCreator ?? (await createProver(config, logSuffix));
   const server = new PXEService(keyStore, aztecNode, db, prover, config, logSuffix);
-  for (const contract of [
-    getCanonicalClassRegisterer(),
-    getCanonicalInstanceDeployer(),
-    getCanonicalMultiCallEntrypointContract(),
-    getCanonicalFeeJuice(),
-    getCanonicalAuthRegistry(),
-    getCanonicalRouter(),
-  ]) {
-    await server.registerContract(contract);
-  }
-
   await server.start();
   return server;
 }
@@ -71,5 +54,5 @@ function createProver(config: PXEServiceConfig, logSuffix?: string) {
   }
   const bbConfig = config as Required<Pick<PXEServiceConfig, 'bbBinaryPath' | 'bbWorkingDirectory'>> & PXEServiceConfig;
   const log = createDebugLogger('aztec:pxe:bb-native-prover' + (logSuffix ? `:${logSuffix}` : ''));
-  return BBNativePrivateKernelProver.new(bbConfig, log);
+  return BBNativePrivateKernelProver.new({ bbSkipCleanup: false, ...bbConfig }, log);
 }

package/src/pxe_service/pxe_service.ts

@@ -1,8 +1,6 @@
 import {
   type AuthWitness,
   type AztecNode,
-  EncryptedNoteTxL2Logs,
-  EncryptedTxL2Logs,
   type EventMetadata,
   EventType,
   type ExtendedNote,
@@ -16,17 +14,20 @@ import {
   type OutgoingNotesFilter,
   type PXE,
   type PXEInfo,
+  type PrivateExecutionResult,
   type PrivateKernelProver,
+  type PrivateKernelSimulateOutput,
+  PrivateSimulationResult,
+  type PublicSimulationOutput,
   type SiblingPath,
-  SimulatedTx,
   SimulationError,
-  TaggedLog,
-  Tx,
+  type Tx,
   type TxEffect,
   type TxExecutionRequest,
   type TxHash,
+  TxProvingResult,
   type TxReceipt,
-  UnencryptedTxL2Logs,
+  TxSimulationResult,
   UniqueNote,
   getNonNullifiedL1ToL2MessageWitness,
   isNoirCallStackUnresolved,
@@ -35,8 +36,13 @@ import { type NoteProcessorStats } from '@aztec/circuit-types/stats';
 import {
   AztecAddress,
   type CompleteAddress,
+  type ContractClassWithId,
+  type ContractInstanceWithAddress,
   type L1_TO_L2_MSG_TREE_HEIGHT,
+  type NodeInfo,
+  PUBLIC_DISPATCH_SELECTOR,
   type PartialAddress,
+  type PrivateKernelTailCircuitPublicInputs,
   computeContractAddressFromInstance,
   computeContractClassId,
   getContractClassFromArtifact,
@@ -53,24 +59,12 @@ import { Fr, type Point } from '@aztec/foundation/fields';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { SerialQueue } from '@aztec/foundation/queue';
 import { type KeyStore } from '@aztec/key-store';
-import { ClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
-import { getCanonicalFeeJuice } from '@aztec/protocol-contracts/fee-juice';
-import { getCanonicalInstanceDeployer } from '@aztec/protocol-contracts/instance-deployer';
-import { getCanonicalMultiCallEntrypointAddress } from '@aztec/protocol-contracts/multi-call-entrypoint';
 import {
-  type AcirSimulator,
-  type ExecutionResult,
-  accumulateReturnValues,
-  collectEnqueuedPublicFunctionCalls,
-  collectPublicTeardownFunctionCall,
-  collectSortedEncryptedLogs,
-  collectSortedNoteEncryptedLogs,
-  collectSortedUnencryptedLogs,
-  resolveAssertionMessage,
-  resolveOpcodeLocations,
-} from '@aztec/simulator';
-import { type ContractClassWithId, type ContractInstanceWithAddress } from '@aztec/types/contracts';
-import { type NodeInfo } from '@aztec/types/interfaces';
+  ProtocolContractAddress,
+  getCanonicalProtocolContract,
+  protocolContractNames,
+} from '@aztec/protocol-contracts';
+import { type AcirSimulator, resolveAssertionMessage, resolveOpcodeLocations } from '@aztec/simulator';
 
 import { type PXEServiceConfig, getPackageInfo } from '../config/index.js';
 import { ContractDataOracle } from '../contract_data_oracle/index.js';
@@ -123,6 +117,7 @@ export class PXEService implements PXE {
     const { l2BlockPollingIntervalMS } = this.config;
     await this.synchronizer.start(1, l2BlockPollingIntervalMS);
     await this.restoreNoteProcessors();
+    await this.#registerProtocolContracts();
     const info = await this.getNodeInfo();
     this.log.info(`Started PXE connected to chain ${info.l1ChainId} version ${info.protocolVersion}`);
   }
@@ -141,7 +136,7 @@ export class PXEService implements PXE {
       }
 
       count++;
-      await this.synchronizer.addAccount(address.address, this.keyStore, this.config.l2StartingBlock);
+      await this.synchronizer.addAccount(address, this.keyStore, this.config.l2StartingBlock);
     }
 
     if (count > 0) {
@@ -200,7 +195,7 @@ export class PXEService implements PXE {
       this.log.info(`Account:\n "${accountCompleteAddress.address.toString()}"\n already registered.`);
       return accountCompleteAddress;
     } else {
-      await this.synchronizer.addAccount(accountCompleteAddress.address, this.keyStore, this.config.l2StartingBlock);
+      await this.synchronizer.addAccount(accountCompleteAddress, this.keyStore, this.config.l2StartingBlock);
       this.log.info(`Registered account ${accountCompleteAddress.address.toString()}`);
       this.log.debug(`Registered account\n ${accountCompleteAddress.toReadableString()}`);
     }
@@ -510,13 +505,21 @@ export class PXEService implements PXE {
     return await this.node.getBlock(blockNumber);
   }
 
-  public proveTx(txRequest: TxExecutionRequest, simulatePublic: boolean, scopes?: AztecAddress[]): Promise<Tx> {
+  async #simulateKernels(
+    txRequest: TxExecutionRequest,
+    privateExecutionResult: PrivateExecutionResult,
+  ): Promise<PrivateKernelTailCircuitPublicInputs> {
+    const result = await this.#prove(txRequest, new TestPrivateKernelProver(), privateExecutionResult);
+    return result.publicInputs;
+  }
+
+  public proveTx(
+    txRequest: TxExecutionRequest,
+    privateExecutionResult: PrivateExecutionResult,
+  ): Promise<TxProvingResult> {
     return this.jobQueue.put(async () => {
-      const simulatedTx = await this.#simulateAndProve(txRequest, this.proofCreator, undefined, scopes);
-      if (simulatePublic) {
-        simulatedTx.publicOutput = await this.#simulatePublicCalls(simulatedTx.tx);
-      }
-      return simulatedTx.tx;
+      const { publicInputs, clientIvcProof } = await this.#prove(txRequest, this.proofCreator, privateExecutionResult);
+      return new TxProvingResult(privateExecutionResult, publicInputs, clientIvcProof!);
     });
   }
 
@@ -527,15 +530,19 @@ export class PXEService implements PXE {
     msgSender: AztecAddress | undefined = undefined,
     skipTxValidation: boolean = false,
     scopes?: AztecAddress[],
-  ): Promise<SimulatedTx> {
+  ): Promise<TxSimulationResult> {
     return await this.jobQueue.put(async () => {
-      const simulatedTx = await this.#simulateAndProve(txRequest, this.fakeProofCreator, msgSender, scopes);
+      const privateExecutionResult = await this.#executePrivate(txRequest, msgSender, scopes);
+      const publicInputs = await this.#simulateKernels(txRequest, privateExecutionResult);
+      const privateSimulationResult = new PrivateSimulationResult(privateExecutionResult, publicInputs);
+      const simulatedTx = privateSimulationResult.toSimulatedTx();
+      let publicOutput: PublicSimulationOutput | undefined;
       if (simulatePublic) {
-        simulatedTx.publicOutput = await this.#simulatePublicCalls(simulatedTx.tx);
+        publicOutput = await this.#simulatePublicCalls(simulatedTx);
       }
 
       if (!skipTxValidation) {
-        if (!(await this.node.isValidTx(simulatedTx.tx, true))) {
+        if (!(await this.node.isValidTx(simulatedTx, true))) {
           throw new Error('The simulated transaction is unable to be added to state and is invalid.');
         }
       }
@@ -545,9 +552,9 @@ export class PXEService implements PXE {
       // Meaning that it will not necessarily have produced a nullifier (and thus have no TxHash)
       // If we log, the `getTxHash` function will throw.
       if (!msgSender) {
-        this.log.info(`Executed local simulation for ${simulatedTx.tx.getTxHash()}`);
+        this.log.info(`Executed local simulation for ${simulatedTx.getTxHash()}`);
       }
-      return simulatedTx;
+      return TxSimulationResult.fromPrivateSimulationResultAndPublicOutput(privateSimulationResult, publicOutput);
     });
   }
 
@@ -656,14 +663,24 @@ export class PXEService implements PXE {
     return Promise.resolve({
       pxeVersion: this.packageVersion,
       protocolContractAddresses: {
-        classRegisterer: ClassRegistererAddress,
-        feeJuice: getCanonicalFeeJuice().address,
-        instanceDeployer: getCanonicalInstanceDeployer().address,
-        multiCallEntrypoint: getCanonicalMultiCallEntrypointAddress(),
+        classRegisterer: ProtocolContractAddress.ContractClassRegisterer,
+        feeJuice: ProtocolContractAddress.FeeJuice,
+        instanceDeployer: ProtocolContractAddress.ContractInstanceDeployer,
+        multiCallEntrypoint: ProtocolContractAddress.MultiCallEntrypoint,
       },
     });
   }
 
+  async #registerProtocolContracts() {
+    for (const name of protocolContractNames) {
+      const { address, contractClass, instance, artifact } = getCanonicalProtocolContract(name);
+      await this.db.addContractArtifact(contractClass.id, artifact);
+      await this.db.addContractInstance(instance);
+      await this.synchronizer.reprocessDeferredNotesForContract(address);
+      this.log.info(`Added protocol contract ${name} at ${address.toString()}`);
+    }
+  }
+
   /**
    * Retrieves the simulation parameters required to run an ACIR simulation.
    * This includes the contract address, function artifact, and historical tree roots.
@@ -687,11 +704,11 @@ export class PXEService implements PXE {
     };
   }
 
-  async #simulate(
+  async #executePrivate(
     txRequest: TxExecutionRequest,
     msgSender?: AztecAddress,
     scopes?: AztecAddress[],
-  ): Promise<ExecutionResult> {
+  ): Promise<PrivateExecutionResult> {
     // TODO - Pause syncing while simulating.
 
     const { contractAddress, functionArtifact } = await this.#getSimulationParameters(txRequest);
@@ -749,9 +766,13 @@ export class PXEService implements PXE {
       if (err instanceof SimulationError) {
         const callStack = err.getCallStack();
         const originalFailingFunction = callStack[callStack.length - 1];
+        // TODO(https://github.com/AztecProtocol/aztec-packages/issues/8985): Properly fix this.
+        // To be able to resolve the assertion message, we need to use the information from the public dispatch function,
+        // no matter what the call stack selector points to (since we've modified it to point to the target function).
+        // We should remove this because the AVM (or public protocol) shouldn't be aware of the public dispatch calling convention.
         const debugInfo = await this.contractDataOracle.getFunctionDebugMetadata(
           originalFailingFunction.contractAddress,
-          originalFailingFunction.functionSelector,
+          FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
         );
         const noirCallStack = err.getNoirCallStack();
         if (debugInfo) {
@@ -794,40 +815,18 @@ export class PXEService implements PXE {
    * A private transaction object containing the proof, public inputs, and encrypted logs.
    * The return values of the private execution
    */
-  async #simulateAndProve(
+  async #prove(
     txExecutionRequest: TxExecutionRequest,
     proofCreator: PrivateKernelProver,
-    msgSender?: AztecAddress,
-    scopes?: AztecAddress[],
-  ): Promise<SimulatedTx> {
-    // Get values that allow us to reconstruct the block hash
-    const executionResult = await this.#simulate(txExecutionRequest, msgSender, scopes);
-
-    const kernelOracle = new KernelOracle(this.contractDataOracle, this.keyStore, this.node);
+    privateExecutionResult: PrivateExecutionResult,
+  ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
+    // use the block the tx was simulated against
+    const block =
+      privateExecutionResult.callStackItem.publicInputs.historicalHeader.globalVariables.blockNumber.toNumber();
+    const kernelOracle = new KernelOracle(this.contractDataOracle, this.keyStore, this.node, block);
     const kernelProver = new KernelProver(kernelOracle, proofCreator);
     this.log.debug(`Executing kernel prover...`);
-    const { clientIvcProof, publicInputs } = await kernelProver.prove(
-      txExecutionRequest.toTxRequest(),
-      executionResult,
-    );
-
-    const noteEncryptedLogs = new EncryptedNoteTxL2Logs([collectSortedNoteEncryptedLogs(executionResult)]);
-    const unencryptedLogs = new UnencryptedTxL2Logs([collectSortedUnencryptedLogs(executionResult)]);
-    const encryptedLogs = new EncryptedTxL2Logs([collectSortedEncryptedLogs(executionResult)]);
-    const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(executionResult);
-    const teardownPublicFunction = collectPublicTeardownFunctionCall(executionResult);
-
-    const tx = new Tx(
-      publicInputs,
-      clientIvcProof!,
-      noteEncryptedLogs,
-      encryptedLogs,
-      unencryptedLogs,
-      enqueuedPublicFunctions,
-      teardownPublicFunction,
-    );
-
-    return new SimulatedTx(tx, accumulateReturnValues(executionResult));
+    return await kernelProver.prove(txExecutionRequest.toTxRequest(), privateExecutionResult);
   }
 
   /**
@@ -944,11 +943,10 @@ export class PXEService implements PXE {
 
     const visibleEvents = encryptedLogs.flatMap(encryptedLog => {
       for (const sk of vsks) {
-        const decryptedLog =
-          TaggedLog.decryptAsIncoming(encryptedLog, sk, L1EventPayload) ??
-          TaggedLog.decryptAsOutgoing(encryptedLog, sk, L1EventPayload);
-        if (decryptedLog !== undefined) {
-          return [decryptedLog];
+        const decryptedEvent =
+          L1EventPayload.decryptAsIncoming(encryptedLog, sk) ?? L1EventPayload.decryptAsOutgoing(encryptedLog, sk);
+        if (decryptedEvent !== undefined) {
+          return [decryptedEvent];
         }
       }
 
@@ -957,19 +955,19 @@ export class PXEService implements PXE {
 
     const decodedEvents = visibleEvents
       .map(visibleEvent => {
-        if (visibleEvent.payload === undefined) {
+        if (visibleEvent === undefined) {
           return undefined;
         }
-        if (!visibleEvent.payload.eventTypeId.equals(eventMetadata.eventSelector)) {
+        if (!visibleEvent.eventTypeId.equals(eventMetadata.eventSelector)) {
           return undefined;
         }
-        if (visibleEvent.payload.event.items.length !== eventMetadata.fieldNames.length) {
+        if (visibleEvent.event.items.length !== eventMetadata.fieldNames.length) {
           throw new Error(
             'Something is weird here, we have matching EventSelectors, but the actual payload has mismatched length',
           );
         }
 
-        return eventMetadata.decode(visibleEvent.payload);
+        return eventMetadata.decode(visibleEvent);
       })
       .filter(visibleEvent => visibleEvent !== undefined) as T[];