@aztec/stdlib 0.0.1-commit.d3ec352c → 0.0.1-commit.d58ff9d0

package/src/keys/public_keys.ts

@@ -1,16 +1,15 @@
 import {
+  DEFAULT_FBPK_M_HASH,
   DEFAULT_IVPK_M_X,
   DEFAULT_IVPK_M_Y,
-  DEFAULT_NPK_M_X,
-  DEFAULT_NPK_M_Y,
-  DEFAULT_OVPK_M_X,
-  DEFAULT_OVPK_M_Y,
-  DEFAULT_TPK_M_X,
-  DEFAULT_TPK_M_Y,
-  GeneratorIndex,
+  DEFAULT_MSPK_M_HASH,
+  DEFAULT_NPK_M_HASH,
+  DEFAULT_OVPK_M_HASH,
+  DEFAULT_TPK_M_HASH,
+  DomainSeparator,
 } from '@aztec/constants';
-import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
-import { Fr, Point } from '@aztec/foundation/fields';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, withoutHexPrefix } from '@aztec/foundation/string';
@@ -18,108 +17,137 @@ import type { FieldsOf } from '@aztec/foundation/types';
 
 import { z } from 'zod';
 
-import type { PublicKey } from './public_key.js';
+import { PublicKey, hashPublicKey } from './public_key.js';
 
+/**
+ * A non-owner's view of an account's master public keys.
+ *
+ * Only `ivpkM` is exposed as a point (since address derivation needs the curve
+ * point in-circuit); the other five keys are exposed as their `hashPublicKey` digests.
+ */
 export class PublicKeys {
   public constructor(
-    /** Master nullifier public key */
-    public masterNullifierPublicKey: PublicKey,
+    /** Hash of the master nullifier public key */
+    public npkMHash: Fr,
     /** Master incoming viewing public key */
-    public masterIncomingViewingPublicKey: PublicKey,
-    /** Master outgoing viewing public key */
-    public masterOutgoingViewingPublicKey: PublicKey,
-    /** Master tagging viewing public key */
-    public masterTaggingPublicKey: PublicKey,
+    public ivpkM: PublicKey,
+    /** Hash of the master outgoing viewing public key */
+    public ovpkMHash: Fr,
+    /** Hash of the master tagging public key */
+    public tpkMHash: Fr,
+    /** Hash of the master message-signing public key */
+    public mspkMHash: Fr,
+    /** Hash of the master fallback public key */
+    public fbpkMHash: Fr,
   ) {}
 
   static get schema() {
     return z
       .object({
-        masterNullifierPublicKey: schemas.Point,
-        masterIncomingViewingPublicKey: schemas.Point,
-        masterOutgoingViewingPublicKey: schemas.Point,
-        masterTaggingPublicKey: schemas.Point,
+        npkMHash: schemas.Fr,
+        ivpkM: schemas.Point,
+        ovpkMHash: schemas.Fr,
+        tpkMHash: schemas.Fr,
+        mspkMHash: schemas.Fr,
+        fbpkMHash: schemas.Fr,
       })
       .transform(PublicKeys.from);
   }
 
   static from(fields: FieldsOf<PublicKeys>) {
     return new PublicKeys(
-      fields.masterNullifierPublicKey,
-      fields.masterIncomingViewingPublicKey,
-      fields.masterOutgoingViewingPublicKey,
-      fields.masterTaggingPublicKey,
+      fields.npkMHash,
+      fields.ivpkM,
+      fields.ovpkMHash,
+      fields.tpkMHash,
+      fields.mspkMHash,
+      fields.fbpkMHash,
     );
   }
 
   /**
    * Creates a PublicKeys 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 PublicKeys fields
-   * @returns A PublicKeys instance
+   * Suitable for deserializing trusted data (e.g., from C++ via MessagePack).
    */
   static fromPlainObject(obj: any): PublicKeys {
     if (obj instanceof PublicKeys) {
       return obj;
     }
     return new PublicKeys(
-      Point.fromPlainObject(obj.masterNullifierPublicKey),
-      Point.fromPlainObject(obj.masterIncomingViewingPublicKey),
-      Point.fromPlainObject(obj.masterOutgoingViewingPublicKey),
-      Point.fromPlainObject(obj.masterTaggingPublicKey),
+      Fr.fromPlainObject(obj.npkMHash),
+      PublicKey.fromPlainObject(obj.ivpkM),
+      Fr.fromPlainObject(obj.ovpkMHash),
+      Fr.fromPlainObject(obj.tpkMHash),
+      Fr.fromPlainObject(obj.mspkMHash),
+      Fr.fromPlainObject(obj.fbpkMHash),
     );
   }
 
-  hash() {
-    return this.isEmpty()
-      ? Fr.ZERO
-      : poseidon2HashWithSeparator(
-          [
-            this.masterNullifierPublicKey,
-            this.masterIncomingViewingPublicKey,
-            this.masterOutgoingViewingPublicKey,
-            this.masterTaggingPublicKey,
-          ],
-          GeneratorIndex.PUBLIC_KEYS_HASH,
-        );
+  async hash() {
+    if (this.isEmpty()) {
+      return Fr.ZERO;
+    }
+    // Mirror Noir's `PublicKeys::hash`: hash the six single-key digests under
+    // DOM_SEP__PUBLIC_KEYS_HASH. `ivpk_m` must be reduced to its single-key digest first
+    // (Poseidon2 over [x, y]); passing the Point directly would omit the DOM_SEP__SINGLE_PUBLIC_KEY_HASH
+    const ivpkMHash = await hashPublicKey(this.ivpkM);
+    return poseidon2HashWithSeparator(
+      [this.npkMHash, ivpkMHash, this.ovpkMHash, this.tpkMHash, this.mspkMHash, this.fbpkMHash],
+      DomainSeparator.PUBLIC_KEYS_HASH,
+    );
   }
 
   isEmpty() {
     return (
-      this.masterNullifierPublicKey.isZero() &&
-      this.masterIncomingViewingPublicKey.isZero() &&
-      this.masterOutgoingViewingPublicKey.isZero() &&
-      this.masterTaggingPublicKey.isZero()
+      this.npkMHash.isZero() &&
+      this.ivpkM.isZero() &&
+      this.ovpkMHash.isZero() &&
+      this.tpkMHash.isZero() &&
+      this.mspkMHash.isZero() &&
+      this.fbpkMHash.isZero()
     );
   }
 
   static default(): PublicKeys {
+    // Precomputed `hash_public_key(PublicKey { DEFAULT_*_X, DEFAULT_*_Y })` for the hash-only keys.
+    // Sourced from constants.gen.ts (originally defined in
+    // noir-protocol-circuits/crates/types/src/constants.nr); a self-test in public_keys.nr
+    // (`default_hashes_match_default_points`) catches drift between the *_HASH constants and
+    // the underlying X/Y points.
     return new PublicKeys(
-      new Point(new Fr(DEFAULT_NPK_M_X), new Fr(DEFAULT_NPK_M_Y), false),
-      new Point(new Fr(DEFAULT_IVPK_M_X), new Fr(DEFAULT_IVPK_M_Y), false),
-      new Point(new Fr(DEFAULT_OVPK_M_X), new Fr(DEFAULT_OVPK_M_Y), false),
-      new Point(new Fr(DEFAULT_TPK_M_X), new Fr(DEFAULT_TPK_M_Y), false),
+      new Fr(DEFAULT_NPK_M_HASH),
+      new PublicKey(new Fr(DEFAULT_IVPK_M_X), new Fr(DEFAULT_IVPK_M_Y)),
+      new Fr(DEFAULT_OVPK_M_HASH),
+      new Fr(DEFAULT_TPK_M_HASH),
+      new Fr(DEFAULT_MSPK_M_HASH),
+      new Fr(DEFAULT_FBPK_M_HASH),
     );
   }
 
   static async random(): Promise<PublicKeys> {
-    return new PublicKeys(await Point.random(), await Point.random(), await Point.random(), await Point.random());
+    const npkM = await PublicKey.random();
+    const ovpkM = await PublicKey.random();
+    const tpkM = await PublicKey.random();
+    const mspkM = await PublicKey.random();
+    const fbpkM = await PublicKey.random();
+    return new PublicKeys(
+      await hashPublicKey(npkM),
+      await PublicKey.random(),
+      await hashPublicKey(ovpkM),
+      await hashPublicKey(tpkM),
+      await hashPublicKey(mspkM),
+      await hashPublicKey(fbpkM),
+    );
   }
 
-  /**
-   * Determines if this PublicKeys instance is equal to the given PublicKeys instance.
-   * Equality is based on the content of their respective buffers.
-   *
-   * @param other - The PublicKeys instance to compare against.
-   * @returns True if the buffers of both instances are equal, false otherwise.
-   */
   equals(other: PublicKeys): boolean {
     return (
-      this.masterNullifierPublicKey.equals(other.masterNullifierPublicKey) &&
-      this.masterIncomingViewingPublicKey.equals(other.masterIncomingViewingPublicKey) &&
-      this.masterOutgoingViewingPublicKey.equals(other.masterOutgoingViewingPublicKey) &&
-      this.masterTaggingPublicKey.equals(other.masterTaggingPublicKey)
+      this.npkMHash.equals(other.npkMHash) &&
+      this.ivpkM.equals(other.ivpkM) &&
+      this.ovpkMHash.equals(other.ovpkMHash) &&
+      this.tpkMHash.equals(other.tpkMHash) &&
+      this.mspkMHash.equals(other.mspkMHash) &&
+      this.fbpkMHash.equals(other.fbpkMHash)
     );
   }
 
@@ -131,76 +159,63 @@ export class PublicKeys {
    */
   toBuffer(): Buffer {
     return serializeToBuffer([
-      this.masterNullifierPublicKey,
-      this.masterIncomingViewingPublicKey,
-      this.masterOutgoingViewingPublicKey,
-      this.masterTaggingPublicKey,
+      this.npkMHash,
+      this.ivpkM,
+      this.ovpkMHash,
+      this.tpkMHash,
+      this.mspkMHash,
+      this.fbpkMHash,
     ]);
   }
 
-  /**
-   * Creates an PublicKeys instance from a given buffer or BufferReader.
-   * If the input is a Buffer, it wraps it in a BufferReader before processing.
-   * Throws an error if the input length is not equal to the expected size.
-   *
-   * @param buffer - The input buffer or BufferReader containing the address data.
-   * @returns - A new PublicKeys instance with the extracted address data.
-   */
   static fromBuffer(buffer: Buffer | BufferReader): PublicKeys {
     const reader = BufferReader.asReader(buffer);
-    const masterNullifierPublicKey = reader.readObject(Point);
-    const masterIncomingViewingPublicKey = reader.readObject(Point);
-    const masterOutgoingViewingPublicKey = reader.readObject(Point);
-    const masterTaggingPublicKey = reader.readObject(Point);
-    return new PublicKeys(
-      masterNullifierPublicKey,
-      masterIncomingViewingPublicKey,
-      masterOutgoingViewingPublicKey,
-      masterTaggingPublicKey,
-    );
+    const npkMHash = Fr.fromBuffer(reader);
+    const ivpkM = reader.readObject(PublicKey);
+    const ovpkMHash = Fr.fromBuffer(reader);
+    const tpkMHash = Fr.fromBuffer(reader);
+    const mspkMHash = Fr.fromBuffer(reader);
+    const fbpkMHash = Fr.fromBuffer(reader);
+    return new PublicKeys(npkMHash, ivpkM, ovpkMHash, tpkMHash, mspkMHash, fbpkMHash);
   }
 
   toNoirStruct() {
-    // We need to use lowercase identifiers as those are what the noir interface expects
-
+    // We need to use lowercase identifiers as those are what the noir interface expects.
+    /* eslint-disable camelcase */
     return {
-      // TODO(#6337): Directly dump account.publicKeys here
-      /* eslint-disable camelcase */
-      npk_m: this.masterNullifierPublicKey.toWrappedNoirStruct(),
-      ivpk_m: this.masterIncomingViewingPublicKey.toWrappedNoirStruct(),
-      ovpk_m: this.masterOutgoingViewingPublicKey.toWrappedNoirStruct(),
-      tpk_m: this.masterTaggingPublicKey.toWrappedNoirStruct(),
-      /* eslint-enable camelcase */
+      npk_m_hash: this.npkMHash,
+      ivpk_m: this.ivpkM.toWrappedNoirStruct(),
+      ovpk_m_hash: this.ovpkMHash,
+      tpk_m_hash: this.tpkMHash,
+      mspk_m_hash: this.mspkMHash,
+      fbpk_m_hash: this.fbpkMHash,
     };
+    /* eslint-enable camelcase */
   }
 
   /**
-   * Serializes the payload to an array of fields
-   * @returns The fields of the payload
+   * Wire-format fields matching Noir's struct flattening of `PublicKeys`:
+   * `[npk_m_hash, ivpk_m.x, ivpk_m.y, ovpk_m_hash, tpk_m_hash, mspk_m_hash, fbpk_m_hash]`
+   * (7 fields).
    */
   toFields(): Fr[] {
-    return [
-      ...this.masterNullifierPublicKey.toFields(),
-      ...this.masterIncomingViewingPublicKey.toFields(),
-      ...this.masterOutgoingViewingPublicKey.toFields(),
-      ...this.masterTaggingPublicKey.toFields(),
-    ];
+    return [this.npkMHash, this.ivpkM.x, this.ivpkM.y, this.ovpkMHash, this.tpkMHash, this.mspkMHash, this.fbpkMHash];
   }
 
-  // TOOD: This is used in foundation/src/abi/encoder. This is probably non-optimal but I did not want
-  // to spend too much time on the encoder now. It probably needs a refactor.
+  // Used in foundation/src/abi/encoder. Probably non-optimal but the encoder needs a refactor.
   encodeToNoir(): Fr[] {
     return this.toFields();
   }
 
   static fromFields(fields: Fr[] | FieldReader): PublicKeys {
     const reader = FieldReader.asReader(fields);
-    return new PublicKeys(
-      reader.readObject(Point),
-      reader.readObject(Point),
-      reader.readObject(Point),
-      reader.readObject(Point),
-    );
+    const npkMHash = reader.readField();
+    const ivpkM = reader.readObject(PublicKey);
+    const ovpkMHash = reader.readField();
+    const tpkMHash = reader.readField();
+    const mspkMHash = reader.readField();
+    const fbpkMHash = reader.readField();
+    return new PublicKeys(npkMHash, ivpkM, ovpkMHash, tpkMHash, mspkMHash, fbpkMHash);
   }
 
   toString() {

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,29 @@
+import { type L1ContractAddresses, pickL1ContractAddressMappings } from '@aztec/ethereum/l1-contract-addresses';
+import { type ConfigMappingsType, getConfigFromMappings, numberConfigHelper } from '@aztec/foundation/config';
+
+export type DataStoreConfig = {
+  dataDirectory?: string;
+  dataStoreMapSizeKb: number;
+} & Partial<Pick<L1ContractAddresses, 'rollupAddress'>>;
+
+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
+  },
+  ...pickL1ContractAddressMappings('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/l1-contracts/index.ts

@@ -1 +1 @@
-export * from './slash_factory.js';
+// No exports.

package/src/logs/app_tagging_secret.ts

@@ -0,0 +1,160 @@
+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 { AztecAddress } from '../aztec-address/index.js';
+import type { CompleteAddress } from '../contract/complete_address.js';
+import { computeAddressSecret, computePreaddress } from '../keys/derivation.js';
+import { AppTaggingSecretKind } from './app_tagging_secret_kind.js';
+import { appSiloEcdhSharedSecretPoint } from './shared_secret_derivation.js';
+
+const AppTaggingSecretKindSchema = z.union([
+  z.literal(AppTaggingSecretKind.UNCONSTRAINED),
+  z.literal(AppTaggingSecretKind.CONSTRAINED),
+]);
+
+/**
+ * Application tagging secret used for log tagging.
+ *
+ * It bundles a tagging secret with the app contract address. Unconstrained secrets are derived by the simulator from
+ * `(sender, recipient, app)` via ECDH. Constrained secrets are supplied to the simulator by the caller as an
+ * app-siloed shared secret retrieved from a handshake registry.
+ */
+export class AppTaggingSecret {
+  constructor(
+    public readonly secret: Fr,
+    public readonly app: AztecAddress,
+    public readonly kind: AppTaggingSecretKind = AppTaggingSecretKind.UNCONSTRAINED,
+  ) {}
+
+  /**
+   * Derives an app-siloed, recipient-directional tagging secret from a shared tagging secret point.
+   *
+   * App-silos the point via {@link appSiloEcdhSharedSecretPoint}, then directs the result to `recipient`:
+   * `h([s_app, recipient])`. The directional step stops a symmetric shared secret (ECDH against an address, or an
+   * arbitrary registered point) from colliding bidirectionally, so two parties never share a tag sequence.
+   *
+   * The point is obtained either via {@link computeSharedTaggingSecret} (an ECDH key exchange against a sender) or
+   * registered directly as a pre-shared secret.
+   *
+   * @param taggingSecretPoint - The shared tagging secret point (ECDH output, or a directly registered pre-shared secret)
+   * @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 computeDirectional(
+    taggingSecretPoint: Point,
+    app: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<AppTaggingSecret> {
+    const appSiloedSecret = await appSiloEcdhSharedSecretPoint(taggingSecretPoint, app);
+    const directionalAppTaggingSecret = await poseidon2Hash([appSiloedSecret, recipient]);
+
+    return new AppTaggingSecret(directionalAppTaggingSecret, app);
+  }
+
+  /**
+   * Derives the bare app-siloed tagging secret from a shared secret point via {@link appSiloEcdhSharedSecretPoint},
+   * under the given delivery-mode kind.
+   */
+  static async computeAppSiloed(
+    taggingSecretPoint: Point,
+    app: AztecAddress,
+    kind: AppTaggingSecretKind,
+  ): Promise<AppTaggingSecret> {
+    return new AppTaggingSecret(await appSiloEcdhSharedSecretPoint(taggingSecretPoint, app), app, kind);
+  }
+
+  /**
+   * Derives the tagging secret for `(externalAddress, recipient, app)` by performing an ECDH key exchange against
+   * `externalAddress` to obtain the shared point, then siloing and directing it via {@link computeDirectional}.
+   * Returns undefined if `externalAddress` is not a valid address.
+   */
+  static async computeViaEcdh(
+    localAddress: CompleteAddress,
+    localIvsk: Fq,
+    externalAddress: AztecAddress,
+    app: AztecAddress,
+    recipient: AztecAddress,
+  ): Promise<AppTaggingSecret | undefined> {
+    const taggingSecretPoint = await computeSharedTaggingSecret(localAddress, localIvsk, externalAddress);
+    if (!taggingSecretPoint) {
+      return undefined;
+    }
+
+    return AppTaggingSecret.computeDirectional(taggingSecretPoint, app, recipient);
+  }
+
+  toString(): string {
+    return `${this.kind}:${this.secret.toString()}:${this.app.toString()}`;
+  }
+
+  static fromString(str: string): AppTaggingSecret {
+    const parts = str.split(':');
+    if (parts.length !== 3) {
+      throw new Error(`Invalid AppTaggingSecret string: ${str}`);
+    }
+    const [kindStr, secretStr, appStr] = parts;
+    return new AppTaggingSecret(
+      Fr.fromString(secretStr),
+      AztecAddress.fromStringUnsafe(appStr),
+      appTaggingSecretKindFromString(kindStr),
+    );
+  }
+}
+
+/**
+ * Parses a stored `AppTaggingSecret` string key.
+ */
+export function appTaggingSecretFromString(str: string): AppTaggingSecret {
+  return AppTaggingSecret.fromString(str);
+}
+
+export const AppTaggingSecretSchema = z
+  .object({
+    kind: AppTaggingSecretKindSchema.default(AppTaggingSecretKind.UNCONSTRAINED),
+    secret: Fr.schema,
+    app: AztecAddress.schema,
+  })
+  .transform(({ kind, secret, app }) => new AppTaggingSecret(secret, app, kind));
+
+function appTaggingSecretKindFromString(kind: string): AppTaggingSecretKind {
+  switch (kind) {
+    case AppTaggingSecretKind.CONSTRAINED:
+      return AppTaggingSecretKind.CONSTRAINED;
+    case AppTaggingSecretKind.UNCONSTRAINED:
+      return AppTaggingSecretKind.UNCONSTRAINED;
+    default:
+      throw new Error(`Invalid AppTaggingSecret kind: ${kind}`);
+  }
+}
+
+/**
+ * Computes the shared tagging secret point between a local address (i.e. one for which the privacy keys are known) and
+ * an external one via a Diffie-Hellman key exchange.
+ *
+ * Returns undefined if `externalAddress` is an invalid address.
+ */
+export async function computeSharedTaggingSecret(
+  localAddress: CompleteAddress,
+  localIvsk: Fq,
+  externalAddress: AztecAddress,
+): Promise<Point | undefined> {
+  // An invalid address has no corresponding address point
+  if (!(await externalAddress.isValid())) {
+    return undefined;
+  }
+
+  const externalAddressPoint = await externalAddress.toAddressPoint();
+
+  const localPreaddress = await computePreaddress(await localAddress.publicKeys.hash(), localAddress.partialAddress);
+  const localAddressSecret = await computeAddressSecret(localPreaddress, localIvsk);
+
+  // For a given local address A and external address B, the shared tagging secret S is (h_A + ivsk_A) * Addr_Point_B
+  // (conceptually, in reality we don't use h_A + ivsk_A directly but rather the actual address secret, which is the
+  // same but with an optional sign adjustment to prevent A's address point from having a negative y-coordinate).
+  return Grumpkin.mul(externalAddressPoint, localAddressSecret);
+}

package/src/logs/app_tagging_secret_kind.ts

@@ -0,0 +1,21 @@
+export const AppTaggingSecretKind = {
+  UNCONSTRAINED: 'unconstrained',
+  CONSTRAINED: 'constrained',
+} as const;
+
+export type AppTaggingSecretKind = (typeof AppTaggingSecretKind)[keyof typeof AppTaggingSecretKind];
+
+// Keep in sync with aztec::messages::delivery::OnchainDeliveryMode.
+const ONCHAIN_UNCONSTRAINED_DELIVERY_MODE = 2;
+const ONCHAIN_CONSTRAINED_DELIVERY_MODE = 3;
+
+export function appTaggingSecretKindFromDeliveryMode(deliveryMode: number): AppTaggingSecretKind {
+  switch (deliveryMode) {
+    case ONCHAIN_UNCONSTRAINED_DELIVERY_MODE:
+      return AppTaggingSecretKind.UNCONSTRAINED;
+    case ONCHAIN_CONSTRAINED_DELIVERY_MODE:
+      return AppTaggingSecretKind.CONSTRAINED;
+    default:
+      throw new Error(`Unrecognized delivery mode for tagging: ${deliveryMode}`);
+  }
+}

package/src/logs/contract_class_log.ts

@@ -1,8 +1,8 @@
 import { CONTRACT_CLASS_LOG_LENGTH, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
-import { poseidon2Hash } from '@aztec/foundation/crypto';
-import { Fr } from '@aztec/foundation/fields';
+import { poseidon2Hash } from '@aztec/foundation/crypto/poseidon';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { schemas } from '@aztec/foundation/schemas';
-import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+import { BufferReader, BufferSink, FieldReader, serializeToFields, serializeToSink } from '@aztec/foundation/serialize';
 import type { FieldsOf } from '@aztec/foundation/types';
 
 import { inspect } from 'util';
@@ -56,8 +56,13 @@ export class ContractClassLogFields {
     );
   }
 
-  toBuffer() {
-    return serializeToBuffer(this.fields);
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.fields);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {
@@ -133,15 +138,6 @@ export class ContractClassLog {
     );
   }
 
-  static fromFields(fields: Fr[] | FieldReader) {
-    const reader = FieldReader.asReader(fields);
-    return new ContractClassLog(
-      reader.readObject(AztecAddress),
-      reader.readObject(ContractClassLogFields),
-      reader.readU32(),
-    );
-  }
-
   getEmittedFields() {
     return this.fields.getEmittedFields(this.emittedLength);
   }
@@ -169,8 +165,13 @@ export class ContractClassLog {
     return new ContractClassLog(AztecAddress.ZERO, ContractClassLogFields.empty(), 0);
   }
 
-  toBuffer(): Buffer {
-    return serializeToBuffer([this.contractAddress, this.fields, this.emittedLength]);
+  toBuffer(): Buffer;
+  toBuffer(sink: BufferSink): void;
+  toBuffer(sink?: BufferSink): Buffer | void {
+    if (!sink) {
+      return BufferSink.serialize(this);
+    }
+    serializeToSink(sink, this.contractAddress, this.fields, this.emittedLength);
   }
 
   static fromBuffer(buffer: Buffer | BufferReader) {

package/src/logs/debug_log.ts

@@ -1,4 +1,4 @@
-import { Fr } from '@aztec/foundation/fields';
+import { Fr } from '@aztec/foundation/curves/bn254';
 import { type LogLevel, LogLevels } from '@aztec/foundation/log';
 import { type ZodFor, schemas } from '@aztec/foundation/schemas';