@aztec/pxe 0.59.0 → 0.61.0

package/src/note_processor/utils/produce_note_daos.ts

@@ -46,8 +46,6 @@ export async function produceNoteDaos(
   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.');
   }
@@ -78,11 +76,11 @@ export async function produceNoteDaos(
       // 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.note,
+        incomingNote.contractAddress,
+        incomingNote.storageSlot,
+        incomingNote.noteTypeId,
+        incomingNote.txHash,
         incomingNote.nonce,
         incomingNote.noteHash,
         incomingNote.index,

package/src/note_processor/utils/produce_note_daos_for_key.ts

@@ -1,11 +1,11 @@
-import { type L1NotePayload, type TxHash, UnencryptedTxL2Logs } from '@aztec/circuit-types';
-import { Fr, type PublicKey } from '@aztec/circuits.js';
+import { type L1NotePayload, type Note, type TxHash, type UnencryptedTxL2Logs } from '@aztec/circuit-types';
+import { type 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 { getOrderedNoteItems } from './add_public_values_to_payload.js';
 import { type NoteInfo, bruteForceNoteInfo } from './brute_force_note_info.js';
 
 export async function produceNoteDaosForKey<T>(
@@ -19,61 +19,40 @@ export async function produceNoteDaosForKey<T>(
   excludedIndices: Set<number>,
   logger: Logger,
   unencryptedLogs: UnencryptedTxL2Logs,
-  daoConstructor: (payload: L1NotePayload, noteInfo: NoteInfo, dataStartIndexForTx: number, pkM: PublicKey) => T,
+  daoConstructor: (
+    note: Note,
+    payload: L1NotePayload,
+    noteInfo: NoteInfo,
+    dataStartIndexForTx: number,
+    pkM: PublicKey,
+  ) => T,
 ): Promise<[T | undefined, DeferredNoteDao | undefined]> {
   let noteDao: T | undefined;
   let deferredNoteDao: DeferredNoteDao | undefined;
 
   try {
+    // We get the note by merging publicly and privately delivered note values.
+    const note = await getOrderedNoteItems(db, payload);
+
     const noteInfo = await bruteForceNoteInfo(
       simulator,
       noteHashes,
       txHash,
-      payload,
+      payload.contractAddress,
+      payload.storageSlot,
+      payload.noteTypeId,
+      note,
       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);
+    noteDao = daoConstructor(note, 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,
-      );
+      deferredNoteDao = new DeferredNoteDao(pkM, payload, txHash, noteHashes, dataStartIndexForTx, unencryptedLogs);
     } else {
       logger.error(`Could not process note because of "${e}". Discarding note...`);
     }
@@ -81,77 +60,3 @@ export async function produceNoteDaosForKey<T>(
 
   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

@@ -26,7 +26,7 @@ import {
   UnencryptedL2Log,
   UniqueNote,
 } from '@aztec/circuit-types';
-import { FunctionSelector, PrivateCallStackItem, PublicKeys } from '@aztec/circuits.js';
+import { FunctionSelector, PrivateCircuitPublicInputs, PublicKeys } from '@aztec/circuits.js';
 import { NoteSelector } from '@aztec/foundation/abi';
 import { AztecAddress } from '@aztec/foundation/aztec-address';
 import { Buffer32 } from '@aztec/foundation/buffer';
@@ -74,8 +74,8 @@ export function createPXERpcServer(pxeService: PXE): JsonRpcServer {
       NullifierMembershipWitness,
       TxSimulationResult,
       TxProvingResult,
+      PrivateCircuitPublicInputs,
       PrivateExecutionResult,
-      PrivateCallStackItem,
       CountedPublicExecutionRequest,
       CountedNoteLog,
       Tx,

package/src/pxe_service/error_enriching.ts

@@ -0,0 +1,91 @@
+import { type SimulationError, isNoirCallStackUnresolved } from '@aztec/circuit-types';
+import { AztecAddress, Fr, FunctionSelector, PUBLIC_DISPATCH_SELECTOR } from '@aztec/circuits.js';
+import { type DebugLogger } from '@aztec/foundation/log';
+import { resolveAssertionMessage, resolveOpcodeLocations } from '@aztec/simulator';
+
+import { type ContractDataOracle, type PxeDatabase } from '../index.js';
+
+/**
+ * Adds contract and function names to a simulation error, if they
+ * can be found in the PXE database
+ * @param err - The error to enrich.
+ */
+export async function enrichSimulationError(err: SimulationError, db: PxeDatabase, logger: DebugLogger) {
+  // Maps contract addresses to the set of functions selectors that were in error.
+  // Map and Set do reference equality for their keys instead of value equality, so we store the string
+  // representation to get e.g. different contract address objects with the same address value to match.
+  const mentionedFunctions: Map<string, Set<string>> = new Map();
+
+  err.getCallStack().forEach(({ contractAddress, functionSelector }) => {
+    if (!mentionedFunctions.has(contractAddress.toString())) {
+      mentionedFunctions.set(contractAddress.toString(), new Set());
+    }
+    mentionedFunctions.get(contractAddress.toString())!.add(functionSelector.toString());
+  });
+
+  await Promise.all(
+    [...mentionedFunctions.entries()].map(async ([contractAddress, selectors]) => {
+      const parsedContractAddress = AztecAddress.fromString(contractAddress);
+      const contract = await db.getContract(parsedContractAddress);
+      if (contract) {
+        err.enrichWithContractName(parsedContractAddress, contract.name);
+        selectors.forEach(selector => {
+          const functionArtifact = contract.functions.find(f => FunctionSelector.fromString(selector).equals(f));
+          if (functionArtifact) {
+            err.enrichWithFunctionName(
+              parsedContractAddress,
+              FunctionSelector.fromNameAndParameters(functionArtifact),
+              functionArtifact.name,
+            );
+          } else {
+            logger.warn(
+              `Could not function artifact in contract ${contract.name} for selector ${selector} when enriching error callstack`,
+            );
+          }
+        });
+      } else {
+        logger.warn(
+          `Could not find contract in database for address: ${parsedContractAddress} when enriching error callstack`,
+        );
+      }
+    }),
+  );
+}
+
+export async function enrichPublicSimulationError(
+  err: SimulationError,
+  contractDataOracle: ContractDataOracle,
+  db: PxeDatabase,
+  logger: DebugLogger,
+) {
+  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 contractDataOracle.getFunctionDebugMetadata(
+    originalFailingFunction.contractAddress,
+    FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
+  );
+  const noirCallStack = err.getNoirCallStack();
+  if (debugInfo) {
+    if (isNoirCallStackUnresolved(noirCallStack)) {
+      const assertionMessage = resolveAssertionMessage(noirCallStack, debugInfo);
+      if (assertionMessage) {
+        err.setOriginalMessage(err.getOriginalMessage() + `: ${assertionMessage}`);
+      }
+      try {
+        // Public functions are simulated as a single Brillig entry point.
+        // Thus, we can safely assume here that the Brillig function id is `0`.
+        const parsedCallStack = resolveOpcodeLocations(noirCallStack, debugInfo, 0);
+        err.setNoirCallStack(parsedCallStack);
+      } catch (err) {
+        logger.warn(
+          `Could not resolve noir call stack for ${originalFailingFunction.contractAddress.toString()}:${originalFailingFunction.functionSelector.toString()}: ${err}`,
+        );
+      }
+    }
+    await enrichSimulationError(err, db, logger);
+  }
+}

package/src/pxe_service/index.ts

@@ -1,3 +1,4 @@
 export * from './pxe_service.js';
 export * from './create_pxe_service.js';
+export { enrichPublicSimulationError } from './error_enriching.js';
 export { pxeTestSuite } from './test/pxe_test_suite.js';

package/src/pxe_service/pxe_service.ts

@@ -30,19 +30,18 @@ import {
   TxSimulationResult,
   UniqueNote,
   getNonNullifiedL1ToL2MessageWitness,
-  isNoirCallStackUnresolved,
 } from '@aztec/circuit-types';
 import { type NoteProcessorStats } from '@aztec/circuit-types/stats';
 import {
-  AztecAddress,
+  type AztecAddress,
   type CompleteAddress,
   type ContractClassWithId,
   type ContractInstanceWithAddress,
   type L1_TO_L2_MSG_TREE_HEIGHT,
   type NodeInfo,
-  PUBLIC_DISPATCH_SELECTOR,
   type PartialAddress,
   type PrivateKernelTailCircuitPublicInputs,
+  computeAddressSecret,
   computeContractAddressFromInstance,
   computeContractClassId,
   getContractClassFromArtifact,
@@ -64,7 +63,7 @@ import {
   getCanonicalProtocolContract,
   protocolContractNames,
 } from '@aztec/protocol-contracts';
-import { type AcirSimulator, resolveAssertionMessage, resolveOpcodeLocations } from '@aztec/simulator';
+import { type AcirSimulator } from '@aztec/simulator';
 
 import { type PXEServiceConfig, getPackageInfo } from '../config/index.js';
 import { ContractDataOracle } from '../contract_data_oracle/index.js';
@@ -75,6 +74,7 @@ import { KernelProver } from '../kernel_prover/kernel_prover.js';
 import { TestPrivateKernelProver } from '../kernel_prover/test/test_circuit_prover.js';
 import { getAcirSimulator } from '../simulator/index.js';
 import { Synchronizer } from '../synchronizer/index.js';
+import { enrichPublicSimulationError, enrichSimulationError } from './error_enriching.js';
 
 /**
  * A Private eXecution Environment (PXE) implementation.
@@ -136,7 +136,7 @@ export class PXEService implements PXE {
       }
 
       count++;
-      await this.synchronizer.addAccount(address, this.keyStore, this.config.l2StartingBlock);
+      this.synchronizer.addAccount(address, this.keyStore, this.config.l2StartingBlock);
     }
 
     if (count > 0) {
@@ -195,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, this.keyStore, this.config.l2StartingBlock);
+      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()}`);
     }
@@ -720,7 +720,7 @@ export class PXEService implements PXE {
       return result;
     } catch (err) {
       if (err instanceof SimulationError) {
-        await this.#enrichSimulationError(err);
+        await enrichSimulationError(err, this.db, this.log);
       }
       throw err;
     }
@@ -746,7 +746,7 @@ export class PXEService implements PXE {
       return result;
     } catch (err) {
       if (err instanceof SimulationError) {
-        await this.#enrichSimulationError(err);
+        await enrichSimulationError(err, this.db, this.log);
       }
       throw err;
     }
@@ -764,36 +764,7 @@ export class PXEService implements PXE {
     } catch (err) {
       // Try to fill in the noir call stack since the PXE may have access to the debug metadata
       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,
-          FunctionSelector.fromField(new Fr(PUBLIC_DISPATCH_SELECTOR)),
-        );
-        const noirCallStack = err.getNoirCallStack();
-        if (debugInfo) {
-          if (isNoirCallStackUnresolved(noirCallStack)) {
-            const assertionMessage = resolveAssertionMessage(noirCallStack, debugInfo);
-            if (assertionMessage) {
-              err.setOriginalMessage(err.getOriginalMessage() + `: ${assertionMessage}`);
-            }
-            try {
-              // Public functions are simulated as a single Brillig entry point.
-              // Thus, we can safely assume here that the Brillig function id is `0`.
-              const parsedCallStack = resolveOpcodeLocations(noirCallStack, debugInfo, 0);
-              err.setNoirCallStack(parsedCallStack);
-            } catch (err) {
-              this.log.warn(
-                `Could not resolve noir call stack for ${originalFailingFunction.contractAddress.toString()}:${originalFailingFunction.functionSelector.toString()}: ${err}`,
-              );
-            }
-          }
-          await this.#enrichSimulationError(err);
-        }
+        await enrichPublicSimulationError(err, this.contractDataOracle, this.db, this.log);
       }
 
       throw err;
@@ -821,51 +792,13 @@ export class PXEService implements PXE {
     privateExecutionResult: PrivateExecutionResult,
   ): Promise<PrivateKernelSimulateOutput<PrivateKernelTailCircuitPublicInputs>> {
     // use the block the tx was simulated against
-    const block =
-      privateExecutionResult.callStackItem.publicInputs.historicalHeader.globalVariables.blockNumber.toNumber();
+    const block = privateExecutionResult.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...`);
     return await kernelProver.prove(txExecutionRequest.toTxRequest(), privateExecutionResult);
   }
 
-  /**
-   * Adds contract and function names to a simulation error.
-   * @param err - The error to enrich.
-   */
-  async #enrichSimulationError(err: SimulationError) {
-    // Maps contract addresses to the set of functions selectors that were in error.
-    // Using strings because map and set don't use .equals()
-    const mentionedFunctions: Map<string, Set<string>> = new Map();
-
-    err.getCallStack().forEach(({ contractAddress, functionSelector }) => {
-      if (!mentionedFunctions.has(contractAddress.toString())) {
-        mentionedFunctions.set(contractAddress.toString(), new Set());
-      }
-      mentionedFunctions.get(contractAddress.toString())!.add(functionSelector.toString());
-    });
-
-    await Promise.all(
-      [...mentionedFunctions.entries()].map(async ([contractAddress, selectors]) => {
-        const parsedContractAddress = AztecAddress.fromString(contractAddress);
-        const contract = await this.db.getContract(parsedContractAddress);
-        if (contract) {
-          err.enrichWithContractName(parsedContractAddress, contract.name);
-          selectors.forEach(selector => {
-            const functionArtifact = contract.functions.find(f => FunctionSelector.fromString(selector).equals(f));
-            if (functionArtifact) {
-              err.enrichWithFunctionName(
-                parsedContractAddress,
-                FunctionSelector.fromNameAndParameters(functionArtifact),
-                functionArtifact.name,
-              );
-            }
-          });
-        }
-      }),
-    );
-  }
-
   public async isGlobalStateSynchronized() {
     return await this.synchronizer.isGlobalStateSynchronized();
   }
@@ -926,6 +859,7 @@ export class PXEService implements PXE {
     from: number,
     limit: number,
     eventMetadata: EventMetadata<T>,
+    // TODO (#9272): Make this better, we should be able to only pass an address now
     vpks: Point[],
   ): Promise<T[]> {
     if (vpks.length === 0) {
@@ -939,7 +873,24 @@ export class PXEService implements PXE {
 
     const encryptedLogs = encryptedTxLogs.flatMap(encryptedTxLog => encryptedTxLog.unrollLogs());
 
-    const vsks = await Promise.all(vpks.map(vpk => this.keyStore.getMasterSecretKey(vpk)));
+    const vsks = await Promise.all(
+      vpks.map(async vpk => {
+        const [keyPrefix, account] = this.keyStore.getKeyPrefixAndAccount(vpk);
+        let secretKey = await this.keyStore.getMasterSecretKey(vpk);
+        if (keyPrefix === 'iv') {
+          const registeredAccount = await this.getRegisteredAccount(account);
+          if (!registeredAccount) {
+            throw new Error('No registered account');
+          }
+
+          const preaddress = registeredAccount.getPreaddress();
+
+          secretKey = computeAddressSecret(preaddress, secretKey);
+        }
+
+        return secretKey;
+      }),
+    );
 
     const visibleEvents = encryptedLogs.flatMap(encryptedLog => {
       for (const sk of vsks) {

package/src/simulator_oracle/index.ts

@@ -14,10 +14,13 @@ import {
   type Fr,
   type FunctionSelector,
   type Header,
+  IndexedTaggingSecret,
   type KeyValidationRequest,
   type L1_TO_L2_MSG_TREE_HEIGHT,
+  computeTaggingSecret,
 } from '@aztec/circuits.js';
 import { type FunctionArtifact, getFunctionArtifact } from '@aztec/foundation/abi';
+import { poseidon2Hash } from '@aztec/foundation/crypto';
 import { createDebugLogger } from '@aztec/foundation/log';
 import { type KeyStore } from '@aztec/key-store';
 import { type DBOracle, MessageLoadOracleInputs } from '@aztec/simulator';
@@ -226,4 +229,52 @@ export class SimulatorOracle implements DBOracle {
   public getDebugFunctionName(contractAddress: AztecAddress, selector: FunctionSelector): Promise<string> {
     return this.contractDataOracle.getDebugFunctionName(contractAddress, selector);
   }
+
+  /**
+   * Returns the tagging secret for a given sender and recipient pair. For this to work, the ivpsk_m of the sender must be known.
+   * Includes the last known index used for tagging with this secret.
+   * @param contractAddress - The contract address to silo the secret for
+   * @param sender - The address sending the note
+   * @param recipient - The address receiving the note
+   * @returns A siloed tagging secret that can be used to tag notes.
+   */
+  public async getAppTaggingSecret(
+    contractAddress: AztecAddress,
+    sender: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<IndexedTaggingSecret> {
+    const senderCompleteAddress = await this.getCompleteAddress(sender);
+    const senderIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(sender);
+    const sharedSecret = computeTaggingSecret(senderCompleteAddress, senderIvsk, recipient);
+    // Silo the secret to the app so it can't be used to track other app's notes
+    const secret = poseidon2Hash([sharedSecret.x, sharedSecret.y, contractAddress]);
+    const [index] = await this.db.getTaggingSecretsIndexes([secret]);
+    return new IndexedTaggingSecret(secret, index);
+  }
+
+  /**
+   * Returns the siloed tagging secrets for a given recipient and all the senders in the address book
+   * @param contractAddress - The contract address to silo the secret for
+   * @param recipient - The address receiving the notes
+   * @returns A list of siloed tagging secrets
+   */
+  public async getAppTaggingSecretsForSenders(
+    contractAddress: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<IndexedTaggingSecret[]> {
+    const recipientCompleteAddress = await this.getCompleteAddress(recipient);
+    const completeAddresses = await this.db.getCompleteAddresses();
+    // Filter out the addresses corresponding to accounts
+    const accounts = await this.keyStore.getAccounts();
+    const senders = completeAddresses.filter(
+      completeAddress => !accounts.find(account => account.equals(completeAddress.address)),
+    );
+    const recipientIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(recipient);
+    const secrets = senders.map(({ address: sender }) => {
+      const sharedSecret = computeTaggingSecret(recipientCompleteAddress, recipientIvsk, sender);
+      return poseidon2Hash([sharedSecret.x, sharedSecret.y, contractAddress]);
+    });
+    const indexes = await this.db.getTaggingSecretsIndexes(secrets);
+    return secrets.map((secret, i) => new IndexedTaggingSecret(secret, indexes[i]));
+  }
 }

package/src/synchronizer/synchronizer.ts

@@ -249,14 +249,14 @@ export class Synchronizer {
    * @param startingBlock - The block where to start scanning for notes for this accounts.
    * @returns A promise that resolves once the account is added to the Synchronizer.
    */
-  public async addAccount(account: CompleteAddress, keyStore: KeyStore, startingBlock: number) {
+  public addAccount(account: CompleteAddress, keyStore: KeyStore, startingBlock: number) {
     const predicate = (x: NoteProcessor) => x.account.equals(account);
     const processor = this.noteProcessors.find(predicate) ?? this.noteProcessorsToCatchUp.find(predicate);
     if (processor) {
       return;
     }
 
-    this.noteProcessorsToCatchUp.push(await NoteProcessor.create(account, keyStore, this.db, this.node, startingBlock));
+    this.noteProcessorsToCatchUp.push(NoteProcessor.create(account, keyStore, this.db, this.node, startingBlock));
   }
 
   /**

package/dest/note_processor/utils/add_nullable_field_to_payload.d.ts

@@ -1,12 +0,0 @@
-import { L1NotePayload } from '@aztec/circuit-types';
-import { type Fr } from '@aztec/foundation/fields';
-import { type PxeDatabase } from '../../database/pxe_database.js';
-/**
- * Inserts publicly delivered nullable fields into the note payload.
- * @param db - PXE database used to fetch contract instance and artifact.
- * @param payload - Note payload to which nullable fields should be added.
- * @param nullableFields - List of nullable fields to be added to the note payload.
- * @returns Note payload with nullable fields added.
- */
-export declare function addNullableFieldsToPayload(db: PxeDatabase, payload: L1NotePayload, nullableFields: Fr[]): Promise<L1NotePayload>;
-//# sourceMappingURL=add_nullable_field_to_payload.d.ts.map

package/dest/note_processor/utils/add_nullable_field_to_payload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"add_nullable_field_to_payload.d.ts","sourceRoot":"","sources":["../../../src/note_processor/utils/add_nullable_field_to_payload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAQ,MAAM,sBAAsB,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAGnD,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,gCAAgC,CAAC;AAElE;;;;;;GAMG;AACH,wBAAsB,0BAA0B,CAC9C,EAAE,EAAE,WAAW,EACf,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,EAAE,EAAE,GACnB,OAAO,CAAC,aAAa,CAAC,CAiDxB"}

package/dest/note_processor/utils/add_nullable_field_to_payload.js

@@ -1,46 +0,0 @@
-import { L1NotePayload, Note } from '@aztec/circuit-types';
-import { ContractNotFoundError } from '@aztec/simulator';
-/**
- * Inserts publicly delivered nullable fields into the note payload.
- * @param db - PXE database used to fetch contract instance and artifact.
- * @param payload - Note payload to which nullable fields should be added.
- * @param nullableFields - List of nullable fields to be added to the note payload.
- * @returns Note payload with nullable fields added.
- */
-export async function addNullableFieldsToPayload(db, payload, nullableFields) {
-    const instance = await db.getContractInstance(payload.contractAddress);
-    if (!instance) {
-        throw new ContractNotFoundError(`Could not find instance for ${payload.contractAddress.toString()}. This should never happen here as the partial notes flow should be triggered only for non-deferred notes.`);
-    }
-    const artifact = await db.getContractArtifact(instance.contractClassId);
-    if (!artifact) {
-        throw new Error(`Could not find artifact for contract class ${instance.contractClassId.toString()}. This should never happen here as the partial notes flow should be triggered only for non-deferred notes.`);
-    }
-    const noteFields = Object.values(artifact.notes).find(note => note.id.equals(payload.noteTypeId))?.fields;
-    if (!noteFields) {
-        throw new Error(`Could not find note fields for note type ${payload.noteTypeId.toString()}.`);
-    }
-    // We sort note fields by index so that we can iterate over them in order.
-    noteFields.sort((a, b) => a.index - b.index);
-    // Now we insert the nullable fields into the note based on its indices defined in the ABI.
-    const modifiedNoteItems = [...payload.note.items];
-    let indexInNullable = 0;
-    for (let i = 0; i < noteFields.length; i++) {
-        const noteField = noteFields[i];
-        if (noteField.nullable) {
-            if (i == noteFields.length - 1) {
-                // We are processing the last field so we simply insert the rest of the nullable fields at the end
-                modifiedNoteItems.push(...nullableFields.slice(indexInNullable));
-            }
-            else {
-                const noteFieldLength = noteFields[i + 1].index - noteField.index;
-                const nullableFieldsToInsert = nullableFields.slice(indexInNullable, indexInNullable + noteFieldLength);
-                indexInNullable += noteFieldLength;
-                // Now we insert the nullable fields at the note field index
-                modifiedNoteItems.splice(noteField.index, 0, ...nullableFieldsToInsert);
-            }
-        }
-    }
-    return new L1NotePayload(new Note(modifiedNoteItems), payload.contractAddress, payload.storageSlot, payload.noteTypeId);
-}
-//# sourceMappingURL=data:application/json;base64,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