@aztec/pxe 0.0.1-commit.993d240 → 0.0.1-commit.9a89641

package/src/events/event_service.ts

@@ -1,8 +1,10 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
 import { createLogger } from '@aztec/foundation/log';
 import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { InBlock } from '@aztec/stdlib/block';
 import { computePrivateEventCommitment, siloNullifier } from '@aztec/stdlib/hash';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import type { BlockHeader, IndexedTxEffect } from '@aztec/stdlib/tx';
+import type { BlockHeader } from '@aztec/stdlib/tx';
 
 import type { EventValidationRequest } from '../contract_function_simulator/noir-structs/event_validation_request.js';
 import { PrivateEventStore } from '../storage/private_event_store/private_event_store.js';
@@ -17,17 +19,17 @@ export class EventService {
   ) {}
 
   /**
-   * Validates and stores a batch of private events against pre-fetched tx effects.
+   * Validates and stores a batch of private events against the pre-fetched onchain context of their txs.
    *
    * @param requests - The events to validate and store.
    * @param scope - The scope under which the events are being stored.
-   * @param txEffects - Pre-fetched tx effects keyed by `TxHash.toString()`. Must contain entries for every request's
-   *                   txHash; missing entries are treated as a node bug and cause an error.
+   * @param validationTxData - The onchain context of each request's tx, keyed by `TxHash.toString()`. Must contain
+   * entries for every request's txHash; missing entries are treated as a node bug and cause an error.
    */
   public async validateAndStoreEvents(
     requests: EventValidationRequest[],
     scope: AztecAddress,
-    txEffects: Map<string, IndexedTxEffect>,
+    validationTxData: ReadonlyMap<string, EventValidationTxData>,
   ): Promise<void> {
     if (requests.length === 0) {
       return;
@@ -35,13 +37,15 @@ export class EventService {
 
     const anchorBlockNumber = this.anchorBlockHeader.getBlockNumber();
 
-    await Promise.all(requests.map(req => this.#validateAndStoreEvent(req, scope, txEffects, anchorBlockNumber)));
+    await Promise.all(
+      requests.map(req => this.#validateAndStoreEvent(req, scope, validationTxData, anchorBlockNumber)),
+    );
   }
 
   async #validateAndStoreEvent(
     request: EventValidationRequest,
     scope: AztecAddress,
-    txEffects: Map<string, IndexedTxEffect>,
+    validationTxData: ReadonlyMap<string, EventValidationTxData>,
     anchorBlockNumber: number,
   ): Promise<void> {
     const {
@@ -71,15 +75,15 @@ export class EventService {
     // since `fetchTaggedLogs` only processes logs up to the synced block.
     const siloedEventCommitment = await siloNullifier(contractAddress, eventCommitment);
 
-    const txEffect = txEffects.get(txHash.toString());
-    if (!txEffect) {
+    const txData = validationTxData.get(txHash.toString());
+    if (!txData) {
       // We error out instead of just logging a warning and skipping the event because this would indicate a bug. This
       // is because the node has already served info about this tx either when obtaining the log (LogResult carries
       // the tx info) or when getting metadata for the offchain message (before the message got passed to `process_log`).
       throw new Error(`Could not find tx effect for tx hash ${txHash} when processing an event.`);
     }
 
-    if (txEffect.l2BlockNumber > anchorBlockNumber) {
+    if (txData.l2BlockNumber > anchorBlockNumber) {
       // We should never process a message from a tx past the anchor block. If we got here, a preprocessing step made
       // a mistake.
       throw new Error(
@@ -88,7 +92,7 @@ export class EventService {
     }
 
     // Find the index of the event commitment in the nullifiers array to determine event ordering within the tx
-    const eventIndexInTx = txEffect.data.nullifiers.findIndex(n => n.equals(siloedEventCommitment));
+    const eventIndexInTx = txData.nullifiers.findIndex(n => n.equals(siloedEventCommitment));
     if (eventIndexInTx === -1) {
       // Unlike in NoteService, this might not be a bug since the commitment hasn't been verified yet in the message
       // processing pipeline. A malformed or malicious message could trigger this condition. Because of this we don't
@@ -108,12 +112,18 @@ export class EventService {
         contractAddress,
         scope,
         txHash,
-        l2BlockNumber: txEffect.l2BlockNumber,
-        l2BlockHash: txEffect.l2BlockHash,
-        txIndexInBlock: txEffect.txIndexInBlock,
+        l2BlockNumber: txData.l2BlockNumber,
+        l2BlockHash: txData.l2BlockHash,
+        txIndexInBlock: txData.txIndexInBlock,
         eventIndexInTx,
       },
       this.jobId,
     );
   }
 }
+
+/** The onchain context of the tx an event validation request points at: where it was mined and its nullifiers. */
+export type EventValidationTxData = InBlock & {
+  nullifiers: Fr[];
+  txIndexInBlock: number;
+};

package/src/hooks/execution_hooks.ts

@@ -1,16 +1,18 @@
 import type { AuthorizeUtilityCall } from './authorize_utility_call.js';
+import type { ResolveCustomRequest } from './resolve_custom_request.js';
+import type { ResolveTaggingSecretStrategy } from './resolve_tagging_secret_strategy.js';
 
 /**
- * Hooks that PXE invokes during client-side simulation to gate operations that the protocol
+ * Hooks that PXE invokes during client-side simulation to gate or steer operations that the protocol
  * does not restrict on its own. They give the wallet a chance to apply custom policies (e.g.
  * prompting the user, consulting a dynamic allowlist, or inspecting call arguments) before the
- * execution proceeds.
+ * execution proceeds. All hooks are optional, and when a hook is absent PXE applies a safe default.
  *
- * For example, {@link authorizeUtilityCall} is called whenever a utility function makes a
- * cross-contract call. A call made by a malicious contract could leak private information, so the
- * hook lets the wallet decide, per-call, whether to allow it. A static allowlist would not work
- * here because neither the app nor the wallet can predict ahead of time which contracts will be
- * invoked during execution.
+ * For example, {@link authorizeUtilityCall} is called whenever a utility function makes a cross-contract call. A call
+ * made by a malicious contract could leak private information, so the hook lets the wallet decide, per-call, whether
+ * to allow it. A static allowlist would not work here because neither the app nor the wallet can predict ahead of
+ * time which contracts will be invoked during execution. Calls to standard contracts (such as the HandshakeRegistry)
+ * bypass this hook and are always authorized. When the hook is absent, cross-contract utility calls are denied.
  *
  * Note: hooks are unrelated to authentication witnesses (authwits). Authwits are an on-chain
  * mechanism where a contract verifies that a caller was authorized by a specific account; hooks
@@ -27,22 +29,40 @@ import type { AuthorizeUtilityCall } from './authorize_utility_call.js';
  *         ? { authorized: true }
  *         : { authorized: false, reason: 'Unknown target' };
  *     },
+ *     // Apply per-recipient policy: reach a known contact via their address keys (no onchain trace) and use a
+ *     // non-interactive handshake for everyone else.
+ *     resolveTaggingSecretStrategy: async ({ recipient }) =>
+ *       knownContacts.has(recipient.toString())
+ *         ? { type: 'address-derived' }
+ *         : { type: 'non-interactive-handshake' },
  *   },
  * });
  * ```
  */
 export interface ExecutionHooks {
-  /** Called when a contract attempts a cross-contract utility call. */
-  authorizeUtilityCall: AuthorizeUtilityCall;
+  /** Called when a contract attempts a cross-contract utility call. Calls are denied when absent. */
+  authorizeUtilityCall?: AuthorizeUtilityCall;
+  /**
+   * Resolves a message's tagging secret when none is already established for the sender/recipient pair, letting the
+   * wallet apply per-recipient policy. PXE applies a default when absent.
+   * See {@link ResolveTaggingSecretStrategy} for the request shape and defaults.
+   */
+  resolveTaggingSecretStrategy?: ResolveTaggingSecretStrategy;
+  /**
+   * Resolves a custom, caller-defined request a circuit cannot serve from local state. Any contract can issue one, so
+   * an implementor should verify both the request `kind` and the issuing contract (its address and class ID) before
+   * fulfilling it. Rejected when absent; see {@link ResolveCustomRequest}.
+   */
+  resolveCustomRequest?: ResolveCustomRequest;
 }
 
 /**
  * Builds an {@link ExecutionHooks} from individually-constructed hook callbacks. Returns `undefined`
  * when every field is absent, so callers can unconditionally pass the result as `hooks`.
  */
-export function composeHooks(partial: Partial<ExecutionHooks>): ExecutionHooks | undefined {
-  if (Object.values(partial).every(v => v === undefined)) {
+export function composeHooks(hooks: ExecutionHooks): ExecutionHooks | undefined {
+  if (Object.values(hooks).every(v => v === undefined)) {
     return undefined;
   }
-  return partial as ExecutionHooks;
+  return hooks;
 }

package/src/hooks/index.ts

@@ -3,5 +3,11 @@ export type {
   UtilityCallAuthorizationRequest,
   UtilityCallAuthorizationResponse,
 } from './authorize_utility_call.js';
-export type { ExecutionHooks } from './execution_hooks.js';
-export { composeHooks } from './execution_hooks.js';
+export { type ExecutionHooks, composeHooks } from './execution_hooks.js';
+export { type CustomRequest, type ResolveCustomRequest } from './resolve_custom_request.js';
+export {
+  DEFAULT_TAGGING_SECRET_STRATEGY,
+  type ResolveTaggingSecretStrategy,
+  type TaggingSecretStrategy,
+  type TaggingSecretStrategyRequest,
+} from './resolve_tagging_secret_strategy.js';

package/src/hooks/resolve_custom_request.ts

@@ -0,0 +1,24 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+
+/**
+ * A custom, caller-defined request resolved via the {@link ResolveCustomRequest} hook. It carries no fixed meaning:
+ * `kind` selects the request type so one hook can serve many such types, and `payload` holds the opaque,
+ * request-specific arguments. The resolver answers by whatever means it needs (local state, a third party,
+ * offchain data).
+ */
+export type CustomRequest = {
+  /** The address of the contract issuing the request. */
+  contractAddress: AztecAddress;
+  /** The issuing contract's class ID, so resolvers can apply class-level (not just per-address) policy. */
+  contractClassId: Fr;
+  /** Discriminates the request type, letting one hook serve many such types. */
+  kind: Fr;
+  /** Opaque, request-specific arguments. */
+  payload: Fr[];
+};
+
+/**
+ * Hook resolving a {@link CustomRequest}. The resolver produces the response however it needs to.
+ */
+export type ResolveCustomRequest = (request: CustomRequest) => Promise<Fr[]>;

package/src/hooks/resolve_tagging_secret_strategy.ts

@@ -0,0 +1,60 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { Point } from '@aztec/foundation/curves/grumpkin';
+import type { AztecAddress } from '@aztec/stdlib/aztec-address';
+import type { AppTaggingSecretKind } from '@aztec/stdlib/logs';
+
+// eslint-disable-next-line @typescript-eslint/no-unused-vars -- only referenced by a {@link} doc tag
+import type { ResolveCustomRequest } from './resolve_custom_request.js';
+
+/**
+ * How a message's tagging secret is chosen: the wallet's strategy, returned by the `resolveTaggingSecretStrategy` hook
+ * when no onchain handshake has been registered for the sender/recipient pair. This is intent (plus, for an arbitrary
+ * secret, the raw material); PXE resolves it into the secret it hands the contract.
+ */
+export type TaggingSecretStrategy =
+  | {
+      /** Establish a fresh non-interactive handshake via the onchain registry; reveals the recipient onchain. */
+      type: 'non-interactive-handshake';
+    }
+  | {
+      /**
+       * Establish a fresh interactive handshake via the onchain registry. Reveals nothing about the recipient
+       * onchain, but requires the recipient to answer the registry's signed-authorization request (served through
+       * the {@link ResolveCustomRequest} hook), so the send fails when it cannot be served.
+       */
+      type: 'interactive-handshake';
+    }
+  | {
+      /** Derive the secret from the sender's and recipient's address keys via ECDH. PXE computes and silos it. */
+      type: 'address-derived';
+    }
+  | {
+      /**
+       * A raw shared secret point the two parties already share offchain (e.g. coordinated out-of-band), supplied by
+       * the wallet. PXE app-silos it before use. Only sound for unconstrained delivery, since nothing onchain proves
+       * the recipient knows it.
+       */
+      type: 'arbitrary-secret';
+      /** The raw (un-siloed) shared secret point to derive the tag from. */
+      secret: Point;
+    };
+
+/** The strategy PXE applies to both delivery modes when no `resolveTaggingSecretStrategy` hook is configured. */
+export const DEFAULT_TAGGING_SECRET_STRATEGY: TaggingSecretStrategy = { type: 'non-interactive-handshake' };
+
+/** Information about the message delivery requesting a tagging secret strategy. */
+export type TaggingSecretStrategyRequest = {
+  contractAddress: AztecAddress;
+  /**
+   * The contract class ID of the executing contract, so wallets can apply class-level (not just per-address) policy.
+   */
+  contractClassId: Fr;
+  sender: AztecAddress;
+  recipient: AztecAddress;
+  deliveryMode: AppTaggingSecretKind;
+};
+
+/**
+ * Hook returning the {@link TaggingSecretStrategy} for an outgoing message.
+ */
+export type ResolveTaggingSecretStrategy = (request: TaggingSecretStrategyRequest) => Promise<TaggingSecretStrategy>;

package/src/logs/log_service.ts

@@ -1,23 +1,36 @@
 import type { BlockNumber } from '@aztec/foundation/branded-types';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';
 import { type Logger, type LoggerBindings, createLogger } from '@aztec/foundation/log';
 import type { KeyStore } from '@aztec/key-store';
 import { AztecAddress } from '@aztec/stdlib/aztec-address';
-import type { BlockHash, L2TipsProvider } from '@aztec/stdlib/block';
+import type { L2TipsProvider } from '@aztec/stdlib/block';
+import type { CompleteAddress } from '@aztec/stdlib/contract';
 import type { AztecNode } from '@aztec/stdlib/interfaces/server';
-import { AppTaggingSecret, type LogResult, PendingTaggedLog, SiloedTag } from '@aztec/stdlib/logs';
+import {
+  AppTaggingSecret,
+  AppTaggingSecretKind,
+  type LogResult,
+  SiloedTag,
+  computeSharedTaggingSecret,
+} from '@aztec/stdlib/logs';
 import type { BlockHeader } from '@aztec/stdlib/tx';
+import type { UInt64 } from '@aztec/stdlib/types';
 
 import {
   type LogRetrievalRequest,
   LogSource,
 } from '../contract_function_simulator/noir-structs/log_retrieval_request.js';
-import { LogRetrievalResponse } from '../contract_function_simulator/noir-structs/log_retrieval_response.js';
+import type { TxOnchainContext } from '../messages/tx_resolver_service.js';
 import { AddressStore } from '../storage/address_store/address_store.js';
+import { assertAllowedScope } from '../storage/allowed_scopes.js';
 import type { RecipientTaggingStore } from '../storage/tagging_store/recipient_tagging_store.js';
-import type { SenderAddressBookStore } from '../storage/tagging_store/sender_address_book_store.js';
+import type { TaggingSecretSourcesStore } from '../storage/tagging_store/tagging_secret_sources_store.js';
 import {
+  type LogQueryAnchor,
   getAllPrivateLogsByTags,
   getAllPublicLogsByTagsFromContract,
+  logQueryAnchorOf,
   syncTaggedPrivateLogs,
 } from '../tagging/index.js';
 
@@ -34,8 +47,9 @@ export class LogService {
     private readonly l2TipsStore: L2TipsProvider,
     private readonly keyStore: KeyStore,
     private readonly recipientTaggingStore: RecipientTaggingStore,
-    private readonly senderAddressBookStore: SenderAddressBookStore,
+    private readonly taggingSecretSourcesStore: TaggingSecretSourcesStore,
     private readonly addressStore: AddressStore,
+    private readonly scopes: AztecAddress[],
     private readonly jobId: string,
     bindings?: LoggerBindings,
   ) {
@@ -46,7 +60,7 @@ export class LogService {
   public async fetchLogsByTag(
     contractAddress: AztecAddress,
     logRetrievalRequests: LogRetrievalRequest[],
-  ): Promise<LogRetrievalResponse[][]> {
+  ): Promise<RetrievedTaggedLog[][]> {
     for (const request of logRetrievalRequests) {
       if (!contractAddress.equals(request.contractAddress)) {
         throw new Error(`Got a log retrieval request from ${request.contractAddress}, expected ${contractAddress}`);
@@ -57,23 +71,23 @@ export class LogService {
       return [];
     }
 
-    const anchorBlockHash = await this.anchorBlockHeader.hash();
+    const anchor = await logQueryAnchorOf(this.anchorBlockHeader);
 
     const [publicLogsPerRequest, privateLogsPerRequest] = await Promise.all([
-      this.#fetchPublicLogs(contractAddress, logRetrievalRequests, anchorBlockHash),
-      this.#fetchPrivateLogs(logRetrievalRequests, anchorBlockHash),
+      this.#fetchPublicLogs(contractAddress, logRetrievalRequests, anchor),
+      this.#fetchPrivateLogs(logRetrievalRequests, anchor),
     ]);
 
     return logRetrievalRequests.map((_request, i) => [
-      ...publicLogsPerRequest[i].map(LogService.#toLogRetrievalResponse),
-      ...privateLogsPerRequest[i].map(LogService.#toLogRetrievalResponse),
+      ...publicLogsPerRequest[i].map(LogService.#toRetrievedTaggedLog),
+      ...privateLogsPerRequest[i].map(LogService.#toRetrievedTaggedLog),
     ]);
   }
 
   async #fetchPublicLogs(
     contractAddress: AztecAddress,
     requests: LogRetrievalRequest[],
-    anchorBlockHash: BlockHash,
+    anchor: LogQueryAnchor,
   ): Promise<LogResult[][]> {
     const indices = requests.flatMap((r, i) => (r.source !== LogSource.PRIVATE ? [i] : []));
     if (indices.length === 0) {
@@ -86,13 +100,11 @@ export class LogService {
     await Promise.all(
       Array.from(groups.values()).map(async group => {
         const tags = group.entries.map(e => e.request.tag);
-        const results = await getAllPublicLogsByTagsFromContract(
-          this.aztecNode,
-          contractAddress,
-          tags,
-          anchorBlockHash,
-          { fromBlock: group.fromBlock, toBlock: group.toBlock, includeEffects: true },
-        );
+        const results = await getAllPublicLogsByTagsFromContract(this.aztecNode, contractAddress, tags, anchor, {
+          fromBlock: group.fromBlock,
+          toBlock: group.toBlock,
+          includeEffects: true,
+        });
         group.entries.forEach((entry, i) => {
           resultsPerRequest[entry.index] = results[i];
         });
@@ -102,7 +114,7 @@ export class LogService {
     return resultsPerRequest;
   }
 
-  async #fetchPrivateLogs(requests: LogRetrievalRequest[], anchorBlockHash: BlockHash): Promise<LogResult[][]> {
+  async #fetchPrivateLogs(requests: LogRetrievalRequest[], anchor: LogQueryAnchor): Promise<LogResult[][]> {
     const indices = requests.flatMap((r, i) => (r.source !== LogSource.PUBLIC ? [i] : []));
     if (indices.length === 0) {
       return requests.map(() => []);
@@ -116,7 +128,7 @@ export class LogService {
         const siloedTags = await Promise.all(
           group.entries.map(e => SiloedTag.computeFromTagAndApp(e.request.tag, e.request.contractAddress)),
         );
-        const results = await getAllPrivateLogsByTags(this.aztecNode, siloedTags, anchorBlockHash, {
+        const results = await getAllPrivateLogsByTags(this.aztecNode, siloedTags, anchor, {
           fromBlock: group.fromBlock,
           toBlock: group.toBlock,
           includeEffects: true,
@@ -139,18 +151,20 @@ export class LogService {
   ): Map<RangeKey, { fromBlock?: BlockNumber; toBlock?: BlockNumber; entries: typeof entries }> {
     const groups = new Map<RangeKey, { fromBlock?: BlockNumber; toBlock?: BlockNumber; entries: typeof entries }>();
     for (const entry of entries) {
-      const key = rangeKey(entry.request.fromBlock, entry.request.toBlock);
+      const fromBlock = entry.request.fromBlock.value;
+      const toBlock = entry.request.toBlock.value;
+      const key = rangeKey(fromBlock, toBlock);
       const existing = groups.get(key);
       if (existing) {
         existing.entries.push(entry);
       } else {
-        groups.set(key, { fromBlock: entry.request.fromBlock, toBlock: entry.request.toBlock, entries: [entry] });
+        groups.set(key, { fromBlock, toBlock, entries: [entry] });
       }
     }
     return groups;
   }
 
-  static #toLogRetrievalResponse(log: LogResult): LogRetrievalResponse {
+  static #toRetrievedTaggedLog(log: LogResult): RetrievedTaggedLog {
     // includeEffects: true was used, so noteHashes and nullifiers are populated. Every tx has at least one nullifier
     // (the first nullifier derived from the tx hash); empty here would indicate a buggy node.
     const noteHashes = log.noteHashes!;
@@ -158,20 +172,42 @@ export class LogService {
     if (nullifiers.length === 0) {
       throw new Error(`Log for tx ${log.txHash} returned no nullifiers from the node`);
     }
-    return new LogRetrievalResponse(
-      log.logData.slice(1), // Skip the tag
-      log.txHash,
+    return {
+      logData: log.logData,
+      txHash: log.txHash,
       noteHashes,
-      nullifiers[0],
-    );
+      nullifiers,
+      blockNumber: log.blockNumber,
+      blockTimestamp: log.blockTimestamp,
+      blockHash: log.blockHash,
+      // The log index and the tx receipt both count the tx's position in `block.body.txEffects`, so this is the same
+      // index a receipt reports. Note ordering depends on the two staying in agreement.
+      txIndexInBlock: log.txIndexWithinBlock,
+    };
   }
 
-  public async fetchTaggedLogs(contractAddress: AztecAddress, recipient: AztecAddress): Promise<PendingTaggedLog[]> {
-    this.log.verbose(`Fetching tagged logs for ${contractAddress.toString()}`);
+  /** Fetches the pending tagged logs for a recipient across all its tagging secrets for the contract. */
+  public async fetchTaggedLogs(
+    contractAddress: AztecAddress,
+    recipient: AztecAddress,
+    providedSecrets: AppTaggingSecret[],
+  ): Promise<RetrievedTaggedLog[]> {
+    assertAllowedScope(recipient, this.scopes);
+
+    this.log.verbose(
+      `Fetching tagged logs for contract ${contractAddress.toString()} and recipient ${recipient.toString()}`,
+    );
 
     const l2Tips = await this.l2TipsStore.getL2Tips();
-    // Get all secrets for this recipient (one per sender)
-    const secrets = await this.#getSecretsForSenders(contractAddress, recipient);
+
+    // Secrets PXE can enumerate for this recipient (senders via ECDH + pre-shared store secrets), plus any the app
+    // supplies explicitly for secrets PXE cannot enumerate itself (e.g. handshake-derived ones). The latter arrive
+    // already computed and are searched even when the recipient's account is unknown locally, since they need no ECDH.
+    const combinedSecrets = [...(await this.#getPointDerivedSecrets(contractAddress, recipient)), ...providedSecrets];
+
+    // These sources can overlap (a sender that is also a PXE account, or a pre-shared secret that coincides with a
+    // sender-derived one), so we deduplicate the combined set.
+    const secrets = Array.from(new Map(combinedSecrets.map(secret => [secret.toString(), secret])).values());
 
     const logs = await syncTaggedPrivateLogs(
       secrets,
@@ -182,51 +218,76 @@ export class LogService {
       this.jobId,
     );
 
-    return logs.map(log => {
-      const noteHashes = log.noteHashes!;
-      const nullifiers = log.nullifiers!;
-      if (nullifiers.length === 0) {
-        throw new Error(`Log for tx ${log.txHash} returned no nullifiers from the node`);
-      }
-      return new PendingTaggedLog(log.logData, log.txHash, noteHashes, nullifiers[0]);
-    });
+    return logs.map(log => LogService.#toRetrievedTaggedLog(log));
   }
 
-  async #getSecretsForSenders(contractAddress: AztecAddress, recipient: AztecAddress): Promise<AppTaggingSecret[]> {
+  /**
+   * Computes the tagging secrets PXE can enumerate for a recipient: one per known sender (via ECDH) plus any
+   * pre-shared secrets registered directly for the recipient. Each registered secret is scanned under the tag
+   * streams its kind can back. Deriving the sender-based secrets requires the recipient's address preimage and keys,
+   * so returns an empty array when those are unavailable. App-supplied secrets (e.g. derived from discovered
+   * handshakes) are handled separately by the caller and do not go through here.
+   */
+  async #getPointDerivedSecrets(contractAddress: AztecAddress, recipient: AztecAddress): Promise<AppTaggingSecret[]> {
     const recipientCompleteAddress = await this.addressStore.getCompleteAddress(recipient);
-    if (!recipientCompleteAddress) {
+    if (!recipientCompleteAddress || !(await this.keyStore.hasAccount(recipient))) {
+      this.log.warn(
+        `Skipping sender-derived tag retrieval for ${recipient.toString()} due to unknown address preimage`,
+      );
       return [];
     }
     const recipientIvsk = await this.keyStore.getMasterIncomingViewingSecretKey(recipient);
 
-    // We implicitly add all PXE accounts as senders, this helps us find tagged logs with messages that are sent to a
-    // local account (recipient = us, sender = us)
-    const allSenders = [...(await this.senderAddressBookStore.getSenders()), ...(await this.keyStore.getAccounts())];
+    const [senderPoints, registeredSecrets] = await Promise.all([
+      this.#getSecretsForSenders(recipientCompleteAddress, recipientIvsk),
+      this.taggingSecretSourcesStore.getSharedSecretsForRecipient(recipient),
+    ]);
+    return Promise.all([
+      ...senderPoints.map(secret => AppTaggingSecret.computeDirectional(secret, contractAddress, recipient)),
+      ...registeredSecrets.flatMap(({ kind, secret }) => {
+        switch (kind) {
+          case 'arbitrary-secret':
+            return [AppTaggingSecret.computeDirectional(secret, contractAddress, recipient)];
+          case 'handshake':
+            // A handshake-backed sender tags messages with the bare app-siloed secret, one tag domain per delivery
+            // mode.
+            return [
+              AppTaggingSecret.computeAppSiloed(secret, contractAddress, AppTaggingSecretKind.UNCONSTRAINED),
+              AppTaggingSecret.computeAppSiloed(secret, contractAddress, AppTaggingSecretKind.CONSTRAINED),
+            ];
+        }
+      }),
+    ]);
+  }
 
-    // We deduplicate the senders by adding them to a set and then converting the set back to an array
-    const deduplicatedSenders = Array.from(new Set(allSenders.map(sender => sender.toString()))).map(sender =>
-      AztecAddress.fromString(sender),
-    );
+  async #getSecretsForSenders(
+    recipientCompleteAddress: CompleteAddress,
+    recipientIvsk: GrumpkinScalar,
+  ): Promise<Point[]> {
+    // We implicitly add all PXE accounts as senders, this helps us decrypt tags on notes that we send to ourselves
+    // (recipient = us, sender = us).
+    const allSenders = [...(await this.taggingSecretSourcesStore.getSenders()), ...(await this.keyStore.getAccounts())];
 
     return Promise.all(
-      deduplicatedSenders.map(async sender => {
-        const secret = await AppTaggingSecret.computeUnconstrained(
-          recipientCompleteAddress,
-          recipientIvsk,
-          sender,
-          contractAddress,
-          recipient,
-        );
+      allSenders.map(async sender => {
+        const taggingSecretPoint = await computeSharedTaggingSecret(recipientCompleteAddress, recipientIvsk, sender);
 
-        if (!secret) {
-          // Note that all senders originate from either the SenderAddressBookStore or the KeyStore.
+        if (!taggingSecretPoint) {
+          // Note that all senders originate from either the TaggingSecretSourcesStore or the KeyStore.
           throw new Error(
             `Failed to compute a tagging secret for sender ${sender} - this implies this is an invalid address, which should not happen as they have been previously registered in PXE.`,
           );
         }
 
-        return secret;
+        return taggingSecretPoint;
       }),
     );
   }
 }
+
+/** A tagged log fetched from the node, together with the onchain context of the tx that emitted it. */
+export type RetrievedTaggedLog = TxOnchainContext & {
+  /** The raw log payload, tag included. */
+  logData: Fr[];
+  blockTimestamp: UInt64;
+};

package/src/messages/tx_resolver_service.ts

@@ -0,0 +1,80 @@
+import type { BlockNumber } from '@aztec/foundation/branded-types';
+import { uniqueBy } from '@aztec/foundation/collection';
+import { Fr } from '@aztec/foundation/curves/bn254';
+import type { BlockHash } from '@aztec/stdlib/block';
+import type { AztecNode } from '@aztec/stdlib/interfaces/server';
+import { type IndexedTxEffect, TxHash } from '@aztec/stdlib/tx';
+
+/** Resolves transaction hashes into their on-chain context (note hashes, nullifiers, and mined position). */
+export class TxResolverService {
+  constructor(private readonly aztecNode: AztecNode) {}
+
+  /**
+   * Resolves a list of tx hashes into their on-chain context.
+   *
+   * For each tx hash, looks up the corresponding tx effect and extracts its note hashes and nullifiers, and the
+   * position it was mined at. Returns `null` for tx hashes that are zero, not yet available, or in blocks beyond the
+   * anchor block.
+   */
+  async resolveTxs(txHashes: Fr[], anchorBlockNumber: number): Promise<(TxOnchainContext | null)[]> {
+    const nonZeroTxHashes = txHashes.filter(h => !h.isZero()).map(h => TxHash.fromField(h));
+    const uniqueTxHashes = uniqueBy(nonZeroTxHashes, h => h.toString());
+    const fetched = await Promise.all(
+      uniqueTxHashes.map(h => this.aztecNode.getTxReceipt(h, { includeTxEffect: true })),
+    );
+    const txEffects = new Map(
+      uniqueTxHashes
+        .map((h, i): [string, IndexedTxEffect | undefined] => {
+          const receipt = fetched[i];
+          if (!receipt.isMined() || !receipt.txEffect) {
+            return [h.toString(), undefined];
+          }
+          return [
+            h.toString(),
+            {
+              data: receipt.txEffect,
+              l2BlockNumber: receipt.blockNumber,
+              l2BlockHash: receipt.blockHash,
+              txIndexInBlock: receipt.txIndexInBlock,
+              slotNumber: receipt.slotNumber,
+            },
+          ];
+        })
+        .filter((entry): entry is [string, IndexedTxEffect] => entry[1] !== undefined),
+    );
+
+    return txHashes.map(txHashField => {
+      const txHash = TxHash.fromField(txHashField);
+      const txEffect = txEffects.get(txHash.toString());
+      if (!txEffect || txEffect.l2BlockNumber > anchorBlockNumber) {
+        return null;
+      }
+
+      // Every tx has at least one nullifier (the first nullifier derived from the tx hash). Hitting this condition
+      // would mean a buggy node, but since consumers rely on nullifiers[0], the defensive check does no harm.
+      const data = txEffect.data;
+      if (data.nullifiers.length === 0) {
+        throw new Error(`Tx effect for ${txHash} has no nullifiers`);
+      }
+
+      return {
+        txHash: data.txHash,
+        noteHashes: data.noteHashes,
+        nullifiers: data.nullifiers,
+        blockNumber: txEffect.l2BlockNumber,
+        blockHash: txEffect.l2BlockHash,
+        txIndexInBlock: txEffect.txIndexInBlock,
+      };
+    });
+  }
+}
+
+/** The onchain context of a tx: the position it was mined at, and the effects it produced. */
+export type TxOnchainContext = {
+  txHash: TxHash;
+  noteHashes: Fr[];
+  nullifiers: Fr[];
+  blockNumber: BlockNumber;
+  blockHash: BlockHash;
+  txIndexInBlock: number;
+};