@aztec/stdlib 0.77.0-testnet-ignition.17

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,40 @@
+/// <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;
+    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[];
+    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;IAKR,eAAe,EAAE,YAAY;IAAS,MAAM,EAAE,EAAE,EAAE;IAJrE,MAAM,CAAC,aAAa,SAAwD;gBAIzD,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;IAMhB,gBAAgB;IAWV,IAAI;IAIV,MAAM,KAAK,MAAM;;;;;;;;;;;;OAOhB;IAED,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,MAAM;CAK3B"}

package/dest/logs/contract_class_log.js

@@ -0,0 +1,104 @@
+import { CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS, CONTRACT_CLASS_LOG_SIZE_IN_FIELDS } from '@aztec/constants';
+import { poseidon2Hash } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { schemas } from '@aztec/foundation/schemas';
+import { BufferReader, FieldReader, serializeToBuffer } from '@aztec/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { AztecAddress } from '../aztec-address/index.js';
+export class ContractClassLog {
+    contractAddress;
+    fields;
+    static SIZE_IN_BYTES = Fr.SIZE_IN_BYTES * CONTRACT_CLASS_LOG_SIZE_IN_FIELDS;
+    // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
+    // public fields: Tuple<Fr, typeof CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS>
+    constructor(contractAddress, fields){
+        this.contractAddress = contractAddress;
+        this.fields = fields;
+        if (fields.length !== CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS) {
+            throw new Error(`Invalid number of fields for ContractClassLog. Expected ${CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS}, got ${fields.length}`);
+        }
+    }
+    toFields() {
+        return [
+            this.contractAddress.toField(),
+            ...this.fields
+        ];
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
+        // return new ContractClassLog(reader.readFieldArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS));
+        return new ContractClassLog(reader.readObject(AztecAddress), Array.from({
+            length: CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS
+        }, ()=>reader.readField()));
+    }
+    isEmpty() {
+        return this.fields.every((f)=>f.isZero());
+    }
+    static empty() {
+        return new ContractClassLog(AztecAddress.ZERO, new Array(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS).fill(Fr.ZERO));
+    }
+    toBuffer() {
+        return serializeToBuffer([
+            this.contractAddress,
+            this.fields
+        ]);
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
+        // reader.readArray(CONTRACT_CLASS_LOG_SIZE_IN_FIELDS, Fr);
+        const address = reader.readObject(AztecAddress);
+        const fields = Array.from({
+            length: CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS
+        }, ()=>reader.remainingBytes() == 0 ? Fr.ZERO : Fr.fromBuffer(reader));
+        return new ContractClassLog(address, fields);
+    }
+    clone() {
+        return ContractClassLog.fromBuffer(this.toBuffer());
+    }
+    static async random() {
+        // NB: Using half the maximum number of fields per log because max fields keeps overfilling blobs in tests.
+        // Below line gives error 'Type instantiation is excessively deep and possibly infinite. ts(2589)'
+        // makeTuple(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS, Fr.random);
+        const fields = Array.from({
+            length: Math.ceil(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS / 2)
+        }, ()=>Fr.random());
+        return new ContractClassLog(await AztecAddress.random(), fields.concat(Array.from({
+            length: Math.floor(CONTRACT_CLASS_LOG_DATA_SIZE_IN_FIELDS / 2)
+        }, ()=>Fr.ZERO)));
+    }
+    getEmittedLength() {
+        // This assumes that we cut trailing zeroes from the end of the log. In ts, these will always be added back.
+        // Does not include address and length prefix.
+        return this.getEmittedFields().length;
+    }
+    getEmittedFields() {
+        let lastZeroIndex = 0;
+        for(let i = this.fields.length - 1; i >= 0; i--){
+            if (!this.fields[i].isZero() && lastZeroIndex == 0) {
+                lastZeroIndex = i + 1;
+                break;
+            }
+        }
+        return this.fields.slice(0, lastZeroIndex);
+    }
+    async hash() {
+        return await poseidon2Hash(this.getEmittedFields());
+    }
+    static get schema() {
+        return z.object({
+            contractAddress: AztecAddress.schema,
+            fields: z.array(schemas.Fr)
+        }).transform(({ contractAddress, fields })=>ContractClassLog.fromFields([
+                contractAddress.toField(),
+                ...fields
+            ]));
+    }
+    [inspect.custom]() {
+        return `ContractClassLog {
+      fields: [${this.fields.map((x)=>inspect(x)).join(', ')}],
+    }`;
+    }
+}

package/dest/logs/extended_contract_class_log.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { ZodFor } from '@aztec/foundation/schemas';
+import { BufferReader } from '@aztec/foundation/serialize';
+import type { FieldsOf } from '@aztec/foundation/types';
+import { ContractClassLog } from './contract_class_log.js';
+import { LogId } from './log_id.js';
+/**
+ * Represents an individual contract class log entry extended with info about the block and tx it was emitted in.
+ */
+export declare class ExtendedContractClassLog {
+    /** Globally unique id of the log. */
+    readonly id: LogId;
+    /** The data contents of the log. */
+    readonly log: ContractClassLog;
+    constructor(
+    /** Globally unique id of the log. */
+    id: LogId, 
+    /** The data contents of the log. */
+    log: ContractClassLog);
+    static random(): Promise<ExtendedContractClassLog>;
+    static get schema(): ZodFor<ExtendedContractClassLog>;
+    static from(fields: FieldsOf<ExtendedContractClassLog>): ExtendedContractClassLog;
+    /**
+     * Serializes log to a buffer.
+     * @returns A buffer containing the serialized log.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Serializes log to a string.
+     * @returns A string containing the serialized log.
+     */
+    toString(): string;
+    /**
+     * Checks if two ExtendedContractClassLog objects are equal.
+     * @param other - Another ExtendedContractClassLog object to compare with.
+     * @returns True if the two objects are equal, false otherwise.
+     */
+    equals(other: ExtendedContractClassLog): boolean;
+    /**
+     * Deserializes log from a buffer.
+     * @param buffer - The buffer or buffer reader containing the log.
+     * @returns Deserialized instance of `Log`.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): ExtendedContractClassLog;
+    /**
+     * Deserializes `ExtendedContractClassLog` object from a hex string representation.
+     * @param data - A hex string representation of the log.
+     * @returns An `ExtendedContractClassLog` object.
+     */
+    static fromString(data: string): ExtendedContractClassLog;
+}
+//# sourceMappingURL=extended_contract_class_log.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"extended_contract_class_log.d.ts","sourceRoot":"","sources":["../../src/logs/extended_contract_class_log.ts"],"names":[],"mappings":";;AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAC;AACxD,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAKxD,OAAO,EAAE,gBAAgB,EAAE,MAAM,yBAAyB,CAAC;AAC3D,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEpC;;GAEG;AACH,qBAAa,wBAAwB;IAEjC,qCAAqC;aACrB,EAAE,EAAE,KAAK;IACzB,oCAAoC;aACpB,GAAG,EAAE,gBAAgB;;IAHrC,qCAAqC;IACrB,EAAE,EAAE,KAAK;IACzB,oCAAoC;IACpB,GAAG,EAAE,gBAAgB;WAG1B,MAAM;IAInB,MAAM,KAAK,MAAM,IAAI,MAAM,CAAC,wBAAwB,CAAC,CAOpD;IAED,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,QAAQ,CAAC,wBAAwB,CAAC;IAItD;;;OAGG;IACI,QAAQ,IAAI,MAAM;IAIzB;;;OAGG;IACI,QAAQ,IAAI,MAAM;IAIzB;;;;OAIG;IACI,MAAM,CAAC,KAAK,EAAE,wBAAwB,GAAG,OAAO;IAIvD;;;;OAIG;WACW,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,wBAAwB;IASjF;;;;OAIG;WACW,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,wBAAwB;CAGjE"}