@aztec/stdlib 4.0.0-nightly.20250907 → 4.0.0-nightly.20260108

package/src/logs/directional_app_tagging_secret.ts

@@ -0,0 +1,79 @@
+import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { type Fq, Fr } from '@aztec/foundation/curves/bn254';
+import type { Point } from '@aztec/foundation/curves/grumpkin';
+
+import { z } from 'zod';
+
+import type { 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.
+ *
+ * "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) {}
+
+  /**
+   * Derives shared tagging secret and from that, the app address and recipient derives the directional app tagging
+   * secret.
+   *
+   * @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
+   * @param externalAddress - The address of entity B in the shared tagging secret derivation scheme
+   * @param app - Contract address to silo the secret to
+   * @param recipient - Recipient of the log. Defines the "direction of the secret".
+   * @returns The secret that can be used along with an index to compute a tag to be included in a log.
+   */
+  static async compute(
+    localAddress: CompleteAddress,
+    localIvsk: Fq,
+    externalAddress: AztecAddress,
+    app: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<DirectionalAppTaggingSecret> {
+    const taggingSecretPoint = await computeSharedTaggingSecret(localAddress, localIvsk, externalAddress);
+    const appTaggingSecret = await poseidon2Hash([taggingSecretPoint.x, taggingSecretPoint.y, app]);
+    const directionalAppTaggingSecret = await poseidon2Hash([appTaggingSecret, recipient]);
+
+    return new DirectionalAppTaggingSecret(directionalAppTaggingSecret);
+  }
+
+  toString(): string {
+    return this.value.toString();
+  }
+
+  static fromString(str: string): DirectionalAppTaggingSecret {
+    return new DirectionalAppTaggingSecret(Fr.fromString(str));
+  }
+}
+
+// Returns shared tagging secret computed with Diffie-Hellman key exchange.
+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();
+  // Given A (local complete address) -> B (external address) and h == preaddress
+  // Compute shared secret as S = (h_A + local_ivsk_A) * Addr_Point_B
+
+  // 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,
+});

package/src/logs/index.ts

@@ -1,5 +1,5 @@
-export * from './log_with_tx_data.js';
-export * from './indexed_tagging_secret.js';
+export * from './directional_app_tagging_secret.js';
+export * from './pre_tag.js';
 export * from './contract_class_log.js';
 export * from './public_log.js';
 export * from './private_log.js';
@@ -11,3 +11,6 @@ export * from './extended_contract_class_log.js';
 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 './tag.js';
+export * from './siloed_tag.js';

package/src/logs/log_id.ts

@@ -1,9 +1,11 @@
 import { INITIAL_L2_BLOCK_NUM } from '@aztec/constants';
 import { toBufferBE } from '@aztec/foundation/bigint-buffer';
+import { BlockNumber, BlockNumberSchema } from '@aztec/foundation/branded-types';
 import { BufferReader } from '@aztec/foundation/serialize';
 
 import { z } from 'zod';
 
+import { L2BlockHash } from '../block/block_hash.js';
 import { schemas } from '../schemas/index.js';
 
 /** A globally unique log id. */
@@ -16,7 +18,9 @@ export class LogId {
    */
   constructor(
     /** The block number the log was emitted in. */
-    public readonly blockNumber: number,
+    public readonly blockNumber: BlockNumber,
+    /** The hash of the block the log was emitted in. */
+    public readonly blockHash: L2BlockHash,
     /** 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. */
@@ -35,7 +39,8 @@ export class LogId {
 
   static random() {
     return new LogId(
-      Math.floor(Math.random() * 1000) + 1,
+      BlockNumber(Math.floor(Math.random() * 1000) + 1),
+      L2BlockHash.random(),
       Math.floor(Math.random() * 1000),
       Math.floor(Math.random() * 100),
     );
@@ -44,11 +49,14 @@ export class LogId {
   static get schema() {
     return z
       .object({
-        blockNumber: schemas.Integer,
+        blockNumber: BlockNumberSchema,
+        blockHash: L2BlockHash.schema,
         txIndex: schemas.Integer,
         logIndex: schemas.Integer,
       })
-      .transform(({ blockNumber, txIndex, logIndex }) => new LogId(blockNumber, txIndex, logIndex));
+      .transform(
+        ({ blockNumber, blockHash, txIndex, logIndex }) => new LogId(blockNumber, blockHash, txIndex, logIndex),
+      );
   }
 
   /**
@@ -58,6 +66,7 @@ export class LogId {
   public toBuffer(): Buffer {
     return Buffer.concat([
       toBufferBE(BigInt(this.blockNumber), 4),
+      this.blockHash.toBuffer(),
       toBufferBE(BigInt(this.txIndex), 4),
       toBufferBE(BigInt(this.logIndex), 4),
     ]);
@@ -71,11 +80,12 @@ export class LogId {
   static fromBuffer(buffer: Buffer | BufferReader): LogId {
     const reader = BufferReader.asReader(buffer);
 
-    const blockNumber = reader.readNumber();
+    const blockNumber = BlockNumber(reader.readNumber());
+    const blockHash = reader.readObject(L2BlockHash);
     const txIndex = reader.readNumber();
     const logIndex = reader.readNumber();
 
-    return new LogId(blockNumber, txIndex, logIndex);
+    return new LogId(blockNumber, blockHash, txIndex, logIndex);
   }
 
   /**
@@ -83,7 +93,7 @@ export class LogId {
    * @returns A string representation of the log id.
    */
   public toString(): string {
-    return `${this.blockNumber}-${this.txIndex}-${this.logIndex}`;
+    return `${this.blockNumber}-${this.txIndex}-${this.logIndex}-${this.blockHash.toString()}`;
   }
 
   /**
@@ -92,12 +102,13 @@ export class LogId {
    * @returns A log id.
    */
   static fromString(data: string): LogId {
-    const [rawBlockNumber, rawTxIndex, rawLogIndex] = data.split('-');
-    const blockNumber = Number(rawBlockNumber);
+    const [rawBlockNumber, rawTxIndex, rawLogIndex, rawBlockHash] = data.split('-');
+    const blockNumber = BlockNumber(Number(rawBlockNumber));
+    const blockHash = L2BlockHash.fromString(rawBlockHash);
     const txIndex = Number(rawTxIndex);
     const logIndex = Number(rawLogIndex);
 
-    return new LogId(blockNumber, txIndex, logIndex);
+    return new LogId(blockNumber, blockHash, txIndex, logIndex);
   }
 
   /**
@@ -105,6 +116,6 @@ export class LogId {
    * @returns A human readable representation of the log id.
    */
   public toHumanReadable(): string {
-    return `logId: (blockNumber: ${this.blockNumber}, txIndex: ${this.txIndex}, logIndex: ${this.logIndex})`;
+    return `logId: (blockNumber: ${this.blockNumber}, blockHash: ${this.blockHash.toString()}, txIndex: ${this.txIndex}, logIndex: ${this.logIndex})`;
   }
 }

package/src/logs/message_context.ts

@@ -1,5 +1,5 @@
 import { MAX_NOTE_HASHES_PER_TX } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import type { TxEffect } from '../tx/tx_effect.js';

package/src/logs/pending_tagged_log.ts

@@ -1,5 +1,5 @@
 import { PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 
 import type { AztecAddress } from '../aztec-address/index.js';
 import type { TxHash } from '../tx/tx_hash.js';

package/src/logs/pre_tag.ts

@@ -0,0 +1,25 @@
+import { schemas } from '@aztec/foundation/schemas';
+
+import { z } from 'zod';
+
+import {
+  type DirectionalAppTaggingSecret,
+  DirectionalAppTaggingSecretSchema,
+} from './directional_app_tagging_secret.js';
+
+/**
+ * Represents a preimage of a private log tag (see `Tag` in `pxe/src/tagging`).
+ *
+ * Note: It's a bit unfortunate that this type resides in `stdlib` as the rest of the tagging functionality resides
+ * in `pxe/src/tagging`. But this type is used by other types in stdlib hence there doesn't seem to be a good way
+ * around this.
+ */
+export type PreTag = {
+  secret: DirectionalAppTaggingSecret;
+  index: number;
+};
+
+export const PreTagSchema = z.object({
+  secret: DirectionalAppTaggingSecretSchema,
+  index: schemas.Integer,
+});

package/src/logs/private_log.ts

@@ -1,7 +1,7 @@
 import { PRIVATE_LOG_LENGTH, PRIVATE_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
 import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
 import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import {
   BufferReader,
@@ -49,18 +49,18 @@ export class PrivateLog {
   }
 
   toBlobFields(): Fr[] {
-    return [new Fr(this.emittedLength)].concat(this.getEmittedFields());
+    return this.getEmittedFields();
   }
 
-  static fromBlobFields(fields: Fr[] | FieldReader) {
+  static fromBlobFields(emittedLength: number, fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    const emittedLength = reader.readU32();
     const emittedFields = reader.readFieldArray(emittedLength);
     return new PrivateLog(padArrayEnd(emittedFields, Fr.ZERO, PRIVATE_LOG_SIZE_IN_FIELDS), emittedLength);
   }
 
   isEmpty() {
-    return this.fields.every(f => f.isZero());
+    // Faster to check emittedLength than compare all fields against zero
+    return this.emittedLength === 0;
   }
 
   static empty() {
@@ -92,6 +92,23 @@ export class PrivateLog {
       .transform(({ fields, emittedLength }) => PrivateLog.fromFields(fields.concat(new Fr(emittedLength))));
   }
 
+  /**
+   * Creates a PrivateLog from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing PrivateLog fields
+   * @returns A PrivateLog instance
+   */
+  static fromPlainObject(obj: any): PrivateLog {
+    if (obj instanceof PrivateLog) {
+      return obj;
+    }
+    return new PrivateLog(
+      obj.fields.map((f: any) => Fr.fromPlainObject(f)),
+      obj.emittedLength,
+    );
+  }
+
   equals(other: PrivateLog) {
     return this.fields.every((field, i) => field.equals(other.fields[i])) && this.emittedLength === other.emittedLength;
   }

package/src/logs/public_log.ts

@@ -1,28 +1,127 @@
-import { PUBLIC_LOG_LENGTH, PUBLIC_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
-import { type FieldsOf, makeTuple } from '@aztec/foundation/array';
-import { padArrayEnd } from '@aztec/foundation/collection';
-import { Fr } from '@aztec/foundation/fields';
+import { FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH, PUBLIC_LOG_HEADER_LENGTH } from '@aztec/constants';
+import type { FieldsOf } from '@aztec/foundation/array';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';
-import {
-  BufferReader,
-  FieldReader,
-  type Tuple,
-  serializeToBuffer,
-  serializeToFields,
-} from '@aztec/foundation/serialize';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 
 import { inspect } from 'util';
 import { z } from 'zod';
 
 import { AztecAddress } from '../aztec-address/index.js';
 
-export class PublicLog {
-  static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * PUBLIC_LOG_LENGTH;
+function totalSizeInFields(logs: PublicLog[]) {
+  return logs.reduce((acc, log) => acc + log.sizeInFields(), 0);
+}
 
+// This class represents logs in the same format as noir does, with a bounded maximum length.
+export class FlatPublicLogs {
+  // We don't use tuple here because FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH is too large
+  constructor(
+    public length: number,
+    public payload: Fr[],
+  ) {
+    if (payload.length !== FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH) {
+      throw new Error('Invalid payload given to FlatPublicLogs');
+    }
+    if (length > payload.length) {
+      throw new Error('Invalid length given to FlatPublicLogs');
+    }
+  }
+
+  private static fromUnpaddedPayload(payload: Fr[]) {
+    const length = payload.length;
+    return new FlatPublicLogs(length, [...payload, ...Array(FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH - length).fill(Fr.ZERO)]);
+  }
+
+  // In blobs, the actual nonempty length of the logs is encoded with the prefix, and then we have the non-padded payload.
+  static fromBlobFields(length: number, fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    const payload = reader.readFieldArray(length);
+    return this.fromUnpaddedPayload(payload);
+  }
+
+  toBlobFields() {
+    return this.payload.slice(0, this.length);
+  }
+
+  static fromLogs(logs: PublicLog[]) {
+    return this.fromUnpaddedPayload(logs.flatMap(log => log.toFields()));
+  }
+
+  toLogs() {
+    const reader = FieldReader.asReader(this.payload);
+    const logs = [];
+    while (totalSizeInFields(logs) < this.length) {
+      logs.push(PublicLog.fromFields(reader));
+    }
+    if (totalSizeInFields(logs) !== this.length) {
+      throw new Error('Wrong length in FlatPublicLogs');
+    }
+    return logs;
+  }
+
+  static get schema(): ZodFor<FlatPublicLogs> {
+    return z
+      .object({
+        length: z.number(),
+        payload: z.array(schemas.Fr).min(FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH).max(FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH),
+      })
+      .transform(({ length, payload }) => new FlatPublicLogs(length, payload));
+  }
+
+  toBuffer(): Buffer {
+    return serializeToBuffer(this.length, this.payload.slice(0, this.length));
+  }
+
+  static fromBuffer(buffer: Buffer | BufferReader) {
+    const reader = BufferReader.asReader(buffer);
+    const length = reader.readNumber();
+    return this.fromUnpaddedPayload(reader.readArray(length, Fr));
+  }
+
+  // ToFields and fromFields expect the noir style representation, with constant length payload.
+  toFields(): Fr[] {
+    return [new Fr(this.length), ...this.payload];
+  }
+
+  static fromFields(fields: Fr[] | FieldReader) {
+    const reader = FieldReader.asReader(fields);
+    // We need to do this because field reader returns tuples, which break the type system on these sizes.
+    const length = reader.readU32();
+    const payload: Fr[] = [];
+    for (let i = 0; i < FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH; ++i) {
+      payload.push(reader.readField());
+    }
+    return new FlatPublicLogs(length, payload);
+  }
+
+  static empty() {
+    return new FlatPublicLogs(0, Array(FLAT_PUBLIC_LOGS_PAYLOAD_LENGTH).fill(Fr.ZERO));
+  }
+
+  /**
+   * Creates a FlatPublicLogs instance from a plain object without Zod validation.
+   * This method is optimized for performance and skips validation, making it suitable
+   * for deserializing trusted data (e.g., from C++ via MessagePack).
+   * @param obj - Plain object containing FlatPublicLogs fields
+   * @returns A FlatPublicLogs instance
+   */
+  static fromPlainObject(obj: any): FlatPublicLogs {
+    return new FlatPublicLogs(
+      obj.length,
+      obj.payload.map((p: any) => Fr.fromPlainObject(p)),
+    );
+  }
+
+  isEmpty() {
+    return this.length === 0;
+  }
+}
+
+export class PublicLog {
   constructor(
     public contractAddress: AztecAddress,
-    public fields: Tuple<Fr, typeof PUBLIC_LOG_SIZE_IN_FIELDS>,
-    public emittedLength: number,
+    public fields: Fr[],
   ) {}
 
   static from(fields: FieldsOf<PublicLog>) {
@@ -30,104 +129,88 @@ export class PublicLog {
   }
 
   static getFields(fields: FieldsOf<PublicLog>) {
-    return [fields.contractAddress, fields.fields, fields.emittedLength] as const;
+    return [fields.contractAddress, fields.fields] as const;
   }
 
   toFields(): Fr[] {
-    return serializeToFields(...PublicLog.getFields(this));
+    return [new Fr(this.fields.length), this.contractAddress.toField(), ...this.fields];
   }
 
   static fromFields(fields: Fr[] | FieldReader) {
     const reader = FieldReader.asReader(fields);
-    return new PublicLog(
-      reader.readObject(AztecAddress),
-      reader.readFieldArray(PUBLIC_LOG_SIZE_IN_FIELDS),
-      reader.readU32(),
-    );
+    const fieldsLength = reader.readU32();
+    return new PublicLog(reader.readObject(AztecAddress), reader.readFieldArray(fieldsLength));
   }
 
-  getEmittedFields() {
-    return this.fields.slice(0, this.emittedLength);
-  }
-
-  getEmittedFieldsWithoutTag() {
-    return this.fields.slice(1, this.emittedLength);
+  sizeInFields() {
+    return this.fields.length + PUBLIC_LOG_HEADER_LENGTH;
   }
 
-  toBlobFields(): Fr[] {
-    return [new Fr(this.emittedLength), this.contractAddress.toField()].concat(this.getEmittedFields());
+  getEmittedFields() {
+    return this.fields.slice(0);
   }
 
-  static fromBlobFields(fields: Fr[] | FieldReader) {
-    const reader = FieldReader.asReader(fields);
-    const emittedLength = reader.readU32();
-    const contractAddress = reader.readObject(AztecAddress);
-    const emittedFields = reader.readFieldArray(emittedLength);
-    return new PublicLog(
-      contractAddress,
-      padArrayEnd(emittedFields, Fr.ZERO, PUBLIC_LOG_SIZE_IN_FIELDS),
-      emittedLength,
-    );
+  getEmittedFieldsWithoutTag() {
+    return this.fields.slice(1);
   }
 
   isEmpty() {
-    return this.contractAddress.isZero() && this.fields.every(f => f.isZero()) && this.emittedLength === 0;
+    return this.contractAddress.isZero() && this.fields.length === 0;
   }
 
   static empty() {
-    return new PublicLog(AztecAddress.ZERO, makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, Fr.zero), 0);
+    return new PublicLog(AztecAddress.ZERO, []);
   }
 
   toBuffer(): Buffer {
-    return serializeToBuffer(...PublicLog.getFields(this));
+    return serializeToBuffer(this.fields.length, this.contractAddress, this.fields);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
     const reader = BufferReader.asReader(buffer);
+    const fieldsLength = reader.readNumber();
+    return new PublicLog(reader.readObject(AztecAddress), reader.readArray(fieldsLength, Fr));
+  }
+
+  static fromPlainObject(obj: any): PublicLog {
     return new PublicLog(
-      reader.readObject(AztecAddress),
-      reader.readArray(PUBLIC_LOG_SIZE_IN_FIELDS, Fr),
-      reader.readNumber(),
+      AztecAddress.fromPlainObject(obj.contractAddress),
+      obj.fields.map((f: any) => Fr.fromPlainObject(f)),
     );
   }
 
   static async random() {
     return new PublicLog(
       await AztecAddress.random(),
-      makeTuple(PUBLIC_LOG_SIZE_IN_FIELDS, Fr.random),
-      PUBLIC_LOG_SIZE_IN_FIELDS,
+      Array.from({ length: 10 }, () => Fr.random()),
     );
   }
 
   equals(other: this) {
     return (
+      this.fields.length === other.fields.length &&
       this.contractAddress.equals(other.contractAddress) &&
-      this.fields.every((field, i) => field.equals(other.fields[i])) &&
-      this.emittedLength === other.emittedLength
+      this.fields.every((field, i) => field.equals(other.fields[i]))
     );
   }
 
   toHumanReadable(): string {
-    return `PublicLog: (contractAddress: ${this.contractAddress} fields: ${this.fields}) emittedLength: ${this.emittedLength}`;
+    return `PublicLog: (contractAddress: ${this.contractAddress} fields: ${this.fields})`;
   }
 
   static get schema(): ZodFor<PublicLog> {
     return z
       .object({
         contractAddress: AztecAddress.schema,
-        fields: z.array(schemas.Fr).refine(arr => arr.length === PUBLIC_LOG_SIZE_IN_FIELDS),
-        emittedLength: z.number(),
+        fields: z.array(schemas.Fr),
       })
-      .transform(({ contractAddress, fields, emittedLength }) =>
-        PublicLog.fromFields([contractAddress.toField(), ...fields, new Fr(emittedLength)]),
-      );
+      .transform(({ contractAddress, fields }) => PublicLog.from({ contractAddress, fields }));
   }
 
   [inspect.custom](): string {
     return `PublicLog {
       contractAddress: ${inspect(this.contractAddress)},
       fields: [${this.fields.map(x => inspect(x)).join(', ')}],
-      emittedLength: ${this.emittedLength},
     }`;
   }
 }

package/src/logs/shared_secret_derivation.ts

@@ -1,5 +1,5 @@
-import { Grumpkin } from '@aztec/foundation/crypto';
-import type { GrumpkinScalar, Point } from '@aztec/foundation/fields';
+import { Grumpkin } from '@aztec/foundation/crypto/grumpkin';
+import type { GrumpkinScalar, Point } from '@aztec/foundation/curves/grumpkin';
 
 import type { PublicKey } from '../keys/public_key.js';
 
@@ -16,13 +16,11 @@ import type { PublicKey } from '../keys/public_key.js';
  * TODO(#12656): This function is kept around because of the utilityGetSharedSecret oracle. Nuke this once returning
  * the app-siloed secret.
  */
-export async function deriveEcdhSharedSecret(secretKey: GrumpkinScalar, publicKey: PublicKey): Promise<Point> {
+export function deriveEcdhSharedSecret(secretKey: GrumpkinScalar, publicKey: PublicKey): Promise<Point> {
   if (publicKey.isZero()) {
     throw new Error(
       `Attempting to derive a shared secret with a zero public key. You have probably passed a zero public key in your Noir code somewhere thinking that the note won't be broadcast... but it was.`,
     );
   }
-  const curve = new Grumpkin();
-  const sharedSecret = await curve.mul(publicKey, secretKey);
-  return sharedSecret;
+  return Grumpkin.mul(publicKey, secretKey);
 }

package/src/logs/siloed_tag.ts

@@ -0,0 +1,44 @@
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import type { Fr } from '@aztec/foundation/curves/bn254';
+import type { ZodFor } from '@aztec/foundation/schemas';
+
+import type { AztecAddress } from '../aztec-address/index.js';
+import { schemas } from '../schemas/schemas.js';
+import type { Tag } from './tag.js';
+
+/* eslint-disable @typescript-eslint/no-unsafe-declaration-merging */
+
+/** Branding to ensure fields are not interchangeable types. */
+export interface SiloedTag {
+  /** Brand. */
+  _branding: 'SiloedTag';
+}
+
+/**
+ * Represents a tag used in private log as it "appears on the chain" - that is the tag is siloed with a contract
+ * address that emitted the log.
+ */
+export class SiloedTag {
+  constructor(public readonly value: Fr) {}
+
+  static async compute(tag: Tag, app: AztecAddress): Promise<SiloedTag> {
+    const siloedTag = await poseidon2Hash([app, tag.value]);
+    return new SiloedTag(siloedTag);
+  }
+
+  toString(): string {
+    return this.value.toString();
+  }
+
+  toJSON(): string {
+    return this.value.toString();
+  }
+
+  equals(other: SiloedTag): boolean {
+    return this.value.equals(other.value);
+  }
+
+  static get schema(): ZodFor<SiloedTag> {
+    return schemas.Fr.transform((fr: Fr) => new SiloedTag(fr));
+  }
+}