@aztec/foundation 0.0.0-test.0

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/foundation/buffer';
+import type { EthAddress } from '@aztec/foundation/eth-address';
+import type { Signature } from '@aztec/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=secp256k1_signer.d.ts.map

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,0BAA0B,CAAC;AACpD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAChE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAC;AAIjE;;;;;;GAMG;AACH,qBAAa,eAAe;IAGd,OAAO,CAAC,UAAU;IAF9B,SAAgB,OAAO,EAAE,UAAU,CAAC;gBAEhB,UAAU,EAAE,QAAQ;IAIxC,IAAI,CAAC,OAAO,EAAE,QAAQ,GAAG,SAAS;IAIlC;;;;OAIG;IACH,WAAW,CAAC,OAAO,EAAE,QAAQ,GAAG,SAAS;IAKzC,MAAM,CAAC,MAAM,IAAI,eAAe;CAGjC"}

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

@@ -0,0 +1,30 @@
+import { Buffer32 } from '@aztec/foundation/buffer';
+import { addressFromPrivateKey, makeEthSignDigest, signMessage } from './utils.js';
+/**
+ * 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 class Secp256k1Signer {
+    privateKey;
+    address;
+    constructor(privateKey){
+        this.privateKey = privateKey;
+        this.address = addressFromPrivateKey(privateKey.buffer);
+    }
+    sign(message) {
+        return signMessage(message, this.privateKey.buffer);
+    }
+    /**
+   * Sign a message using the same method as eth_sign
+   * @param message - The message to sign.
+   * @returns The signature.
+   */ signMessage(message) {
+        const digest = makeEthSignDigest(message);
+        return this.sign(digest);
+    }
+    static random() {
+        return new Secp256k1Signer(Buffer32.random());
+    }
+}

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

@@ -0,0 +1,40 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Buffer32 } from '../../buffer/buffer32.js';
+import { EthAddress } from '../../eth-address/index.js';
+import { Signature } from '../../eth-signature/eth_signature.js';
+export declare function makeEthSignDigest(message: Buffer32): Buffer32;
+/**
+ * Converts a private key to a public key.
+ * @param privateKey - The private key to convert.
+ * @returns The public key.
+ */
+export declare function publicKeyFromPrivateKey(privateKey: Buffer): Buffer;
+/**
+ * Converts a private key to an address.
+ * @param privateKey - The private key to convert.
+ * @returns The address.
+ */
+export declare function addressFromPrivateKey(privateKey: Buffer): EthAddress;
+/**
+ * Recovers an address from a hash and a signature.
+ * @param hash - The hash to recover the address from.
+ * @param signature - The signature to recover the address from.
+ * @returns The address.
+ */
+export declare function recoverAddress(hash: Buffer32, signature: Signature): EthAddress;
+/**
+ * Signs a message using ecdsa over the secp256k1 curve.
+ * @param message - The message to sign.
+ * @param privateKey - The private key to sign the message with.
+ * @returns The signature.
+ */
+export declare function signMessage(message: Buffer32, privateKey: Buffer): Signature;
+/**
+ * Recovers a public key from a hash and a signature.
+ * @param hash - The hash to recover the public key from.
+ * @param signature - The signature to recover the public key from.
+ * @returns The public key.
+ */
+export declare function recoverPublicKey(hash: Buffer32, signature: Signature): Buffer;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/crypto/secp256k1-signer/utils.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AACpD,OAAO,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AACxD,OAAO,EAAE,SAAS,EAAE,MAAM,sCAAsC,CAAC;AAMjE,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,QAAQ,GAAG,QAAQ,CAG7D;AAYD;;;;GAIG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,UAAU,CAGpE;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,GAAG,UAAU,CAG/E;AAqBD;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,aAGhE;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,SAAS,GAAG,MAAM,CAO7E"}

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

@@ -0,0 +1,84 @@
+import { secp256k1 } from '@noble/curves/secp256k1';
+import { Buffer32 } from '../../buffer/buffer32.js';
+import { EthAddress } from '../../eth-address/index.js';
+import { Signature } from '../../eth-signature/eth_signature.js';
+import { keccak256 } from '../keccak/index.js';
+const ETH_SIGN_PREFIX = '\x19Ethereum Signed Message:\n32';
+// We just hash the message to make it easier to work with in the smart contract.
+export function makeEthSignDigest(message) {
+    const prefix = Buffer.from(ETH_SIGN_PREFIX);
+    return Buffer32.fromBuffer(keccak256(Buffer.concat([
+        prefix,
+        message.buffer
+    ])));
+}
+/**
+ * Converts a public key to an address.
+ * @param publicKey - The public key to convert.
+ * @returns The address.
+ */ function publicKeyToAddress(publicKey) {
+    const hash = keccak256(publicKey.subarray(1));
+    return new EthAddress(hash.subarray(12));
+}
+/**
+ * Converts a private key to a public key.
+ * @param privateKey - The private key to convert.
+ * @returns The public key.
+ */ export function publicKeyFromPrivateKey(privateKey) {
+    return Buffer.from(secp256k1.getPublicKey(privateKey, false));
+}
+/**
+ * Converts a private key to an address.
+ * @param privateKey - The private key to convert.
+ * @returns The address.
+ */ export function addressFromPrivateKey(privateKey) {
+    const publicKey = publicKeyFromPrivateKey(privateKey);
+    return publicKeyToAddress(publicKey);
+}
+/**
+ * Recovers an address from a hash and a signature.
+ * @param hash - The hash to recover the address from.
+ * @param signature - The signature to recover the address from.
+ * @returns The address.
+ */ export function recoverAddress(hash, signature) {
+    const publicKey = recoverPublicKey(hash, signature);
+    return publicKeyToAddress(publicKey);
+}
+/**
+ * @attribution - viem
+ * Converts a yParityOrV value to a recovery bit.
+ * @param yParityOrV - The yParityOrV value to convert.
+ * @returns The recovery bit.
+ */ function toRecoveryBit(yParityOrV) {
+    if (yParityOrV === 0 || yParityOrV === 1) {
+        return yParityOrV;
+    }
+    if (yParityOrV === 27) {
+        return 0;
+    }
+    if (yParityOrV === 28) {
+        return 1;
+    }
+    throw new Error('Invalid yParityOrV value');
+}
+/**
+ * Signs a message using ecdsa over the secp256k1 curve.
+ * @param message - The message to sign.
+ * @param privateKey - The private key to sign the message with.
+ * @returns The signature.
+ */ export function signMessage(message, privateKey) {
+    const { r, s, recovery } = secp256k1.sign(message.buffer, privateKey);
+    return new Signature(Buffer32.fromBigInt(r), Buffer32.fromBigInt(s), recovery ? 28 : 27);
+}
+/**
+ * Recovers a public key from a hash and a signature.
+ * @param hash - The hash to recover the public key from.
+ * @param signature - The signature to recover the public key from.
+ * @returns The public key.
+ */ export function recoverPublicKey(hash, signature) {
+    const { r, s, v } = signature;
+    const recoveryBit = toRecoveryBit(v);
+    const sig = new secp256k1.Signature(r.toBigInt(), s.toBigInt()).addRecoveryBit(recoveryBit);
+    const publicKey = sig.recoverPublicKey(hash.buffer).toHex(false);
+    return Buffer.from(publicKey, 'hex');
+}

package/dest/crypto/serialize.d.ts

@@ -0,0 +1,53 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Buffer } from 'buffer';
+/**
+ * For serializing an array of fixed length buffers.
+ * TODO move to foundation pkg.
+ * @param arr - Array of bufffers.
+ * @returns The serialized buffers.
+ */
+export declare function serializeBufferArrayToVector(arr: Buffer[]): Buffer;
+/**
+ * Helper function for deserializeArrayFromVector.
+ */
+type DeserializeFn<T> = (buf: Buffer, offset: number) => {
+    /**
+     * The deserialized type.
+     */
+    elem: T;
+    /**
+     * How many bytes to advance by.
+     */
+    adv: number;
+};
+/**
+ * For deserializing numbers to 32-bit little-endian form.
+ * TODO move to foundation pkg.
+ * @param n - The number.
+ * @returns The endian-corrected number.
+ */
+export declare function deserializeArrayFromVector<T>(deserialize: DeserializeFn<T>, vector: Buffer, offset?: number): {
+    elem: T[];
+    adv: number;
+};
+/**
+ * For serializing numbers to 32 bit little-endian form.
+ * TODO move to foundation pkg.
+ * @param n - The number.
+ * @returns The endian-corrected number.
+ */
+export declare function numToUInt32LE(n: number, bufferSize?: number): Buffer;
+/**
+ * Deserialize the 256-bit number at address `offset`.
+ * @param buf - The buffer.
+ * @param offset - The address.
+ * @returns The derserialized 256-bit field.
+ */
+export declare function deserializeField(buf: Buffer, offset?: number): {
+    elem: Buffer;
+    adv: number;
+};
+export declare function concatenateUint8Arrays(arrayOfUint8Arrays: Uint8Array[]): Uint8Array;
+export {};
+//# sourceMappingURL=serialize.d.ts.map

package/dest/crypto/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/crypto/serialize.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC;;;;;GAKG;AACH,wBAAgB,4BAA4B,CAAC,GAAG,EAAE,MAAM,EAAE,UAIzD;AAED;;GAEG;AACH,KAAK,aAAa,CAAC,CAAC,IAAI,CACtB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,KACX;IACH;;OAEG;IACH,IAAI,EAAE,CAAC,CAAC;IACR;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAEF;;;;;GAKG;AACH,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,WAAW,EAAE,aAAa,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,SAAI;;;EAWtG;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,SAAI,UAItD;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,SAAI;;;EAGvD;AAED,wBAAgB,sBAAsB,CAAC,kBAAkB,EAAE,UAAU,EAAE,cAStE"}

package/dest/crypto/serialize.js

@@ -0,0 +1,68 @@
+// TODO find a new home for this as we move to external bb.js
+// See https://github.com/AztecProtocol/aztec-packages/issues/782
+import { Buffer } from 'buffer';
+/**
+ * For serializing an array of fixed length buffers.
+ * TODO move to foundation pkg.
+ * @param arr - Array of bufffers.
+ * @returns The serialized buffers.
+ */ export function serializeBufferArrayToVector(arr) {
+    const lengthBuf = Buffer.alloc(4);
+    lengthBuf.writeUInt32BE(arr.length, 0);
+    return Buffer.concat([
+        lengthBuf,
+        ...arr
+    ]);
+}
+/**
+ * For deserializing numbers to 32-bit little-endian form.
+ * TODO move to foundation pkg.
+ * @param n - The number.
+ * @returns The endian-corrected number.
+ */ export function deserializeArrayFromVector(deserialize, vector, offset = 0) {
+    let pos = offset;
+    const size = vector.readUInt32BE(pos);
+    pos += 4;
+    const arr = new Array(size);
+    for(let i = 0; i < size; ++i){
+        const { elem, adv } = deserialize(vector, pos);
+        pos += adv;
+        arr[i] = elem;
+    }
+    return {
+        elem: arr,
+        adv: pos - offset
+    };
+}
+/**
+ * For serializing numbers to 32 bit little-endian form.
+ * TODO move to foundation pkg.
+ * @param n - The number.
+ * @returns The endian-corrected number.
+ */ export function numToUInt32LE(n, bufferSize = 4) {
+    const buf = Buffer.alloc(bufferSize);
+    buf.writeUInt32LE(n, bufferSize - 4);
+    return buf;
+}
+/**
+ * Deserialize the 256-bit number at address `offset`.
+ * @param buf - The buffer.
+ * @param offset - The address.
+ * @returns The derserialized 256-bit field.
+ */ export function deserializeField(buf, offset = 0) {
+    const adv = 32;
+    return {
+        elem: buf.slice(offset, offset + adv),
+        adv
+    };
+}
+export function concatenateUint8Arrays(arrayOfUint8Arrays) {
+    const totalLength = arrayOfUint8Arrays.reduce((prev, curr)=>prev + curr.length, 0);
+    const result = new Uint8Array(totalLength);
+    let length = 0;
+    for (const array of arrayOfUint8Arrays){
+        result.set(array, length);
+        length += array.length;
+    }
+    return result;
+}

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

@@ -0,0 +1,20 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '../../fields/fields.js';
+import { type Bufferable } from '../../serialize/serialize.js';
+export declare function sha256(data: Buffer): Buffer;
+export declare function sha256Trunc(data: Buffer): Buffer;
+export declare function sha256ToField(data: Bufferable[]): Fr;
+/**
+ * The "SHA256 Compression" operation (component operation of SHA256 "Hash").
+ * WARNING: modifies `state` in place (and also returns it)
+ *
+ * This algorithm is extracted from the hash.js package
+ * and modified to take in an initial state to operate on.
+ *
+ * @param state - The initial state to operate on (modified in-place). 8 u32s.
+ * @param inputs - The inputs to compress into the state. 16 u32s.
+ * @returns The modified state. 8 u32s.
+ */
+export declare function sha256Compression(state: Uint32Array, inputs: Uint32Array): Uint32Array;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/sha256/index.ts"],"names":[],"mappings":";;AAGA,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAE5C,OAAO,EAAE,KAAK,UAAU,EAAqB,MAAM,8BAA8B,CAAC;AAElF,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,UAElC;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,UAEvC;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,UAAU,EAAE,MAG/C;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,WAAW,GAAG,WAAW,CAyEtF"}

package/dest/crypto/sha256/index.js

@@ -0,0 +1,166 @@
+/* eslint-disable camelcase */ import { default as hash } from 'hash.js';
+import { Fr } from '../../fields/fields.js';
+import { truncateAndPad } from '../../serialize/free_funcs.js';
+import { serializeToBuffer } from '../../serialize/serialize.js';
+export function sha256(data) {
+    return Buffer.from(hash.sha256().update(data).digest());
+}
+export function sha256Trunc(data) {
+    return truncateAndPad(sha256(data));
+}
+export function sha256ToField(data) {
+    const buffer = serializeToBuffer(data);
+    return Fr.fromBuffer(sha256Trunc(buffer));
+}
+/**
+ * The "SHA256 Compression" operation (component operation of SHA256 "Hash").
+ * WARNING: modifies `state` in place (and also returns it)
+ *
+ * This algorithm is extracted from the hash.js package
+ * and modified to take in an initial state to operate on.
+ *
+ * @param state - The initial state to operate on (modified in-place). 8 u32s.
+ * @param inputs - The inputs to compress into the state. 16 u32s.
+ * @returns The modified state. 8 u32s.
+ */ export function sha256Compression(state, inputs) {
+    if (state.length !== 8) {
+        throw new Error('`state` argument to SHA256 compression must be of length 8');
+    }
+    if (inputs.length !== 16) {
+        throw new Error('`inputs` argument to SHA256 compression must be of length 16');
+    }
+    const W = new Array(64);
+    const k = [
+        0x428a2f98,
+        0x71374491,
+        0xb5c0fbcf,
+        0xe9b5dba5,
+        0x3956c25b,
+        0x59f111f1,
+        0x923f82a4,
+        0xab1c5ed5,
+        0xd807aa98,
+        0x12835b01,
+        0x243185be,
+        0x550c7dc3,
+        0x72be5d74,
+        0x80deb1fe,
+        0x9bdc06a7,
+        0xc19bf174,
+        0xe49b69c1,
+        0xefbe4786,
+        0x0fc19dc6,
+        0x240ca1cc,
+        0x2de92c6f,
+        0x4a7484aa,
+        0x5cb0a9dc,
+        0x76f988da,
+        0x983e5152,
+        0xa831c66d,
+        0xb00327c8,
+        0xbf597fc7,
+        0xc6e00bf3,
+        0xd5a79147,
+        0x06ca6351,
+        0x14292967,
+        0x27b70a85,
+        0x2e1b2138,
+        0x4d2c6dfc,
+        0x53380d13,
+        0x650a7354,
+        0x766a0abb,
+        0x81c2c92e,
+        0x92722c85,
+        0xa2bfe8a1,
+        0xa81a664b,
+        0xc24b8b70,
+        0xc76c51a3,
+        0xd192e819,
+        0xd6990624,
+        0xf40e3585,
+        0x106aa070,
+        0x19a4c116,
+        0x1e376c08,
+        0x2748774c,
+        0x34b0bcb5,
+        0x391c0cb3,
+        0x4ed8aa4a,
+        0x5b9cca4f,
+        0x682e6ff3,
+        0x748f82ee,
+        0x78a5636f,
+        0x84c87814,
+        0x8cc70208,
+        0x90befffa,
+        0xa4506ceb,
+        0xbef9a3f7,
+        0xc67178f2
+    ];
+    let i = 0;
+    for(i = 0; i < 16; i++){
+        W[i] = inputs[i];
+    }
+    for(i = 16; i < W.length; i++){
+        W[i] = sum32_4(W[i - 16], W[i - 7], g0_256(W[i - 15]), g1_256(W[i - 2]));
+    }
+    let a = state[0];
+    let b = state[1];
+    let c = state[2];
+    let d = state[3];
+    let e = state[4];
+    let f = state[5];
+    let g = state[6];
+    let h = state[7];
+    for(let i = 0; i < 64; i++){
+        const T1 = sum32_5(h, s1_256(e), ch32(e, f, g), k[i], W[i]);
+        const T2 = sum32(s0_256(a), maj32(a, b, c));
+        h = g;
+        g = f;
+        f = e;
+        e = sum32(d, T1);
+        d = c;
+        c = b;
+        b = a;
+        a = sum32(T1, T2);
+    }
+    state[0] = sum32(state[0], a);
+    state[1] = sum32(state[1], b);
+    state[2] = sum32(state[2], c);
+    state[3] = sum32(state[3], d);
+    state[4] = sum32(state[4], e);
+    state[5] = sum32(state[5], f);
+    state[6] = sum32(state[6], g);
+    state[7] = sum32(state[7], h);
+    return state;
+}
+// SHA256  HELPER FUNCTIONS (from hash.js package)
+function rotr32(w, b) {
+    return w >>> b | w << 32 - b;
+}
+function sum32(a, b) {
+    return a + b >>> 0;
+}
+function sum32_4(a, b, c, d) {
+    return a + b + c + d >>> 0;
+}
+function sum32_5(a, b, c, d, e) {
+    return a + b + c + d + e >>> 0;
+}
+function ch32(x, y, z) {
+    return x & y ^ ~x & z;
+}
+function maj32(x, y, z) {
+    return x & y ^ x & z ^ y & z;
+}
+function s0_256(x) {
+    return rotr32(x, 2) ^ rotr32(x, 13) ^ rotr32(x, 22);
+}
+function s1_256(x) {
+    return rotr32(x, 6) ^ rotr32(x, 11) ^ rotr32(x, 25);
+}
+function g0_256(x) {
+    return rotr32(x, 7) ^ rotr32(x, 18) ^ x >>> 3;
+}
+function g1_256(x) {
+    return rotr32(x, 17) ^ rotr32(x, 19) ^ x >>> 10;
+}

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

@@ -0,0 +1,11 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { type Bufferable } from '../../serialize/serialize.js';
+export declare const sha512: (data: Buffer) => Buffer;
+/**
+ * @dev We don't truncate in this function (unlike in sha256ToField) because this function is used in situations where
+ * we don't care only about collision resistance but we need the output to be uniformly distributed as well. This is
+ * because we use it as a pseudo-random function.
+ */
+export declare const sha512ToGrumpkinScalar: (data: Bufferable[]) => import("../../fields/fields.js").Fq;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/sha512/index.ts"],"names":[],"mappings":";;AAGA,OAAO,EAAE,KAAK,UAAU,EAAqB,MAAM,8BAA8B,CAAC;AAElF,eAAO,MAAM,MAAM,SAAU,MAAM,WAAqD,CAAC;AAEzF;;;;GAIG;AACH,eAAO,MAAM,sBAAsB,SAAU,UAAU,EAAE,wCAGxD,CAAC"}

package/dest/crypto/sha512/index.js

@@ -0,0 +1,12 @@
+import { default as hash } from 'hash.js';
+import { GrumpkinScalar } from '../../fields/fields.js';
+import { serializeToBuffer } from '../../serialize/serialize.js';
+export const sha512 = (data)=>Buffer.from(hash.sha512().update(data).digest());
+/**
+ * @dev We don't truncate in this function (unlike in sha256ToField) because this function is used in situations where
+ * we don't care only about collision resistance but we need the output to be uniformly distributed as well. This is
+ * because we use it as a pseudo-random function.
+ */ export const sha512ToGrumpkinScalar = (data)=>{
+    const buffer = serializeToBuffer(data);
+    return GrumpkinScalar.fromBufferReduce(sha512(buffer));
+};

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

@@ -0,0 +1,19 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import type { Fr } from '@aztec/foundation/fields';
+/**
+ * Interface to represent a signature.
+ */
+export interface Signature {
+    /**
+     * Serializes to a buffer.
+     * @returns A buffer.
+     */
+    toBuffer(): Buffer;
+    /**
+     * Serializes to an array of fields.
+     * @returns Fields.
+     */
+    toFields(): Fr[];
+}
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/signature/index.ts"],"names":[],"mappings":";;AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,0BAA0B,CAAC;AAEnD;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB;;;OAGG;IACH,QAAQ,IAAI,MAAM,CAAC;IACnB;;;OAGG;IACH,QAAQ,IAAI,EAAE,EAAE,CAAC;CAClB"}

package/dest/crypto/signature/index.js

@@ -0,0 +1,3 @@
+/**
+ * Interface to represent a signature.
+ */ export { };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/sync/index.ts"],"names":[],"mappings":"AAEA,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC"}

package/dest/crypto/sync/index.js

@@ -0,0 +1,4 @@
+import { BarretenbergSync } from '@aztec/bb.js';
+export * from './poseidon/index.js';
+export * from './pedersen/index.js';
+await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);

package/dest/crypto/sync/pedersen/index.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '../../../fields/fields.js';
+import { type Fieldable } from '../../../serialize/serialize.js';
+/**
+ * Create a pedersen commitment (point) from an array of input fields.
+ * Left pads any inputs less than 32 bytes.
+ */
+export declare function pedersenCommit(input: Buffer[], offset?: number): Buffer[];
+/**
+ * Create a pedersen hash (field) from an array of input fields.
+ * @param input - The input fieldables to hash.
+ * @param index - The separator index to use for the hash.
+ * @returns The pedersen hash.
+ */
+export declare function pedersenHash(input: Fieldable[], index?: number): Fr;
+/**
+ * Create a pedersen hash from an arbitrary length buffer.
+ */
+export declare function pedersenHashBuffer(input: Buffer, index?: number): Buffer;
+//# sourceMappingURL=index.d.ts.map

package/dest/crypto/sync/pedersen/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/crypto/sync/pedersen/index.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,2BAA2B,CAAC;AAC/C,OAAO,EAAE,KAAK,SAAS,EAAqB,MAAM,iCAAiC,CAAC;AAEpF;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,MAAM,SAAI,YAYzD;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,EAAE,EAAE,KAAK,SAAI,GAAG,EAAE,CAO9D;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,SAAI,UAG1D"}

package/dest/crypto/sync/pedersen/index.js

@@ -0,0 +1,38 @@
+import { BarretenbergSync, Fr as FrBarretenberg } from '@aztec/bb.js';
+import { Fr } from '../../../fields/fields.js';
+import { serializeToFields } from '../../../serialize/serialize.js';
+/**
+ * Create a pedersen commitment (point) from an array of input fields.
+ * Left pads any inputs less than 32 bytes.
+ */ export function pedersenCommit(input, offset = 0) {
+    if (!input.every((i)=>i.length <= 32)) {
+        throw new Error('All Pedersen Commit input buffers must be <= 32 bytes.');
+    }
+    input = input.map((i)=>i.length < 32 ? Buffer.concat([
+            Buffer.alloc(32 - i.length, 0),
+            i
+        ]) : i);
+    const point = BarretenbergSync.getSingleton().pedersenCommit(input.map((i)=>new FrBarretenberg(i)), offset);
+    // toBuffer returns Uint8Arrays (browser/worker-boundary friendly).
+    // TODO: rename toTypedArray()?
+    return [
+        Buffer.from(point.x.toBuffer()),
+        Buffer.from(point.y.toBuffer())
+    ];
+}
+/**
+ * Create a pedersen hash (field) from an array of input fields.
+ * @param input - The input fieldables to hash.
+ * @param index - The separator index to use for the hash.
+ * @returns The pedersen hash.
+ */ export function pedersenHash(input, index = 0) {
+    const inputFields = serializeToFields(input);
+    const hash = BarretenbergSync.getSingleton().pedersenHash(inputFields.map((i)=>new FrBarretenberg(i.toBuffer())), index);
+    return Fr.fromBuffer(Buffer.from(hash.toBuffer()));
+}
+/**
+ * Create a pedersen hash from an arbitrary length buffer.
+ */ export function pedersenHashBuffer(input, index = 0) {
+    const result = BarretenbergSync.getSingleton().pedersenHashBuffer(input, index);
+    return Buffer.from(result.toBuffer());
+}