@aztec-labs/stdlib 6.0.0-nightly.20260829

package/dest/kernel/public_call_request.js

@@ -0,0 +1,219 @@
+var _computedKey, _computedKey1;
+import { COUNTED_PUBLIC_CALL_REQUEST_LENGTH, PUBLIC_CALL_REQUEST_LENGTH } from '@aztec-labs/constants';
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { schemas } from '@aztec-labs/foundation/schemas';
+import { BufferReader, BufferSink, FieldReader, serializeToFields, serializeToSink } from '@aztec-labs/foundation/serialize';
+import { inspect } from 'util';
+import { z } from 'zod';
+import { AztecAddress } from '../aztec-address/index.js';
+import { computeCalldataHash } from '../hash/index.js';
+_computedKey = inspect.custom;
+/**
+ * Represents a request to call a public function.
+ */ export class PublicCallRequest {
+    msgSender;
+    contractAddress;
+    isStaticCall;
+    calldataHash;
+    constructor(/**
+     * Address of the account which represents the entity who invoked the call.
+     */ msgSender, /**
+     * The contract address being called.
+     */ contractAddress, /**
+     * Determines whether the call is modifying state.
+     */ isStaticCall, /**
+     * Hash of the calldata of the function being called.
+     */ calldataHash){
+        this.msgSender = msgSender;
+        this.contractAddress = contractAddress;
+        this.isStaticCall = isStaticCall;
+        this.calldataHash = calldataHash;
+    }
+    static get schema() {
+        return z.object({
+            msgSender: AztecAddress.schema,
+            contractAddress: AztecAddress.schema,
+            isStaticCall: z.boolean(),
+            calldataHash: schemas.Fr
+        }).transform(({ msgSender, contractAddress, isStaticCall, calldataHash })=>{
+            return new PublicCallRequest(msgSender, contractAddress, isStaticCall, calldataHash);
+        });
+    }
+    getSize() {
+        return this.isEmpty() ? 0 : this.toBuffer().length;
+    }
+    static from(fields) {
+        return new PublicCallRequest(...PublicCallRequest.getFields(fields));
+    }
+    static getFields(fields) {
+        return [
+            fields.msgSender,
+            fields.contractAddress,
+            fields.isStaticCall,
+            fields.calldataHash
+        ];
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new PublicCallRequest(reader.readObject(AztecAddress), reader.readObject(AztecAddress), reader.readBoolean(), reader.readField());
+    }
+    toFields() {
+        const fields = serializeToFields(...PublicCallRequest.getFields(this));
+        if (fields.length !== PUBLIC_CALL_REQUEST_LENGTH) {
+            throw new Error(`Invalid number of fields for PublicCallRequest. Expected ${PUBLIC_CALL_REQUEST_LENGTH}, got ${fields.length}`);
+        }
+        return fields;
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new PublicCallRequest(reader.readObject(AztecAddress), reader.readObject(AztecAddress), reader.readBoolean(), reader.readObject(Fr));
+    }
+    toBuffer(sink) {
+        if (!sink) {
+            return BufferSink.serialize(this);
+        }
+        serializeToSink(sink, ...PublicCallRequest.getFields(this));
+    }
+    static empty() {
+        return new PublicCallRequest(AztecAddress.ZERO, AztecAddress.ZERO, false, Fr.ZERO);
+    }
+    /**
+   * Creates a PublicCallRequest instance 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 PublicCallRequest fields
+   * @returns A PublicCallRequest instance
+   */ static fromPlainObject(obj) {
+        return new PublicCallRequest(AztecAddress.fromPlainObject(obj.msgSender), AztecAddress.fromPlainObject(obj.contractAddress), obj.isStaticCall, Fr.fromPlainObject(obj.calldataHash));
+    }
+    isEmpty() {
+        return this.msgSender.isZero() && this.contractAddress.isZero() && !this.isStaticCall && this.calldataHash.isEmpty();
+    }
+    [_computedKey]() {
+        return `PublicCallRequest {
+      msgSender: ${this.msgSender}
+      contractAddress: ${this.contractAddress}
+      isStaticCall: ${this.isStaticCall}
+      calldataHash: ${this.calldataHash}
+    }`;
+    }
+    static async fromCalldata(msgSender, contractAddress, isStaticCall, calldata) {
+        const calldataHash = await computeCalldataHash(calldata);
+        return new PublicCallRequest(msgSender, contractAddress, isStaticCall, calldataHash);
+    }
+}
+_computedKey1 = inspect.custom;
+/**
+ * Represents lengths of arrays of public call requests.
+ */ export class PublicCallRequestArrayLengths {
+    setupCalls;
+    appLogicCalls;
+    teardownCall;
+    constructor(/**
+     * Number of setup call requests
+     */ setupCalls, /**
+     * Number of app logic call requests
+     */ appLogicCalls, /**
+     * Whether there is a teardown call request
+     */ teardownCall){
+        this.setupCalls = setupCalls;
+        this.appLogicCalls = appLogicCalls;
+        this.teardownCall = teardownCall;
+    }
+    static get schema() {
+        return z.object({
+            setupCalls: z.number(),
+            appLogicCalls: z.number(),
+            teardownCall: z.boolean()
+        }).transform(({ setupCalls, appLogicCalls, teardownCall })=>{
+            return new PublicCallRequestArrayLengths(setupCalls, appLogicCalls, teardownCall);
+        });
+    }
+    static getFields(fields) {
+        return [
+            fields.setupCalls,
+            fields.appLogicCalls,
+            fields.teardownCall
+        ];
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new PublicCallRequestArrayLengths(reader.readU32(), reader.readU32(), reader.readBoolean());
+    }
+    toFields() {
+        return serializeToFields(...PublicCallRequestArrayLengths.getFields(this));
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new PublicCallRequestArrayLengths(reader.readNumber(), reader.readNumber(), reader.readBoolean());
+    }
+    toBuffer(sink) {
+        if (!sink) {
+            return BufferSink.serialize(this);
+        }
+        serializeToSink(sink, ...PublicCallRequestArrayLengths.getFields(this));
+    }
+    static empty() {
+        return new PublicCallRequestArrayLengths(0, 0, false);
+    }
+    /**
+   * Creates a PublicCallRequestArrayLengths instance 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 PublicCallRequestArrayLengths fields
+   * @returns A PublicCallRequestArrayLengths instance
+   */ static fromPlainObject(obj) {
+        return new PublicCallRequestArrayLengths(obj.setupCalls, obj.appLogicCalls, obj.teardownCall);
+    }
+    [_computedKey1]() {
+        return `PublicCallRequestArrayLengths {
+      setupCalls: ${this.setupCalls}
+      appLogicCalls: ${this.appLogicCalls}
+      teardownCall: ${this.teardownCall}
+    }`;
+    }
+}
+export class CountedPublicCallRequest {
+    inner;
+    counter;
+    constructor(inner, counter){
+        this.inner = inner;
+        this.counter = counter;
+    }
+    getSize() {
+        return this.isEmpty() ? 0 : this.toBuffer().length;
+    }
+    static getFields(fields) {
+        return [
+            fields.inner,
+            fields.counter
+        ];
+    }
+    static fromFields(fields) {
+        const reader = FieldReader.asReader(fields);
+        return new CountedPublicCallRequest(reader.readObject(PublicCallRequest), reader.readU32());
+    }
+    toFields() {
+        const fields = serializeToFields(...CountedPublicCallRequest.getFields(this));
+        if (fields.length !== COUNTED_PUBLIC_CALL_REQUEST_LENGTH) {
+            throw new Error(`Invalid number of fields for CountedPublicCallRequest. Expected ${COUNTED_PUBLIC_CALL_REQUEST_LENGTH}, got ${fields.length}`);
+        }
+        return fields;
+    }
+    static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new CountedPublicCallRequest(reader.readObject(PublicCallRequest), reader.readNumber());
+    }
+    toBuffer(sink) {
+        if (!sink) {
+            return BufferSink.serialize(this);
+        }
+        serializeToSink(sink, ...CountedPublicCallRequest.getFields(this));
+    }
+    static empty() {
+        return new CountedPublicCallRequest(PublicCallRequest.empty(), 0);
+    }
+    isEmpty() {
+        return this.inner.isEmpty() && this.counter == 0;
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from './interfaces.js';
+export * from './order_and_comparison.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9rZXJuZWwvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxjQUFjLDJCQUEyQixDQUFDIn0=

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/kernel/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,2BAA2B,CAAC"}

package/dest/kernel/utils/index.js

@@ -0,0 +1,2 @@
+export * from './interfaces.js';
+export * from './order_and_comparison.js';

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

@@ -0,0 +1,7 @@
+export interface IsEmpty {
+    isEmpty: () => boolean;
+}
+export interface Ordered {
+    counter: number;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW50ZXJmYWNlcy5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2tlcm5lbC91dGlscy9pbnRlcmZhY2VzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sV0FBVyxPQUFPO0lBQ3RCLE9BQU8sRUFBRSxNQUFNLE9BQU8sQ0FBQztDQUN4QjtBQUVELE1BQU0sV0FBVyxPQUFPO0lBQ3RCLE9BQU8sRUFBRSxNQUFNLENBQUM7Q0FDakIifQ==

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

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../../src/kernel/utils/interfaces.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,OAAO;IACtB,OAAO,EAAE,MAAM,OAAO,CAAC;CACxB;AAED,MAAM,WAAW,OAAO;IACtB,OAAO,EAAE,MAAM,CAAC;CACjB"}

package/dest/kernel/utils/interfaces.js

@@ -0,0 +1 @@
+export { };

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

@@ -0,0 +1,5 @@
+import type { Tuple } from '@aztec-labs/foundation/serialize';
+import type { IsEmpty, Ordered } from './interfaces.js';
+export declare function countAccumulatedItems<T extends IsEmpty>(arr: T[]): number;
+export declare function sortByCounter<T extends Ordered & IsEmpty, N extends number>(arr: Tuple<T, N>, ascending?: boolean): Tuple<T, N>;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoib3JkZXJfYW5kX2NvbXBhcmlzb24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9rZXJuZWwvdXRpbHMvb3JkZXJfYW5kX2NvbXBhcmlzb24udHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsS0FBSyxFQUFFLE1BQU0sa0NBQWtDLENBQUM7QUFFOUQsT0FBTyxLQUFLLEVBQUUsT0FBTyxFQUFFLE9BQU8sRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBS3hELHdCQUFnQixxQkFBcUIsQ0FBQyxDQUFDLFNBQVMsT0FBTyxFQUFFLEdBQUcsRUFBRSxDQUFDLEVBQUUsVUFVaEU7QUF1QkQsd0JBQWdCLGFBQWEsQ0FBQyxDQUFDLFNBQVMsT0FBTyxHQUFHLE9BQU8sRUFBRSxDQUFDLFNBQVMsTUFBTSxFQUN6RSxHQUFHLEVBQUUsS0FBSyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsRUFDaEIsU0FBUyxHQUFFLE9BQWMsR0FDeEIsS0FBSyxDQUFDLENBQUMsRUFBRSxDQUFDLENBQUMsQ0FFYiJ9

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,kCAAkC,CAAC;AAE9D,OAAO,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAC;AAKxD,wBAAgB,qBAAqB,CAAC,CAAC,SAAS,OAAO,EAAE,GAAG,EAAE,CAAC,EAAE,UAUhE;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"}

package/dest/kernel/utils/order_and_comparison.js

@@ -0,0 +1,33 @@
+// 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);
+}
+// 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);
+}

package/dest/keys/derivation.d.ts

@@ -0,0 +1,68 @@
+import { Fq, Fr } from '@aztec-labs/foundation/curves/bn254';
+import { GrumpkinScalar } from '@aztec-labs/foundation/curves/grumpkin';
+import { AztecAddress } from '../aztec-address/index.js';
+import type { KeyPrefix } from './key_types.js';
+import { PublicKey } from './public_key.js';
+import { PublicKeys } from './public_keys.js';
+export declare function computeAppNullifierHidingKey(masterNullifierHidingSecretKey: 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 deriveMasterNullifierHidingSecretKey(secretKey: Fr): GrumpkinScalar;
+export declare function deriveMasterIncomingViewingSecretKey(secretKey: Fr): GrumpkinScalar;
+export declare function deriveMasterOutgoingViewingSecretKey(secretKey: Fr): GrumpkinScalar;
+export declare function deriveMasterMessageSigningSecretKey(secretKey: Fr): GrumpkinScalar;
+export declare function deriveMasterFallbackSecretKey(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<PublicKey>;
+/**
+ * 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 declare function deriveKeys(secretKey: Fr): Promise<{
+    masterNullifierHidingSecretKey: Fq;
+    masterIncomingViewingSecretKey: Fq;
+    masterOutgoingViewingSecretKey: Fq;
+    masterTaggingSecretKey: Fq;
+    masterMessageSigningSecretKey: Fq;
+    masterFallbackSecretKey: Fq;
+    masterNullifierHidingPublicKey: import("@aztec-labs/foundation/curves/grumpkin").Point;
+    masterOutgoingViewingPublicKey: import("@aztec-labs/foundation/curves/grumpkin").Point;
+    masterTaggingPublicKey: import("@aztec-labs/foundation/curves/grumpkin").Point;
+    masterMessageSigningPublicKey: import("@aztec-labs/foundation/curves/grumpkin").Point;
+    masterFallbackPublicKey: import("@aztec-labs/foundation/curves/grumpkin").Point;
+    publicKeys: PublicKeys;
+}>;
+/**
+ * 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 declare function deriveKeysFromMasterSecretKeys(secretKeys: MasterSecretKeys): Promise<{
+    masterNullifierHidingSecretKey: Fq;
+    masterIncomingViewingSecretKey: Fq;
+    masterOutgoingViewingSecretKey: Fq;
+    masterTaggingSecretKey: Fq;
+    masterMessageSigningSecretKey: Fq;
+    masterFallbackSecretKey: Fq;
+    masterNullifierHidingPublicKey: import("@aztec-labs/foundation/curves/grumpkin").Point;
+    masterOutgoingViewingPublicKey: import("@aztec-labs/foundation/curves/grumpkin").Point;
+    masterTaggingPublicKey: import("@aztec-labs/foundation/curves/grumpkin").Point;
+    masterMessageSigningPublicKey: import("@aztec-labs/foundation/curves/grumpkin").Point;
+    masterFallbackPublicKey: import("@aztec-labs/foundation/curves/grumpkin").Point;
+    publicKeys: PublicKeys;
+}>;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1 @@
+{"version":3,"file":"derivation.d.ts","sourceRoot":"","sources":["../../src/keys/derivation.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,EAAE,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAC7D,OAAO,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAExE,OAAO,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AACzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,SAAS,EAAiB,MAAM,iBAAiB,CAAC;AAC3D,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,wBAAgB,4BAA4B,CAC1C,8BAA8B,EAAE,cAAc,EAC9C,GAAG,EAAE,YAAY,GAChB,OAAO,CAAC,EAAE,CAAC,CAEb;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,oCAAoC,CAAC,SAAS,EAAE,EAAE,GAAG,cAAc,CAElF;AAED,wBAAgB,oCAAoC,CAAC,SAAS,EAAE,EAAE,GAAG,cAAc,CAElF;AAED,wBAAgB,oCAAoC,CAAC,SAAS,EAAE,EAAE,GAAG,cAAc,CAElF;AAED,wBAAgB,mCAAmC,CAAC,SAAS,EAAE,EAAE,GAAG,cAAc,CAEjF;AAED,wBAAgB,6BAA6B,CAAC,SAAS,EAAE,EAAE,GAAG,cAAc,CAE3E;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,GAAG,OAAO,CAAC,SAAS,CAAC,CAO9E;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,8BAA8B,EAAE,cAAc,CAAC;IAC/C,8BAA8B,EAAE,cAAc,CAAC;IAC/C,8BAA8B,EAAE,cAAc,CAAC;IAC/C,sBAAsB,EAAE,cAAc,CAAC;IACvC,6BAA6B,EAAE,cAAc,CAAC;IAC9C,uBAAuB,EAAE,cAAc,CAAC;CACzC,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,SAAS,EAAE,EAAE;;;;;;;;;;;;;GAWvC;AAED;;;;GAIG;AACH,wBAAsB,8BAA8B,CAAC,UAAU,EAAE,gBAAgB;;;;;;;;;;;;;GA4ChF"}

package/dest/keys/derivation.js

@@ -0,0 +1,150 @@
+import { DomainSeparator } from '@aztec-labs/constants';
+import { Grumpkin } from '@aztec-labs/foundation/crypto/grumpkin';
+import { poseidon2HashWithSeparator } from '@aztec-labs/foundation/crypto/poseidon';
+import { sha512ToGrumpkinScalar } from '@aztec-labs/foundation/crypto/sha512';
+import { Fq, Fr } from '@aztec-labs/foundation/curves/bn254';
+import { GrumpkinScalar } from '@aztec-labs/foundation/curves/grumpkin';
+import { AztecAddress } from '../aztec-address/index.js';
+import { PublicKey, hashPublicKey } from './public_key.js';
+import { PublicKeys } from './public_keys.js';
+import { getKeyGenerator } from './utils.js';
+export function computeAppNullifierHidingKey(masterNullifierHidingSecretKey, app) {
+    return computeAppSecretKey(masterNullifierHidingSecretKey, app, 'n'); // 'n' is the key prefix for nullifier hiding 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 deriveMasterNullifierHidingSecretKey(secretKey) {
+    return sha512ToGrumpkinScalar([
+        secretKey,
+        DomainSeparator.NHK_M
+    ]);
+}
+export function deriveMasterIncomingViewingSecretKey(secretKey) {
+    return sha512ToGrumpkinScalar([
+        secretKey,
+        DomainSeparator.IVSK_M
+    ]);
+}
+export function deriveMasterOutgoingViewingSecretKey(secretKey) {
+    return sha512ToGrumpkinScalar([
+        secretKey,
+        DomainSeparator.OVSK_M
+    ]);
+}
+export function deriveMasterMessageSigningSecretKey(secretKey) {
+    return sha512ToGrumpkinScalar([
+        secretKey,
+        DomainSeparator.MSSK_M
+    ]);
+}
+export function deriveMasterFallbackSecretKey(secretKey) {
+    return sha512ToGrumpkinScalar([
+        secretKey,
+        DomainSeparator.FBSK_M
+    ]);
+}
+export function computePreaddress(publicKeysHash, partialAddress) {
+    return poseidon2HashWithSeparator([
+        publicKeysHash,
+        partialAddress
+    ], DomainSeparator.CONTRACT_ADDRESS_V2);
+}
+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], 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.ivpkM);
+    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) {
+    // 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);
+}
+/**
+ * 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 function deriveKeys(secretKey) {
+    // First we derive master secret/hiding keys -  we use sha512 here because this derivation will never take place
+    // in a circuit
+    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) {
+    const { masterNullifierHidingSecretKey, masterIncomingViewingSecretKey, masterOutgoingViewingSecretKey, masterTaggingSecretKey, masterMessageSigningSecretKey, masterFallbackSecretKey } = secretKeys;
+    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);
+    // 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(await hashPublicKey(masterNullifierHidingPublicKey), masterIncomingViewingPublicKey, await hashPublicKey(masterOutgoingViewingPublicKey), await hashPublicKey(masterTaggingPublicKey), await hashPublicKey(masterMessageSigningPublicKey), await hashPublicKey(masterFallbackPublicKey));
+    return {
+        masterNullifierHidingSecretKey,
+        masterIncomingViewingSecretKey,
+        masterOutgoingViewingSecretKey,
+        masterTaggingSecretKey,
+        masterMessageSigningSecretKey,
+        masterFallbackSecretKey,
+        masterNullifierHidingPublicKey,
+        masterOutgoingViewingPublicKey,
+        masterTaggingPublicKey,
+        masterMessageSigningPublicKey,
+        masterFallbackPublicKey,
+        publicKeys
+    };
+}

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=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9rZXlzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsa0JBQWtCLENBQUMifQ==

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 { DomainSeparator } from '@aztec-labs/constants';
+export type KeyGenerator = DomainSeparator.NHK_M | DomainSeparator.IVSK_M | DomainSeparator.OVSK_M | DomainSeparator.TSK_M;
+export type KeyPrefix = 'n' | 'iv' | 'ov' | 't';
+export declare const KEY_PREFIXES: KeyPrefix[];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5X3R5cGVzLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMva2V5cy9rZXlfdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLEVBQUUsZUFBZSxFQUFFLE1BQU0sdUJBQXVCLENBQUM7QUFFN0QsTUFBTSxNQUFNLFlBQVksR0FDcEIsZUFBZSxDQUFDLEtBQUssR0FDckIsZUFBZSxDQUFDLE1BQU0sR0FDdEIsZUFBZSxDQUFDLE1BQU0sR0FDdEIsZUFBZSxDQUFDLEtBQUssQ0FBQztBQUMxQixNQUFNLE1BQU0sU0FBUyxHQUFHLEdBQUcsR0FBRyxJQUFJLEdBQUcsSUFBSSxHQUFHLEdBQUcsQ0FBQztBQUNoRCxlQUFPLE1BQU0sWUFBWSxFQUFFLFNBQVMsRUFBMkIsQ0FBQyJ9

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,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAE7D,MAAM,MAAM,YAAY,GACpB,eAAe,CAAC,KAAK,GACrB,eAAe,CAAC,MAAM,GACtB,eAAe,CAAC,MAAM,GACtB,eAAe,CAAC,KAAK,CAAC;AAC1B,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,23 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { Point } from '@aztec-labs/foundation/curves/grumpkin';
+/**
+ * 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 declare function hashPublicKey(pk: PublicKey): Promise<Fr>;
+/**
+ * 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 declare const PublicKey: typeof Point;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2tleS5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2tleXMvcHVibGljX2tleS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEVBQUUsRUFBRSxFQUFFLE1BQU0scUNBQXFDLENBQUM7QUFDekQsT0FBTyxFQUFFLEtBQUssRUFBRSxNQUFNLHdDQUF3QyxDQUFDO0FBRS9EOzs7Ozs7Ozs7O0dBVUc7QUFDSCx3QkFBZ0IsYUFBYSxDQUFDLEVBQUUsRUFBRSxTQUFTLEdBQUcsT0FBTyxDQUFDLEVBQUUsQ0FBQyxDQUV4RDtBQUVEOzs7OztHQUtHO0FBQ0gsTUFBTSxNQUFNLFNBQVMsR0FBRyxLQUFLLENBQUM7QUFDOUIsZUFBTyxNQUFNLFNBQVMsY0FBUSxDQUFDIn0=

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":"AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AACzD,OAAO,EAAE,KAAK,EAAE,MAAM,wCAAwC,CAAC;AAE/D;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,SAAS,GAAG,OAAO,CAAC,EAAE,CAAC,CAExD;AAED;;;;;GAKG;AACH,MAAM,MAAM,SAAS,GAAG,KAAK,CAAC;AAC9B,eAAO,MAAM,SAAS,cAAQ,CAAC"}

package/dest/keys/public_key.js

@@ -0,0 +1,20 @@
+import { DomainSeparator } from '@aztec-labs/constants';
+import { poseidon2HashWithSeparator } from '@aztec-labs/foundation/crypto/poseidon';
+import { Point } from '@aztec-labs/foundation/curves/grumpkin';
+/**
+ * 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) {
+    return poseidon2HashWithSeparator([
+        pk.x,
+        pk.y
+    ], DomainSeparator.SINGLE_PUBLIC_KEY_HASH);
+}
+export const PublicKey = Point;