@aztec/stdlib 0.0.1-commit.b2a5d0dd1 → 0.0.1-commit.b3d3157a

package/src/keys/public_keys.ts

@@ -1,17 +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,
+  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/poseidon';
 import { Fr } from '@aztec/foundation/curves/bn254';
-import { Point } from '@aztec/foundation/curves/grumpkin';
 import { schemas } from '@aztec/foundation/schemas';
 import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
 import { bufferToHex, withoutHexPrefix } from '@aztec/foundation/string';
@@ -19,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,
-          ],
-          DomainSeparator.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)
     );
   }
 
@@ -132,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/kv-store/config.ts

@@ -1,12 +1,10 @@
-import { l1ContractAddressesMapping } from '@aztec/ethereum/l1-contract-addresses';
+import { type L1ContractAddresses, pickL1ContractAddressMappings } 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 };
-};
+} & Partial<Pick<L1ContractAddresses, 'rollupAddress'>>;
 
 export const dataConfigMappings: ConfigMappingsType<DataStoreConfig> = {
   dataDirectory: {
@@ -18,12 +16,7 @@ export const dataConfigMappings: ConfigMappingsType<DataStoreConfig> = {
     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,
-    },
-  },
+  ...pickL1ContractAddressMappings('rollupAddress'),
 };
 
 /**

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

@@ -8,24 +8,25 @@ 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';
+
+const AppTaggingSecretKindSchema = z.union([
+  z.literal(AppTaggingSecretKind.UNCONSTRAINED),
+  z.literal(AppTaggingSecretKind.CONSTRAINED),
+]);
 
 /**
- * Extended directional application tagging secret used for log tagging.
- *
- * "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.
+ * 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.
+ * 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 ExtendedDirectionalAppTaggingSecret {
+export class AppTaggingSecret {
   constructor(
     public readonly secret: Fr,
     public readonly app: AztecAddress,
+    public readonly kind: AppTaggingSecretKind = AppTaggingSecretKind.UNCONSTRAINED,
   ) {}
 
   /**
@@ -39,13 +40,13 @@ export class ExtendedDirectionalAppTaggingSecret {
    * @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(
+  static async computeUnconstrained(
     localAddress: CompleteAddress,
     localIvsk: Fq,
     externalAddress: AztecAddress,
     app: AztecAddress,
     recipient: AztecAddress,
-  ): Promise<ExtendedDirectionalAppTaggingSecret | undefined> {
+  ): Promise<AppTaggingSecret | undefined> {
     const taggingSecretPoint = await computeSharedTaggingSecret(localAddress, localIvsk, externalAddress);
     if (!taggingSecretPoint) {
       return undefined;
@@ -54,16 +55,59 @@ export class ExtendedDirectionalAppTaggingSecret {
     const appTaggingSecret = await poseidon2Hash([taggingSecretPoint.x, taggingSecretPoint.y, app]);
     const directionalAppTaggingSecret = await poseidon2Hash([appTaggingSecret, recipient]);
 
-    return new ExtendedDirectionalAppTaggingSecret(directionalAppTaggingSecret, app);
+    return new AppTaggingSecret(directionalAppTaggingSecret, app);
   }
 
   toString(): string {
-    return `${this.secret.toString()}:${this.app.toString()}`;
+    // TODO(F-680): Migrate stored tagging keys and remove the legacy unconstrained format.
+    if (this.kind === AppTaggingSecretKind.UNCONSTRAINED) {
+      return `${this.secret.toString()}:${this.app.toString()}`;
+    }
+    return `${this.kind}:${this.secret.toString()}:${this.app.toString()}`;
   }
 
-  static fromString(str: string): ExtendedDirectionalAppTaggingSecret {
-    const [secretStr, appStr] = str.split(':');
-    return new ExtendedDirectionalAppTaggingSecret(Fr.fromString(secretStr), AztecAddress.fromString(appStr));
+  static fromString(str: string): AppTaggingSecret {
+    const parts = str.split(':');
+    if (parts.length === 2) {
+      // TODO(F-680): Remove legacy two-part parsing after stored tagging keys are migrated.
+      const [secretStr, appStr] = parts;
+      return new AppTaggingSecret(Fr.fromString(secretStr), AztecAddress.fromString(appStr));
+    }
+    if (parts.length === 3) {
+      const [kindStr, secretStr, appStr] = parts;
+      return new AppTaggingSecret(
+        Fr.fromString(secretStr),
+        AztecAddress.fromString(appStr),
+        appTaggingSecretKindFromString(kindStr),
+      );
+    }
+    throw new Error(`Invalid AppTaggingSecret string: ${str}`);
+  }
+}
+
+/**
+ * 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}`);
   }
 }
 
@@ -91,8 +135,3 @@ async function computeSharedTaggingSecret(
   // leads to a positive y-coordinate, which is the only valid address point
   return Grumpkin.mul(externalAddressPoint, await computeAddressSecret(knownPreaddress, localIvsk));
 }
-
-export const ExtendedDirectionalAppTaggingSecretSchema = z.object({
-  secret: Fr.schema,
-  app: AztecAddress.schema,
-});

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::message_delivery::{ONCHAIN_UNCONSTRAINED, ONCHAIN_CONSTRAINED}.
+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

@@ -2,7 +2,7 @@ import { CONTRACT_CLASS_LOG_LENGTH, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS } from '@a
 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) {
@@ -169,8 +174,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/index.ts

@@ -1,16 +1,16 @@
-export * from './extended_directional_app_tagging_secret.js';
+export * from './app_tagging_secret_kind.js';
+export * from './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';
 export * from './pending_tagged_log.js';
-export * from './log_id.js';
-export * from './log_filter.js';
-export * from './extended_public_log.js';
-export * from './extended_contract_class_log.js';
+export * from './log_result.js';
+export * from './log_cursor.js';
+export * from './logs_query.js';
+export * from './query_all_logs_by_tags.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 './debug_log_store.js';