@aztec/pxe 0.42.0 → 0.43.0

package/src/note_processor/produce_note_dao.ts

@@ -1,9 +1,12 @@
 import { type L1NotePayload, type TxHash } from '@aztec/circuit-types';
 import { Fr, type PublicKey } from '@aztec/circuits.js';
 import { computeNoteHashNonce, siloNullifier } from '@aztec/circuits.js/hash';
-import { type AcirSimulator } from '@aztec/simulator';
+import { type Logger } from '@aztec/foundation/log';
+import { type AcirSimulator, ContractNotFoundError } from '@aztec/simulator';
 
-import { NoteDao } from '../database/note_dao.js';
+import { DeferredNoteDao } from '../database/deferred_note_dao.js';
+import { IncomingNoteDao } from '../database/incoming_note_dao.js';
+import { OutgoingNoteDao } from '../database/outgoing_note_dao.js';
 
 /**
  * Decodes a note from a transaction that we know was intended for us.
@@ -11,96 +14,207 @@ import { NoteDao } from '../database/note_dao.js';
  * 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 publicKey - The public counterpart to the private key to be used in note decryption.
+ * @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 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.
- * @returns an instance of NoteDao, or throws. inserts the index of the note into the excludedIndices set.
+ * @returns An object containing the incoming, outgoing, and deferred notes.
  */
-export async function produceNoteDao(
+export async function produceNoteDaos(
   simulator: AcirSimulator,
-  publicKey: PublicKey,
+  ivpkM: PublicKey | undefined,
+  ovpkM: PublicKey | undefined,
   payload: L1NotePayload,
   txHash: TxHash,
   newNoteHashes: Fr[],
   dataStartIndexForTx: number,
   excludedIndices: Set<number>,
-): Promise<NoteDao> {
-  const { commitmentIndex, nonce, innerNoteHash, siloedNullifier } = await findNoteIndexAndNullifier(
-    simulator,
-    newNoteHashes,
-    txHash,
-    payload,
-    excludedIndices,
-  );
-  const index = BigInt(dataStartIndexForTx + commitmentIndex);
-  excludedIndices?.add(commitmentIndex);
-  return new NoteDao(
-    payload.note,
-    payload.contractAddress,
-    payload.storageSlot,
-    payload.noteTypeId,
-    txHash,
-    nonce,
-    innerNoteHash,
-    siloedNullifier,
-    index,
-    publicKey,
-  );
+  log: Logger,
+): Promise<{
+  incomingNote: IncomingNoteDao | undefined;
+  outgoingNote: OutgoingNoteDao | undefined;
+  incomingDeferredNote: DeferredNoteDao | undefined;
+  outgoingDeferredNote: DeferredNoteDao | undefined;
+}> {
+  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;
+
+  try {
+    if (ivpkM) {
+      const { noteHashIndex, nonce, innerNoteHash, siloedNullifier } = await findNoteIndexAndNullifier(
+        simulator,
+        newNoteHashes,
+        txHash,
+        payload,
+        excludedIndices,
+        true, // For incoming we compute a nullifier (recipient of incoming is the party that nullifies).
+      );
+      const index = BigInt(dataStartIndexForTx + noteHashIndex);
+      excludedIndices?.add(noteHashIndex);
+
+      incomingNote = new IncomingNoteDao(
+        payload.note,
+        payload.contractAddress,
+        payload.storageSlot,
+        payload.noteTypeId,
+        txHash,
+        nonce,
+        innerNoteHash,
+        siloedNullifier,
+        index,
+        ivpkM,
+      );
+    }
+  } catch (e) {
+    if (e instanceof ContractNotFoundError) {
+      log.warn(e.message);
+
+      if (ivpkM) {
+        incomingDeferredNote = new DeferredNoteDao(
+          ivpkM,
+          payload.note,
+          payload.contractAddress,
+          payload.storageSlot,
+          payload.noteTypeId,
+          txHash,
+          newNoteHashes,
+          dataStartIndexForTx,
+        );
+      }
+    } else {
+      log.error(`Could not process note because of "${e}". Discarding note...`);
+    }
+  }
+
+  try {
+    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.innerNoteHash,
+          incomingNote.index,
+          ovpkM,
+        );
+      } else {
+        const { noteHashIndex, nonce, innerNoteHash } = await findNoteIndexAndNullifier(
+          simulator,
+          newNoteHashes,
+          txHash,
+          payload,
+          excludedIndices,
+          false, // For outgoing we do not compute a nullifier.
+        );
+        const index = BigInt(dataStartIndexForTx + noteHashIndex);
+        excludedIndices?.add(noteHashIndex);
+        outgoingNote = new OutgoingNoteDao(
+          payload.note,
+          payload.contractAddress,
+          payload.storageSlot,
+          payload.noteTypeId,
+          txHash,
+          nonce,
+          innerNoteHash,
+          index,
+          ovpkM,
+        );
+      }
+    }
+  } catch (e) {
+    if (e instanceof ContractNotFoundError) {
+      log.warn(e.message);
+
+      if (ovpkM) {
+        outgoingDeferredNote = new DeferredNoteDao(
+          ovpkM,
+          payload.note,
+          payload.contractAddress,
+          payload.storageSlot,
+          payload.noteTypeId,
+          txHash,
+          newNoteHashes,
+          dataStartIndexForTx,
+        );
+      }
+    } else {
+      log.error(`Could not process note because of "${e}". Discarding note...`);
+    }
+  }
+
+  return {
+    incomingNote,
+    outgoingNote,
+    incomingDeferredNote,
+    outgoingDeferredNote,
+  };
 }
 
 /**
- * Find the index of the note in the note hash tree by computing the note hash with different nonce and see which
- * commitment for the current tx matches this value.
- * Compute a nullifier for a given l1NotePayload.
- * The nullifier is calculated using the private key of the account,
- * contract address, and the note associated with the l1NotePayload.
- * This method assists in identifying spent commitments in the private state.
- * @param commitments - Commitments in the tx. One of them should be the note's commitment.
- * @param txHash - First nullifier in the tx.
- * @param l1NotePayload - An instance of l1NotePayload.
+ * Finds nonce, index, inner hash and siloed nullifier for a given note.
+ * @dev Finds the index in the note hash tree by computing the note hash with different nonce and see which hash for
+ * the current tx matches this value.
+ * @remarks This method assists in identifying spent notes in the note hash tree.
+ * @param noteHashes - Note hashes in the tx. One of them should correspond to the note we are looking for
+ * @param txHash - Hash of a tx the note was emitted in.
+ * @param l1NotePayload - The note payload.
  * @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.
- * @returns Information for a decrypted note, including the index of its commitment, nonce, inner note
- * hash, and the siloed nullifier. Throw if cannot find the nonce for the note.
+ * @param computeNullifier - A flag indicating whether to compute the nullifier or just return 0.
+ * @returns Nonce, index, inner hash and siloed nullifier for a given note.
+ * @throws If cannot find the nonce for the note.
  */
 async function findNoteIndexAndNullifier(
   simulator: AcirSimulator,
-  commitments: Fr[],
+  noteHashes: Fr[],
   txHash: TxHash,
   { contractAddress, storageSlot, noteTypeId, note }: L1NotePayload,
   excludedIndices: Set<number>,
+  computeNullifier: boolean,
 ) {
-  let commitmentIndex = 0;
+  let noteHashIndex = 0;
   let nonce: Fr | undefined;
   let innerNoteHash: Fr | undefined;
   let siloedNoteHash: Fr | undefined;
   let innerNullifier: Fr | undefined;
   const firstNullifier = Fr.fromBuffer(txHash.toBuffer());
 
-  for (; commitmentIndex < commitments.length; ++commitmentIndex) {
-    if (excludedIndices.has(commitmentIndex)) {
+  for (; noteHashIndex < noteHashes.length; ++noteHashIndex) {
+    if (excludedIndices.has(noteHashIndex)) {
       continue;
     }
 
-    const commitment = commitments[commitmentIndex];
-    if (commitment.equals(Fr.ZERO)) {
+    const noteHash = noteHashes[noteHashIndex];
+    if (noteHash.equals(Fr.ZERO)) {
       break;
     }
 
-    const expectedNonce = computeNoteHashNonce(firstNullifier, commitmentIndex);
-    ({ innerNoteHash, siloedNoteHash, innerNullifier } = await simulator.computeNoteHashAndNullifier(
+    const expectedNonce = computeNoteHashNonce(firstNullifier, noteHashIndex);
+    ({ innerNoteHash, siloedNoteHash, innerNullifier } = await simulator.computeNoteHashAndOptionallyANullifier(
       contractAddress,
       expectedNonce,
       storageSlot,
       noteTypeId,
+      computeNullifier,
       note,
     ));
 
-    if (commitment.equals(siloedNoteHash)) {
+    if (noteHash.equals(siloedNoteHash)) {
       nonce = expectedNonce;
       break;
     }
@@ -109,11 +223,11 @@ async function findNoteIndexAndNullifier(
   if (!nonce) {
     // NB: this used to warn the user that a decrypted log didn't match any notes.
     // This was previously fine as we didn't chop transient note logs, but now we do (#1641 complete).
-    throw new Error('Cannot find a matching commitment for the note.');
+    throw new Error('Cannot find a matching note hash for the note.');
   }
 
   return {
-    commitmentIndex,
+    noteHashIndex,
     nonce,
     innerNoteHash: innerNoteHash!,
     siloedNullifier: siloNullifier(contractAddress, innerNullifier!),

package/src/pxe_service/create_pxe_service.ts

@@ -5,6 +5,7 @@ import { createDebugLogger } from '@aztec/foundation/log';
 import { KeyStore } from '@aztec/key-store';
 import { AztecLmdbStore } from '@aztec/kv-store/lmdb';
 import { initStoreForRollup } from '@aztec/kv-store/utils';
+import { getCanonicalAuthRegistry } from '@aztec/protocol-contracts/auth-registry';
 import { getCanonicalClassRegisterer } from '@aztec/protocol-contracts/class-registerer';
 import { getCanonicalGasToken } from '@aztec/protocol-contracts/gas-token';
 import { getCanonicalInstanceDeployer } from '@aztec/protocol-contracts/instance-deployer';
@@ -67,6 +68,7 @@ export async function createPXEService(
     getCanonicalMultiCallEntrypointContract(),
     getCanonicalGasToken(),
     getCanonicalKeyRegistry(),
+    getCanonicalAuthRegistry(),
   ]) {
     await server.registerContract(contract);
   }

package/src/pxe_service/pxe_service.ts

@@ -3,18 +3,22 @@ import {
   type AztecNode,
   EncryptedNoteTxL2Logs,
   EncryptedTxL2Logs,
+  type EventMetadata,
   ExtendedNote,
   type FunctionCall,
   type GetUnencryptedLogsResponse,
+  type IncomingNotesFilter,
+  L1EventPayload,
   type L2Block,
   type LogFilter,
   MerkleTreeId,
-  type NoteFilter,
+  type OutgoingNotesFilter,
   type PXE,
   type PXEInfo,
   type ProofCreator,
   SimulatedTx,
   SimulationError,
+  TaggedLog,
   Tx,
   type TxEffect,
   type TxExecutionRequest,
@@ -32,11 +36,11 @@ import {
 } from '@aztec/circuits.js';
 import { computeNoteHashNonce, siloNullifier } from '@aztec/circuits.js/hash';
 import { type ContractArtifact, type DecodedReturn, FunctionSelector, encodeArguments } from '@aztec/foundation/abi';
-import { type Fq, Fr } from '@aztec/foundation/fields';
+import { type Fq, Fr, type Point } from '@aztec/foundation/fields';
 import { SerialQueue } from '@aztec/foundation/fifo';
 import { type DebugLogger, createDebugLogger } from '@aztec/foundation/log';
 import { type KeyStore } from '@aztec/key-store';
-import { getCanonicalClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
+import { ClassRegistererAddress } from '@aztec/protocol-contracts/class-registerer';
 import { getCanonicalGasToken } from '@aztec/protocol-contracts/gas-token';
 import { getCanonicalInstanceDeployer } from '@aztec/protocol-contracts/instance-deployer';
 import { getCanonicalKeyRegistryAddress } from '@aztec/protocol-contracts/key-registry';
@@ -57,10 +61,11 @@ import { type NodeInfo } from '@aztec/types/interfaces';
 
 import { type PXEServiceConfig, getPackageInfo } from '../config/index.js';
 import { ContractDataOracle } from '../contract_data_oracle/index.js';
+import { IncomingNoteDao } from '../database/incoming_note_dao.js';
 import { type PxeDatabase } from '../database/index.js';
-import { NoteDao } from '../database/note_dao.js';
 import { KernelOracle } from '../kernel_oracle/index.js';
 import { KernelProver } from '../kernel_prover/kernel_prover.js';
+import { TestProofCreator } from '../kernel_prover/test/test_circuit_prover.js';
 import { getAcirSimulator } from '../simulator/index.js';
 import { Synchronizer } from '../synchronizer/index.js';
 
@@ -77,6 +82,8 @@ export class PXEService implements PXE {
   // ensures that state is not changed while simulating
   private jobQueue = new SerialQueue();
 
+  private fakeProofCreator = new TestProofCreator();
+
   constructor(
     private keyStore: KeyStore,
     private node: AztecNode,
@@ -121,11 +128,7 @@ export class PXEService implements PXE {
       }
 
       count++;
-      this.synchronizer.addAccount(
-        address.publicKeys.masterIncomingViewingPublicKey,
-        this.keyStore,
-        this.config.l2StartingBlock,
-      );
+      await this.synchronizer.addAccount(address.address, this.keyStore, this.config.l2StartingBlock);
     }
 
     if (count > 0) {
@@ -177,6 +180,10 @@ export class PXEService implements PXE {
     return artifact && getContractClassFromArtifact(artifact);
   }
 
+  public getContractArtifact(id: Fr): Promise<ContractArtifact | undefined> {
+    return this.db.getContractArtifact(id);
+  }
+
   public async registerAccount(secretKey: Fr, partialAddress: PartialAddress): Promise<CompleteAddress> {
     const accounts = await this.keyStore.getAccounts();
     const accountCompleteAddress = await this.keyStore.addAccount(secretKey, partialAddress);
@@ -184,10 +191,7 @@ export class PXEService implements PXE {
       this.log.info(`Account:\n "${accountCompleteAddress.address.toString()}"\n already registered.`);
       return accountCompleteAddress;
     } else {
-      const masterIncomingViewingPublicKey = await this.keyStore.getMasterIncomingViewingPublicKey(
-        accountCompleteAddress.address,
-      );
-      this.synchronizer.addAccount(masterIncomingViewingPublicKey, this.keyStore, this.config.l2StartingBlock);
+      await this.synchronizer.addAccount(accountCompleteAddress.address, this.keyStore, this.config.l2StartingBlock);
       this.log.info(`Registered account ${accountCompleteAddress.address.toString()}`);
       this.log.debug(`Registered account\n ${accountCompleteAddress.toReadableString()}`);
     }
@@ -258,6 +262,7 @@ export class PXEService implements PXE {
         );
       }
       await this.db.addContractArtifact(contractClassId, artifact);
+      await this.node.addContractArtifact(instance.address, artifact);
     } else {
       // Otherwise, make sure there is an artifact already registered for that class id
       artifact = await this.db.getContractArtifact(instance.contractClassId);
@@ -284,19 +289,40 @@ export class PXEService implements PXE {
     return await this.node.getPublicStorageAt(contract, slot);
   }
 
-  public async getNotes(filter: NoteFilter): Promise<ExtendedNote[]> {
-    const noteDaos = await this.db.getNotes(filter);
+  public async getIncomingNotes(filter: IncomingNotesFilter): Promise<ExtendedNote[]> {
+    const noteDaos = await this.db.getIncomingNotes(filter);
 
-    // TODO(benesjan): Refactor --> This type conversion is ugly but I decided to keep it this way for now because
-    // key derivation will affect all this
+    // TODO(#6531): Refactor --> This type conversion is ugly but I decided to keep it this way for now because
+    // key rotation will affect this
     const extendedNotes = noteDaos.map(async dao => {
       let owner = filter.owner;
       if (owner === undefined) {
         const completeAddresses = (await this.db.getCompleteAddresses()).find(address =>
-          address.publicKeys.masterIncomingViewingPublicKey.equals(dao.publicKey),
+          address.publicKeys.masterIncomingViewingPublicKey.equals(dao.ivpkM),
         );
         if (completeAddresses === undefined) {
-          throw new Error(`Cannot find complete address for public key ${dao.publicKey.toString()}`);
+          throw new Error(`Cannot find complete address for IvpkM ${dao.ivpkM.toString()}`);
+        }
+        owner = completeAddresses.address;
+      }
+      return new ExtendedNote(dao.note, owner, dao.contractAddress, dao.storageSlot, dao.noteTypeId, dao.txHash);
+    });
+    return Promise.all(extendedNotes);
+  }
+
+  public async getOutgoingNotes(filter: OutgoingNotesFilter): Promise<ExtendedNote[]> {
+    const noteDaos = await this.db.getOutgoingNotes(filter);
+
+    // TODO(#6532): Refactor --> This type conversion is ugly but I decided to keep it this way for now because
+    // key rotation will affect this
+    const extendedNotes = noteDaos.map(async dao => {
+      let owner = filter.owner;
+      if (owner === undefined) {
+        const completeAddresses = (await this.db.getCompleteAddresses()).find(address =>
+          address.publicKeys.masterOutgoingViewingPublicKey.equals(dao.ovpkM),
+        );
+        if (completeAddresses === undefined) {
+          throw new Error(`Cannot find complete address for OvpkM ${dao.ovpkM.toString()}`);
         }
         owner = completeAddresses.address;
       }
@@ -317,13 +343,15 @@ export class PXEService implements PXE {
     }
 
     for (const nonce of nonces) {
-      const { innerNoteHash, siloedNoteHash, innerNullifier } = await this.simulator.computeNoteHashAndNullifier(
-        note.contractAddress,
-        nonce,
-        note.storageSlot,
-        note.noteTypeId,
-        note.note,
-      );
+      const { innerNoteHash, siloedNoteHash, innerNullifier } =
+        await this.simulator.computeNoteHashAndOptionallyANullifier(
+          note.contractAddress,
+          nonce,
+          note.storageSlot,
+          note.noteTypeId,
+          true,
+          note.note,
+        );
 
       const index = await this.node.findLeafIndex('latest', MerkleTreeId.NOTE_HASH_TREE, siloedNoteHash);
       if (index === undefined) {
@@ -337,7 +365,7 @@ export class PXEService implements PXE {
       }
 
       await this.db.addNote(
-        new NoteDao(
+        new IncomingNoteDao(
           note.note,
           note.contractAddress,
           note.storageSlot,
@@ -353,6 +381,54 @@ export class PXEService implements PXE {
     }
   }
 
+  public async addNullifiedNote(note: ExtendedNote) {
+    const owner = await this.db.getCompleteAddress(note.owner);
+    if (!owner) {
+      throw new Error(`Unknown account: ${note.owner.toString()}`);
+    }
+
+    const nonces = await this.getNoteNonces(note);
+    if (nonces.length === 0) {
+      throw new Error(`Cannot find the note in tx: ${note.txHash}.`);
+    }
+
+    for (const nonce of nonces) {
+      const { innerNoteHash, siloedNoteHash, innerNullifier } =
+        await this.simulator.computeNoteHashAndOptionallyANullifier(
+          note.contractAddress,
+          nonce,
+          note.storageSlot,
+          note.noteTypeId,
+          false,
+          note.note,
+        );
+
+      if (!innerNullifier.equals(Fr.ZERO)) {
+        throw new Error('Unexpectedly received non-zero nullifier.');
+      }
+
+      const index = await this.node.findLeafIndex('latest', MerkleTreeId.NOTE_HASH_TREE, siloedNoteHash);
+      if (index === undefined) {
+        throw new Error('Note does not exist.');
+      }
+
+      await this.db.addNullifiedNote(
+        new IncomingNoteDao(
+          note.note,
+          note.contractAddress,
+          note.storageSlot,
+          note.noteTypeId,
+          note.txHash,
+          nonce,
+          innerNoteHash,
+          Fr.ZERO, // We are not able to derive
+          index,
+          owner.publicKeys.masterIncomingViewingPublicKey,
+        ),
+      );
+    }
+  }
+
   /**
    * Finds the nonce(s) for a given note.
    * @param note - The note to find the nonces for.
@@ -372,11 +448,12 @@ export class PXEService implements PXE {
     // Remove this once notes added from public also include nonces.
     {
       const publicNoteNonce = Fr.ZERO;
-      const { siloedNoteHash } = await this.simulator.computeNoteHashAndNullifier(
+      const { siloedNoteHash } = await this.simulator.computeNoteHashAndOptionallyANullifier(
         note.contractAddress,
         publicNoteNonce,
         note.storageSlot,
         note.noteTypeId,
+        false,
         note.note,
       );
       if (tx.noteHashes.some(hash => hash.equals(siloedNoteHash))) {
@@ -393,11 +470,12 @@ export class PXEService implements PXE {
       }
 
       const nonce = computeNoteHashNonce(firstNullifier, i);
-      const { siloedNoteHash } = await this.simulator.computeNoteHashAndNullifier(
+      const { siloedNoteHash } = await this.simulator.computeNoteHashAndOptionallyANullifier(
         note.contractAddress,
         nonce,
         note.storageSlot,
         note.noteTypeId,
+        false,
         note.note,
       );
       if (hash.equals(siloedNoteHash)) {
@@ -416,8 +494,14 @@ export class PXEService implements PXE {
     return await this.node.getBlock(blockNumber);
   }
 
-  public async proveTx(txRequest: TxExecutionRequest, simulatePublic: boolean) {
-    return (await this.simulateTx(txRequest, simulatePublic)).tx;
+  public proveTx(txRequest: TxExecutionRequest, simulatePublic: boolean): Promise<Tx> {
+    return this.jobQueue.put(async () => {
+      const simulatedTx = await this.#simulateAndProve(txRequest, this.proofCreator, undefined);
+      if (simulatePublic) {
+        simulatedTx.publicOutput = await this.#simulatePublicCalls(simulatedTx.tx);
+      }
+      return simulatedTx.tx;
+    });
   }
 
   public async simulateTx(
@@ -426,16 +510,15 @@ export class PXEService implements PXE {
     msgSender: AztecAddress | undefined = undefined,
   ): Promise<SimulatedTx> {
     return await this.jobQueue.put(async () => {
-      const simulatedTx = await this.#simulateAndProve(txRequest, msgSender);
-      // We log only if the msgSender is undefined, as simulating with a different msgSender
-      // is unlikely to be a real transaction, and likely to be only used to read data.
-      // Meaning that it will not necessarily have produced a nullifier (and thus have no TxHash)
-      // If we log, the `getTxHash` function will throw.
-
+      const simulatedTx = await this.#simulateAndProve(txRequest, this.fakeProofCreator, msgSender);
       if (simulatePublic) {
         simulatedTx.publicOutput = await this.#simulatePublicCalls(simulatedTx.tx);
       }
 
+      // We log only if the msgSender is undefined, as simulating with a different msgSender
+      // is unlikely to be a real transaction, and likely to be only used to read data.
+      // 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()}`);
       }
@@ -539,7 +622,7 @@ export class PXEService implements PXE {
     return Promise.resolve({
       pxeVersion: this.packageVersion,
       protocolContractAddresses: {
-        classRegisterer: getCanonicalClassRegistererAddress(),
+        classRegisterer: ClassRegistererAddress,
         gasToken: getCanonicalGasToken().address,
         instanceDeployer: getCanonicalInstanceDeployer().address,
         keyRegistry: getCanonicalKeyRegistryAddress(),
@@ -652,18 +735,22 @@ export class PXEService implements PXE {
    * the function will also include the new contract's public functions in the transaction object.
    *
    * @param txExecutionRequest - The transaction request to be simulated and proved.
-   * @param signature - The ECDSA signature for the transaction request.
+   * @param proofCreator - The proof creator to use for proving the execution.
    * @param msgSender - (Optional) The message sender to use for the simulation.
-   * @returns An object tract contains:
+   * @returns An object that contains:
    * A private transaction object containing the proof, public inputs, and encrypted logs.
    * The return values of the private execution
    */
-  async #simulateAndProve(txExecutionRequest: TxExecutionRequest, msgSender?: AztecAddress) {
+  async #simulateAndProve(
+    txExecutionRequest: TxExecutionRequest,
+    proofCreator: ProofCreator,
+    msgSender?: AztecAddress,
+  ): Promise<SimulatedTx> {
     // Get values that allow us to reconstruct the block hash
     const executionResult = await this.#simulate(txExecutionRequest, msgSender);
 
     const kernelOracle = new KernelOracle(this.contractDataOracle, this.keyStore, this.node);
-    const kernelProver = new KernelProver(kernelOracle, this.proofCreator);
+    const kernelProver = new KernelProver(kernelOracle, proofCreator);
     this.log.debug(`Executing kernel prover...`);
     const { proof, publicInputs } = await kernelProver.prove(txExecutionRequest.toTxRequest(), executionResult);
 
@@ -746,4 +833,45 @@ export class PXEService implements PXE {
   public async isContractPubliclyDeployed(address: AztecAddress): Promise<boolean> {
     return !!(await this.node.getContract(address));
   }
+
+  public async getEvents<T>(from: number, limit: number, eventMetadata: EventMetadata<T>, ivpk: Point): Promise<T[]> {
+    const blocks = await this.node.getBlocks(from, limit);
+
+    const txEffects = blocks.flatMap(block => block.body.txEffects);
+    const encryptedTxLogs = txEffects.flatMap(txEffect => txEffect.encryptedLogs);
+
+    const encryptedLogs = encryptedTxLogs.flatMap(encryptedTxLog => encryptedTxLog.unrollLogs());
+
+    const ivsk = await this.keyStore.getMasterSecretKey(ivpk);
+
+    const visibleEvents = encryptedLogs
+      .map(encryptedLog => TaggedLog.decryptAsIncoming(encryptedLog, ivsk, L1EventPayload))
+      .filter(item => item !== undefined) as TaggedLog<L1EventPayload>[];
+
+    const decodedEvents = visibleEvents
+      .map(visibleEvent => {
+        if (visibleEvent.payload === undefined) {
+          return undefined;
+        }
+        if (!FunctionSelector.fromField(visibleEvent.payload.eventTypeId).equals(eventMetadata.functionSelector)) {
+          return undefined;
+        }
+        if (visibleEvent.payload.event.items.length !== eventMetadata.fieldNames.length) {
+          throw new Error(
+            'Something is weird here, we have matching FunctionSelectors, but the actual payload has mismatched length',
+          );
+        }
+
+        return eventMetadata.fieldNames.reduce(
+          (acc, curr, i) => ({
+            ...acc,
+            [curr]: visibleEvent.payload.event.items[i],
+          }),
+          {} as T,
+        );
+      })
+      .filter(visibleEvent => visibleEvent !== undefined) as T[];
+
+    return decodedEvents;
+  }
 }