@aztec/pxe 0.35.1 → 0.37.0

package/src/kernel_prover/private_inputs_builders/build_private_kernel_inner_hints.ts

@@ -0,0 +1,17 @@
+import {
+  type MAX_NEW_NOTE_HASHES_PER_CALL,
+  type PrivateCircuitPublicInputs,
+  PrivateKernelInnerHints,
+} from '@aztec/circuits.js';
+import { type Tuple } from '@aztec/foundation/serialize';
+
+export function buildPrivateKernelInnerHints(
+  publicInputs: PrivateCircuitPublicInputs,
+  noteHashNullifierCounterMap: Map<number, number>,
+) {
+  const nullifierCounters = publicInputs.newNoteHashes.map(
+    n => noteHashNullifierCounterMap.get(n.counter) ?? 0,
+  ) as Tuple<number, typeof MAX_NEW_NOTE_HASHES_PER_CALL>;
+
+  return new PrivateKernelInnerHints(nullifierCounters);
+}

package/src/kernel_prover/private_inputs_builders/build_private_kernel_tail_hints.ts

@@ -0,0 +1,194 @@
+import {
+  type Fr,
+  GrumpkinScalar,
+  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,
+  PrivateKernelTailHints,
+  type ReadRequestContext,
+  type SideEffect,
+  type SideEffectType,
+  buildNullifierReadRequestHints,
+  buildTransientDataHints,
+  countAccumulatedItems,
+  sortByCounterGetSortedHints,
+} from '@aztec/circuits.js';
+import { makeTuple } from '@aztec/foundation/array';
+import { type Tuple } from '@aztec/foundation/serialize';
+
+import { type ProvingDataOracle } from '../proving_data_oracle.js';
+
+/** @deprecated Use sortByCounterGetSortedHints instead */
+function 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>];
+}
+
+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>,
+  oracle: ProvingDataOracle,
+) {
+  const getNullifierMembershipWitness = async (nullifier: Fr) => {
+    const res = await oracle.getNullifierMembershipWitness(nullifier);
+    if (!res) {
+      throw new Error(`Cannot find the leaf for nullifier ${nullifier.toBigInt()}.`);
+    }
+
+    const { index, siblingPath, leafPreimage } = res;
+    return {
+      membershipWitness: new MembershipWitness(
+        NULLIFIER_TREE_HEIGHT,
+        index,
+        siblingPath.toTuple<typeof NULLIFIER_TREE_HEIGHT>(),
+      ),
+      leafPreimage,
+    };
+  };
+
+  return buildNullifierReadRequestHints({ getNullifierMembershipWitness }, nullifierReadRequests, nullifiers);
+}
+
+async function getMasterNullifierSecretKeys(
+  nullifierKeyValidationRequests: Tuple<
+    NullifierKeyValidationRequestContext,
+    typeof MAX_NULLIFIER_KEY_VALIDATION_REQUESTS_PER_TX
+  >,
+  oracle: ProvingDataOracle,
+) {
+  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 oracle.getMasterNullifierSecretKey(request.masterNullifierPublicKey);
+  }
+  return keys;
+}
+
+export async function buildPrivateKernelTailHints(
+  publicInputs: PrivateKernelCircuitPublicInputs,
+  oracle: ProvingDataOracle,
+) {
+  const noteHashReadRequestHints = getNoteHashReadRequestHints(
+    publicInputs.validationRequests.noteHashReadRequests,
+    publicInputs.end.newNoteHashes,
+  );
+
+  const nullifierReadRequestHints = await getNullifierReadRequestHints(
+    publicInputs.validationRequests.nullifierReadRequests,
+    publicInputs.end.newNullifiers,
+    oracle,
+  );
+
+  const masterNullifierSecretKeys = await getMasterNullifierSecretKeys(
+    publicInputs.validationRequests.nullifierKeyValidationRequests,
+    oracle,
+  );
+
+  const [sortedNoteHashes, sortedNoteHashesIndexes] = sortByCounterGetSortedHints(
+    publicInputs.end.newNoteHashes,
+    MAX_NEW_NOTE_HASHES_PER_TX,
+  );
+
+  const [sortedNullifiers, sortedNullifiersIndexes] = sortByCounterGetSortedHints(
+    publicInputs.end.newNullifiers,
+    MAX_NEW_NULLIFIERS_PER_TX,
+  );
+
+  const [sortedEncryptedLogHashes, sortedEncryptedLogHashesIndexes] = sortSideEffects<
+    SideEffect,
+    typeof MAX_ENCRYPTED_LOGS_PER_TX
+  >(publicInputs.end.encryptedLogsHashes);
+
+  const [sortedUnencryptedLogHashes, sortedUnencryptedLogHashesIndexes] = sortSideEffects<
+    SideEffect,
+    typeof MAX_UNENCRYPTED_LOGS_PER_TX
+  >(publicInputs.end.unencryptedLogsHashes);
+
+  const [transientNullifierIndexesForNoteHashes, transientNoteHashIndexesForNullifiers] = buildTransientDataHints(
+    sortedNoteHashes,
+    sortedNullifiers,
+    MAX_NEW_NOTE_HASHES_PER_TX,
+    MAX_NEW_NULLIFIERS_PER_TX,
+  );
+
+  return new PrivateKernelTailHints(
+    transientNullifierIndexesForNoteHashes,
+    transientNoteHashIndexesForNullifiers,
+    noteHashReadRequestHints,
+    nullifierReadRequestHints,
+    masterNullifierSecretKeys,
+    sortedNoteHashes,
+    sortedNoteHashesIndexes,
+    sortedNullifiers,
+    sortedNullifiersIndexes,
+    sortedEncryptedLogHashes,
+    sortedEncryptedLogHashesIndexes,
+    sortedUnencryptedLogHashes,
+    sortedUnencryptedLogHashesIndexes,
+  );
+}

package/src/kernel_prover/private_inputs_builders/build_private_kernel_tail_outputs.ts

@@ -0,0 +1,30 @@
+import {
+  MAX_NEW_NOTE_HASHES_PER_TX,
+  MAX_NEW_NULLIFIERS_PER_TX,
+  NoteHashContext,
+  Nullifier,
+  PrivateKernelTailOutputs,
+} from '@aztec/circuits.js';
+import { padArrayEnd } from '@aztec/foundation/collection';
+import { type Tuple } from '@aztec/foundation/serialize';
+
+export function buildPrivateKernelTailOutputs(
+  prevNoteHashes: Tuple<NoteHashContext, typeof MAX_NEW_NOTE_HASHES_PER_TX>,
+  prevNullifiers: Tuple<Nullifier, typeof MAX_NEW_NULLIFIERS_PER_TX>,
+) {
+  // Propagate note hashes that are not linked to a nullifier.
+  // Note that note hashes can't link to the first nullifier (counter == 0).
+  const noteHashes = padArrayEnd(
+    prevNoteHashes.filter(n => !n.nullifierCounter),
+    NoteHashContext.empty(),
+    MAX_NEW_NOTE_HASHES_PER_TX,
+  );
+
+  const nullifiers = padArrayEnd(
+    prevNullifiers.filter(n => n.noteHash.isZero()),
+    Nullifier.empty(),
+    MAX_NEW_NULLIFIERS_PER_TX,
+  );
+
+  return new PrivateKernelTailOutputs(noteHashes, nullifiers);
+}

package/src/kernel_prover/private_inputs_builders/index.ts

@@ -0,0 +1,3 @@
+export { buildPrivateKernelInnerHints } from './build_private_kernel_inner_hints.js';
+export { buildPrivateKernelTailHints } from './build_private_kernel_tail_hints.js';
+export { buildPrivateKernelTailOutputs } from './build_private_kernel_tail_outputs.js';

package/src/note_processor/note_processor.ts

@@ -8,7 +8,6 @@ import {
 } from '@aztec/circuit-types';
 import { type NoteProcessorStats } from '@aztec/circuit-types/stats';
 import { INITIAL_L2_BLOCK_NUM, MAX_NEW_NOTE_HASHES_PER_TX, type PublicKey } from '@aztec/circuits.js';
-import { Grumpkin } from '@aztec/circuits.js/barretenberg';
 import { type Fr } from '@aztec/foundation/fields';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { Timer } from '@aztec/foundation/timer';
@@ -49,7 +48,7 @@ export class NoteProcessor {
     /**
      * The public counterpart to the private key to be used in note decryption.
      */
-    public readonly publicKey: PublicKey,
+    public readonly masterIncomingViewingPublicKey: PublicKey,
     private keyStore: KeyStore,
     private db: PxeDatabase,
     private node: AztecNode,
@@ -78,7 +77,7 @@ export class NoteProcessor {
   }
 
   private getSyncedToBlock(): number {
-    return this.db.getSynchedBlockNumberForPublicKey(this.publicKey) ?? this.startingBlock - 1;
+    return this.db.getSynchedBlockNumberForPublicKey(this.masterIncomingViewingPublicKey) ?? this.startingBlock - 1;
   }
 
   /**
@@ -99,7 +98,6 @@ export class NoteProcessor {
       return;
     }
 
-    const curve = new Grumpkin();
     const blocksAndNotes: ProcessedData[] = [];
     // Keep track of notes that we couldn't process because the contract was not found.
     const deferredNoteDaos: DeferredNoteDao[] = [];
@@ -116,7 +114,9 @@ export class NoteProcessor {
       // We are using set for `userPertainingTxIndices` to avoid duplicates. This would happen in case there were
       // multiple encrypted logs in a tx pertaining to a user.
       const noteDaos: NoteDao[] = [];
-      const privateKey = await this.keyStore.getAccountPrivateKey(this.publicKey);
+      const secretKey = await this.keyStore.getMasterIncomingViewingSecretKeyForPublicKey(
+        this.masterIncomingViewingPublicKey,
+      );
 
       // Iterate over all the encrypted logs and try decrypting them. If successful, store the note.
       for (let indexOfTxInABlock = 0; indexOfTxInABlock < txLogs.length; ++indexOfTxInABlock) {
@@ -130,7 +130,7 @@ export class NoteProcessor {
         for (const functionLogs of txFunctionLogs) {
           for (const log of functionLogs.logs) {
             this.stats.seen++;
-            const taggedNote = TaggedNote.fromEncryptedBuffer(log.data, privateKey, curve);
+            const taggedNote = TaggedNote.fromEncryptedBuffer(log.data, secretKey);
             if (taggedNote?.notePayload) {
               const { notePayload: payload } = taggedNote;
               // We have successfully decrypted the data.
@@ -138,7 +138,7 @@ export class NoteProcessor {
               try {
                 const noteDao = await produceNoteDao(
                   this.simulator,
-                  this.publicKey,
+                  this.masterIncomingViewingPublicKey,
                   payload,
                   txHash,
                   newNoteHashes,
@@ -152,7 +152,7 @@ export class NoteProcessor {
                   this.stats.deferred++;
                   this.log.warn(e.message);
                   const deferredNoteDao = new DeferredNoteDao(
-                    this.publicKey,
+                    this.masterIncomingViewingPublicKey,
                     payload.note,
                     payload.contractAddress,
                     payload.storageSlot,
@@ -164,7 +164,7 @@ export class NoteProcessor {
                   deferredNoteDaos.push(deferredNoteDao);
                 } else {
                   this.stats.failed++;
-                  this.log.warn(`Could not process note because of "${e}". Discarding note...`);
+                  this.log.error(`Could not process note because of "${e}". Discarding note...`);
                 }
               }
             }
@@ -182,7 +182,7 @@ export class NoteProcessor {
     await this.processDeferredNotes(deferredNoteDaos);
 
     const syncedToBlock = l2Blocks[l2Blocks.length - 1].number;
-    await this.db.setSynchedBlockNumberForPublicKey(this.publicKey, syncedToBlock);
+    await this.db.setSynchedBlockNumberForPublicKey(this.masterIncomingViewingPublicKey, syncedToBlock);
 
     this.log.debug(`Synched block ${syncedToBlock}`);
   }
@@ -212,7 +212,7 @@ export class NoteProcessor {
     const newNullifiers: Fr[] = blocksAndNotes.flatMap(b =>
       b.block.body.txEffects.flatMap(txEffect => txEffect.nullifiers),
     );
-    const removedNotes = await this.db.removeNullifiedNotes(newNullifiers, this.publicKey);
+    const removedNotes = await this.db.removeNullifiedNotes(newNullifiers, this.masterIncomingViewingPublicKey);
     removedNotes.forEach(noteDao => {
       this.log.verbose(
         `Removed note for contract ${noteDao.contractAddress} at slot ${
@@ -260,7 +260,7 @@ export class NoteProcessor {
       try {
         const noteDao = await produceNoteDao(
           this.simulator,
-          this.publicKey,
+          this.masterIncomingViewingPublicKey,
           payload,
           txHash,
           newNoteHashes,

package/src/pxe_service/create_pxe_service.ts

@@ -1,5 +1,4 @@
 import { type AztecNode } from '@aztec/circuit-types';
-import { Grumpkin } from '@aztec/circuits.js/barretenberg';
 import { randomBytes } from '@aztec/foundation/crypto';
 import { TestKeyStore } from '@aztec/key-store';
 import { AztecLmdbStore } from '@aztec/kv-store/lmdb';
@@ -7,6 +6,7 @@ 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 { getCanonicalKeyRegistry } from '@aztec/protocol-contracts/key-registry';
 import { getCanonicalMultiCallEntrypointContract } from '@aztec/protocol-contracts/multi-call-entrypoint';
 
 import { join } from 'path';
@@ -38,7 +38,6 @@ export async function createPXEService(
   const l1Contracts = await aztecNode.getL1ContractAddresses();
 
   const keyStore = new TestKeyStore(
-    new Grumpkin(),
     await initStoreForRollup(AztecLmdbStore.open(keyStorePath), l1Contracts.rollupAddress),
   );
   const db = new KVPxeDatabase(await initStoreForRollup(AztecLmdbStore.open(pxeDbPath), l1Contracts.rollupAddress));
@@ -49,6 +48,7 @@ export async function createPXEService(
     getCanonicalInstanceDeployer(),
     getCanonicalMultiCallEntrypointContract(),
     getCanonicalGasToken(l1Contracts.gasPortalAddress),
+    getCanonicalKeyRegistry(),
   ]) {
     await server.registerContract(contract);
   }

package/src/pxe_service/pxe_service.ts

@@ -1,6 +1,8 @@
 import {
   type AuthWitness,
   type AztecNode,
+  EncryptedFunctionL2Logs,
+  type EncryptedL2Log,
   EncryptedTxL2Logs,
   ExtendedNote,
   type FunctionCall,
@@ -18,6 +20,8 @@ import {
   type TxExecutionRequest,
   type TxHash,
   type TxReceipt,
+  UnencryptedFunctionL2Logs,
+  type UnencryptedL2Log,
   UnencryptedTxL2Logs,
   isNoirCallStackUnresolved,
 } from '@aztec/circuit-types';
@@ -27,18 +31,18 @@ import {
   CallRequest,
   CompleteAddress,
   FunctionData,
-  type GrumpkinPrivateKey,
   MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX,
   type PartialAddress,
   type PrivateKernelTailCircuitPublicInputs,
   type PublicCallRequest,
+  type SideEffect,
   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';
@@ -105,7 +109,8 @@ export class PXEService implements PXE {
   }
 
   private async restoreNoteProcessors() {
-    const publicKeys = await this.keyStore.getAccounts();
+    const accounts = await this.keyStore.getAccounts();
+    const publicKeys = accounts.map(async account => await this.keyStore.getMasterIncomingViewingPublicKey(account));
     const publicKeysSet = new Set(publicKeys.map(k => k.toString()));
 
     const registeredAddresses = await this.db.getCompleteAddresses();
@@ -165,27 +170,36 @@ export class PXEService implements PXE {
     return artifact && getContractClassFromArtifact(artifact);
   }
 
-  public async registerAccount(privKey: GrumpkinPrivateKey, partialAddress: PartialAddress): Promise<CompleteAddress> {
-    const completeAddress = CompleteAddress.fromPrivateKeyAndPartialAddress(privKey, partialAddress);
-    const wasAdded = await this.db.addCompleteAddress(completeAddress);
-    if (wasAdded) {
-      const pubKey = await this.keyStore.addAccount(privKey);
-      this.synchronizer.addAccount(pubKey, this.keyStore, this.config.l2StartingBlock);
+  public async registerAccount(secretKey: Fr, partialAddress: PartialAddress): Promise<CompleteAddress> {
+    const accounts = await this.keyStore.getAccounts();
+    const account = await this.keyStore.addAccount(secretKey, partialAddress);
+    const completeAddress = new CompleteAddress(
+      account,
+      await this.keyStore.getMasterIncomingViewingPublicKey(account),
+      partialAddress,
+    );
+    if (accounts.includes(account)) {
+      this.log.info(`Account:\n "${completeAddress.address.toString()}"\n already registered.`);
+      return completeAddress;
+    } else {
+      const masterIncomingViewingPublicKey = await this.keyStore.getMasterIncomingViewingPublicKey(account);
+      this.synchronizer.addAccount(masterIncomingViewingPublicKey, this.keyStore, this.config.l2StartingBlock);
       this.log.info(`Registered account ${completeAddress.address.toString()}`);
       this.log.debug(`Registered account\n ${completeAddress.toReadableString()}`);
-    } else {
-      this.log.info(`Account:\n "${completeAddress.address.toString()}"\n already registered.`);
     }
+
+    await this.db.addCompleteAddress(completeAddress);
     return completeAddress;
   }
 
   public async getRegisteredAccounts(): Promise<CompleteAddress[]> {
     // Get complete addresses of both the recipients and the accounts
-    const addresses = await this.db.getCompleteAddresses();
+    const completeAddresses = await this.db.getCompleteAddresses();
     // Filter out the addresses not corresponding to accounts
-    const accountPubKeys = await this.keyStore.getAccounts();
-    const accounts = addresses.filter(address => accountPubKeys.find(pubKey => pubKey.equals(address.publicKey)));
-    return accounts;
+    const accounts = await this.keyStore.getAccounts();
+    return completeAddresses.filter(completeAddress =>
+      accounts.find(address => address.equals(completeAddress.address)),
+    );
   }
 
   public async getRegisteredAccount(address: AztecAddress): Promise<CompleteAddress | undefined> {
@@ -194,8 +208,28 @@ export class PXEService implements PXE {
     return Promise.resolve(account);
   }
 
-  public async registerRecipient(recipient: CompleteAddress): Promise<void> {
+  public async getRegisteredAccountPublicKeysHash(address: AztecAddress): Promise<Fr | undefined> {
+    const accounts = await this.keyStore.getAccounts();
+    if (!accounts.some(account => account.equals(address))) {
+      return undefined;
+    }
+    return this.keyStore.getPublicKeysHash(address);
+  }
+
+  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 {
@@ -205,10 +239,12 @@ export class PXEService implements PXE {
 
   public async getRecipients(): Promise<CompleteAddress[]> {
     // Get complete addresses of both the recipients and the accounts
-    const addresses = await this.db.getCompleteAddresses();
+    const completeAddresses = await this.db.getCompleteAddresses();
     // Filter out the addresses corresponding to accounts
-    const accountPubKeys = await this.keyStore.getAccounts();
-    const recipients = addresses.filter(address => !accountPubKeys.find(pubKey => pubKey.equals(address.publicKey)));
+    const accounts = await this.keyStore.getAccounts();
+    const recipients = completeAddresses.filter(
+      completeAddress => !accounts.find(account => account.equals(completeAddress.address)),
+    );
     return recipients;
   }
 
@@ -396,7 +432,7 @@ export class PXEService implements PXE {
     txRequest: TxExecutionRequest,
     simulatePublic: boolean,
     msgSender: AztecAddress | undefined = undefined,
-  ) {
+  ): Promise<SimulatedTx> {
     if (!txRequest.functionData.isPrivate) {
       throw new Error(`Public entrypoints are not allowed`);
     }
@@ -417,8 +453,7 @@ export class PXEService implements PXE {
       }
 
       if (simulatePublic) {
-        // Only one transaction, so we can take index 0.
-        simulatedTx.publicReturnValues = (await this.#simulatePublicCalls(simulatedTx.tx))[0];
+        simulatedTx.publicOutput = await this.#simulatePublicCalls(simulatedTx.tx);
       }
 
       if (!msgSender) {
@@ -514,10 +549,10 @@ export class PXEService implements PXE {
 
   /**
    * Retrieves the simulation parameters required to run an ACIR simulation.
-   * This includes the contract address, function artifact, portal contract address, and historical tree roots.
+   * This includes the contract address, function artifact, and historical tree roots.
    *
    * @param execRequest - The transaction request object containing details of the contract call.
-   * @returns An object containing the contract address, function artifact, portal contract address, and historical tree roots.
+   * @returns An object containing the contract address, function artifact, and historical tree roots.
    */
   async #getSimulationParameters(execRequest: FunctionCall | TxExecutionRequest) {
     const contractAddress = (execRequest as FunctionCall).to ?? (execRequest as TxExecutionRequest).origin;
@@ -529,7 +564,6 @@ export class PXEService implements PXE {
       contractAddress,
       execRequest.functionData.selector,
     );
-    const portalContract = await this.contractDataOracle.getPortalContractAddress(contractAddress);
 
     return {
       contractAddress,
@@ -537,18 +571,17 @@ export class PXEService implements PXE {
         ...functionArtifact,
         debug,
       },
-      portalContract,
     };
   }
 
   async #simulate(txRequest: TxExecutionRequest, msgSender?: AztecAddress): Promise<ExecutionResult> {
     // TODO - Pause syncing while simulating.
 
-    const { contractAddress, functionArtifact, portalContract } = await this.#getSimulationParameters(txRequest);
+    const { contractAddress, functionArtifact } = await this.#getSimulationParameters(txRequest);
 
     this.log.debug('Executing simulator...');
     try {
-      const result = await this.simulator.run(txRequest, functionArtifact, contractAddress, portalContract, msgSender);
+      const result = await this.simulator.run(txRequest, functionArtifact, contractAddress, msgSender);
       this.log.verbose(`Simulation completed for ${contractAddress.toString()}:${functionArtifact.name}`);
       return result;
     } catch (err) {
@@ -637,8 +670,7 @@ export class PXEService implements PXE {
     this.log.debug(`Executing kernel prover...`);
     const { proof, publicInputs } = await kernelProver.prove(txExecutionRequest.toTxRequest(), executionResult);
 
-    const encryptedLogs = new EncryptedTxL2Logs(collectEncryptedLogs(executionResult));
-    const unencryptedLogs = new UnencryptedTxL2Logs(collectUnencryptedLogs(executionResult));
+    const { encryptedLogs, unencryptedLogs } = this.patchLogsOrdering(executionResult);
     const enqueuedPublicFunctions = collectEnqueuedPublicFunctionCalls(executionResult);
 
     // HACK(#1639): Manually patches the ordering of the public call stack
@@ -646,7 +678,7 @@ export class PXEService implements PXE {
     await this.patchPublicCallStackOrdering(publicInputs, enqueuedPublicFunctions);
 
     const tx = new Tx(publicInputs, proof, encryptedLogs, unencryptedLogs, enqueuedPublicFunctions);
-    return new SimulatedTx(tx, [executionResult.returnValues]);
+    return new SimulatedTx(tx, executionResult.returnValues);
   }
 
   /**
@@ -756,6 +788,61 @@ 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();
   }