@aztec-labs/foundation 6.0.0-nightly.20260829

package/dest/crypto/poseidon/index.js

@@ -0,0 +1,71 @@
+import { Barretenberg, BarretenbergSync } from '@aztec/bb.js';
+import { Fr } from '../../curves/bn254/field.js';
+import { serializeToFields } from '../../serialize/serialize.js';
+const IS_BROWSER = typeof self !== 'undefined';
+async function poseidon2HashFields(inputFields) {
+    if (IS_BROWSER) {
+        await BarretenbergSync.initSingleton();
+        const api = BarretenbergSync.getSingleton();
+        const response = api.poseidon2Hash({
+            inputs: inputFields.map((i)=>i.toBuffer())
+        });
+        return Fr.fromBuffer(Buffer.from(response.hash));
+    } else {
+        await Barretenberg.initSingleton();
+        const api = Barretenberg.getSingleton();
+        const response = await api.poseidon2Hash({
+            inputs: inputFields.map((i)=>i.toBuffer())
+        });
+        return Fr.fromBuffer(Buffer.from(response.hash));
+    }
+}
+/**
+ * Create a poseidon hash (field) from an array of input fields.
+ * @param input - The input fields to hash.
+ * @returns The poseidon hash.
+ */ export function poseidon2Hash(input) {
+    return poseidon2HashFields(serializeToFields(input));
+}
+/**
+ * Create a poseidon hash (field) from an array of input fields and a domain separator.
+ * @param input - The input fields to hash.
+ * @param separator - The domain separator.
+ * @returns The poseidon hash.
+ */ export function poseidon2HashWithSeparator(input, separator) {
+    const inputFields = serializeToFields(input);
+    inputFields.unshift(new Fr(separator));
+    return poseidon2HashFields(inputFields);
+}
+/**
+ * Runs a Poseidon2 permutation.
+ * @param input the input state. Expected to be of size 4.
+ * @returns the output state, size 4.
+ */ export async function poseidon2Permutation(input) {
+    const inputFields = serializeToFields(input);
+    if (IS_BROWSER) {
+        await BarretenbergSync.initSingleton();
+        const api = BarretenbergSync.getSingleton();
+        const response = api.poseidon2Permutation({
+            inputs: inputFields.map((i)=>i.toBuffer())
+        });
+        return response.outputs.map((o)=>Fr.fromBuffer(Buffer.from(o)));
+    } else {
+        await Barretenberg.initSingleton();
+        const api = Barretenberg.getSingleton();
+        const response = await api.poseidon2Permutation({
+            inputs: inputFields.map((i)=>i.toBuffer())
+        });
+        return response.outputs.map((o)=>Fr.fromBuffer(Buffer.from(o)));
+    }
+}
+export function poseidon2HashBytes(input) {
+    const inputFields = [];
+    for(let i = 0; i < input.length; i += 31){
+        const fieldBytes = Buffer.alloc(32, 0);
+        input.slice(i, i + 31).copy(fieldBytes);
+        // Noir builds the bytes as little-endian, so we need to reverse them.
+        fieldBytes.reverse();
+        inputFields.push(Fr.fromBuffer(fieldBytes));
+    }
+    return poseidon2HashFields(inputFields);
+}

package/dest/crypto/random/index.d.ts

@@ -0,0 +1,23 @@
+export declare const randomBytes: (len: number) => Buffer<ArrayBufferLike>;
+/**
+ * Generate a random integer less than max.
+ * @param max - The maximum value.
+ * @returns A random integer.
+ *
+ * TODO(#3949): This is insecure as it's modulo biased. Nuke or safeguard before mainnet.
+ */
+export declare const randomInt: (max: number) => number;
+/**
+ * Generate a random bigint less than max.
+ * @param max - The maximum value.
+ * @returns A random bigint.
+ *
+ * TODO(#3949): This is insecure as it's modulo biased. Nuke or safeguard before mainnet.
+ */
+export declare const randomBigInt: (max: bigint) => bigint;
+/**
+ * Generate a random boolean value.
+ * @returns A random boolean value.
+ */
+export declare const randomBoolean: () => boolean;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jcnlwdG8vcmFuZG9tL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUlBLGVBQU8sTUFBTSxXQUFXLDBDQU92QixDQUFDO0FBRUY7Ozs7OztHQU1HO0FBQ0gsZUFBTyxNQUFNLFNBQVMseUJBSXJCLENBQUM7QUFFRjs7Ozs7O0dBTUc7QUFDSCxlQUFPLE1BQU0sWUFBWSx5QkFJeEIsQ0FBQztBQUVGOzs7R0FHRztBQUNILGVBQU8sTUFBTSxhQUFhLGVBR3pCLENBQUMifQ==

package/dest/crypto/random/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/random/index.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW,0CAOvB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,yBAIrB,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,yBAIxB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,eAGzB,CAAC"}

package/dest/crypto/random/index.js

@@ -0,0 +1,38 @@
+import { randomBytes as bbRandomBytes } from '@aztec/bb.js';
+import { RandomnessSingleton } from './randomness_singleton.js';
+export const randomBytes = (len)=>{
+    const singleton = RandomnessSingleton.getInstance();
+    if (singleton.isDeterministic()) {
+        return singleton.getBytes(len);
+    }
+    return Buffer.from(bbRandomBytes(len));
+};
+/**
+ * Generate a random integer less than max.
+ * @param max - The maximum value.
+ * @returns A random integer.
+ *
+ * TODO(#3949): This is insecure as it's modulo biased. Nuke or safeguard before mainnet.
+ */ export const randomInt = (max)=>{
+    const randomBuffer = randomBytes(6); // Generate a buffer of 6 random bytes.
+    const randomInt = parseInt(randomBuffer.toString('hex'), 16); // Convert buffer to a large integer.
+    return randomInt % max; // Use modulo to ensure the result is less than max.
+};
+/**
+ * Generate a random bigint less than max.
+ * @param max - The maximum value.
+ * @returns A random bigint.
+ *
+ * TODO(#3949): This is insecure as it's modulo biased. Nuke or safeguard before mainnet.
+ */ export const randomBigInt = (max)=>{
+    const randomBuffer = randomBytes(8); // Generate a buffer of 8 random bytes.
+    const randomBigInt = BigInt(`0x${randomBuffer.toString('hex')}`); // Convert buffer to a large integer.
+    return randomBigInt % max; // Use modulo to ensure the result is less than max.
+};
+/**
+ * Generate a random boolean value.
+ * @returns A random boolean value.
+ */ export const randomBoolean = ()=>{
+    const randomByte = randomBytes(1)[0]; // Generate a single random byte.
+    return randomByte % 2 === 0; // Use modulo to determine if the byte is even or odd.
+};

package/dest/crypto/random/randomness_singleton.d.ts

@@ -0,0 +1,24 @@
+import { type LoggerBindings } from '../../log/pino-logger.js';
+/**
+ * A number generator which is used as a source of randomness in the system. If the SEED env variable is set, the
+ * generator will be deterministic and will always produce the same sequence of numbers. Otherwise a true randomness
+ * sourced by crypto library will be used.
+ * @remarks This class was implemented so that tests can be run deterministically.
+ *
+ * TODO(#3949): This is not safe enough for production and should be made safer or removed before mainnet.
+ */
+export declare class RandomnessSingleton {
+    private readonly seed?;
+    private static instance;
+    private counter;
+    private log;
+    private constructor();
+    static getInstance(bindings?: LoggerBindings): RandomnessSingleton;
+    /**
+     * Indicates whether the generator is deterministic (was seeded) or not.
+     * @returns Whether the generator is deterministic.
+     */
+    isDeterministic(): boolean;
+    getBytes(length: number): Buffer;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmFuZG9tbmVzc19zaW5nbGV0b24uZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jcnlwdG8vcmFuZG9tL3JhbmRvbW5lc3Nfc2luZ2xldG9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBZSxLQUFLLGNBQWMsRUFBZ0IsTUFBTSwwQkFBMEIsQ0FBQztBQUUxRjs7Ozs7OztHQU9HO0FBQ0gscUJBQWEsbUJBQW1CO0lBTzVCLE9BQU8sQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDO0lBTnhCLE9BQU8sQ0FBQyxNQUFNLENBQUMsUUFBUSxDQUFzQjtJQUU3QyxPQUFPLENBQUMsT0FBTyxDQUFLO0lBQ3BCLE9BQU8sQ0FBQyxHQUFHLENBQVM7SUFFcEIsT0FBTyxlQVdOO0lBRUQsT0FBYyxXQUFXLENBQUMsUUFBUSxDQUFDLEVBQUUsY0FBYyxHQUFHLG1CQUFtQixDQU94RTtJQUVEOzs7T0FHRztJQUNJLGVBQWUsSUFBSSxPQUFPLENBRWhDO0lBRU0sUUFBUSxDQUFDLE1BQU0sRUFBRSxNQUFNLEdBQUcsTUFBTSxDQWdCdEM7Q0FDRiJ9

package/dest/crypto/random/randomness_singleton.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomness_singleton.d.ts","sourceRoot":"","sources":["../../../src/crypto/random/randomness_singleton.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,cAAc,EAAgB,MAAM,0BAA0B,CAAC;AAE1F;;;;;;;GAOG;AACH,qBAAa,mBAAmB;IAO5B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;IANxB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAsB;IAE7C,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,GAAG,CAAS;IAEpB,OAAO,eAWN;IAED,OAAc,WAAW,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,mBAAmB,CAOxE;IAED;;;OAGG;IACI,eAAe,IAAI,OAAO,CAEhC;IAEM,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAgBtC;CACF"}

package/dest/crypto/random/randomness_singleton.js

@@ -0,0 +1,55 @@
+import { createLogger } from '../../log/pino-logger.js';
+/**
+ * A number generator which is used as a source of randomness in the system. If the SEED env variable is set, the
+ * generator will be deterministic and will always produce the same sequence of numbers. Otherwise a true randomness
+ * sourced by crypto library will be used.
+ * @remarks This class was implemented so that tests can be run deterministically.
+ *
+ * TODO(#3949): This is not safe enough for production and should be made safer or removed before mainnet.
+ */ export class RandomnessSingleton {
+    seed;
+    static instance;
+    counter;
+    log;
+    constructor(seed, bindings){
+        this.seed = seed;
+        this.counter = 0;
+        this.log = createLogger('foundation:randomness_singleton', bindings);
+        if (seed !== undefined) {
+            this.log.debug(`Using pseudo-randomness with seed: ${seed}`);
+            this.counter = seed;
+        } else {
+            this.log.debug('Using true randomness');
+        }
+    }
+    static getInstance(bindings) {
+        if (!RandomnessSingleton.instance) {
+            const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+            RandomnessSingleton.instance = new RandomnessSingleton(seed, bindings);
+        }
+        return RandomnessSingleton.instance;
+    }
+    /**
+   * Indicates whether the generator is deterministic (was seeded) or not.
+   * @returns Whether the generator is deterministic.
+   */ isDeterministic() {
+        return this.seed !== undefined;
+    }
+    getBytes(length) {
+        if (this.seed === undefined) {
+            // Note: It would be more natural to just have the contents of randomBytes(...) function from
+            // yarn-project/foundation/src/crypto/random/index.ts here but that would result in a larger
+            // refactor so I think prohibiting use of this func when the seed is undefined is and handling
+            // the singleton within randomBytes func is fine.
+            throw new Error('RandomnessSingleton is not implemented for non-deterministic mode');
+        }
+        const result = Buffer.alloc(length);
+        for(let i = 0; i < length; i++){
+            // Each byte of the buffer is set to a 1 byte of this.counter's value. 0xff is 255 in decimal and it's used as
+            // a mask to get the last 8 bits of the shifted counter.
+            result[i] = this.counter >> i * 8 & 0xff;
+        }
+        this.counter++;
+        return result;
+    }
+}

package/dest/crypto/schnorr/index.d.ts

@@ -0,0 +1,32 @@
+import type { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { GrumpkinScalar } from '@aztec-labs/foundation/curves/grumpkin';
+import { Point } from '@aztec-labs/foundation/curves/grumpkin';
+import { SchnorrSignature } from './signature.js';
+export * from './signature.js';
+/**
+ * Schnorr signature construction and helper operations.
+ */
+export declare class Schnorr {
+    /**
+     * Computes a grumpkin public key from a private key.
+     * @param privateKey - The private key.
+     * @returns A grumpkin public key.
+     */
+    computePublicKey(privateKey: GrumpkinScalar): Promise<Point>;
+    /**
+     * Constructs a Schnorr signature over a 32-byte message field element.
+     * @param msg - The message hash, as a grumpkin base field element.
+     * @param privateKey - The private key of the signer.
+     * @returns A Schnorr signature of the form (s, e).
+     */
+    constructSignature(msg: Fr, privateKey: GrumpkinScalar): Promise<SchnorrSignature>;
+    /**
+     * Verifies a Schnorr signature against a Grumpkin public key.
+     * @param msg - The message hash, as a grumpkin base field element.
+     * @param pubKey - The Grumpkin public key of the signer.
+     * @param sig - The Schnorr signature.
+     * @returns True or false.
+     */
+    verifySignature(msg: Fr, pubKey: Point, sig: SchnorrSignature): Promise<boolean>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jcnlwdG8vc2Nobm9yci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxPQUFPLEtBQUssRUFBRSxFQUFFLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUM5RCxPQUFPLEtBQUssRUFBRSxjQUFjLEVBQUUsTUFBTSx3Q0FBd0MsQ0FBQztBQUM3RSxPQUFPLEVBQUUsS0FBSyxFQUFFLE1BQU0sd0NBQXdDLENBQUM7QUFFL0QsT0FBTyxFQUFFLGdCQUFnQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFbEQsY0FBYyxnQkFBZ0IsQ0FBQztBQUUvQjs7R0FFRztBQUNILHFCQUFhLE9BQU87SUFDbEI7Ozs7T0FJRztJQUNVLGdCQUFnQixDQUFDLFVBQVUsRUFBRSxjQUFjLEdBQUcsT0FBTyxDQUFDLEtBQUssQ0FBQyxDQUt4RTtJQUVEOzs7OztPQUtHO0lBQ1Usa0JBQWtCLENBQUMsR0FBRyxFQUFFLEVBQUUsRUFBRSxVQUFVLEVBQUUsY0FBYyw2QkFRbEU7SUFFRDs7Ozs7O09BTUc7SUFDVSxlQUFlLENBQUMsR0FBRyxFQUFFLEVBQUUsRUFBRSxNQUFNLEVBQUUsS0FBSyxFQUFFLEdBQUcsRUFBRSxnQkFBZ0Isb0JBVXpFO0NBQ0YifQ==

package/dest/crypto/schnorr/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/schnorr/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAC9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,wCAAwC,CAAC;AAC7E,OAAO,EAAE,KAAK,EAAE,MAAM,wCAAwC,CAAC;AAE/D,OAAO,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AAElD,cAAc,gBAAgB,CAAC;AAE/B;;GAEG;AACH,qBAAa,OAAO;IAClB;;;;OAIG;IACU,gBAAgB,CAAC,UAAU,EAAE,cAAc,GAAG,OAAO,CAAC,KAAK,CAAC,CAKxE;IAED;;;;;OAKG;IACU,kBAAkB,CAAC,GAAG,EAAE,EAAE,EAAE,UAAU,EAAE,cAAc,6BAQlE;IAED;;;;;;OAMG;IACU,eAAe,CAAC,GAAG,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,gBAAgB,oBAUzE;CACF"}

package/dest/crypto/schnorr/index.js

@@ -0,0 +1,60 @@
+import { BarretenbergSync } from '@aztec/bb.js';
+import { Point } from '@aztec-labs/foundation/curves/grumpkin';
+import { SchnorrSignature } from './signature.js';
+export * from './signature.js';
+/**
+ * Schnorr signature construction and helper operations.
+ */ export class Schnorr {
+    /**
+   * Computes a grumpkin public key from a private key.
+   * @param privateKey - The private key.
+   * @returns A grumpkin public key.
+   */ async computePublicKey(privateKey) {
+        await BarretenbergSync.initSingleton();
+        const api = BarretenbergSync.getSingleton();
+        const response = api.schnorrComputePublicKey({
+            privateKey: privateKey.toBuffer()
+        });
+        return Point.fromBuffer(Buffer.concat([
+            Buffer.from(response.publicKey.x),
+            Buffer.from(response.publicKey.y)
+        ]));
+    }
+    /**
+   * Constructs a Schnorr signature over a 32-byte message field element.
+   * @param msg - The message hash, as a grumpkin base field element.
+   * @param privateKey - The private key of the signer.
+   * @returns A Schnorr signature of the form (s, e).
+   */ async constructSignature(msg, privateKey) {
+        await BarretenbergSync.initSingleton();
+        const api = BarretenbergSync.getSingleton();
+        const response = api.schnorrConstructSignature({
+            messageField: msg.toBuffer(),
+            privateKey: privateKey.toBuffer()
+        });
+        return new SchnorrSignature(Buffer.from([
+            ...response.s,
+            ...response.e
+        ]));
+    }
+    /**
+   * Verifies a Schnorr signature against a Grumpkin public key.
+   * @param msg - The message hash, as a grumpkin base field element.
+   * @param pubKey - The Grumpkin public key of the signer.
+   * @param sig - The Schnorr signature.
+   * @returns True or false.
+   */ async verifySignature(msg, pubKey, sig) {
+        await BarretenbergSync.initSingleton();
+        const api = BarretenbergSync.getSingleton();
+        const response = api.schnorrVerifySignature({
+            messageField: msg.toBuffer(),
+            publicKey: {
+                x: pubKey.x.toBuffer(),
+                y: pubKey.y.toBuffer()
+            },
+            s: sig.s,
+            e: sig.e
+        });
+        return response.verified;
+    }
+}

package/dest/crypto/schnorr/signature.d.ts

@@ -0,0 +1,48 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import type { Signature } from '../signature/index.js';
+/**
+ * Schnorr signature used for transactions.
+ * @see cpp/barretenberg/cpp/src/barretenberg/crypto/schnorr/schnorr.hpp
+ */
+export declare class SchnorrSignature implements Signature {
+    private buffer;
+    /**
+     * The size of the signature in bytes.
+     */
+    static SIZE: number;
+    constructor(buffer: Buffer);
+    /**
+     * Returns the 's' component of the signature.
+     * @returns A buffer containing the signature's 's' component.
+     */
+    get s(): Buffer<ArrayBufferLike>;
+    /**
+     * Returns the 'e' component of the signature.
+     * @returns A buffer containing the signature's 'e' component.
+     */
+    get e(): Buffer<ArrayBufferLike>;
+    /**
+     * Returns the full signature as a buffer.
+     * @returns A buffer containing the signature.
+     */
+    toBuffer(): Buffer<ArrayBufferLike>;
+    /**
+     * Returns the full signature as a hex string.
+     * @returns A string containing the signature in hex format.
+     */
+    toString(): string;
+    /**
+     * Converts the signature to an array of three fields.
+     * @returns The signature components as an array of three fields
+     */
+    toFields(): Fr[];
+    /**
+     * Splits the signature into the four 128-bit limbs that Noir's `EmbeddedCurveScalar` consumes:
+     * `[s.lo, s.hi, e.lo, e.hi]`, where each component scalar is encoded as `lo + hi * 2^128`.
+     *
+     * Each 32-byte big-endian component is sliced into its top 16 bytes (`hi`) and bottom 16 bytes
+     * (`lo`); each half is zero-padded into a 32-byte buffer and decoded as `Fr` (big-endian).
+     */
+    toLimbFields(): [Fr, Fr, Fr, Fr];
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2lnbmF0dXJlLmQudHMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY3J5cHRvL3NjaG5vcnIvc2lnbmF0dXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxFQUFFLEVBQUUsTUFBTSxxQ0FBcUMsQ0FBQztBQUd6RCxPQUFPLEtBQUssRUFBRSxTQUFTLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUV2RDs7O0dBR0c7QUFDSCxxQkFBYSxnQkFBaUIsWUFBVyxTQUFTO0lBTXBDLE9BQU8sQ0FBQyxNQUFNO0lBTDFCOztPQUVHO0lBQ0gsT0FBYyxJQUFJLFNBQU07SUFFeEIsWUFBb0IsTUFBTSxFQUFFLE1BQU0sRUFJakM7SUFFRDs7O09BR0c7SUFDSCxJQUFJLENBQUMsNEJBRUo7SUFFRDs7O09BR0c7SUFDSCxJQUFJLENBQUMsNEJBRUo7SUFFRDs7O09BR0c7SUFDSCxRQUFRLDRCQUVQO0lBRUQ7OztPQUdHO0lBQ0gsUUFBUSxXQUVQO0lBRUQ7OztPQUdHO0lBQ0gsUUFBUSxJQUFJLEVBQUUsRUFBRSxDQVlmO0lBRUQ7Ozs7OztPQU1HO0lBQ0gsWUFBWSxJQUFJLENBQUMsRUFBRSxFQUFFLEVBQUUsRUFBRSxFQUFFLEVBQUUsRUFBRSxDQUFDLENBTy9CO0NBQ0YifQ==

package/dest/crypto/schnorr/signature.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signature.d.ts","sourceRoot":"","sources":["../../../src/crypto/schnorr/signature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,MAAM,qCAAqC,CAAC;AAGzD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;;GAGG;AACH,qBAAa,gBAAiB,YAAW,SAAS;IAMpC,OAAO,CAAC,MAAM;IAL1B;;OAEG;IACH,OAAc,IAAI,SAAM;IAExB,YAAoB,MAAM,EAAE,MAAM,EAIjC;IAED;;;OAGG;IACH,IAAI,CAAC,4BAEJ;IAED;;;OAGG;IACH,IAAI,CAAC,4BAEJ;IAED;;;OAGG;IACH,QAAQ,4BAEP;IAED;;;OAGG;IACH,QAAQ,WAEP;IAED;;;OAGG;IACH,QAAQ,IAAI,EAAE,EAAE,CAYf;IAED;;;;;;OAMG;IACH,YAAY,IAAI,CAAC,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,EAAE,CAAC,CAO/B;CACF"}

package/dest/crypto/schnorr/signature.js

@@ -0,0 +1,77 @@
+import { Fr } from '@aztec-labs/foundation/curves/bn254';
+import { mapTuple } from '@aztec-labs/foundation/serialize';
+/**
+ * Schnorr signature used for transactions.
+ * @see cpp/barretenberg/cpp/src/barretenberg/crypto/schnorr/schnorr.hpp
+ */ export class SchnorrSignature {
+    buffer;
+    /**
+   * The size of the signature in bytes.
+   */ static SIZE = 64;
+    constructor(buffer){
+        this.buffer = buffer;
+        if (buffer.length !== SchnorrSignature.SIZE) {
+            throw new Error(`Invalid signature buffer of length ${buffer.length}.`);
+        }
+    }
+    /**
+   * Returns the 's' component of the signature.
+   * @returns A buffer containing the signature's 's' component.
+   */ get s() {
+        return this.buffer.subarray(0, 32);
+    }
+    /**
+   * Returns the 'e' component of the signature.
+   * @returns A buffer containing the signature's 'e' component.
+   */ get e() {
+        return this.buffer.subarray(32);
+    }
+    /**
+   * Returns the full signature as a buffer.
+   * @returns A buffer containing the signature.
+   */ toBuffer() {
+        return this.buffer;
+    }
+    /**
+   * Returns the full signature as a hex string.
+   * @returns A string containing the signature in hex format.
+   */ toString() {
+        return `0x${this.buffer.toString('hex')}`;
+    }
+    /**
+   * Converts the signature to an array of three fields.
+   * @returns The signature components as an array of three fields
+   */ toFields() {
+        const sig = this.toBuffer();
+        const buf1 = Buffer.alloc(32);
+        const buf2 = Buffer.alloc(32);
+        const buf3 = Buffer.alloc(32);
+        sig.copy(buf1, 1, 0, 31);
+        sig.copy(buf2, 1, 31, 62);
+        sig.copy(buf3, 1, 62, 64);
+        return mapTuple([
+            buf1,
+            buf2,
+            buf3
+        ], Fr.fromBuffer);
+    }
+    /**
+   * Splits the signature into the four 128-bit limbs that Noir's `EmbeddedCurveScalar` consumes:
+   * `[s.lo, s.hi, e.lo, e.hi]`, where each component scalar is encoded as `lo + hi * 2^128`.
+   *
+   * Each 32-byte big-endian component is sliced into its top 16 bytes (`hi`) and bottom 16 bytes
+   * (`lo`); each half is zero-padded into a 32-byte buffer and decoded as `Fr` (big-endian).
+   */ toLimbFields() {
+        const limb = (start)=>{
+            const buf = Buffer.alloc(32);
+            this.buffer.copy(buf, 16, start, start + 16);
+            return Fr.fromBuffer(buf);
+        };
+        return [
+            limb(16),
+            limb(0),
+            limb(48),
+            limb(32)
+        ];
+    }
+}

package/dest/crypto/secp256k1/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Secp256k1 elliptic curve operations.
+ */
+export declare class Secp256k1 {
+    static generator: Buffer<ArrayBuffer>;
+    /**
+     * Point generator
+     * @returns The generator for the curve.
+     */
+    generator(): Buffer;
+    /**
+     * Multiplies a point by a scalar (adds the point `scalar` amount of time).
+     * @param point - Point to multiply.
+     * @param scalar - Scalar to multiply by.
+     * @returns Result of the multiplication.
+     */
+    mul(point: Uint8Array, scalar: Uint8Array): Promise<Buffer<ArrayBuffer>>;
+    /**
+     * Gets a random field element.
+     * @returns Random field element.
+     */
+    getRandomFr(): Promise<Buffer<ArrayBuffer>>;
+    /**
+     * Converts a 512 bits long buffer to a field.
+     * @param uint512Buf - The buffer to convert.
+     * @returns Buffer representation of the field element.
+     */
+    reduce512BufferToFr(uint512Buf: Buffer): Promise<Buffer<ArrayBuffer>>;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jcnlwdG8vc2VjcDI1NmsxL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOztHQUVHO0FBQ0gscUJBQWEsU0FBUztJQUVwQixNQUFNLENBQUMsU0FBUyxzQkFLYjtJQUVIOzs7T0FHRztJQUNJLFNBQVMsSUFBSSxNQUFNLENBRXpCO0lBRUQ7Ozs7O09BS0c7SUFDVSxHQUFHLENBQUMsS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLEVBQUUsVUFBVSxnQ0FRckQ7SUFFRDs7O09BR0c7SUFDVSxXQUFXLGlDQUt2QjtJQUVEOzs7O09BSUc7SUFDVSxtQkFBbUIsQ0FBQyxVQUFVLEVBQUUsTUFBTSxnQ0FLbEQ7Q0FDRiJ9

package/dest/crypto/secp256k1/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/secp256k1/index.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,qBAAa,SAAS;IAEpB,MAAM,CAAC,SAAS,sBAKb;IAEH;;;OAGG;IACI,SAAS,IAAI,MAAM,CAEzB;IAED;;;;;OAKG;IACU,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU,gCAQrD;IAED;;;OAGG;IACU,WAAW,iCAKvB;IAED;;;;OAIG;IACU,mBAAmB,CAAC,UAAU,EAAE,MAAM,gCAKlD;CACF"}

package/dest/crypto/secp256k1/index.js

@@ -0,0 +1,121 @@
+import { BarretenbergSync } from '@aztec/bb.js';
+/**
+ * Secp256k1 elliptic curve operations.
+ */ export class Secp256k1 {
+    // prettier-ignore
+    static generator = Buffer.from([
+        0x79,
+        0xbe,
+        0x66,
+        0x7e,
+        0xf9,
+        0xdc,
+        0xbb,
+        0xac,
+        0x55,
+        0xa0,
+        0x62,
+        0x95,
+        0xce,
+        0x87,
+        0x0b,
+        0x07,
+        0x02,
+        0x9b,
+        0xfc,
+        0xdb,
+        0x2d,
+        0xce,
+        0x28,
+        0xd9,
+        0x59,
+        0xf2,
+        0x81,
+        0x5b,
+        0x16,
+        0xf8,
+        0x17,
+        0x98,
+        0x48,
+        0x3a,
+        0xda,
+        0x77,
+        0x26,
+        0xa3,
+        0xc4,
+        0x65,
+        0x5d,
+        0xa4,
+        0xfb,
+        0xfc,
+        0x0e,
+        0x11,
+        0x08,
+        0xa8,
+        0xfd,
+        0x17,
+        0xb4,
+        0x48,
+        0xa6,
+        0x85,
+        0x54,
+        0x19,
+        0x9c,
+        0x47,
+        0xd0,
+        0x8f,
+        0xfb,
+        0x10,
+        0xd4,
+        0xb8
+    ]);
+    /**
+   * Point generator
+   * @returns The generator for the curve.
+   */ generator() {
+        return Secp256k1.generator;
+    }
+    /**
+   * Multiplies a point by a scalar (adds the point `scalar` amount of time).
+   * @param point - Point to multiply.
+   * @param scalar - Scalar to multiply by.
+   * @returns Result of the multiplication.
+   */ async mul(point, scalar) {
+        await BarretenbergSync.initSingleton();
+        const api = BarretenbergSync.getSingleton();
+        const response = api.secp256k1Mul({
+            point: {
+                x: point.subarray(0, 32),
+                y: point.subarray(32, 64)
+            },
+            scalar
+        });
+        return Buffer.concat([
+            Buffer.from(response.point.x),
+            Buffer.from(response.point.y)
+        ]);
+    }
+    /**
+   * Gets a random field element.
+   * @returns Random field element.
+   */ async getRandomFr() {
+        await BarretenbergSync.initSingleton();
+        const api = BarretenbergSync.getSingleton();
+        const response = api.secp256k1GetRandomFr({
+            dummy: 0
+        });
+        return Buffer.from(response.value);
+    }
+    /**
+   * Converts a 512 bits long buffer to a field.
+   * @param uint512Buf - The buffer to convert.
+   * @returns Buffer representation of the field element.
+   */ async reduce512BufferToFr(uint512Buf) {
+        await BarretenbergSync.initSingleton();
+        const api = BarretenbergSync.getSingleton();
+        const response = api.secp256k1Reduce512({
+            input: uint512Buf
+        });
+        return Buffer.from(response.value);
+    }
+}

package/dest/crypto/secp256k1-signer/index.d.ts

@@ -0,0 +1,3 @@
+export * from './secp256k1_signer.js';
+export * from './utils.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9jcnlwdG8vc2VjcDI1NmsxLXNpZ25lci9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsWUFBWSxDQUFDIn0=

package/dest/crypto/secp256k1-signer/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/secp256k1-signer/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,YAAY,CAAC"}

package/dest/crypto/secp256k1-signer/index.js

@@ -0,0 +1,2 @@
+export * from './secp256k1_signer.js';
+export * from './utils.js';

package/dest/crypto/secp256k1-signer/secp256k1_signer.d.ts

@@ -0,0 +1,24 @@
+import { Buffer32 } from '@aztec-labs/foundation/buffer';
+import type { EthAddress } from '@aztec-labs/foundation/eth-address';
+import type { Signature } from '@aztec-labs/foundation/eth-signature';
+/**
+ * Secp256k1Signer
+ *
+ * A class for signing messages using a secp256k1 private key.
+ * - This is a slim drop in replacement for an Ethereum signer, so it can be used in the same way.
+ * - See `utils.ts` for functions that enable recovering addresses and public keys from signatures.
+ */
+export declare class Secp256k1Signer {
+    private privateKey;
+    readonly address: EthAddress;
+    constructor(privateKey: Buffer32);
+    sign(message: Buffer32): Signature;
+    /**
+     * Sign a message using the same method as eth_sign
+     * @param message - The message to sign.
+     * @returns The signature.
+     */
+    signMessage(message: Buffer32): Signature;
+    static random(): Secp256k1Signer;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic2VjcDI1NmsxX3NpZ25lci5kLnRzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2NyeXB0by9zZWNwMjU2azEtc2lnbmVyL3NlY3AyNTZrMV9zaWduZXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLCtCQUErQixDQUFDO0FBQ3pELE9BQU8sS0FBSyxFQUFFLFVBQVUsRUFBRSxNQUFNLG9DQUFvQyxDQUFDO0FBQ3JFLE9BQU8sS0FBSyxFQUFFLFNBQVMsRUFBRSxNQUFNLHNDQUFzQyxDQUFDO0FBSXRFOzs7Ozs7R0FNRztBQUNILHFCQUFhLGVBQWU7SUFHZCxPQUFPLENBQUMsVUFBVTtJQUY5QixTQUFnQixPQUFPLEVBQUUsVUFBVSxDQUFDO0lBRXBDLFlBQW9CLFVBQVUsRUFBRSxRQUFRLEVBRXZDO0lBRUQsSUFBSSxDQUFDLE9BQU8sRUFBRSxRQUFRLEdBQUcsU0FBUyxDQUVqQztJQUVEOzs7O09BSUc7SUFDSCxXQUFXLENBQUMsT0FBTyxFQUFFLFFBQVEsR0FBRyxTQUFTLENBR3hDO0lBRUQsTUFBTSxDQUFDLE1BQU0sSUFBSSxlQUFlLENBRS9CO0NBQ0YifQ==

package/dest/crypto/secp256k1-signer/secp256k1_signer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secp256k1_signer.d.ts","sourceRoot":"","sources":["../../../src/crypto/secp256k1-signer/secp256k1_signer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,+BAA+B,CAAC;AACzD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oCAAoC,CAAC;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAItE;;;;;;GAMG;AACH,qBAAa,eAAe;IAGd,OAAO,CAAC,UAAU;IAF9B,SAAgB,OAAO,EAAE,UAAU,CAAC;IAEpC,YAAoB,UAAU,EAAE,QAAQ,EAEvC;IAED,IAAI,CAAC,OAAO,EAAE,QAAQ,GAAG,SAAS,CAEjC;IAED;;;;OAIG;IACH,WAAW,CAAC,OAAO,EAAE,QAAQ,GAAG,SAAS,CAGxC;IAED,MAAM,CAAC,MAAM,IAAI,eAAe,CAE/B;CACF"}