@aztec/stdlib 0.0.0-test.0

package/dest/kernel/utils/optional_number.js

@@ -0,0 +1,42 @@
+import { BufferReader, FieldReader, serializeToBuffer, serializeToFields } from '@aztec/foundation/serialize';
+export class OptionalNumber {
+    isSome;
+    value;
+    constructor(/**
+     * Whether a value was set.
+     */ isSome, /**
+     * The actual number, if isSome is true.
+     */ value){
+        this.isSome = isSome;
+        this.value = value;
+    }
+    getSize() {
+        return this.toBuffer().length;
+    }
+    static getFields(fields) {
+        return [
+            fields.isSome,
+            fields.value
+        ];
+    }
+    toBuffer() {
+        return serializeToBuffer(...OptionalNumber.getFields(this));
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new OptionalNumber(reader.readBoolean(), reader.readNumber());
+    }
+    toFields() {
+        return serializeToFields(...OptionalNumber.getFields(this));
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new OptionalNumber(reader.readBoolean(), reader.readU32());
+    }
+    isEmpty() {
+        return !this.isSome && !this.value;
+    }
+    static empty() {
+        return new OptionalNumber(false, 0);
+    }
+}

package/dest/kernel/utils/order_and_comparison.d.ts

@@ -0,0 +1,8 @@
+import type { Tuple } from '@aztec/foundation/serialize';
+import type { IsEmpty, Ordered } from './interfaces.js';
+export declare function countAccumulatedItems<T extends IsEmpty>(arr: T[]): number;
+export declare function mergeAccumulatedData<T extends IsEmpty, N extends number>(arr0: Tuple<T, N>, arr1: Tuple<T, N>, length?: N): Tuple<T, N>;
+export declare function sortByCounter<T extends Ordered & IsEmpty, N extends number>(arr: Tuple<T, N>, ascending?: boolean): Tuple<T, N>;
+export declare function isEmptyArray<T extends IsEmpty>(arr: T[]): boolean;
+export declare function getNonEmptyItems<T extends IsEmpty>(arr: T[]): T[];
+//# sourceMappingURL=order_and_comparison.d.ts.map

package/dest/kernel/utils/order_and_comparison.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"order_and_comparison.d.ts","sourceRoot":"","sources":["../../../src/kernel/utils/order_and_comparison.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,6BAA6B,CAAC;AAEzD,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAKxD,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,UAUhE;AAGD,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,OAAO,EAAE,CAAC,SAAS,MAAM,EACtE,IAAI,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EACjB,IAAI,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EACjB,MAAM,GAAE,CAAoB,GAC3B,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAUb;AAuBD,wBAAgB,aAAa,CAAC,CAAC,SAAS,OAAO,GAAG,OAAO,EAAE,CAAC,SAAS,MAAM,EACzE,GAAG,EAAE,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAChB,SAAS,GAAE,OAAc,GACxB,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAEb;AAED,wBAAgB,YAAY,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,OAAO,CAEjE;AAED,wBAAgB,gBAAgB,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,GAAG,CAAC,EAAE,CAEjE"}

package/dest/kernel/utils/order_and_comparison.js

@@ -0,0 +1,52 @@
+// Define these utils here as their design is very specific to kernel's accumulated data and not general enough to be put in foundation.
+// Returns number of non-empty items in an array.
+export function countAccumulatedItems(arr) {
+    return arr.reduce((num, item, i)=>{
+        if (!item.isEmpty()) {
+            if (num !== i) {
+                throw new Error('Non-empty items must be placed continuously from index 0.');
+            }
+            return num + 1;
+        }
+        return num;
+    }, 0);
+}
+// Merges two arrays of length N into an array of length N.
+export function mergeAccumulatedData(arr0, arr1, length = arr0.length) {
+    const numNonEmptyItems0 = countAccumulatedItems(arr0);
+    const numNonEmptyItems1 = countAccumulatedItems(arr1);
+    if (numNonEmptyItems0 + numNonEmptyItems1 > length) {
+        throw new Error('Combined non-empty items exceeded the maximum allowed.');
+    }
+    const arr = [
+        ...arr0
+    ];
+    arr1.slice(0, numNonEmptyItems1).forEach((item, i)=>arr[i + numNonEmptyItems0] = item);
+    return arr;
+}
+// Sort items by a provided compare function. All empty items are padded to the right.
+function genericSort(arr, compareFn, ascending = true) {
+    return [
+        ...arr
+    ].sort((a, b)=>{
+        if (a.isEmpty()) {
+            return 1; // Move empty items to the right.
+        }
+        if (b.isEmpty()) {
+            return -1; // Move non-empty items to the left.
+        }
+        return ascending ? compareFn(a, b) : compareFn(b, a);
+    });
+}
+function compareByCounter(a, b) {
+    return a.counter - b.counter;
+}
+export function sortByCounter(arr, ascending = true) {
+    return genericSort(arr, compareByCounter, ascending);
+}
+export function isEmptyArray(arr) {
+    return arr.every((item)=>item.isEmpty());
+}
+export function getNonEmptyItems(arr) {
+    return arr.filter((item)=>!item.isEmpty());
+}

package/dest/keys/derivation.d.ts

@@ -0,0 +1,30 @@
+import { Fq, Fr, GrumpkinScalar } from '@aztec/foundation/fields';
+import { AztecAddress } from '../aztec-address/index.js';
+import type { CompleteAddress } from '../contract/complete_address.js';
+import type { KeyPrefix } from './key_types.js';
+import { PublicKeys } from './public_keys.js';
+export declare function computeAppNullifierSecretKey(masterNullifierSecretKey: GrumpkinScalar, app: AztecAddress): Promise<Fr>;
+export declare function computeAppSecretKey(skM: GrumpkinScalar, app: AztecAddress, keyPrefix: KeyPrefix): Promise<Fr>;
+export declare function computeOvskApp(ovsk: GrumpkinScalar, app: AztecAddress): Promise<Fq>;
+export declare function deriveMasterNullifierSecretKey(secretKey: Fr): GrumpkinScalar;
+export declare function deriveMasterIncomingViewingSecretKey(secretKey: Fr): GrumpkinScalar;
+export declare function deriveMasterOutgoingViewingSecretKey(secretKey: Fr): GrumpkinScalar;
+export declare function deriveSigningKey(secretKey: Fr): GrumpkinScalar;
+export declare function computePreaddress(publicKeysHash: Fr, partialAddress: Fr): Promise<Fr>;
+export declare function computeAddress(publicKeys: PublicKeys, partialAddress: Fr): Promise<AztecAddress>;
+export declare function computeAddressSecret(preaddress: Fr, ivsk: Fq): Promise<Fq>;
+export declare function derivePublicKeyFromSecretKey(secretKey: Fq): Promise<import("@aztec/foundation/fields").Point>;
+/**
+ * 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 declare function deriveKeys(secretKey: Fr): Promise<{
+    masterNullifierSecretKey: Fq;
+    masterIncomingViewingSecretKey: Fq;
+    masterOutgoingViewingSecretKey: Fq;
+    masterTaggingSecretKey: Fq;
+    publicKeys: PublicKeys;
+}>;
+export declare function computeTaggingSecretPoint(knownAddress: CompleteAddress, ivsk: Fq, externalAddress: AztecAddress): Promise<import("@aztec/foundation/fields").Point>;
+//# sourceMappingURL=derivation.d.ts.map

package/dest/keys/derivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivation.d.ts","sourceRoot":"","sources":["../../src/keys/derivation.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAC;AAElE,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iCAAiC,CAAC;AACvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,wBAAgB,4BAA4B,CAAC,wBAAwB,EAAE,cAAc,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC,CAErH;AAED,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,cAAc,EAAE,GAAG,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,GAAG,OAAO,CAAC,EAAE,CAAC,CAG7G;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE,cAAc,EAAE,GAAG,EAAE,YAAY,GAAG,OAAO,CAAC,EAAE,CAAC,CAKzF;AAED,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,EAAE,GAAG,cAAc,CAE5E;AAED,wBAAgB,oCAAoC,CAAC,SAAS,EAAE,EAAE,GAAG,cAAc,CAElF;AAED,wBAAgB,oCAAoC,CAAC,SAAS,EAAE,EAAE,GAAG,cAAc,CAElF;AAED,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,EAAE,GAAG,cAAc,CAG9D;AAED,wBAAgB,iBAAiB,CAAC,cAAc,EAAE,EAAE,EAAE,cAAc,EAAE,EAAE,eAEvE;AAED,wBAAsB,cAAc,CAAC,UAAU,EAAE,UAAU,EAAE,cAAc,EAAE,EAAE,GAAG,OAAO,CAAC,YAAY,CAAC,CAYtG;AAED,wBAAsB,oBAAoB,CAAC,UAAU,EAAE,EAAE,EAAE,IAAI,EAAE,EAAE,eAoBlE;AAED,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,EAAE,qDAGzD;AAED;;;;GAIG;AACH,wBAAsB,UAAU,CAAC,SAAS,EAAE,EAAE;;;;;;GA6B7C;AAGD,wBAAsB,yBAAyB,CAC7C,YAAY,EAAE,eAAe,EAC7B,IAAI,EAAE,EAAE,EACR,eAAe,EAAE,YAAY,qDAY9B"}

package/dest/keys/derivation.js

@@ -0,0 +1,127 @@
+import { GeneratorIndex } from '@aztec/constants';
+import { Grumpkin, poseidon2HashWithSeparator, sha512ToGrumpkinScalar } from '@aztec/foundation/crypto';
+import { Fq, Fr, GrumpkinScalar } from '@aztec/foundation/fields';
+import { AztecAddress } from '../aztec-address/index.js';
+import { PublicKeys } from './public_keys.js';
+import { getKeyGenerator } from './utils.js';
+export function computeAppNullifierSecretKey(masterNullifierSecretKey, app) {
+    return computeAppSecretKey(masterNullifierSecretKey, app, 'n'); // 'n' is the key prefix for nullifier secret key
+}
+export function computeAppSecretKey(skM, app, keyPrefix) {
+    const generator = getKeyGenerator(keyPrefix);
+    return poseidon2HashWithSeparator([
+        skM.hi,
+        skM.lo,
+        app
+    ], generator);
+}
+export async function computeOvskApp(ovsk, app) {
+    const ovskAppFr = await computeAppSecretKey(ovsk, app, 'ov'); // 'ov' is the key prefix for outgoing viewing key
+    // Here we are intentionally converting Fr (output of poseidon) to Fq. This is fine even though a distribution of
+    // P = s * G will not be uniform because 2 * (q - r) / q is small.
+    return GrumpkinScalar.fromBuffer(ovskAppFr.toBuffer());
+}
+export function deriveMasterNullifierSecretKey(secretKey) {
+    return sha512ToGrumpkinScalar([
+        secretKey,
+        GeneratorIndex.NSK_M
+    ]);
+}
+export function deriveMasterIncomingViewingSecretKey(secretKey) {
+    return sha512ToGrumpkinScalar([
+        secretKey,
+        GeneratorIndex.IVSK_M
+    ]);
+}
+export function deriveMasterOutgoingViewingSecretKey(secretKey) {
+    return sha512ToGrumpkinScalar([
+        secretKey,
+        GeneratorIndex.OVSK_M
+    ]);
+}
+export function deriveSigningKey(secretKey) {
+    // TODO(#5837): come up with a standard signing key derivation scheme instead of using ivsk_m as signing keys here
+    return sha512ToGrumpkinScalar([
+        secretKey,
+        GeneratorIndex.IVSK_M
+    ]);
+}
+export function computePreaddress(publicKeysHash, partialAddress) {
+    return poseidon2HashWithSeparator([
+        publicKeysHash,
+        partialAddress
+    ], GeneratorIndex.CONTRACT_ADDRESS_V1);
+}
+export async function computeAddress(publicKeys, partialAddress) {
+    // Given public keys and a partial address, we can compute our address in the following steps.
+    // 1. preaddress = poseidon2([publicKeysHash, partialAddress], GeneratorIndex.CONTRACT_ADDRESS_V1);
+    // 2. addressPoint = (preaddress * G) + ivpk_m
+    // 3. address = addressPoint.x
+    const preaddress = await computePreaddress(await publicKeys.hash(), partialAddress);
+    const address = await new Grumpkin().add(await derivePublicKeyFromSecretKey(new Fq(preaddress.toBigInt())), publicKeys.masterIncomingViewingPublicKey);
+    return new AztecAddress(address.x);
+}
+export async function computeAddressSecret(preaddress, ivsk) {
+    // TLDR; P1 = (h + ivsk) * G
+    // if P1.y is pos
+    //   S = (h + ivsk)
+    // else
+    //   S = Fq.MODULUS - (h + ivsk)
+    //
+    // Given h (our preaddress) and our ivsk, we have two different addressSecret candidates. One encodes to a point with a positive y-coordinate
+    // and the other encodes to a point with a negative y-coordinate. We take the addressSecret candidate that is a simple addition of the two Scalars.
+    const addressSecretCandidate = ivsk.add(new Fq(preaddress.toBigInt()));
+    // We then multiply this secretCandidate by the generator G to create an addressPoint candidate.
+    const addressPointCandidate = await derivePublicKeyFromSecretKey(addressSecretCandidate);
+    // Because all encryption to addresses is done using a point with the positive y-coordinate, if our addressSecret candidate derives a point with a
+    // negative y-coordinate, we use the other candidate by negating the secret. This transformation of the secret simply flips the y-coordinate of the derived point while keeping the x-coordinate the same.
+    if (!(addressPointCandidate.y.toBigInt() <= (Fr.MODULUS - 1n) / 2n)) {
+        return new Fq(Fq.MODULUS - addressSecretCandidate.toBigInt());
+    }
+    return addressSecretCandidate;
+}
+export function derivePublicKeyFromSecretKey(secretKey) {
+    const curve = new Grumpkin();
+    return curve.mul(curve.generator(), secretKey);
+}
+/**
+ * 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) {
+    // First we derive master secret keys -  we use sha512 here because this derivation will never take place
+    // in a circuit
+    const masterNullifierSecretKey = deriveMasterNullifierSecretKey(secretKey);
+    const masterIncomingViewingSecretKey = deriveMasterIncomingViewingSecretKey(secretKey);
+    const masterOutgoingViewingSecretKey = deriveMasterOutgoingViewingSecretKey(secretKey);
+    const masterTaggingSecretKey = sha512ToGrumpkinScalar([
+        secretKey,
+        GeneratorIndex.TSK_M
+    ]);
+    // Then we derive master public keys
+    const masterNullifierPublicKey = await derivePublicKeyFromSecretKey(masterNullifierSecretKey);
+    const masterIncomingViewingPublicKey = await derivePublicKeyFromSecretKey(masterIncomingViewingSecretKey);
+    const masterOutgoingViewingPublicKey = await derivePublicKeyFromSecretKey(masterOutgoingViewingSecretKey);
+    const masterTaggingPublicKey = await derivePublicKeyFromSecretKey(masterTaggingSecretKey);
+    // We hash the public keys to get the public keys hash
+    const publicKeys = new PublicKeys(masterNullifierPublicKey, masterIncomingViewingPublicKey, masterOutgoingViewingPublicKey, masterTaggingPublicKey);
+    return {
+        masterNullifierSecretKey,
+        masterIncomingViewingSecretKey,
+        masterOutgoingViewingSecretKey,
+        masterTaggingSecretKey,
+        publicKeys
+    };
+}
+// Returns shared tagging secret computed with Diffie-Hellman key exchange.
+export async function computeTaggingSecretPoint(knownAddress, ivsk, externalAddress) {
+    const knownPreaddress = await computePreaddress(await knownAddress.publicKeys.hash(), knownAddress.partialAddress);
+    // TODO: #8970 - Computation of address point from x coordinate might fail
+    const externalAddressPoint = await externalAddress.toAddressPoint();
+    const curve = new Grumpkin();
+    // Given A (known complete address) -> B (external address) and h == preaddress
+    // Compute shared secret as S = (h_A + ivsk_A) * Addr_Point_B
+    // Beware! h_a + 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 curve.mul(externalAddressPoint, await computeAddressSecret(knownPreaddress, ivsk));
+}

package/dest/keys/index.d.ts

@@ -0,0 +1,6 @@
+export * from './derivation.js';
+export * from './key_types.js';
+export * from './utils.js';
+export * from './public_key.js';
+export * from './public_keys.js';
+//# sourceMappingURL=index.d.ts.map

package/dest/keys/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/keys/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,YAAY,CAAC;AAC3B,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC"}

package/dest/keys/index.js

@@ -0,0 +1,5 @@
+export * from './derivation.js';
+export * from './key_types.js';
+export * from './utils.js';
+export * from './public_key.js';
+export * from './public_keys.js';

package/dest/keys/key_types.d.ts

@@ -0,0 +1,5 @@
+import type { GeneratorIndex } from '@aztec/constants';
+export type KeyGenerator = GeneratorIndex.NSK_M | GeneratorIndex.IVSK_M | GeneratorIndex.OVSK_M | GeneratorIndex.TSK_M;
+export type KeyPrefix = 'n' | 'iv' | 'ov' | 't';
+export declare const KEY_PREFIXES: KeyPrefix[];
+//# sourceMappingURL=key_types.d.ts.map

package/dest/keys/key_types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"key_types.d.ts","sourceRoot":"","sources":["../../src/keys/key_types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAEvD,MAAM,MAAM,YAAY,GAAG,cAAc,CAAC,KAAK,GAAG,cAAc,CAAC,MAAM,GAAG,cAAc,CAAC,MAAM,GAAG,cAAc,CAAC,KAAK,CAAC;AACvH,MAAM,MAAM,SAAS,GAAG,GAAG,GAAG,IAAI,GAAG,IAAI,GAAG,GAAG,CAAC;AAChD,eAAO,MAAM,YAAY,EAAE,SAAS,EAA2B,CAAC"}

package/dest/keys/key_types.js

@@ -0,0 +1,6 @@
+export const KEY_PREFIXES = [
+    'n',
+    'iv',
+    'ov',
+    't'
+];

package/dest/keys/public_key.d.ts

@@ -0,0 +1,4 @@
+import type { Point } from '@aztec/foundation/fields';
+/** Represents a user public key. */
+export type PublicKey = Point;
+//# sourceMappingURL=public_key.d.ts.map

package/dest/keys/public_key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_key.d.ts","sourceRoot":"","sources":["../../src/keys/public_key.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAEtD,oCAAoC;AACpC,MAAM,MAAM,SAAS,GAAG,KAAK,CAAC"}

package/dest/keys/public_key.js

@@ -0,0 +1 @@
+/** Represents a user public key. */ export { };

package/dest/keys/public_keys.d.ts

@@ -0,0 +1,116 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr, Point } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { z } from 'zod';
+import type { PublicKey } from './public_key.js';
+export declare class PublicKeys {
+    /** Master nullifier public key */
+    masterNullifierPublicKey: PublicKey;
+    /** Master incoming viewing public key */
+    masterIncomingViewingPublicKey: PublicKey;
+    /** Master outgoing viewing public key */
+    masterOutgoingViewingPublicKey: PublicKey;
+    /** Master tagging viewing public key */
+    masterTaggingPublicKey: PublicKey;
+    constructor(
+    /** Master nullifier public key */
+    masterNullifierPublicKey: PublicKey, 
+    /** Master incoming viewing public key */
+    masterIncomingViewingPublicKey: PublicKey, 
+    /** Master outgoing viewing public key */
+    masterOutgoingViewingPublicKey: PublicKey, 
+    /** Master tagging viewing public key */
+    masterTaggingPublicKey: PublicKey);
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        masterNullifierPublicKey: z.ZodType<Point, any, string>;
+        masterIncomingViewingPublicKey: z.ZodType<Point, any, string>;
+        masterOutgoingViewingPublicKey: z.ZodType<Point, any, string>;
+        masterTaggingPublicKey: z.ZodType<Point, any, string>;
+    }, "strip", z.ZodTypeAny, {
+        masterNullifierPublicKey: Point;
+        masterIncomingViewingPublicKey: Point;
+        masterOutgoingViewingPublicKey: Point;
+        masterTaggingPublicKey: Point;
+    }, {
+        masterNullifierPublicKey: string;
+        masterIncomingViewingPublicKey: string;
+        masterOutgoingViewingPublicKey: string;
+        masterTaggingPublicKey: string;
+    }>, PublicKeys, {
+        masterNullifierPublicKey: string;
+        masterIncomingViewingPublicKey: string;
+        masterOutgoingViewingPublicKey: string;
+        masterTaggingPublicKey: string;
+    }>;
+    static from(fields: FieldsOf<PublicKeys>): PublicKeys;
+    hash(): Fr | Promise<Fr>;
+    isEmpty(): boolean;
+    static default(): PublicKeys;
+    static random(): Promise<PublicKeys>;
+    /**
+     * 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;
+    /**
+     * Converts the PublicKeys instance into a Buffer.
+     * This method should be used when encoding the address for storage, transmission or serialization purposes.
+     *
+     * @returns A Buffer representation of the PublicKeys instance.
+     */
+    toBuffer(): Buffer;
+    /**
+     * 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;
+    toNoirStruct(): {
+        npk_m: {
+            inner: {
+                x: Fr;
+                y: Fr;
+                is_infinite: boolean;
+            };
+        };
+        ivpk_m: {
+            inner: {
+                x: Fr;
+                y: Fr;
+                is_infinite: boolean;
+            };
+        };
+        ovpk_m: {
+            inner: {
+                x: Fr;
+                y: Fr;
+                is_infinite: boolean;
+            };
+        };
+        tpk_m: {
+            inner: {
+                x: Fr;
+                y: Fr;
+                is_infinite: boolean;
+            };
+        };
+    };
+    /**
+     * Serializes the payload to an array of fields
+     * @returns The fields of the payload
+     */
+    toFields(): Fr[];
+    encodeToNoir(): Fr[];
+    static fromFields(fields: Fr[] | FieldReader): PublicKeys;
+    toString(): `0x${string}`;
+    static fromString(keys: string): PublicKeys;
+}
+//# sourceMappingURL=public_keys.d.ts.map

package/dest/keys/public_keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"public_keys.d.ts","sourceRoot":"","sources":["../../src/keys/public_keys.ts"],"names":[],"mappings":";;AAYA,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAErD,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAE3F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAEjD,qBAAa,UAAU;IAEnB,kCAAkC;IAC3B,wBAAwB,EAAE,SAAS;IAC1C,yCAAyC;IAClC,8BAA8B,EAAE,SAAS;IAChD,yCAAyC;IAClC,8BAA8B,EAAE,SAAS;IAChD,wCAAwC;IACjC,sBAAsB,EAAE,SAAS;;IAPxC,kCAAkC;IAC3B,wBAAwB,EAAE,SAAS;IAC1C,yCAAyC;IAClC,8BAA8B,EAAE,SAAS;IAChD,yCAAyC;IAClC,8BAA8B,EAAE,SAAS;IAChD,wCAAwC;IACjC,sBAAsB,EAAE,SAAS;IAG1C,MAAM,KAAK,MAAM;;;;;;;;;;;;;;;;;;;;OAShB;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,UAAU,CAAC;IASxC,IAAI;IAcJ,OAAO;IASP,MAAM,CAAC,OAAO,IAAI,UAAU;WASf,MAAM,IAAI,OAAO,CAAC,UAAU,CAAC;IAI1C;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO;IASlC;;;;;OAKG;IACH,QAAQ,IAAI,MAAM;IASlB;;;;;;;OAOG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,UAAU;IAc5D,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAcZ;;;OAGG;IACH,QAAQ,IAAI,EAAE,EAAE;IAWhB,YAAY,IAAI,EAAE,EAAE;IAIpB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW,GAAG,UAAU;IAUzD,QAAQ;IAIR,MAAM,CAAC,UAAU,CAAC,IAAI,EAAE,MAAM;CAG/B"}

package/dest/keys/public_keys.js

@@ -0,0 +1,121 @@
+import { 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 } from '@aztec/constants';
+import { poseidon2HashWithSeparator } from '@aztec/foundation/crypto';
+import { Fr, Point } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { bufferToHex, withoutHexPrefix } from '@aztec/foundation/string';
+import { z } from 'zod';
+export class PublicKeys {
+    masterNullifierPublicKey;
+    masterIncomingViewingPublicKey;
+    masterOutgoingViewingPublicKey;
+    masterTaggingPublicKey;
+    constructor(/** Master nullifier public key */ masterNullifierPublicKey, /** Master incoming viewing public key */ masterIncomingViewingPublicKey, /** Master outgoing viewing public key */ masterOutgoingViewingPublicKey, /** Master tagging viewing public key */ masterTaggingPublicKey){
+        this.masterNullifierPublicKey = masterNullifierPublicKey;
+        this.masterIncomingViewingPublicKey = masterIncomingViewingPublicKey;
+        this.masterOutgoingViewingPublicKey = masterOutgoingViewingPublicKey;
+        this.masterTaggingPublicKey = masterTaggingPublicKey;
+    }
+    static get schema() {
+        return z.object({
+            masterNullifierPublicKey: schemas.Point,
+            masterIncomingViewingPublicKey: schemas.Point,
+            masterOutgoingViewingPublicKey: schemas.Point,
+            masterTaggingPublicKey: schemas.Point
+        }).transform(PublicKeys.from);
+    }
+    static from(fields) {
+        return new PublicKeys(fields.masterNullifierPublicKey, fields.masterIncomingViewingPublicKey, fields.masterOutgoingViewingPublicKey, fields.masterTaggingPublicKey);
+    }
+    hash() {
+        return this.isEmpty() ? Fr.ZERO : poseidon2HashWithSeparator([
+            this.masterNullifierPublicKey,
+            this.masterIncomingViewingPublicKey,
+            this.masterOutgoingViewingPublicKey,
+            this.masterTaggingPublicKey
+        ], GeneratorIndex.PUBLIC_KEYS_HASH);
+    }
+    isEmpty() {
+        return this.masterNullifierPublicKey.isZero() && this.masterIncomingViewingPublicKey.isZero() && this.masterOutgoingViewingPublicKey.isZero() && this.masterTaggingPublicKey.isZero();
+    }
+    static default() {
+        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));
+    }
+    static async random() {
+        return new PublicKeys(await Point.random(), await Point.random(), await Point.random(), await Point.random());
+    }
+    /**
+   * 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) {
+        return this.masterNullifierPublicKey.equals(other.masterNullifierPublicKey) && this.masterIncomingViewingPublicKey.equals(other.masterIncomingViewingPublicKey) && this.masterOutgoingViewingPublicKey.equals(other.masterOutgoingViewingPublicKey) && this.masterTaggingPublicKey.equals(other.masterTaggingPublicKey);
+    }
+    /**
+   * Converts the PublicKeys instance into a Buffer.
+   * This method should be used when encoding the address for storage, transmission or serialization purposes.
+   *
+   * @returns A Buffer representation of the PublicKeys instance.
+   */ toBuffer() {
+        return serializeToBuffer([
+            this.masterNullifierPublicKey,
+            this.masterIncomingViewingPublicKey,
+            this.masterOutgoingViewingPublicKey,
+            this.masterTaggingPublicKey
+        ]);
+    }
+    /**
+   * 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) {
+        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);
+    }
+    toNoirStruct() {
+        // We need to use lowercase identifiers as those are what the noir interface expects
+        // eslint-disable-next-line 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()
+        };
+    }
+    /**
+   * Serializes the payload to an array of fields
+   * @returns The fields of the payload
+   */ toFields() {
+        return [
+            ...this.masterNullifierPublicKey.toFields(),
+            ...this.masterIncomingViewingPublicKey.toFields(),
+            ...this.masterOutgoingViewingPublicKey.toFields(),
+            ...this.masterTaggingPublicKey.toFields()
+        ];
+    }
+    // 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.
+    encodeToNoir() {
+        return this.toFields();
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new PublicKeys(reader.readObject(Point), reader.readObject(Point), reader.readObject(Point), reader.readObject(Point));
+    }
+    toString() {
+        return bufferToHex(this.toBuffer());
+    }
+    static fromString(keys) {
+        return PublicKeys.fromBuffer(Buffer.from(withoutHexPrefix(keys), 'hex'));
+    }
+}

package/dest/keys/utils.d.ts

@@ -0,0 +1,3 @@
+import type { KeyGenerator, KeyPrefix } from './key_types.js';
+export declare function getKeyGenerator(prefix: KeyPrefix): KeyGenerator;
+//# sourceMappingURL=utils.d.ts.map

package/dest/keys/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/keys/utils.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE9D,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,GAAG,YAAY,CAI/D"}

package/dest/keys/utils.js

@@ -0,0 +1,6 @@
+import { GeneratorIndex } from '@aztec/constants';
+export function getKeyGenerator(prefix) {
+    // We get enum key by capitalizing key prefix and concatenating it with 'SK_M'
+    const enumKey = `${prefix.toUpperCase()}SK_M`;
+    return GeneratorIndex[enumKey];
+}

package/dest/logs/contract_class_log.d.ts

@@ -0,0 +1,44 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, FieldReader } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { AztecAddress } from '../aztec-address/index.js';
+export declare class ContractClassLog {
+    contractAddress: AztecAddress;
+    fields: Fr[];
+    static SIZE_IN_BYTES: number;
+    unsiloedFirstField?: Fr | undefined;
+    constructor(contractAddress: AztecAddress, fields: Fr[]);
+    toFields(): Fr[];
+    static fromFields(fields: Fr[] | FieldReader): ContractClassLog;
+    isEmpty(): boolean;
+    static empty(): ContractClassLog;
+    toBuffer(): Buffer;
+    static fromBuffer(buffer: Buffer | BufferReader): ContractClassLog;
+    clone(): ContractClassLog;
+    static random(): Promise<ContractClassLog>;
+    getEmittedLength(): number;
+    getEmittedFields(): Fr[];
+    setUnsiloedFirstField(field: Fr): void;
+    toUnsiloed(): ContractClassLog;
+    silo(): Promise<ContractClassLog>;
+    hash(): Promise<Fr>;
+    static get schema(): z.ZodEffects<z.ZodObject<{
+        contractAddress: import("@aztec/foundation/schemas").ZodFor<AztecAddress>;
+        fields: z.ZodArray<z.ZodType<Fr, any, string>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        fields: Fr[];
+        contractAddress: AztecAddress;
+    }, {
+        fields: string[];
+        contractAddress?: any;
+    }>, ContractClassLog, {
+        fields: string[];
+        contractAddress?: any;
+    }>;
+    [inspect.custom](): string;
+}
+//# sourceMappingURL=contract_class_log.d.ts.map

package/dest/logs/contract_class_log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract_class_log.d.ts","sourceRoot":"","sources":["../../src/logs/contract_class_log.ts"],"names":[],"mappings":";;;AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAE9C,OAAO,EAAE,YAAY,EAAE,WAAW,EAAqB,MAAM,6BAA6B,CAAC;AAE3F,OAAO,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAEzD,qBAAa,gBAAgB;IAOR,eAAe,EAAE,YAAY;IAAS,MAAM,EAAE,EAAE,EAAE;IANrE,MAAM,CAAC,aAAa,SAAwD;IAErE,kBAAkB,CAAC,EAAE,EAAE,GAAG,SAAS,CAAC;gBAIxB,eAAe,EAAE,YAAY,EAAS,MAAM,EAAE,EAAE,EAAE;IAQrE,QAAQ,IAAI,EAAE,EAAE;IAIhB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,GAAG,WAAW;IAU5C,OAAO;IAIP,MAAM,CAAC,KAAK;IAIZ,QAAQ,IAAI,MAAM;IAIlB,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY;IAW/C,KAAK;WAIQ,MAAM;IAWnB,gBAAgB;IAOhB,gBAAgB;IAKhB,qBAAqB,CAAC,KAAK,EAAE,EAAE;IAI/B,UAAU;IAQJ,IAAI;IAUJ,IAAI;IAIV,MAAM,KAAK,MAAM;;;;;;;;;;;;OAOhB;IAED,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM;CAK3B"}