@aztec/stdlib 0.0.1-commit.e3c1de76 → 0.0.1-commit.e588bc7e5

package/src/kernel/private_validation_requests.ts

@@ -8,7 +8,7 @@ import { bufferToHex, hexToBuffer } from '@aztec/foundation/string';
 
 import { inspect } from 'util';
 
-import { ScopedKeyValidationRequestAndGenerator } from '../kernel/hints/scoped_key_validation_request_and_generator.js';
+import { ScopedKeyValidationRequestAndSeparator } from '../kernel/hints/scoped_key_validation_request_and_separator.js';
 import { ClaimedLengthArray, ClaimedLengthArrayFromBuffer } from './claimed_length_array.js';
 import { ScopedReadRequest } from './hints/read_request.js';
 
@@ -28,8 +28,8 @@ export class PrivateValidationRequests {
     /**
      * All the key validation requests made in this transaction.
      */
-    public scopedKeyValidationRequestsAndGenerators: ClaimedLengthArray<
-      ScopedKeyValidationRequestAndGenerator,
+    public scopedKeyValidationRequestsAndSeparators: ClaimedLengthArray<
+      ScopedKeyValidationRequestAndSeparator,
       typeof MAX_KEY_VALIDATION_REQUESTS_PER_TX
     >,
   ) {}
@@ -38,7 +38,7 @@ export class PrivateValidationRequests {
     return (
       this.noteHashReadRequests.getSize() +
       this.nullifierReadRequests.getSize() +
-      this.scopedKeyValidationRequestsAndGenerators.getSize()
+      this.scopedKeyValidationRequestsAndSeparators.getSize()
     );
   }
 
@@ -46,7 +46,7 @@ export class PrivateValidationRequests {
     return serializeToBuffer(
       this.noteHashReadRequests,
       this.nullifierReadRequests,
-      this.scopedKeyValidationRequestsAndGenerators,
+      this.scopedKeyValidationRequestsAndSeparators,
     );
   }
 
@@ -65,7 +65,7 @@ export class PrivateValidationRequests {
       reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_TX)),
       reader.readObject(ClaimedLengthArrayFromBuffer(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_TX)),
       reader.readObject(
-        ClaimedLengthArrayFromBuffer(ScopedKeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_TX),
+        ClaimedLengthArrayFromBuffer(ScopedKeyValidationRequestAndSeparator, MAX_KEY_VALIDATION_REQUESTS_PER_TX),
       ),
     );
   }
@@ -83,7 +83,7 @@ export class PrivateValidationRequests {
     return new PrivateValidationRequests(
       ClaimedLengthArray.empty(ScopedReadRequest, MAX_NOTE_HASH_READ_REQUESTS_PER_TX),
       ClaimedLengthArray.empty(ScopedReadRequest, MAX_NULLIFIER_READ_REQUESTS_PER_TX),
-      ClaimedLengthArray.empty(ScopedKeyValidationRequestAndGenerator, MAX_KEY_VALIDATION_REQUESTS_PER_TX),
+      ClaimedLengthArray.empty(ScopedKeyValidationRequestAndSeparator, MAX_KEY_VALIDATION_REQUESTS_PER_TX),
     );
   }
 
@@ -91,7 +91,7 @@ export class PrivateValidationRequests {
     return `PrivateValidationRequests {
   noteHashReadRequests: ${inspect(this.noteHashReadRequests)},
   nullifierReadRequests: ${inspect(this.nullifierReadRequests)},
-  scopedKeyValidationRequestsAndGenerators: ${inspect(this.scopedKeyValidationRequestsAndGenerators)},
+  scopedKeyValidationRequestsAndSeparators: ${inspect(this.scopedKeyValidationRequestsAndSeparators)},
   `;
   }
 }

package/src/keys/derivation.ts

@@ -1,4 +1,4 @@
-import { GeneratorIndex } from '@aztec/constants';
+import { DomainSeparator } from '@aztec/constants';
 import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { sha512ToGrumpkinScalar } from '@aztec/foundation/crypto/sha512';
@@ -10,8 +10,8 @@ import type { KeyPrefix } from './key_types.js';
 import { PublicKeys } from './public_keys.js';
 import { getKeyGenerator } from './utils.js';
 
-export function computeAppNullifierSecretKey(masterNullifierSecretKey: GrumpkinScalar, app: AztecAddress): Promise<Fr> {
-  return computeAppSecretKey(masterNullifierSecretKey, app, 'n'); // 'n' is the key prefix for nullifier secret key
+export function computeAppNullifierHidingKey(masterNullifierHidingKey: GrumpkinScalar, app: AztecAddress): Promise<Fr> {
+  return computeAppSecretKey(masterNullifierHidingKey, app, 'n'); // 'n' is the key prefix for nullifier hiding key
 }
 
 export function computeAppSecretKey(skM: GrumpkinScalar, app: AztecAddress, keyPrefix: KeyPrefix): Promise<Fr> {
@@ -26,30 +26,30 @@ export async function computeOvskApp(ovsk: GrumpkinScalar, app: AztecAddress): P
   return GrumpkinScalar.fromBuffer(ovskAppFr.toBuffer());
 }
 
-export function deriveMasterNullifierSecretKey(secretKey: Fr): GrumpkinScalar {
-  return sha512ToGrumpkinScalar([secretKey, GeneratorIndex.NSK_M]);
+export function deriveMasterNullifierHidingKey(secretKey: Fr): GrumpkinScalar {
+  return sha512ToGrumpkinScalar([secretKey, DomainSeparator.NHK_M]);
 }
 
 export function deriveMasterIncomingViewingSecretKey(secretKey: Fr): GrumpkinScalar {
-  return sha512ToGrumpkinScalar([secretKey, GeneratorIndex.IVSK_M]);
+  return sha512ToGrumpkinScalar([secretKey, DomainSeparator.IVSK_M]);
 }
 
 export function deriveMasterOutgoingViewingSecretKey(secretKey: Fr): GrumpkinScalar {
-  return sha512ToGrumpkinScalar([secretKey, GeneratorIndex.OVSK_M]);
+  return sha512ToGrumpkinScalar([secretKey, DomainSeparator.OVSK_M]);
 }
 
 export function deriveSigningKey(secretKey: Fr): GrumpkinScalar {
   // TODO(#5837): come up with a standard signing key derivation scheme instead of using ivsk_m as signing keys here
-  return sha512ToGrumpkinScalar([secretKey, GeneratorIndex.IVSK_M]);
+  return sha512ToGrumpkinScalar([secretKey, DomainSeparator.IVSK_M]);
 }
 
 export function computePreaddress(publicKeysHash: Fr, partialAddress: Fr) {
-  return poseidon2HashWithSeparator([publicKeysHash, partialAddress], GeneratorIndex.CONTRACT_ADDRESS_V1);
+  return poseidon2HashWithSeparator([publicKeysHash, partialAddress], DomainSeparator.CONTRACT_ADDRESS_V1);
 }
 
 export async function computeAddress(publicKeys: PublicKeys, partialAddress: Fr): Promise<AztecAddress> {
   // Given public keys and a partial address, we can compute our address in the following steps.
-  // 1. preaddress = poseidon2([publicKeysHash, partialAddress], GeneratorIndex.CONTRACT_ADDRESS_V1);
+  // 1. preaddress = poseidon2([publicKeysHash, partialAddress], DomainSeparator.CONTRACT_ADDRESS_V1);
   // 2. addressPoint = (preaddress * G) + ivpk_m
   // 3. address = addressPoint.x
   const preaddress = await computePreaddress(await publicKeys.hash(), partialAddress);
@@ -93,15 +93,15 @@ export function derivePublicKeyFromSecretKey(secretKey: Fq) {
  * @returns The derived keys.
  */
 export async function deriveKeys(secretKey: Fr) {
-  // First we derive master secret keys -  we use sha512 here because this derivation will never take place
+  // First we derive master secret/hiding keys -  we use sha512 here because this derivation will never take place
   // in a circuit
-  const masterNullifierSecretKey = deriveMasterNullifierSecretKey(secretKey);
+  const masterNullifierHidingKey = deriveMasterNullifierHidingKey(secretKey);
   const masterIncomingViewingSecretKey = deriveMasterIncomingViewingSecretKey(secretKey);
   const masterOutgoingViewingSecretKey = deriveMasterOutgoingViewingSecretKey(secretKey);
-  const masterTaggingSecretKey = sha512ToGrumpkinScalar([secretKey, GeneratorIndex.TSK_M]);
+  const masterTaggingSecretKey = sha512ToGrumpkinScalar([secretKey, DomainSeparator.TSK_M]);
 
   // Then we derive master public keys
-  const masterNullifierPublicKey = await derivePublicKeyFromSecretKey(masterNullifierSecretKey);
+  const masterNullifierPublicKey = await derivePublicKeyFromSecretKey(masterNullifierHidingKey);
   const masterIncomingViewingPublicKey = await derivePublicKeyFromSecretKey(masterIncomingViewingSecretKey);
   const masterOutgoingViewingPublicKey = await derivePublicKeyFromSecretKey(masterOutgoingViewingSecretKey);
   const masterTaggingPublicKey = await derivePublicKeyFromSecretKey(masterTaggingSecretKey);
@@ -115,7 +115,7 @@ export async function deriveKeys(secretKey: Fr) {
   );
 
   return {
-    masterNullifierSecretKey,
+    masterNullifierHidingKey,
     masterIncomingViewingSecretKey,
     masterOutgoingViewingSecretKey,
     masterTaggingSecretKey,

package/src/keys/key_types.ts

@@ -1,5 +1,9 @@
-import type { GeneratorIndex } from '@aztec/constants';
+import type { DomainSeparator } from '@aztec/constants';
 
-export type KeyGenerator = GeneratorIndex.NSK_M | GeneratorIndex.IVSK_M | GeneratorIndex.OVSK_M | GeneratorIndex.TSK_M;
+export type KeyGenerator =
+  | DomainSeparator.NHK_M
+  | DomainSeparator.IVSK_M
+  | DomainSeparator.OVSK_M
+  | DomainSeparator.TSK_M;
 export type KeyPrefix = 'n' | 'iv' | 'ov' | 't';
 export const KEY_PREFIXES: KeyPrefix[] = ['n', 'iv', 'ov', 't'];

package/src/keys/public_keys.ts

@@ -7,7 +7,7 @@ import {
   DEFAULT_OVPK_M_Y,
   DEFAULT_TPK_M_X,
   DEFAULT_TPK_M_Y,
-  GeneratorIndex,
+  DomainSeparator,
 } from '@aztec/constants';
 import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
@@ -82,7 +82,7 @@ export class PublicKeys {
             this.masterOutgoingViewingPublicKey,
             this.masterTaggingPublicKey,
           ],
-          GeneratorIndex.PUBLIC_KEYS_HASH,
+          DomainSeparator.PUBLIC_KEYS_HASH,
         );
   }
 

package/src/keys/utils.ts

@@ -1,9 +1,13 @@
-import { GeneratorIndex } from '@aztec/constants';
+import { DomainSeparator } from '@aztec/constants';
 
 import type { KeyGenerator, KeyPrefix } from './key_types.js';
 
 export function getKeyGenerator(prefix: KeyPrefix): KeyGenerator {
-  // We get enum key by capitalizing key prefix and concatenating it with 'SK_M'
-  const enumKey = `${prefix.toUpperCase()}SK_M`;
-  return GeneratorIndex[enumKey as keyof typeof GeneratorIndex] as KeyGenerator;
+  const map: Record<KeyPrefix, KeyGenerator> = {
+    n: DomainSeparator.NHK_M,
+    iv: DomainSeparator.IVSK_M,
+    ov: DomainSeparator.OVSK_M,
+    t: DomainSeparator.TSK_M,
+  };
+  return map[prefix];
 }

package/src/kv-store/config.ts

@@ -0,0 +1,36 @@
+import { l1ContractAddressesMapping } from '@aztec/ethereum/l1-contract-addresses';
+import { type ConfigMappingsType, getConfigFromMappings, numberConfigHelper } from '@aztec/foundation/config';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+
+export type DataStoreConfig = {
+  dataDirectory?: string;
+  dataStoreMapSizeKb: number;
+  l1Contracts?: { rollupAddress: EthAddress };
+};
+
+export const dataConfigMappings: ConfigMappingsType<DataStoreConfig> = {
+  dataDirectory: {
+    env: 'DATA_DIRECTORY',
+    description: 'Optional dir to store data. If omitted will store in memory.',
+  },
+  dataStoreMapSizeKb: {
+    env: 'DATA_STORE_MAP_SIZE_KB',
+    description: 'The maximum possible size of a data store DB in KB. Can be overridden by component-specific options.',
+    ...numberConfigHelper(128 * 1_024 * 1_024), // Defaulted to 128 GB
+  },
+  l1Contracts: {
+    description: 'The deployed L1 contract addresses',
+    nested: {
+      rollupAddress: l1ContractAddressesMapping.rollupAddress,
+    },
+  },
+};
+
+/**
+ * Returns the archiver configuration from the environment variables.
+ * Note: If an environment variable is not set, the default value is used.
+ * @returns The archiver configuration.
+ */
+export function getDataConfigFromEnv(): DataStoreConfig {
+  return getConfigFromMappings<DataStoreConfig>(dataConfigMappings);
+}

package/src/kv-store/index.ts

@@ -0,0 +1 @@
+export * from './config.js';

package/src/logs/debug_log_store.ts

@@ -0,0 +1,54 @@
+import type { TxReceipt } from '../tx/tx_receipt.js';
+import type { DebugLog } from './debug_log.js';
+
+/**
+ * Store for debug logs emitted by public functions during transaction execution.
+ *
+ * Uses the Null Object pattern: production code uses NullDebugLogStore (no-op), while test mode uses
+ * InMemoryDebugLogStore (stores and serves logs).
+ */
+export interface DebugLogStore {
+  /** Store debug logs for a processed transaction. */
+  storeLogs(txHash: string, logs: DebugLog[]): void;
+  /** Decorate a TxReceipt with any stored debug logs for the given tx. */
+  decorateReceiptWithLogs(txHash: string, receipt: TxReceipt): void;
+  /** Whether debug log collection is enabled. */
+  readonly isEnabled: boolean;
+}
+
+/** No-op implementation for production mode. */
+export class NullDebugLogStore implements DebugLogStore {
+  storeLogs(_txHash: string, _logs: DebugLog[]): void {
+    return;
+  }
+  decorateReceiptWithLogs(_txHash: string, _receipt: TxReceipt): void {
+    return;
+  }
+  get isEnabled(): boolean {
+    return false;
+  }
+}
+
+/** In-memory implementation for test mode that stores and serves debug logs. */
+export class InMemoryDebugLogStore implements DebugLogStore {
+  private map = new Map<string, DebugLog[]>();
+
+  storeLogs(txHash: string, logs: DebugLog[]): void {
+    if (logs.length > 0) {
+      this.map.set(txHash, logs);
+    }
+  }
+
+  decorateReceiptWithLogs(txHash: string, receipt: TxReceipt): void {
+    if (receipt.isMined()) {
+      const debugLogs = this.map.get(txHash);
+      if (debugLogs) {
+        receipt.debugLogs = debugLogs;
+      }
+    }
+  }
+
+  get isEnabled(): boolean {
+    return true;
+  }
+}

package/src/logs/{directional_app_tagging_secret.ts → extended_directional_app_tagging_secret.ts}

@@ -5,26 +5,32 @@ import type { Point } from '@aztec/foundation/curves/grumpkin';
 
 import { z } from 'zod';
 
-import type { AztecAddress } from '../aztec-address/index.js';
+import { AztecAddress } from '../aztec-address/index.js';
 import type { CompleteAddress } from '../contract/complete_address.js';
 import { computeAddressSecret, computePreaddress } from '../keys/derivation.js';
 
 /**
- * Directional application tagging secret used for log tagging.
+ * Extended directional application tagging secret used for log tagging.
  *
- * "Directional" because the derived secret is bound to the recipient
- * address: A→B differs from B→A even with the same participants and app.
+ * "Extended" because it bundles the directional app tagging secret with the app (contract) address. This bundling was
+ * done because where this type is used we commonly need access to both the secret and the address.
  *
- * Note: It's a bit unfortunate that this type resides in `stdlib` as the rest of the tagging functionality resides
- * in `pxe/src/tagging`. We need to use this type in `PreTag` that in turn is used by other types
- * in stdlib hence there doesn't seem to be a good way around this.
+ * "Directional" because the derived secret is bound to the recipient address: A→B differs from B→A even with the same
+ * participants and app.
+ *
+ * Note: It's a bit unfortunate that this type resides in `stdlib` as the rest of the tagging functionality resides in
+ * `pxe/src/tagging`. We need to use this type in `PreTag` that in turn is used by other types in stdlib hence there
+ * doesn't seem to be a good way around this.
  */
-export class DirectionalAppTaggingSecret {
-  private constructor(public readonly value: Fr) {}
+export class ExtendedDirectionalAppTaggingSecret {
+  constructor(
+    public readonly secret: Fr,
+    public readonly app: AztecAddress,
+  ) {}
 
   /**
    * Derives shared tagging secret and from that, the app address and recipient derives the directional app tagging
-   * secret.
+   * secret. Returns undefined if `externalAddress` is an invalid address.
    *
    * @param localAddress - The complete address of entity A in the shared tagging secret derivation scheme
    * @param localIvsk - The incoming viewing secret key of entity A
@@ -39,41 +45,54 @@ export class DirectionalAppTaggingSecret {
     externalAddress: AztecAddress,
     app: AztecAddress,
     recipient: AztecAddress,
-  ): Promise<DirectionalAppTaggingSecret> {
+  ): Promise<ExtendedDirectionalAppTaggingSecret | undefined> {
     const taggingSecretPoint = await computeSharedTaggingSecret(localAddress, localIvsk, externalAddress);
+    if (!taggingSecretPoint) {
+      return undefined;
+    }
+
     const appTaggingSecret = await poseidon2Hash([taggingSecretPoint.x, taggingSecretPoint.y, app]);
     const directionalAppTaggingSecret = await poseidon2Hash([appTaggingSecret, recipient]);
 
-    return new DirectionalAppTaggingSecret(directionalAppTaggingSecret);
+    return new ExtendedDirectionalAppTaggingSecret(directionalAppTaggingSecret, app);
   }
 
   toString(): string {
-    return this.value.toString();
+    return `${this.secret.toString()}:${this.app.toString()}`;
   }
 
-  static fromString(str: string): DirectionalAppTaggingSecret {
-    return new DirectionalAppTaggingSecret(Fr.fromString(str));
+  static fromString(str: string): ExtendedDirectionalAppTaggingSecret {
+    const [secretStr, appStr] = str.split(':');
+    return new ExtendedDirectionalAppTaggingSecret(Fr.fromString(secretStr), AztecAddress.fromString(appStr));
   }
 }
 
-// Returns shared tagging secret computed with Diffie-Hellman key exchange.
+// Returns shared tagging secret computed with Diffie-Hellman key exchange, or undefined if `externalAddress` is an
+// invalid address.
 async function computeSharedTaggingSecret(
   localAddress: CompleteAddress,
   localIvsk: Fq,
   externalAddress: AztecAddress,
-): Promise<Point> {
-  const knownPreaddress = await computePreaddress(await localAddress.publicKeys.hash(), localAddress.partialAddress);
-  // TODO: #8970 - Computation of address point from x coordinate might fail
-  const externalAddressPoint = await externalAddress.toAddressPoint();
+): Promise<Point | undefined> {
   // Given A (local complete address) -> B (external address) and h == preaddress
   // Compute shared secret as S = (h_A + local_ivsk_A) * Addr_Point_B
 
+  const knownPreaddress = await computePreaddress(await localAddress.publicKeys.hash(), localAddress.partialAddress);
+
+  // An invalid address has no corresponding address point
+  if (!(await externalAddress.isValid())) {
+    return undefined;
+  }
+
+  const externalAddressPoint = await externalAddress.toAddressPoint();
+
   // Beware! h_a + local_ivsk_a (also known as the address secret) can lead to an address point with a negative
   // y-coordinate, since there's two possible candidates computeAddressSecret takes care of selecting the one that
   // leads to a positive y-coordinate, which is the only valid address point
   return Grumpkin.mul(externalAddressPoint, await computeAddressSecret(knownPreaddress, localIvsk));
 }
 
-export const DirectionalAppTaggingSecretSchema = z.object({
-  value: Fr.schema,
+export const ExtendedDirectionalAppTaggingSecretSchema = z.object({
+  secret: Fr.schema,
+  app: AztecAddress.schema,
 });

package/src/logs/index.ts

@@ -1,5 +1,6 @@
-export * from './directional_app_tagging_secret.js';
+export * from './extended_directional_app_tagging_secret.js';
 export * from './pre_tag.js';
+export * from './tagging_index_range.js';
 export * from './contract_class_log.js';
 export * from './public_log.js';
 export * from './private_log.js';
@@ -12,5 +13,6 @@ export * from './shared_secret_derivation.js';
 export * from './tx_scoped_l2_log.js';
 export * from './message_context.js';
 export * from './debug_log.js';
+export * from './debug_log_store.js';
 export * from './tag.js';
 export * from './siloed_tag.js';

package/src/logs/log_filter.ts

@@ -1,3 +1,5 @@
+import type { Fr } from '@aztec/foundation/curves/bn254';
+
 import { z } from 'zod';
 
 import type { AztecAddress } from '../aztec-address/index.js';
@@ -20,6 +22,8 @@ export type LogFilter = {
   afterLog?: LogId;
   /** The contract address to filter logs by. */
   contractAddress?: AztecAddress;
+  /** The tag (first field of the log) to filter logs by. */
+  tag?: Fr;
 };
 
 export const LogFilterSchema: ZodFor<LogFilter> = z.object({
@@ -28,4 +32,5 @@ export const LogFilterSchema: ZodFor<LogFilter> = z.object({
   toBlock: schemas.Integer.optional(),
   afterLog: LogId.schema.optional(),
   contractAddress: schemas.AztecAddress.optional(),
+  tag: schemas.Fr.optional(),
 });

package/src/logs/log_id.ts

@@ -8,20 +8,17 @@ import { z } from 'zod';
 
 import { BlockHash } from '../block/block_hash.js';
 import { schemas } from '../schemas/index.js';
+import { TxHash } from '../tx/tx_hash.js';
 
 /** A globally unique log id. */
 export class LogId {
-  /**
-   * Parses a log id from a string.
-   * @param blockNumber - The block number.
-   * @param txIndex - The transaction index.
-   * @param logIndex - The log index.
-   */
   constructor(
     /** The block number the log was emitted in. */
     public readonly blockNumber: BlockNumber,
     /** The hash of the block the log was emitted in. */
     public readonly blockHash: BlockHash,
+    /** The hash of the transaction the log was emitted in. */
+    public readonly txHash: TxHash,
     /** The index of a tx in a block the log was emitted in. */
     public readonly txIndex: number,
     /** The index of a log the tx was emitted in. */
@@ -42,6 +39,7 @@ export class LogId {
     return new LogId(
       BlockNumber(Math.floor(Math.random() * 1000) + 1),
       BlockHash.random(),
+      TxHash.random(),
       Math.floor(Math.random() * 1000),
       Math.floor(Math.random() * 100),
     );
@@ -52,11 +50,13 @@ export class LogId {
       .object({
         blockNumber: BlockNumberSchema,
         blockHash: BlockHash.schema,
+        txHash: TxHash.schema,
         txIndex: schemas.Integer,
         logIndex: schemas.Integer,
       })
       .transform(
-        ({ blockNumber, blockHash, txIndex, logIndex }) => new LogId(blockNumber, blockHash, txIndex, logIndex),
+        ({ blockNumber, blockHash, txHash, txIndex, logIndex }) =>
+          new LogId(blockNumber, blockHash, txHash, txIndex, logIndex),
       );
   }
 
@@ -68,6 +68,7 @@ export class LogId {
     return Buffer.concat([
       toBufferBE(BigInt(this.blockNumber), 4),
       this.blockHash.toBuffer(),
+      this.txHash.toBuffer(),
       toBufferBE(BigInt(this.txIndex), 4),
       toBufferBE(BigInt(this.logIndex), 4),
     ]);
@@ -83,10 +84,11 @@ export class LogId {
 
     const blockNumber = BlockNumber(reader.readNumber());
     const blockHash = new BlockHash(reader.readObject(Fr));
+    const txHash = reader.readObject(TxHash);
     const txIndex = reader.readNumber();
     const logIndex = reader.readNumber();
 
-    return new LogId(blockNumber, blockHash, txIndex, logIndex);
+    return new LogId(blockNumber, blockHash, txHash, txIndex, logIndex);
   }
 
   /**
@@ -94,7 +96,7 @@ export class LogId {
    * @returns A string representation of the log id.
    */
   public toString(): string {
-    return `${this.blockNumber}-${this.txIndex}-${this.logIndex}-${this.blockHash.toString()}`;
+    return `${this.blockNumber}-${this.txIndex}-${this.logIndex}-${this.blockHash.toString()}-${this.txHash.toString()}`;
   }
 
   /**
@@ -103,13 +105,14 @@ export class LogId {
    * @returns A log id.
    */
   static fromString(data: string): LogId {
-    const [rawBlockNumber, rawTxIndex, rawLogIndex, rawBlockHash] = data.split('-');
+    const [rawBlockNumber, rawTxIndex, rawLogIndex, rawBlockHash, rawTxHash] = data.split('-');
     const blockNumber = BlockNumber(Number(rawBlockNumber));
     const blockHash = BlockHash.fromString(rawBlockHash);
+    const txHash = TxHash.fromString(rawTxHash);
     const txIndex = Number(rawTxIndex);
     const logIndex = Number(rawLogIndex);
 
-    return new LogId(blockNumber, blockHash, txIndex, logIndex);
+    return new LogId(blockNumber, blockHash, txHash, txIndex, logIndex);
   }
 
   /**
@@ -117,6 +120,6 @@ export class LogId {
    * @returns A human readable representation of the log id.
    */
   public toHumanReadable(): string {
-    return `logId: (blockNumber: ${this.blockNumber}, blockHash: ${this.blockHash.toString()}, txIndex: ${this.txIndex}, logIndex: ${this.logIndex})`;
+    return `logId: (blockNumber: ${this.blockNumber}, blockHash: ${this.blockHash.toString()}, txHash: ${this.txHash.toString()}, txIndex: ${this.txIndex}, logIndex: ${this.logIndex})`;
   }
 }

package/src/logs/message_context.ts

@@ -1,8 +1,7 @@
 import { MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
+import { range } from '@aztec/foundation/array';
 import { Fr } from '@aztec/foundation/curves/bn254';
 
-import type { AztecAddress } from '../aztec-address/index.js';
-import type { TxEffect } from '../tx/tx_effect.js';
 import type { TxHash } from '../tx/tx_hash.js';
 
 /**
@@ -19,7 +18,6 @@ export class MessageContext {
     public txHash: TxHash,
     public uniqueNoteHashesInTx: Fr[],
     public firstNullifierInTx: Fr,
-    public recipient: AztecAddress,
   ) {}
 
   toFields(): Fr[] {
@@ -27,7 +25,6 @@ export class MessageContext {
       this.txHash.hash,
       ...serializeBoundedVec(this.uniqueNoteHashesInTx, MAX_NOTE_HASHES_PER_TX),
       this.firstNullifierInTx,
-      this.recipient.toField(),
     ];
   }
 
@@ -37,13 +34,22 @@ export class MessageContext {
       tx_hash: this.txHash.hash,
       unique_note_hashes_in_tx: this.uniqueNoteHashesInTx,
       first_nullifier_in_tx: this.firstNullifierInTx,
-      recipient: this.recipient,
     };
     /* eslint-enable camelcase */
   }
 
-  static fromTxEffectAndRecipient(txEffect: TxEffect, recipient: AztecAddress): MessageContext {
-    return new MessageContext(txEffect.txHash, txEffect.noteHashes, txEffect.nullifiers[0], recipient);
+  static toEmptyFields(): Fr[] {
+    const serializationLen =
+      1 /* txHash */ + MAX_NOTE_HASHES_PER_TX + 1 /* uniqueNoteHashesInTx BVec */ + 1; /* firstNullifierInTx */
+    return range(serializationLen).map(_ => Fr.zero());
+  }
+
+  static toSerializedOption(response: MessageContext | null): Fr[] {
+    if (response) {
+      return [new Fr(1), ...response.toFields()];
+    } else {
+      return [new Fr(0), ...MessageContext.toEmptyFields()];
+    }
   }
 }
 
@@ -55,6 +61,10 @@ export class MessageContext {
  * @dev Copied over from pending_tagged_log.ts.
  */
 function serializeBoundedVec(values: Fr[], maxLength: number): Fr[] {
+  if (values.length > maxLength) {
+    throw new Error(`Attempted to serialize ${values} values into a BoundedVec with max length ${maxLength}`);
+  }
+
   const lengthDiff = maxLength - values.length;
   const zeroPaddingArray = Array(lengthDiff).fill(Fr.ZERO);
   const storage = values.concat(zeroPaddingArray);

package/src/logs/pending_tagged_log.ts

@@ -1,7 +1,6 @@
 import { PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
 import { Fr } from '@aztec/foundation/curves/bn254';
 
-import type { AztecAddress } from '../aztec-address/index.js';
 import type { TxHash } from '../tx/tx_hash.js';
 import { MessageContext } from './message_context.js';
 
@@ -17,9 +16,8 @@ export class PendingTaggedLog {
     txHash: TxHash,
     uniqueNoteHashesInTx: Fr[],
     firstNullifierInTx: Fr,
-    recipient: AztecAddress,
   ) {
-    this.context = new MessageContext(txHash, uniqueNoteHashesInTx, firstNullifierInTx, recipient);
+    this.context = new MessageContext(txHash, uniqueNoteHashesInTx, firstNullifierInTx);
   }
 
   toFields(): Fr[] {

package/src/logs/pre_tag.ts

@@ -3,9 +3,9 @@ import { schemas } from '@aztec/foundation/schemas';
 import { z } from 'zod';
 
 import {
-  type DirectionalAppTaggingSecret,
-  DirectionalAppTaggingSecretSchema,
-} from './directional_app_tagging_secret.js';
+  type ExtendedDirectionalAppTaggingSecret,
+  ExtendedDirectionalAppTaggingSecretSchema,
+} from './extended_directional_app_tagging_secret.js';
 
 /**
  * Represents a preimage of a private log tag (see `Tag` in `pxe/src/tagging`).
@@ -15,11 +15,11 @@ import {
  * around this.
  */
 export type PreTag = {
-  secret: DirectionalAppTaggingSecret;
+  extendedSecret: ExtendedDirectionalAppTaggingSecret;
   index: number;
 };
 
 export const PreTagSchema = z.object({
-  secret: DirectionalAppTaggingSecretSchema,
+  extendedSecret: ExtendedDirectionalAppTaggingSecretSchema,
   index: schemas.Integer,
 });