@aztec/foundation 0.0.0-test.0

package/dest/crypto/keccak/index.js

@@ -0,0 +1,248 @@
+import { Keccak } from 'sha3';
+import { Buffer32 } from '../../buffer/buffer32.js';
+/**
+ * Computes the Keccak-256 hash of the given input buffer.
+ *
+ * @param input - The input buffer to be hashed.
+ * @returns The computed Keccak-256 hash as a Buffer.
+ */ export function keccak256(input) {
+    if (input instanceof Buffer32) {
+        input = input.buffer;
+    }
+    const hash = new Keccak(256);
+    return hash.update(input).digest();
+}
+/**
+ * Computes the keccak-256 hash of a given input string and returns the result as a hexadecimal string.
+ */ export function keccak256String(input) {
+    const hash = new Keccak(256);
+    hash.reset();
+    hash.update(input);
+    return hash.digest('hex');
+}
+/**
+ * Computes the Keccak-224 hash of the given input buffer.
+ *
+ * @param input - The input buffer to be hashed.
+ * @returns The computed Keccak-224 hash as a Buffer.
+ */ export function keccak224(input) {
+    const hash = new Keccak(224);
+    return hash.update(input).digest();
+}
+/**
+ * Computes the Keccak-f1600 permutation of the input.
+ * @param state 25 64-bit words.
+ * @returns The permuted state.
+ */ export function keccakf1600(state) {
+    // Ideally we'd assert the size of the state and its constituent elements here.
+    // But since this gets included in the browser bundle, we can't use Node's assert module.
+    /* The implementation based on the "simple" implementation by Ronny Van Keer. */ /* Adapted from Barretenberg's CPP implementation. */ let Eba, Ebe, Ebi, Ebo, Ebu;
+    let Ega, Ege, Egi, Ego, Egu;
+    let Eka, Eke, Eki, Eko, Eku;
+    let Ema, Eme, Emi, Emo, Emu;
+    let Esa, Ese, Esi, Eso, Esu;
+    let Ba, Be, Bi, Bo, Bu;
+    let Da, De, Di, Do, Du;
+    let Aba = state[0];
+    let Abe = state[1];
+    let Abi = state[2];
+    let Abo = state[3];
+    let Abu = state[4];
+    let Aga = state[5];
+    let Age = state[6];
+    let Agi = state[7];
+    let Ago = state[8];
+    let Agu = state[9];
+    let Aka = state[10];
+    let Ake = state[11];
+    let Aki = state[12];
+    let Ako = state[13];
+    let Aku = state[14];
+    let Ama = state[15];
+    let Ame = state[16];
+    let Ami = state[17];
+    let Amo = state[18];
+    let Amu = state[19];
+    let Asa = state[20];
+    let Ase = state[21];
+    let Asi = state[22];
+    let Aso = state[23];
+    let Asu = state[24];
+    for(let round = 0; round < 24; round += 2){
+        /* Round (round + 0): Axx -> Exx */ Ba = Aba ^ Aga ^ Aka ^ Ama ^ Asa;
+        Be = Abe ^ Age ^ Ake ^ Ame ^ Ase;
+        Bi = Abi ^ Agi ^ Aki ^ Ami ^ Asi;
+        Bo = Abo ^ Ago ^ Ako ^ Amo ^ Aso;
+        Bu = Abu ^ Agu ^ Aku ^ Amu ^ Asu;
+        Da = Bu ^ rol(Be, 1n);
+        De = Ba ^ rol(Bi, 1n);
+        Di = Be ^ rol(Bo, 1n);
+        Do = Bi ^ rol(Bu, 1n);
+        Du = Bo ^ rol(Ba, 1n);
+        Ba = Aba ^ Da;
+        Be = rol(Age ^ De, 44n);
+        Bi = rol(Aki ^ Di, 43n);
+        Bo = rol(Amo ^ Do, 21n);
+        Bu = rol(Asu ^ Du, 14n);
+        Eba = Ba ^ ~Be & Bi ^ roundConstants[round];
+        Ebe = Be ^ ~Bi & Bo;
+        Ebi = Bi ^ ~Bo & Bu;
+        Ebo = Bo ^ ~Bu & Ba;
+        Ebu = Bu ^ ~Ba & Be;
+        Ba = rol(Abo ^ Do, 28n);
+        Be = rol(Agu ^ Du, 20n);
+        Bi = rol(Aka ^ Da, 3n);
+        Bo = rol(Ame ^ De, 45n);
+        Bu = rol(Asi ^ Di, 61n);
+        Ega = Ba ^ ~Be & Bi;
+        Ege = Be ^ ~Bi & Bo;
+        Egi = Bi ^ ~Bo & Bu;
+        Ego = Bo ^ ~Bu & Ba;
+        Egu = Bu ^ ~Ba & Be;
+        Ba = rol(Abe ^ De, 1n);
+        Be = rol(Agi ^ Di, 6n);
+        Bi = rol(Ako ^ Do, 25n);
+        Bo = rol(Amu ^ Du, 8n);
+        Bu = rol(Asa ^ Da, 18n);
+        Eka = Ba ^ ~Be & Bi;
+        Eke = Be ^ ~Bi & Bo;
+        Eki = Bi ^ ~Bo & Bu;
+        Eko = Bo ^ ~Bu & Ba;
+        Eku = Bu ^ ~Ba & Be;
+        Ba = rol(Abu ^ Du, 27n);
+        Be = rol(Aga ^ Da, 36n);
+        Bi = rol(Ake ^ De, 10n);
+        Bo = rol(Ami ^ Di, 15n);
+        Bu = rol(Aso ^ Do, 56n);
+        Ema = Ba ^ ~Be & Bi;
+        Eme = Be ^ ~Bi & Bo;
+        Emi = Bi ^ ~Bo & Bu;
+        Emo = Bo ^ ~Bu & Ba;
+        Emu = Bu ^ ~Ba & Be;
+        Ba = rol(Abi ^ Di, 62n);
+        Be = rol(Ago ^ Do, 55n);
+        Bi = rol(Aku ^ Du, 39n);
+        Bo = rol(Ama ^ Da, 41n);
+        Bu = rol(Ase ^ De, 2n);
+        Esa = Ba ^ ~Be & Bi;
+        Ese = Be ^ ~Bi & Bo;
+        Esi = Bi ^ ~Bo & Bu;
+        Eso = Bo ^ ~Bu & Ba;
+        Esu = Bu ^ ~Ba & Be;
+        /* Round (round + 1): Exx -> Axx */ Ba = Eba ^ Ega ^ Eka ^ Ema ^ Esa;
+        Be = Ebe ^ Ege ^ Eke ^ Eme ^ Ese;
+        Bi = Ebi ^ Egi ^ Eki ^ Emi ^ Esi;
+        Bo = Ebo ^ Ego ^ Eko ^ Emo ^ Eso;
+        Bu = Ebu ^ Egu ^ Eku ^ Emu ^ Esu;
+        Da = Bu ^ rol(Be, 1n);
+        De = Ba ^ rol(Bi, 1n);
+        Di = Be ^ rol(Bo, 1n);
+        Do = Bi ^ rol(Bu, 1n);
+        Du = Bo ^ rol(Ba, 1n);
+        Ba = Eba ^ Da;
+        Be = rol(Ege ^ De, 44n);
+        Bi = rol(Eki ^ Di, 43n);
+        Bo = rol(Emo ^ Do, 21n);
+        Bu = rol(Esu ^ Du, 14n);
+        Aba = Ba ^ ~Be & Bi ^ roundConstants[round + 1];
+        Abe = Be ^ ~Bi & Bo;
+        Abi = Bi ^ ~Bo & Bu;
+        Abo = Bo ^ ~Bu & Ba;
+        Abu = Bu ^ ~Ba & Be;
+        Ba = rol(Ebo ^ Do, 28n);
+        Be = rol(Egu ^ Du, 20n);
+        Bi = rol(Eka ^ Da, 3n);
+        Bo = rol(Eme ^ De, 45n);
+        Bu = rol(Esi ^ Di, 61n);
+        Aga = Ba ^ ~Be & Bi;
+        Age = Be ^ ~Bi & Bo;
+        Agi = Bi ^ ~Bo & Bu;
+        Ago = Bo ^ ~Bu & Ba;
+        Agu = Bu ^ ~Ba & Be;
+        Ba = rol(Ebe ^ De, 1n);
+        Be = rol(Egi ^ Di, 6n);
+        Bi = rol(Eko ^ Do, 25n);
+        Bo = rol(Emu ^ Du, 8n);
+        Bu = rol(Esa ^ Da, 18n);
+        Aka = Ba ^ ~Be & Bi;
+        Ake = Be ^ ~Bi & Bo;
+        Aki = Bi ^ ~Bo & Bu;
+        Ako = Bo ^ ~Bu & Ba;
+        Aku = Bu ^ ~Ba & Be;
+        Ba = rol(Ebu ^ Du, 27n);
+        Be = rol(Ega ^ Da, 36n);
+        Bi = rol(Eke ^ De, 10n);
+        Bo = rol(Emi ^ Di, 15n);
+        Bu = rol(Eso ^ Do, 56n);
+        Ama = Ba ^ ~Be & Bi;
+        Ame = Be ^ ~Bi & Bo;
+        Ami = Bi ^ ~Bo & Bu;
+        Amo = Bo ^ ~Bu & Ba;
+        Amu = Bu ^ ~Ba & Be;
+        Ba = rol(Ebi ^ Di, 62n);
+        Be = rol(Ego ^ Do, 55n);
+        Bi = rol(Eku ^ Du, 39n);
+        Bo = rol(Ema ^ Da, 41n);
+        Bu = rol(Ese ^ De, 2n);
+        Asa = Ba ^ ~Be & Bi;
+        Ase = Be ^ ~Bi & Bo;
+        Asi = Bi ^ ~Bo & Bu;
+        Aso = Bo ^ ~Bu & Ba;
+        Asu = Bu ^ ~Ba & Be;
+    }
+    state[0] = Aba;
+    state[1] = Abe;
+    state[2] = Abi;
+    state[3] = Abo;
+    state[4] = Abu;
+    state[5] = Aga;
+    state[6] = Age;
+    state[7] = Agi;
+    state[8] = Ago;
+    state[9] = Agu;
+    state[10] = Aka;
+    state[11] = Ake;
+    state[12] = Aki;
+    state[13] = Ako;
+    state[14] = Aku;
+    state[15] = Ama;
+    state[16] = Ame;
+    state[17] = Ami;
+    state[18] = Amo;
+    state[19] = Amu;
+    state[20] = Asa;
+    state[21] = Ase;
+    state[22] = Asi;
+    state[23] = Aso;
+    state[24] = Asu;
+    return state;
+}
+function rol(x, s) {
+    return BigInt.asUintN(64, x << s) | x >> 64n - s;
+}
+const roundConstants = [
+    0x0000000000000001n,
+    0x0000000000008082n,
+    0x800000000000808an,
+    0x8000000080008000n,
+    0x000000000000808bn,
+    0x0000000080000001n,
+    0x8000000080008081n,
+    0x8000000000008009n,
+    0x000000000000008an,
+    0x0000000000000088n,
+    0x0000000080008009n,
+    0x000000008000000an,
+    0x000000008000808bn,
+    0x800000000000008bn,
+    0x8000000000008089n,
+    0x8000000000008003n,
+    0x8000000000008002n,
+    0x8000000000000080n,
+    0x000000000000800an,
+    0x800000008000000an,
+    0x8000000080008081n,
+    0x8000000000008080n,
+    0x0000000080000001n,
+    0x8000000080008008n
+];

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

@@ -0,0 +1,5 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+import { Fr } from '../../fields/fields.js';
+export declare function vkAsFieldsMegaHonk(input: Buffer): Promise<Fr[]>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/keys/index.ts"],"names":[],"mappings":";;AAEA,OAAO,EAAE,EAAE,EAAE,MAAM,wBAAwB,CAAC;AAE5C,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,EAAE,EAAE,CAAC,CAKrE"}

package/dest/crypto/keys/index.js

@@ -0,0 +1,7 @@
+import { BarretenbergSync, RawBuffer } from '@aztec/bb.js';
+import { Fr } from '../../fields/fields.js';
+export async function vkAsFieldsMegaHonk(input) {
+    const api = await BarretenbergSync.initSingleton(process.env.BB_WASM_PATH);
+    const result = api.acirVkAsFieldsMegaHonk(new RawBuffer(input));
+    return result.map((bbFr)=>Fr.fromBuffer(Buffer.from(bbFr.toBuffer()))); // TODO(#4189): remove this conversion
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/crypto/pedersen/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dest/crypto/pedersen/index.js

@@ -0,0 +1 @@
+export * from './pedersen.wasm.js';

package/dest/crypto/pedersen/pedersen.elliptic.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" resolution-mode="require"/>
+/// <reference types="node" resolution-mode="require"/>
+/**
+ * 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[], generatorOffset?: number): Buffer[];
+/**
+ * Create a pedersen hash (field) from an array of input fields.
+ * Left pads any inputs less than 32 bytes.
+ */
+export declare function pedersenHash(input: Buffer[], index?: number): Buffer;
+//# sourceMappingURL=pedersen.elliptic.d.ts.map

package/dest/crypto/pedersen/pedersen.elliptic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pedersen.elliptic.d.ts","sourceRoot":"","sources":["../../../src/crypto/pedersen/pedersen.elliptic.ts"],"names":[],"mappings":";;AA+iBA;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,eAAe,SAAI,YAOlE;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,KAAK,SAAI,UAOtD"}