@aztec/stdlib 0.0.1-commit.a89ec08 → 0.0.1-commit.aa0c64f

package/src/keys/derivation.ts

@@ -7,11 +7,15 @@ import { GrumpkinScalar } from '@aztec/foundation/curves/grumpkin';
 
 import { AztecAddress } from '../aztec-address/index.js';
 import type { KeyPrefix } from './key_types.js';
+import { PublicKey, hashPublicKey } from './public_key.js';
 import { PublicKeys } from './public_keys.js';
 import { getKeyGenerator } from './utils.js';
 
-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 computeAppNullifierHidingKey(
+  masterNullifierHidingSecretKey: GrumpkinScalar,
+  app: AztecAddress,
+): Promise<Fr> {
+  return computeAppSecretKey(masterNullifierHidingSecretKey, app, 'n'); // 'n' is the key prefix for nullifier hiding key
 }
 
 export function computeAppSecretKey(skM: GrumpkinScalar, app: AztecAddress, keyPrefix: KeyPrefix): Promise<Fr> {
@@ -26,7 +30,7 @@ export async function computeOvskApp(ovsk: GrumpkinScalar, app: AztecAddress): P
   return GrumpkinScalar.fromBuffer(ovskAppFr.toBuffer());
 }
 
-export function deriveMasterNullifierHidingKey(secretKey: Fr): GrumpkinScalar {
+export function deriveMasterNullifierHidingSecretKey(secretKey: Fr): GrumpkinScalar {
   return sha512ToGrumpkinScalar([secretKey, DomainSeparator.NHK_M]);
 }
 
@@ -38,24 +42,27 @@ export function deriveMasterOutgoingViewingSecretKey(secretKey: Fr): GrumpkinSca
   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, DomainSeparator.IVSK_M]);
+export function deriveMasterMessageSigningSecretKey(secretKey: Fr): GrumpkinScalar {
+  return sha512ToGrumpkinScalar([secretKey, DomainSeparator.MSSK_M]);
+}
+
+export function deriveMasterFallbackSecretKey(secretKey: Fr): GrumpkinScalar {
+  return sha512ToGrumpkinScalar([secretKey, DomainSeparator.FBSK_M]);
 }
 
 export function computePreaddress(publicKeysHash: Fr, partialAddress: Fr) {
-  return poseidon2HashWithSeparator([publicKeysHash, partialAddress], DomainSeparator.CONTRACT_ADDRESS_V1);
+  return poseidon2HashWithSeparator([publicKeysHash, partialAddress], DomainSeparator.CONTRACT_ADDRESS_V2);
 }
 
 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], DomainSeparator.CONTRACT_ADDRESS_V1);
+  // 1. preaddress = poseidon2([publicKeysHash, partialAddress], DomainSeparator.CONTRACT_ADDRESS_V2);
   // 2. addressPoint = (preaddress * G) + ivpk_m
   // 3. address = addressPoint.x
   const preaddress = await computePreaddress(await publicKeys.hash(), partialAddress);
   const address = await Grumpkin.add(
     await derivePublicKeyFromSecretKey(new Fq(preaddress.toBigInt())),
-    publicKeys.masterIncomingViewingPublicKey,
+    publicKeys.ivpkM,
   );
 
   return new AztecAddress(address.x);
@@ -83,42 +90,92 @@ export async function computeAddressSecret(preaddress: Fr, ivsk: Fq) {
   return addressSecretCandidate;
 }
 
-export function derivePublicKeyFromSecretKey(secretKey: Fq) {
+export function derivePublicKeyFromSecretKey(secretKey: Fq): Promise<PublicKey> {
+  // 0 * G is the point at infinity. The WASM encodes infinity with an out-of-field x coordinate that Point cannot
+  // deserialize, so return the point directly instead of calling into it.
+  if (secretKey.isZero()) {
+    return Promise.resolve(PublicKey.INFINITY);
+  }
   return Grumpkin.mul(Grumpkin.generator, secretKey);
 }
 
+/**
+ * The six master secret keys that fully define an account's privacy keys.
+ */
+export type MasterSecretKeys = {
+  masterNullifierHidingSecretKey: GrumpkinScalar;
+  masterIncomingViewingSecretKey: GrumpkinScalar;
+  masterOutgoingViewingSecretKey: GrumpkinScalar;
+  masterTaggingSecretKey: GrumpkinScalar;
+  masterMessageSigningSecretKey: GrumpkinScalar;
+  masterFallbackSecretKey: GrumpkinScalar;
+};
+
 /**
  * Computes secret and public keys and public keys hash from a secret key.
  * @param secretKey - The secret key to derive keys from.
  * @returns The derived keys.
  */
-export async function deriveKeys(secretKey: Fr) {
+export function deriveKeys(secretKey: Fr) {
   // First we derive master secret/hiding keys -  we use sha512 here because this derivation will never take place
   // in a circuit
-  const masterNullifierHidingKey = deriveMasterNullifierHidingKey(secretKey);
-  const masterIncomingViewingSecretKey = deriveMasterIncomingViewingSecretKey(secretKey);
-  const masterOutgoingViewingSecretKey = deriveMasterOutgoingViewingSecretKey(secretKey);
-  const masterTaggingSecretKey = sha512ToGrumpkinScalar([secretKey, DomainSeparator.TSK_M]);
+  return deriveKeysFromMasterSecretKeys({
+    masterNullifierHidingSecretKey: deriveMasterNullifierHidingSecretKey(secretKey),
+    masterIncomingViewingSecretKey: deriveMasterIncomingViewingSecretKey(secretKey),
+    masterOutgoingViewingSecretKey: deriveMasterOutgoingViewingSecretKey(secretKey),
+    masterTaggingSecretKey: sha512ToGrumpkinScalar([secretKey, DomainSeparator.TSK_M]),
+    masterMessageSigningSecretKey: deriveMasterMessageSigningSecretKey(secretKey),
+    masterFallbackSecretKey: deriveMasterFallbackSecretKey(secretKey),
+  });
+}
+
+/**
+ * Derives the master public keys and the {@link PublicKeys} struct from a set of master secret keys.
+ * @param secretKeys - The master secret keys to derive public keys from.
+ * @returns The provided secret keys alongside the derived public keys.
+ */
+export async function deriveKeysFromMasterSecretKeys(secretKeys: MasterSecretKeys) {
+  const {
+    masterNullifierHidingSecretKey,
+    masterIncomingViewingSecretKey,
+    masterOutgoingViewingSecretKey,
+    masterTaggingSecretKey,
+    masterMessageSigningSecretKey,
+    masterFallbackSecretKey,
+  } = secretKeys;
 
-  // Then we derive master public keys
-  const masterNullifierPublicKey = await derivePublicKeyFromSecretKey(masterNullifierHidingKey);
+  const masterNullifierHidingPublicKey = await derivePublicKeyFromSecretKey(masterNullifierHidingSecretKey);
   const masterIncomingViewingPublicKey = await derivePublicKeyFromSecretKey(masterIncomingViewingSecretKey);
   const masterOutgoingViewingPublicKey = await derivePublicKeyFromSecretKey(masterOutgoingViewingSecretKey);
   const masterTaggingPublicKey = await derivePublicKeyFromSecretKey(masterTaggingSecretKey);
+  const masterMessageSigningPublicKey = await derivePublicKeyFromSecretKey(masterMessageSigningSecretKey);
+  const masterFallbackPublicKey = await derivePublicKeyFromSecretKey(masterFallbackSecretKey);
 
-  // We hash the public keys to get the public keys hash
+  // The non-owner-visible PublicKeys carries hashes for npk/ovpk/tpk/mspk/fbpk and the raw
+  // point only for ivpk_m. The npk/ovpk/tpk/mspk/fbpk raw points are also returned alongside so the key
+  // store can persist them under `${account}-{n|ov|t|ms|fb}pk_m` (only their hashes live in publicKeys).
+  // The ivpk_m point isn't returned separately because it already lives in publicKeys.ivpkM.
   const publicKeys = new PublicKeys(
-    masterNullifierPublicKey,
+    await hashPublicKey(masterNullifierHidingPublicKey),
     masterIncomingViewingPublicKey,
-    masterOutgoingViewingPublicKey,
-    masterTaggingPublicKey,
+    await hashPublicKey(masterOutgoingViewingPublicKey),
+    await hashPublicKey(masterTaggingPublicKey),
+    await hashPublicKey(masterMessageSigningPublicKey),
+    await hashPublicKey(masterFallbackPublicKey),
   );
 
   return {
-    masterNullifierHidingKey,
+    masterNullifierHidingSecretKey,
     masterIncomingViewingSecretKey,
     masterOutgoingViewingSecretKey,
     masterTaggingSecretKey,
+    masterMessageSigningSecretKey,
+    masterFallbackSecretKey,
+    masterNullifierHidingPublicKey,
+    masterOutgoingViewingPublicKey,
+    masterTaggingPublicKey,
+    masterMessageSigningPublicKey,
+    masterFallbackPublicKey,
     publicKeys,
   };
 }

package/src/keys/public_key.ts

@@ -1,4 +1,28 @@
-import type { Point } from '@aztec/foundation/curves/grumpkin';
+import { 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';
 
-/** Represents a user public key. */
+/**
+ * Hashes a public key.
+ *
+ * Mirrors Noir's `hash_public_key` in `noir-protocol-circuits/crates/types/src/public_keys.nr`:
+ * `Poseidon2(DOM_SEP__SINGLE_PUBLIC_KEY_HASH, [pk.x, pk.y])`.
+ *
+ * This is distinct from Noir's generic `Hash` impl for `EmbeddedCurvePoint` (`noir_stdlib/src/embedded_curve_ops.nr`),
+ * which simply absorbs `x` then `y` into a `Hasher` state with no domain separator. That generic impl is unsuitable
+ * for hashing keys at the protocol boundary, where the domain separator is required to prevent collisions with hashes
+ * of other Grumpkin points (e.g. note commitments, nullifiers).
+ */
+export function hashPublicKey(pk: PublicKey): Promise<Fr> {
+  return poseidon2HashWithSeparator([pk.x, pk.y], DomainSeparator.SINGLE_PUBLIC_KEY_HASH);
+}
+
+/**
+ * Represents a user public key.
+ *
+ * Structurally identical to a Grumpkin `Point`; exposed as a distinct name so call sites read as "public key" where
+ * that's the domain meaning.
+ */
 export type PublicKey = Point;
+export const PublicKey = Point;

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

@@ -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.