@aztec/pxe 0.79.0 → 0.81.0

package/dest/storage/note_data_provider/note_data_provider.js

@@ -13,14 +13,14 @@ export class NoteDataProvider {
     #nullifiedNotesByContract;
     #nullifiedNotesByStorageSlot;
     #nullifiedNotesByTxHash;
-    #nullifiedNotesByAddressPoint;
+    #nullifiedNotesByRecipient;
     #nullifiedNotesByNullifier;
     #scopes;
     #notesToScope;
     #notesByContractAndScope;
     #notesByStorageSlotAndScope;
     #notesByTxHashAndScope;
-    #notesByAddressPointAndScope;
+    #notesByRecipientAndScope;
     constructor(store){
         this.#store = store;
         this.#notes = store.openMap('notes');
@@ -31,14 +31,14 @@ export class NoteDataProvider {
         this.#nullifiedNotesByContract = store.openMultiMap('nullified_notes_by_contract');
         this.#nullifiedNotesByStorageSlot = store.openMultiMap('nullified_notes_by_storage_slot');
         this.#nullifiedNotesByTxHash = store.openMultiMap('nullified_notes_by_tx_hash');
-        this.#nullifiedNotesByAddressPoint = store.openMultiMap('nullified_notes_by_address_point');
+        this.#nullifiedNotesByRecipient = store.openMultiMap('nullified_notes_by_recipient');
         this.#nullifiedNotesByNullifier = store.openMap('nullified_notes_by_nullifier');
         this.#scopes = store.openMap('scopes');
         this.#notesToScope = store.openMultiMap('notes_to_scope');
         this.#notesByContractAndScope = new Map();
         this.#notesByStorageSlotAndScope = new Map();
         this.#notesByTxHashAndScope = new Map();
-        this.#notesByAddressPointAndScope = new Map();
+        this.#notesByRecipientAndScope = new Map();
     }
     static async create(store) {
         const pxeDB = new NoteDataProvider(store);
@@ -46,7 +46,7 @@ export class NoteDataProvider {
             pxeDB.#notesByContractAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_contract`));
             pxeDB.#notesByStorageSlotAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_storage_slot`));
             pxeDB.#notesByTxHashAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_tx_hash`));
-            pxeDB.#notesByAddressPointAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_address_point`));
+            pxeDB.#notesByRecipientAndScope.set(scope, store.openMultiMap(`${scope}:notes_by_recipient`));
         }
         return pxeDB;
     }
@@ -59,7 +59,7 @@ export class NoteDataProvider {
         this.#notesByContractAndScope.set(scopeString, this.#store.openMultiMap(`${scopeString}:notes_by_contract`));
         this.#notesByStorageSlotAndScope.set(scopeString, this.#store.openMultiMap(`${scopeString}:notes_by_storage_slot`));
         this.#notesByTxHashAndScope.set(scopeString, this.#store.openMultiMap(`${scopeString}:notes_by_tx_hash`));
-        this.#notesByAddressPointAndScope.set(scopeString, this.#store.openMultiMap(`${scopeString}:notes_by_address_point`));
+        this.#notesByRecipientAndScope.set(scopeString, this.#store.openMultiMap(`${scopeString}:notes_by_recipient`));
         return true;
     }
     async addNotes(notes, scope = AztecAddress.ZERO) {
@@ -79,7 +79,7 @@ export class NoteDataProvider {
                 await this.#notesByContractAndScope.get(scope.toString()).set(dao.contractAddress.toString(), noteIndex);
                 await this.#notesByStorageSlotAndScope.get(scope.toString()).set(dao.storageSlot.toString(), noteIndex);
                 await this.#notesByTxHashAndScope.get(scope.toString()).set(dao.txHash.toString(), noteIndex);
-                await this.#notesByAddressPointAndScope.get(scope.toString()).set(dao.addressPoint.toString(), noteIndex);
+                await this.#notesByRecipientAndScope.get(scope.toString()).set(dao.recipient.toString(), noteIndex);
             }
         });
     }
@@ -95,7 +95,7 @@ export class NoteDataProvider {
                     await this.#nullifierToNoteId.delete(noteDao.siloedNullifier.toString());
                     const scopes = await toArray(this.#scopes.keysAsync());
                     for (const scope of scopes){
-                        await this.#notesByAddressPointAndScope.get(scope).deleteValue(noteDao.addressPoint.toString(), noteIndex);
+                        await this.#notesByRecipientAndScope.get(scope).deleteValue(noteDao.recipient.toString(), noteIndex);
                         await this.#notesByTxHashAndScope.get(scope).deleteValue(noteDao.txHash.toString(), noteIndex);
                         await this.#notesByContractAndScope.get(scope).deleteValue(noteDao.contractAddress.toString(), noteIndex);
                         await this.#notesByStorageSlotAndScope.get(scope).deleteValue(noteDao.storageSlot.toString(), noteIndex);
@@ -123,14 +123,14 @@ export class NoteDataProvider {
                 let scopes = await toArray(this.#nullifiedNotesToScope.getValuesAsync(noteIndex)) ?? [];
                 if (scopes.length === 0) {
                     scopes = [
-                        new AztecAddress(dao.addressPoint.x).toString()
+                        dao.recipient.toString()
                     ];
                 }
                 for (const scope of scopes){
                     await this.#notesByContractAndScope.get(scope.toString()).set(dao.contractAddress.toString(), noteIndex);
                     await this.#notesByStorageSlotAndScope.get(scope.toString()).set(dao.storageSlot.toString(), noteIndex);
                     await this.#notesByTxHashAndScope.get(scope.toString()).set(dao.txHash.toString(), noteIndex);
-                    await this.#notesByAddressPointAndScope.get(scope.toString()).set(dao.addressPoint.toString(), noteIndex);
+                    await this.#notesByRecipientAndScope.get(scope.toString()).set(dao.recipient.toString(), noteIndex);
                     await this.#notesToScope.set(noteIndex, scope);
                 }
                 await this.#nullifiedNotes.delete(noteIndex);
@@ -139,13 +139,12 @@ export class NoteDataProvider {
                 await this.#nullifiedNotesByContract.deleteValue(dao.contractAddress.toString(), noteIndex);
                 await this.#nullifiedNotesByStorageSlot.deleteValue(dao.storageSlot.toString(), noteIndex);
                 await this.#nullifiedNotesByTxHash.deleteValue(dao.txHash.toString(), noteIndex);
-                await this.#nullifiedNotesByAddressPoint.deleteValue(dao.addressPoint.toString(), noteIndex);
+                await this.#nullifiedNotesByRecipient.deleteValue(dao.recipient.toString(), noteIndex);
                 await this.#nullifiedNotesByNullifier.delete(dao.siloedNullifier.toString());
             }
         });
     }
     async getNotes(filter) {
-        const publicKey = filter.owner ? await filter.owner.toAddressPoint() : undefined;
         filter.status = filter.status ?? NoteStatus.ACTIVE;
         const candidateNoteSources = [];
         filter.scopes ??= (await toArray(this.#scopes.keysAsync())).map((addressString)=>AztecAddress.fromString(addressString));
@@ -155,7 +154,7 @@ export class NoteDataProvider {
             if (!await this.#scopes.hasAsync(formattedScopeString)) {
                 throw new Error('Trying to get incoming notes of an scope that is not in the PXE database');
             }
-            activeNoteIdsPerScope.push(publicKey ? await toArray(this.#notesByAddressPointAndScope.get(formattedScopeString).getValuesAsync(publicKey.toString())) : filter.txHash ? await toArray(this.#notesByTxHashAndScope.get(formattedScopeString).getValuesAsync(filter.txHash.toString())) : filter.contractAddress ? await toArray(this.#notesByContractAndScope.get(formattedScopeString).getValuesAsync(filter.contractAddress.toString())) : filter.storageSlot ? await toArray(this.#notesByStorageSlotAndScope.get(formattedScopeString).getValuesAsync(filter.storageSlot.toString())) : await toArray(this.#notesByAddressPointAndScope.get(formattedScopeString).valuesAsync()));
+            activeNoteIdsPerScope.push(filter.recipient ? await toArray(this.#notesByRecipientAndScope.get(formattedScopeString).getValuesAsync(filter.recipient.toString())) : filter.txHash ? await toArray(this.#notesByTxHashAndScope.get(formattedScopeString).getValuesAsync(filter.txHash.toString())) : filter.contractAddress ? await toArray(this.#notesByContractAndScope.get(formattedScopeString).getValuesAsync(filter.contractAddress.toString())) : filter.storageSlot ? await toArray(this.#notesByStorageSlotAndScope.get(formattedScopeString).getValuesAsync(filter.storageSlot.toString())) : await toArray(this.#notesByRecipientAndScope.get(formattedScopeString).valuesAsync()));
         }
         candidateNoteSources.push({
             ids: new Set(activeNoteIdsPerScope.flat()),
@@ -163,7 +162,7 @@ export class NoteDataProvider {
         });
         if (filter.status == NoteStatus.ACTIVE_OR_NULLIFIED) {
             candidateNoteSources.push({
-                ids: publicKey ? await toArray(this.#nullifiedNotesByAddressPoint.getValuesAsync(publicKey.toString())) : filter.txHash ? await toArray(this.#nullifiedNotesByTxHash.getValuesAsync(filter.txHash.toString())) : filter.contractAddress ? await toArray(this.#nullifiedNotesByContract.getValuesAsync(filter.contractAddress.toString())) : filter.storageSlot ? await toArray(this.#nullifiedNotesByStorageSlot.getValuesAsync(filter.storageSlot.toString())) : await toArray(this.#nullifiedNotes.keysAsync()),
+                ids: filter.recipient ? await toArray(this.#nullifiedNotesByRecipient.getValuesAsync(filter.recipient.toString())) : filter.txHash ? await toArray(this.#nullifiedNotesByTxHash.getValuesAsync(filter.txHash.toString())) : filter.contractAddress ? await toArray(this.#nullifiedNotesByContract.getValuesAsync(filter.contractAddress.toString())) : filter.storageSlot ? await toArray(this.#nullifiedNotesByStorageSlot.getValuesAsync(filter.storageSlot.toString())) : await toArray(this.#nullifiedNotes.keysAsync()),
                 notes: this.#nullifiedNotes
             });
         }
@@ -184,7 +183,7 @@ export class NoteDataProvider {
                 if (filter.storageSlot && !note.storageSlot.equals(filter.storageSlot)) {
                     continue;
                 }
-                if (publicKey && !note.addressPoint.equals(publicKey)) {
+                if (filter.recipient && !note.recipient.equals(filter.recipient)) {
                     continue;
                 }
                 if (filter.siloedNullifier && !note.siloedNullifier.equals(filter.siloedNullifier)) {
@@ -195,7 +194,7 @@ export class NoteDataProvider {
         }
         return result;
     }
-    removeNullifiedNotes(nullifiers, accountAddressPoint) {
+    removeNullifiedNotes(nullifiers, recipient) {
         if (nullifiers.length === 0) {
             return Promise.resolve([]);
         }
@@ -213,7 +212,7 @@ export class NoteDataProvider {
                 }
                 const noteScopes = await toArray(this.#notesToScope.getValuesAsync(noteIndex)) ?? [];
                 const note = NoteDao.fromBuffer(noteBuffer);
-                if (!note.addressPoint.equals(accountAddressPoint)) {
+                if (!note.recipient.equals(recipient)) {
                     continue;
                 }
                 nullifiedNotes.push(note);
@@ -221,7 +220,7 @@ export class NoteDataProvider {
                 await this.#notesToScope.delete(noteIndex);
                 const scopes = await toArray(this.#scopes.keysAsync());
                 for (const scope of scopes){
-                    await this.#notesByAddressPointAndScope.get(scope).deleteValue(accountAddressPoint.toString(), noteIndex);
+                    await this.#notesByRecipientAndScope.get(scope).deleteValue(note.recipient.toString(), noteIndex);
                     await this.#notesByTxHashAndScope.get(scope).deleteValue(note.txHash.toString(), noteIndex);
                     await this.#notesByContractAndScope.get(scope).deleteValue(note.contractAddress.toString(), noteIndex);
                     await this.#notesByStorageSlotAndScope.get(scope).deleteValue(note.storageSlot.toString(), noteIndex);
@@ -236,7 +235,7 @@ export class NoteDataProvider {
                 await this.#nullifiedNotesByContract.set(note.contractAddress.toString(), noteIndex);
                 await this.#nullifiedNotesByStorageSlot.set(note.storageSlot.toString(), noteIndex);
                 await this.#nullifiedNotesByTxHash.set(note.txHash.toString(), noteIndex);
-                await this.#nullifiedNotesByAddressPoint.set(note.addressPoint.toString(), noteIndex);
+                await this.#nullifiedNotesByRecipient.set(note.recipient.toString(), noteIndex);
                 await this.#nullifiedNotesByNullifier.set(nullifier.toString(), noteIndex);
                 await this.#nullifierToNoteId.delete(nullifier.toString());
             }

package/dest/synchronizer/synchronizer.js

@@ -36,7 +36,7 @@ import { L2BlockStream } from '@aztec/stdlib/block';
         switch(event.type){
             case 'blocks-added':
                 {
-                    const lastBlock = event.blocks.at(-1);
+                    const lastBlock = event.blocks.at(-1).block;
                     this.log.verbose(`Updated pxe last block to ${lastBlock.number}`, {
                         blockHash: lastBlock.hash(),
                         archive: lastBlock.archive.root.toString(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aztec/pxe",
-  "version": "0.79.0",
+  "version": "0.81.0",
   "type": "module",
   "exports": {
     "./server": "./dest/entrypoints/server/index.js",
@@ -59,19 +59,19 @@
     ]
   },
   "dependencies": {
-    "@aztec/bb-prover": "0.79.0",
-    "@aztec/bb.js": "0.79.0",
-    "@aztec/builder": "0.79.0",
-    "@aztec/constants": "0.79.0",
-    "@aztec/ethereum": "0.79.0",
-    "@aztec/foundation": "0.79.0",
-    "@aztec/key-store": "0.79.0",
-    "@aztec/kv-store": "0.79.0",
-    "@aztec/noir-protocol-circuits-types": "0.79.0",
-    "@aztec/noir-types": "0.79.0",
-    "@aztec/protocol-contracts": "0.79.0",
-    "@aztec/simulator": "0.79.0",
-    "@aztec/stdlib": "0.79.0",
+    "@aztec/bb-prover": "0.81.0",
+    "@aztec/bb.js": "0.81.0",
+    "@aztec/builder": "0.81.0",
+    "@aztec/constants": "0.81.0",
+    "@aztec/ethereum": "0.81.0",
+    "@aztec/foundation": "0.81.0",
+    "@aztec/key-store": "0.81.0",
+    "@aztec/kv-store": "0.81.0",
+    "@aztec/noir-protocol-circuits-types": "0.81.0",
+    "@aztec/noir-types": "0.81.0",
+    "@aztec/protocol-contracts": "0.81.0",
+    "@aztec/simulator": "0.81.0",
+    "@aztec/stdlib": "0.81.0",
     "@msgpack/msgpack": "^3.0.0-beta2",
     "koa": "^2.14.2",
     "koa-router": "^12.0.0",
@@ -81,7 +81,7 @@
     "viem": "2.23.7"
   },
   "devDependencies": {
-    "@aztec/noir-contracts.js": "0.79.0",
+    "@aztec/noir-contracts.js": "0.81.0",
     "@jest/globals": "^29.5.0",
     "@types/jest": "^29.5.0",
     "@types/lodash.omit": "^4.5.7",

package/src/config/index.ts

@@ -107,6 +107,7 @@ export const allPxeConfigMappings: ConfigMappingsType<CliPXEOptions & PXEService
     parseEnv: (val: string) => parseBooleanEnv(val) || !!process.env.NETWORK,
     description: 'Enable real proofs',
     isBoolean: true,
+    defaultValue: true,
   },
 };
 

package/src/pxe_oracle_interface/pxe_oracle_interface.ts

@@ -1,48 +1,37 @@
-import {
-  type L1_TO_L2_MSG_TREE_HEIGHT,
-  MAX_NOTE_HASHES_PER_TX,
-  PRIVATE_LOG_SIZE_IN_FIELDS,
-  PUBLIC_LOG_DATA_SIZE_IN_FIELDS,
-} from '@aztec/constants';
+import { type L1_TO_L2_MSG_TREE_HEIGHT, MAX_NOTE_HASHES_PER_TX, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
 import { timesParallel } from '@aztec/foundation/collection';
 import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr, Point } from '@aztec/foundation/fields';
 import { createLogger } from '@aztec/foundation/log';
-import { BufferReader } from '@aztec/foundation/serialize';
 import type { KeyStore } from '@aztec/key-store';
-import { AcirSimulator, type ExecutionDataProvider, type SimulationProvider } from '@aztec/simulator/client';
-import { MessageLoadOracleInputs } from '@aztec/simulator/client';
+import {
+  AcirSimulator,
+  type ExecutionDataProvider,
+  MessageLoadOracleInputs,
+  type SimulationProvider,
+} from '@aztec/simulator/client';
 import {
   type FunctionArtifact,
   FunctionCall,
   FunctionSelector,
   FunctionType,
-  NoteSelector,
   encodeArguments,
   getFunctionArtifact,
 } from '@aztec/stdlib/abi';
-import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import { AztecAddress } from '@aztec/stdlib/aztec-address';
 import type { InBlock, L2Block, L2BlockNumber } from '@aztec/stdlib/block';
 import type { CompleteAddress, ContractInstance } from '@aztec/stdlib/contract';
 import { computeUniqueNoteHash, siloNoteHash, siloNullifier } from '@aztec/stdlib/hash';
 import type { AztecNode } from '@aztec/stdlib/interfaces/client';
 import type { KeyValidationRequest } from '@aztec/stdlib/kernel';
 import { computeAddressSecret, computeTaggingSecretPoint } from '@aztec/stdlib/keys';
-import {
-  IndexedTaggingSecret,
-  L1NotePayload,
-  LogWithTxData,
-  PrivateLog,
-  PublicLog,
-  TxScopedL2Log,
-} from '@aztec/stdlib/logs';
+import { IndexedTaggingSecret, LogWithTxData, TxScopedL2Log, deriveEcdhSharedSecret } from '@aztec/stdlib/logs';
 import { getNonNullifiedL1ToL2MessageWitness } from '@aztec/stdlib/messaging';
 import { Note, type NoteStatus } from '@aztec/stdlib/note';
 import { MerkleTreeId, type NullifierMembershipWitness, PublicDataWitness } from '@aztec/stdlib/trees';
 import type { BlockHeader } from '@aztec/stdlib/tx';
 import { TxHash } from '@aztec/stdlib/tx';
 
-import { getOrderedNoteItems } from '../note_decryption_utils/add_public_values_to_payload.js';
 import type { AddressDataProvider } from '../storage/address_data_provider/address_data_provider.js';
 import type { AuthWitnessDataProvider } from '../storage/auth_witness_data_provider/auth_witness_data_provider.js';
 import type { CapsuleDataProvider } from '../storage/capsule_data_provider/capsule_data_provider.js';
@@ -470,7 +459,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     const recipients = scopes ? scopes : await this.keyStore.getAccounts();
     // A map of logs going from recipient address to logs. Note that the logs might have been processed before
     // due to us having a sliding window that "looks back" for logs as well. (We look back as there is no guarantee
-    // that a logs will be received ordered by a given tax index and that the tags won't be reused).
+    // that a logs will be received ordered by a given tag index and that the tags won't be reused).
     const logsMap = new Map<string, TxScopedL2Log[]>();
     const contractName = await this.contractDataProvider.getDebugContractName(contractAddress);
     for (const recipient of recipients) {
@@ -516,31 +505,21 @@ export class PXEOracleInterface implements ExecutionDataProvider {
 
         logsByTags.forEach((logsByTag, logIndex) => {
           if (logsByTag.length > 0) {
-            // Check that public logs have the correct contract address
-            const checkedLogsbyTag = logsByTag.filter(
-              l => !l.isFromPublic || PublicLog.fromBuffer(l.logData).contractAddress.equals(contractAddress),
-            );
-            if (checkedLogsbyTag.length < logsByTag.length) {
-              const discarded = logsByTag.filter(
-                log => checkedLogsbyTag.find(filteredLog => filteredLog.equals(log)) === undefined,
-              );
-              this.log.warn(
-                `Discarded ${
-                  logsByTag.length - checkedLogsbyTag.length
-                } public logs with mismatched contract address ${contractAddress}:`,
-                discarded.map(l => PublicLog.fromBuffer(l.logData)),
-              );
+            // Discard public logs
+            const filteredLogsByTag = logsByTag.filter(l => !l.isFromPublic);
+            if (filteredLogsByTag.length < logsByTag.length) {
+              this.log.warn(`Discarded ${logsByTag.filter(l => l.isFromPublic).length} public logs with matching tags`);
             }
 
             // The logs for the given tag exist so we store them for later processing
-            logsForRecipient.push(...checkedLogsbyTag);
+            logsForRecipient.push(...filteredLogsByTag);
 
             // We retrieve the indexed tagging secret corresponding to the log as I need that to evaluate whether
             // a new largest index have been found.
             const secretCorrespondingToLog = secretsForTheWholeWindow[logIndex];
             const initialIndex = initialIndexesMap[secretCorrespondingToLog.appTaggingSecret.toString()];
 
-            this.log.debug(`Found ${checkedLogsbyTag.length} logs as recipient ${recipient}`, {
+            this.log.debug(`Found ${filteredLogsByTag.length} logs as recipient ${recipient}`, {
               recipient,
               secret: secretCorrespondingToLog.appTaggingSecret,
               contractName,
@@ -610,77 +589,36 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     return logsMap;
   }
 
-  /**
-   * Decrypts logs tagged for a recipient and returns them.
-   * @param scopedLogs - The logs to decrypt.
-   * @param recipient - The recipient of the logs.
-   * @returns The decrypted notes.
-   */
-  async #decryptTaggedLogs(scopedLogs: TxScopedL2Log[], recipient: AztecAddress) {
-    const recipientCompleteAddress = await this.getCompleteAddress(recipient);
-    const ivskM = await this.keyStore.getMasterSecretKey(
-      recipientCompleteAddress.publicKeys.masterIncomingViewingPublicKey,
-    );
-    const addressSecret = await computeAddressSecret(await recipientCompleteAddress.getPreaddress(), ivskM);
-
-    // Since we could have notes with the same index for different txs, we need
-    // to keep track of them scoping by txHash
-    const excludedIndices: Map<string, Set<number>> = new Map();
-    const decrypted = [];
-
-    for (const scopedLog of scopedLogs) {
-      const payload = scopedLog.isFromPublic
-        ? await L1NotePayload.decryptAsIncomingFromPublic(PublicLog.fromBuffer(scopedLog.logData), addressSecret)
-        : await L1NotePayload.decryptAsIncoming(PrivateLog.fromBuffer(scopedLog.logData), addressSecret);
-
-      if (!payload) {
-        this.log.verbose('Unable to decrypt log');
-        continue;
-      }
-
-      if (!excludedIndices.has(scopedLog.txHash.toString())) {
-        excludedIndices.set(scopedLog.txHash.toString(), new Set());
-      }
-
-      const note = await getOrderedNoteItems(this.contractDataProvider, payload);
-      const plaintext = [payload.storageSlot, payload.noteTypeId.toField(), ...note.items];
-
-      decrypted.push({ plaintext, txHash: scopedLog.txHash, contractAddress: payload.contractAddress });
-    }
-
-    return decrypted;
-  }
-
   /**
    * Processes the tagged logs returned by syncTaggedLogs by decrypting them and storing them in the database.
+   * @param contractAddress - The address of the contract that the logs are tagged for.
    * @param logs - The logs to process.
    * @param recipient - The recipient of the logs.
    */
   public async processTaggedLogs(
+    contractAddress: AztecAddress,
     logs: TxScopedL2Log[],
     recipient: AztecAddress,
     simulator?: AcirSimulator,
   ): Promise<void> {
-    const decryptedLogs = await this.#decryptTaggedLogs(logs, recipient);
+    for (const scopedLog of logs) {
+      if (scopedLog.isFromPublic) {
+        throw new Error('Attempted to decrypt public log');
+      }
 
-    // We've produced the full NoteDao, which we'd be able to simply insert into the database. However, this is
-    // only a temporary measure as we migrate from the PXE-driven discovery into the new contract-driven approach. We
-    // discard most of the work done up to this point and reconstruct the note plaintext to then hand over to the
-    // contract for further processing.
-    for (const decryptedLog of decryptedLogs) {
       // Log processing requires the note hashes in the tx in which the note was created. We are now assuming that the
       // note was included in the same block in which the log was delivered - note that partial notes will not work this
       // way.
-      const txEffect = await this.aztecNode.getTxEffect(decryptedLog.txHash);
+      const txEffect = await this.aztecNode.getTxEffect(scopedLog.txHash);
       if (!txEffect) {
-        throw new Error(`Could not find tx effect for tx hash ${decryptedLog.txHash}`);
+        throw new Error(`Could not find tx effect for tx hash ${scopedLog.txHash}`);
       }
 
       // This will trigger calls to the deliverNote oracle
       await this.callProcessLog(
-        decryptedLog.contractAddress,
-        decryptedLog.plaintext,
-        decryptedLog.txHash,
+        contractAddress,
+        scopedLog.log.toFields(),
+        scopedLog.txHash,
         txEffect.data.noteHashes,
         txEffect.data.nullifiers[0],
         recipient,
@@ -718,10 +656,9 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     // Note that while this technically results in historical queries, we perform it at the latest locally synced block
     // number which *should* be recent enough to be available, even for non-archive nodes.
     const syncedBlockNumber = (await this.syncDataProvider.getBlockNumber())!;
-    // TODO (#12559): handle undefined syncedBlockNumber
-    // if (syncedBlockNumber === undefined) {
-    //  throw new Error(`Attempted to deliver a note with an unsynchronized PXE - this should never happen`);
-    //}
+    if (syncedBlockNumber === undefined) {
+      throw new Error(`Attempted to deliver a note with an unsynchronized PXE - this should never happen`);
+    }
 
     // By computing siloed and unique note hashes ourselves we prevent contracts from interfering with the note storage
     // of other contracts, which would constitute a security breach.
@@ -750,8 +687,6 @@ export class PXEOracleInterface implements ExecutionDataProvider {
       throw new Error(`Failed to fetch tx receipt for tx hash ${txHash} when searching for note hashes`);
     }
 
-    // TODO(#12549): does it make sense to store the recipient's address point instead of just its address?
-    const recipientAddressPoint = await recipient.toAddressPoint();
     const noteDao = new NoteDao(
       new Note(content),
       contractAddress,
@@ -763,8 +698,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
       txReceipt.blockNumber!,
       txReceipt.blockHash!.toString(),
       uniqueNoteHashTreeIndex,
-      recipientAddressPoint,
-      NoteSelector.empty(), // TODO(#12013): remove
+      recipient,
     );
 
     await this.noteDataProvider.addNotes([noteDao], recipient);
@@ -778,10 +712,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
     const [nullifierIndex] = await this.aztecNode.findNullifiersIndexesWithBlock(syncedBlockNumber, [siloedNullifier]);
     if (nullifierIndex !== undefined) {
       const { data: _, ...blockHashAndNum } = nullifierIndex;
-      await this.noteDataProvider.removeNullifiedNotes(
-        [{ data: siloedNullifier, ...blockHashAndNum }],
-        recipientAddressPoint,
-      );
+      await this.noteDataProvider.removeNullifiedNotes([{ data: siloedNullifier, ...blockHashAndNum }], recipient);
 
       this.log.verbose(`Removed just-added note`, {
         contract: contractAddress,
@@ -807,33 +738,33 @@ export class PXEOracleInterface implements ExecutionDataProvider {
       );
     }
 
-    const log = logsForTag[0];
+    const scopedLog = logsForTag[0];
 
     // getLogsByTag doesn't have all of the information that we need (notably note hashes and the first nullifier), so
     // we need to make a second call to the node for `getTxEffect`.
     // TODO(#9789): bundle this information in the `getLogsByTag` call.
-    const txEffect = await this.aztecNode.getTxEffect(log.txHash);
+    const txEffect = await this.aztecNode.getTxEffect(scopedLog.txHash);
     if (txEffect == undefined) {
-      throw new Error(`Unexpected: failed to retrieve tx effects for tx ${log.txHash} which is known to exist`);
+      throw new Error(`Unexpected: failed to retrieve tx effects for tx ${scopedLog.txHash} which is known to exist`);
     }
 
-    const reader = BufferReader.asReader(log.logData);
-    const logArray = reader.readArray(PUBLIC_LOG_DATA_SIZE_IN_FIELDS, Fr);
-
     // Public logs always take up all available fields by padding with zeroes, and the length of the originally emitted
     // log is lost. Until this is improved, we simply remove all of the zero elements (which are expected to be at the
     // end).
     // TODO(#11636): use the actual log length.
-    const trimmedLog = logArray.filter(x => !x.isZero());
+    const trimmedLog = scopedLog.log.toFields().filter(x => !x.isZero());
 
-    return new LogWithTxData(trimmedLog, log.txHash.hash, txEffect.data.noteHashes, txEffect.data.nullifiers[0]);
+    return new LogWithTxData(trimmedLog, scopedLog.txHash.hash, txEffect.data.noteHashes, txEffect.data.nullifiers[0]);
   }
 
+  // TODO(#12553): nuke this as part of tackling that issue. This function is no longer unit tested as I had to remove
+  // it from pxe_oracle_interface.test.ts when moving decryption to Noir (at that point we could not get a hold of
+  // the decrypted note in the test as TS decryption no longer existed).
   public async removeNullifiedNotes(contractAddress: AztecAddress) {
     this.log.verbose('Searching for nullifiers of known notes', { contract: contractAddress });
 
     for (const recipient of await this.keyStore.getAccounts()) {
-      const currentNotesForRecipient = await this.noteDataProvider.getNotes({ contractAddress, owner: recipient });
+      const currentNotesForRecipient = await this.noteDataProvider.getNotes({ contractAddress, recipient });
       const nullifiersToCheck = currentNotesForRecipient.map(note => note.siloedNullifier);
       const nullifierIndexes = await this.aztecNode.findNullifiersIndexesWithBlock('latest', nullifiersToCheck);
 
@@ -845,10 +776,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
         })
         .filter(nullifier => nullifier !== undefined) as InBlock<Fr>[];
 
-      const nullifiedNotes = await this.noteDataProvider.removeNullifiedNotes(
-        foundNullifiers,
-        await recipient.toAddressPoint(),
-      );
+      const nullifiedNotes = await this.noteDataProvider.removeNullifiedNotes(foundNullifiers, recipient);
       nullifiedNotes.forEach(noteDao => {
         this.log.verbose(`Removed note for contract ${noteDao.contractAddress} at slot ${noteDao.storageSlot}`, {
           contract: noteDao.contractAddress,
@@ -861,7 +789,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
 
   async callProcessLog(
     contractAddress: AztecAddress,
-    logPlaintext: Fr[],
+    logCiphertext: Fr[],
     txHash: TxHash,
     noteHashes: Fr[],
     firstNullifier: Fr,
@@ -886,7 +814,7 @@ export class PXEOracleInterface implements ExecutionDataProvider {
       type: FunctionType.UNCONSTRAINED,
       isStatic: artifact.isStatic,
       args: encodeArguments(artifact, [
-        toBoundedVec(logPlaintext, PRIVATE_LOG_SIZE_IN_FIELDS),
+        toBoundedVec(logCiphertext, PRIVATE_LOG_SIZE_IN_FIELDS),
         txHash.toString(),
         toBoundedVec(noteHashes, MAX_NOTE_HASHES_PER_TX),
         firstNullifier,
@@ -918,6 +846,16 @@ export class PXEOracleInterface implements ExecutionDataProvider {
   copyCapsule(contractAddress: AztecAddress, srcSlot: Fr, dstSlot: Fr, numEntries: number): Promise<void> {
     return this.capsuleDataProvider.copyCapsule(contractAddress, srcSlot, dstSlot, numEntries);
   }
+
+  async getSharedSecret(address: AztecAddress, ephPk: Point): Promise<Point> {
+    // TODO(#12656): return an app-siloed secret
+    const recipientCompleteAddress = await this.getCompleteAddress(address);
+    const ivskM = await this.keyStore.getMasterSecretKey(
+      recipientCompleteAddress.publicKeys.masterIncomingViewingPublicKey,
+    );
+    const addressSecret = await computeAddressSecret(await recipientCompleteAddress.getPreaddress(), ivskM);
+    return deriveEcdhSharedSecret(addressSecret, ephPk);
+  }
 }
 
 function toBoundedVec(array: Fr[], maxLength: number) {