@aztec/foundation 0.0.0-test.0

package/dest/crypto/poseidon/index.js

@@ -0,0 +1,58 @@
+import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+import { Fr } from '../../fields/fields.js';
+import { serializeToFields } from '../../serialize/serialize.js';
+/**
+ * Create a poseidon hash (field) from an array of input fields.
+ * @param input - The input fields to hash.
+ * @returns The poseidon hash.
+ */ export async function poseidon2Hash(input) {
+    const inputFields = serializeToFields(input);
+    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+    const hash = api.poseidon2Hash(inputFields.map((i)=>new FrBarretenberg(i.toBuffer())));
+    return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+/**
+ * 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 async function poseidon2HashWithSeparator(input, separator) {
+    const inputFields = serializeToFields(input);
+    inputFields.unshift(new Fr(separator));
+    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+    const hash = api.poseidon2Hash(inputFields.map((i)=>new FrBarretenberg(i.toBuffer())));
+    return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+export async function poseidon2HashAccumulate(input) {
+    const inputFields = serializeToFields(input);
+    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+    const result = api.poseidon2HashAccumulate(inputFields.map((i)=>new FrBarretenberg(i.toBuffer())));
+    return Fr.fromBuffer(Buffer.from(result.toBuffer()));
+}
+/**
+ * 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);
+    // We'd like this assertion but it's not possible to use it in the browser.
+    // assert(input.length === 4, 'Input state must be of size 4');
+    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+    const res = api.poseidon2Permutation(inputFields.map((i)=>new FrBarretenberg(i.toBuffer())));
+    // We'd like this assertion but it's not possible to use it in the browser.
+    // assert(res.length === 4, 'Output state must be of size 4');
+    return res.map((o)=>Fr.fromBuffer(Buffer.from(o.toBuffer())));
+}
+export async 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));
+    }
+    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+    const res = api.poseidon2Hash(inputFields.map((i)=>new FrBarretenberg(i.toBuffer())));
+    return Fr.fromBuffer(Buffer.from(res.toBuffer()));
+}

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

@@ -0,0 +1,25 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+export declare const randomBytes: (len: number) => Buffer;
+/**
+ * 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=index.d.ts.map

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":";;AAmBA,eAAO,MAAM,WAAW,QAAS,MAAM,WA8BtC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,QAAS,MAAM,WAIpC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,QAAS,MAAM,WAIvC,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,aAAa,eAGzB,CAAC"}

package/dest/crypto/random/index.js

@@ -0,0 +1,70 @@
+import nodeCrypto from 'crypto';
+import isNode from 'detect-node';
+import { RandomnessSingleton } from './randomness_singleton.js';
+// limit of Crypto.getRandomValues()
+// https://developer.mozilla.org/en-US/docs/Web/API/Crypto/getRandomValues
+const MAX_BYTES = 65536;
+const getWebCrypto = ()=>{
+    if (typeof window !== 'undefined' && window.crypto) {
+        return window.crypto;
+    }
+    if (typeof self !== 'undefined' && self.crypto) {
+        return self.crypto;
+    }
+    return undefined;
+};
+export const randomBytes = (len)=>{
+    const singleton = RandomnessSingleton.getInstance();
+    if (singleton.isDeterministic()) {
+        return singleton.getBytes(len);
+    }
+    if (isNode) {
+        return nodeCrypto.randomBytes(len);
+    }
+    const crypto = getWebCrypto();
+    if (!crypto) {
+        throw new Error('randomBytes UnsupportedEnvironment');
+    }
+    const buf = Buffer.allocUnsafe(len);
+    if (len > MAX_BYTES) {
+        // this is the max bytes crypto.getRandomValues
+        // can do at once see https://developer.mozilla.org/en-US/docs/Web/API/window.crypto.getRandomValues
+        for(let generated = 0; generated < len; generated += MAX_BYTES){
+            // buffer.slice automatically checks if the end is past the end of
+            // the buffer so we don't have to here
+            crypto.getRandomValues(buf.slice(generated, generated + MAX_BYTES));
+        }
+    } else {
+        crypto.getRandomValues(buf);
+    }
+    return buf;
+};
+/**
+ * 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,25 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * 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 readonly log;
+    private static instance;
+    private counter;
+    private constructor();
+    static getInstance(): RandomnessSingleton;
+    /**
+     * Indicates whether the generator is deterministic (was seeded) or not.
+     * @returns Whether the generator is deterministic.
+     */
+    isDeterministic(): boolean;
+    getBytes(length: number): Buffer;
+}
+//# sourceMappingURL=randomness_singleton.d.ts.map

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":";;AAEA;;;;;;;GAOG;AACH,qBAAa,mBAAmB;IAM5B,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC;IACtB,OAAO,CAAC,QAAQ,CAAC,GAAG;IANtB,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAsB;IAE7C,OAAO,CAAC,OAAO,CAAK;IAEpB,OAAO;WAYO,WAAW,IAAI,mBAAmB;IAShD;;;OAGG;IACI,eAAe,IAAI,OAAO;IAI1B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;CAiBxC"}

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;
+    log;
+    static instance;
+    counter;
+    constructor(seed, log = createLogger('foundation:randomness_singleton')){
+        this.seed = seed;
+        this.log = log;
+        this.counter = 0;
+        if (seed !== undefined) {
+            this.log.debug(`Using pseudo-randomness with seed: ${seed}`);
+            this.counter = seed;
+        } else {
+            this.log.debug('Using true randomness');
+        }
+    }
+    static getInstance() {
+        if (!RandomnessSingleton.instance) {
+            const seed = process.env.SEED ? Number(process.env.SEED) : undefined;
+            RandomnessSingleton.instance = new RandomnessSingleton(seed);
+        }
+        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,30 @@
+import { type GrumpkinScalar, Point } from '@aztec/foundation/fields';
+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 given a msg and a private key.
+     * @param msg - Message over which the signature is constructed.
+     * @param privateKey - The private key of the signer.
+     * @returns A Schnorr signature of the form (s, e).
+     */
+    constructSignature(msg: Uint8Array, privateKey: GrumpkinScalar): Promise<SchnorrSignature>;
+    /**
+     * Verifies a Schnorr signature given a Grumpkin public key.
+     * @param msg - Message over which the signature was constructed.
+     * @param pubKey - The Grumpkin public key of the signer.
+     * @param sig - The Schnorr signature.
+     * @returns True or false.
+     */
+    verifySignature(msg: Uint8Array, pubKey: Point, sig: SchnorrSignature): Promise<boolean>;
+}
+//# sourceMappingURL=index.d.ts.map

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":"AACA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,EAAE,MAAM,0BAA0B,CAAC;AAItE,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;IAMzE;;;;;OAKG;IACU,kBAAkB,CAAC,GAAG,EAAE,UAAU,EAAE,UAAU,EAAE,cAAc;IAS3E;;;;;;OAMG;IACU,eAAe,CAAC,GAAG,EAAE,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,gBAAgB;CAQnF"}

package/dest/crypto/schnorr/index.js

@@ -0,0 +1,68 @@
+import { BarretenbergSync } from '@aztec/bb.js';
+import { Point } from '@aztec/foundation/fields';
+import { numToInt32BE } from '@aztec/foundation/serialize';
+import { concatenateUint8Arrays } from '../serialize.js';
+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) {
+        const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+        const [result] = api.getWasm().callWasmExport('schnorr_compute_public_key', [
+            privateKey.toBuffer()
+        ], [
+            64
+        ]);
+        return Point.fromBuffer(Buffer.from(result));
+    }
+    /**
+   * Constructs a Schnorr signature given a msg and a private key.
+   * @param msg - Message over which the signature is constructed.
+   * @param privateKey - The private key of the signer.
+   * @returns A Schnorr signature of the form (s, e).
+   */ async constructSignature(msg, privateKey) {
+        const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+        const messageArray = concatenateUint8Arrays([
+            numToInt32BE(msg.length),
+            msg
+        ]);
+        const [s, e] = api.getWasm().callWasmExport('schnorr_construct_signature', [
+            messageArray,
+            privateKey.toBuffer()
+        ], [
+            32,
+            32
+        ]);
+        return new SchnorrSignature(Buffer.from([
+            ...s,
+            ...e
+        ]));
+    }
+    /**
+   * Verifies a Schnorr signature given a Grumpkin public key.
+   * @param msg - Message over which the signature was constructed.
+   * @param pubKey - The Grumpkin public key of the signer.
+   * @param sig - The Schnorr signature.
+   * @returns True or false.
+   */ async verifySignature(msg, pubKey, sig) {
+        const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+        const messageArray = concatenateUint8Arrays([
+            numToInt32BE(msg.length),
+            msg
+        ]);
+        const [result] = api.getWasm().callWasmExport('schnorr_verify_signature', [
+            messageArray,
+            pubKey.toBuffer(),
+            sig.s,
+            sig.e
+        ], [
+            1
+        ]);
+        return result[0] === 1;
+    }
+}

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

@@ -0,0 +1,70 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader } from '@aztec/foundation/serialize';
+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;
+    /**
+     * An empty signature.
+     */
+    static EMPTY: SchnorrSignature;
+    constructor(buffer: Buffer);
+    /**
+     * Determines if the provided signature is valid or not.
+     * @param signature - The data to be checked.
+     * @returns Boolean indicating if the provided data is a valid schnorr signature.
+     */
+    static isSignature(signature: string): boolean;
+    /**
+     * Constructs a SchnorrSignature from the provided string.
+     * @param signature - The string to be converted to a schnorr signature.
+     * @returns The constructed schnorr signature.
+     */
+    static fromString(signature: string): SchnorrSignature;
+    /**
+     * Generates a random schnorr signature.
+     * @returns The randomly constructed signature.
+     */
+    static random(): SchnorrSignature;
+    /**
+     * Returns the 's' component of the signature.
+     * @returns A buffer containing the signature's 's' component.
+     */
+    get s(): Buffer;
+    /**
+     * Returns the 'e' component of the signature.
+     * @returns A buffer containing the signature's 'e' component.
+     */
+    get e(): Buffer;
+    /**
+     * Returns the full signature as a buffer.
+     * @returns A buffer containing the signature.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Deserializes from a buffer.
+     * @param buffer - The buffer representation of the object.
+     * @returns The new object.
+     */
+    static fromBuffer(buffer: Buffer | BufferReader): SchnorrSignature;
+    /**
+     * 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[];
+}
+//# sourceMappingURL=signature.d.ts.map

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":";;AACA,OAAO,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAC9C,OAAO,EAAE,YAAY,EAAY,MAAM,6BAA6B,CAAC;AAErE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEvD;;;GAGG;AACH,qBAAa,gBAAiB,YAAW,SAAS;IAWpC,OAAO,CAAC,MAAM;IAV1B;;OAEG;IACH,OAAc,IAAI,SAAM;IAExB;;OAEG;IACH,OAAc,KAAK,mBAA0C;gBAEzC,MAAM,EAAE,MAAM;IAMlC;;;;OAIG;WACW,WAAW,CAAC,SAAS,EAAE,MAAM;IAI3C;;;;OAIG;WACW,UAAU,CAAC,SAAS,EAAE,MAAM;IAO1C;;;OAGG;WACW,MAAM;IAIpB;;;OAGG;IACH,IAAI,CAAC,WAEJ;IAED;;;OAGG;IACH,IAAI,CAAC,WAEJ;IAED;;;OAGG;IACH,QAAQ;IAIR;;;;OAIG;IACH,MAAM,CAAC,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,GAAG,gBAAgB;IAKlE;;;OAGG;IACH,QAAQ;IAIR;;;OAGG;IACH,QAAQ,IAAI,EAAE,EAAE;CAajB"}

package/dest/crypto/schnorr/signature.js

@@ -0,0 +1,93 @@
+import { randomBytes } from '@aztec/foundation/crypto';
+import { Fr } from '@aztec/foundation/fields';
+import { BufferReader, mapTuple } from '@aztec/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;
+    /**
+   * An empty signature.
+   */ static EMPTY = new SchnorrSignature(Buffer.alloc(64));
+    constructor(buffer){
+        this.buffer = buffer;
+        if (buffer.length !== SchnorrSignature.SIZE) {
+            throw new Error(`Invalid signature buffer of length ${buffer.length}.`);
+        }
+    }
+    /**
+   * Determines if the provided signature is valid or not.
+   * @param signature - The data to be checked.
+   * @returns Boolean indicating if the provided data is a valid schnorr signature.
+   */ static isSignature(signature) {
+        return /^(0x)?[0-9a-f]{128}$/i.test(signature);
+    }
+    /**
+   * Constructs a SchnorrSignature from the provided string.
+   * @param signature - The string to be converted to a schnorr signature.
+   * @returns The constructed schnorr signature.
+   */ static fromString(signature) {
+        if (!SchnorrSignature.isSignature(signature)) {
+            throw new Error(`Invalid signature string: ${signature}`);
+        }
+        return new SchnorrSignature(Buffer.from(signature.replace(/^0x/i, ''), 'hex'));
+    }
+    /**
+   * Generates a random schnorr signature.
+   * @returns The randomly constructed signature.
+   */ static random() {
+        return new SchnorrSignature(randomBytes(64));
+    }
+    /**
+   * 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;
+    }
+    /**
+   * Deserializes from a buffer.
+   * @param buffer - The buffer representation of the object.
+   * @returns The new object.
+   */ static fromBuffer(buffer) {
+        const reader = BufferReader.asReader(buffer);
+        return new SchnorrSignature(reader.readBytes(SchnorrSignature.SIZE));
+    }
+    /**
+   * 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);
+    }
+}

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

@@ -0,0 +1,32 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * Secp256k1 elliptic curve operations.
+ */
+export declare class Secp256k1 {
+    static generator: Buffer;
+    /**
+     * 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>;
+    /**
+     * Gets a random field element.
+     * @returns Random field element.
+     */
+    getRandomFr(): Promise<Buffer>;
+    /**
+     * 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>;
+}
+//# sourceMappingURL=index.d.ts.map

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,SAKb;IAEH;;;OAGG;IACI,SAAS,IAAI,MAAM;IAI1B;;;;;OAKG;IACU,GAAG,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,UAAU;IAMtD;;;OAGG;IACU,WAAW;IAMxB;;;;OAIG;IACU,mBAAmB,CAAC,UAAU,EAAE,MAAM;CAOpD"}

package/dest/crypto/secp256k1/index.js

@@ -0,0 +1,116 @@
+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) {
+        const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+        const [result] = api.getWasm().callWasmExport('ecc_secp256k1__mul', [
+            point,
+            scalar
+        ], [
+            64
+        ]);
+        return Buffer.from(result);
+    }
+    /**
+   * Gets a random field element.
+   * @returns Random field element.
+   */ async getRandomFr() {
+        const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+        const [result] = api.getWasm().callWasmExport('ecc_secp256k1__get_random_scalar_mod_circuit_modulus', [], [
+            32
+        ]);
+        return Buffer.from(result);
+    }
+    /**
+   * 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) {
+        const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+        const [result] = api.getWasm().callWasmExport('ecc_secp256k1__reduce512_buffer_mod_circuit_modulus', [
+            uint512Buf
+        ], [
+            32
+        ]);
+        return Buffer.from(result);
+    }
+}

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

@@ -0,0 +1,3 @@
+export * from './secp256k1_signer.js';
+export * from './utils.js';
+//# sourceMappingURL=index.d.ts.map

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"}