Add hashers to Provable SDK and write JS unit tests for them

Author: iamalwaysuncomfortable

sdk/src/browser.ts

@@ -56,13 +56,22 @@ export { logAndThrow } from "./utils";
 
 export {
     Address,
+    BHP256,
+    BHP512,
+    BHP768,
+    BHP1024,
     Ciphertext,
     Execution as FunctionExecution,
     ExecutionResponse,
     Field,
     Group,
     OfflineQuery,
+    Pedersen64,
+    Pedersen128,
     Plaintext,
+    Poseidon2,
+    Poseidon4,
+    Poseidon8,
     PrivateKey,
     PrivateKeyCiphertext,
     Program,

sdk/src/wasm.ts

@@ -1,13 +1,22 @@
 export {
     Address,
+    BHP256,
+    BHP512,
+    BHP768,
+    BHP1024,
     Ciphertext,
     Execution,
     ExecutionResponse,
     Field,
     Group,
     OfflineQuery,
     Metadata,
+    Pedersen64,
+    Pedersen128,
     Plaintext,
+    Poseidon2,
+    Poseidon4,
+    Poseidon8,
     PrivateKey,
     PrivateKeyCiphertext,
     Program,

sdk/tests/algorithm.test.ts

@@ -0,0 +1,100 @@
+import sinon from "sinon";
+import { expect } from "chai";
+import { Field, Group, Scalar, BHP256, BHP512, BHP768, BHP1024, Pedersen64, Pedersen128, Poseidon2, Poseidon4, Poseidon8 } from "@provablehq/sdk/%%NETWORK%%.js";
+import * as algebraicData from "./data/algebra";
+
+const Fg = Field.fromString(algebraicData.FieldGenerator);
+const F2 = Fg.multiply(Fg);
+const F3 = F2.multiply(Fg);
+const F4 = F3.multiply(Fg);
+const SFg = Scalar.fromString(algebraicData.ScalarGenerator);
+const fieldArray = [Fg, F2, F3, F4];
+const finiteFieldBytes = fieldArray.map(field => field.toBitsLe()).flat();
+
+function deepCopyFieldArray(array: Field[]): Field[] {
+    return array.map(item => item.clone());
+}
+
+describe('Hash Function Export Tests', () => {
+    afterEach(() => {
+        sinon.restore();
+    });
+
+    describe('BHP Hasher Tests', () => {
+        it('Check BHP Hashers hash to expected values.', () => {
+            // Create all BHP hashers.
+            const BHP256Hasher = new BHP256();
+            const BHP512Hasher = new BHP512();
+            const BHP768Hasher = new BHP768();
+            const BHP1024Hasher = new BHP1024();
+
+            // Run all possible operations for BHP256.
+            expect(BHP256Hasher.hash(finiteFieldBytes).toString()).equals(algebraicData.expectedBHP256Hash);
+            expect(BHP256Hasher.hashToGroup(finiteFieldBytes).toString()).equals(algebraicData.expectedBHP256HashToGroup);
+            expect(BHP256Hasher.commit(finiteFieldBytes, SFg.clone()).toString()).equals(algebraicData.expectedBHP256Commit);
+            expect(BHP256Hasher.commitToGroup(finiteFieldBytes, SFg.clone()).toString()).equals(algebraicData.expectedBHP256CommitToGroup);
+
+            // Run all possible operations for BHP512.
+            expect(BHP512Hasher.hash(finiteFieldBytes).toString()).equals(algebraicData.expectedBHP512Hash);
+            expect(BHP512Hasher.hashToGroup(finiteFieldBytes).toString()).equals(algebraicData.expectedBHP512HashToGroup);
+            expect(BHP512Hasher.commit(finiteFieldBytes, SFg.clone()).toString()).equals(algebraicData.expectedBHP512Commit);
+            expect(BHP512Hasher.commitToGroup(finiteFieldBytes, SFg.clone()).toString()).equals(algebraicData.expectedBHP512CommitToGroup);
+
+            // Run all possible operations for BHP768.
+            expect(BHP768Hasher.hash(finiteFieldBytes).toString()).equals(algebraicData.expectedBHP768Hash);
+            expect(BHP768Hasher.hashToGroup(finiteFieldBytes).toString()).equals(algebraicData.expectedBHP768HashToGroup);
+            expect(BHP768Hasher.commit(finiteFieldBytes, SFg.clone()).toString()).equals(algebraicData.expectedBHP768Commit);
+            expect(BHP768Hasher.commitToGroup(finiteFieldBytes, SFg.clone()).toString()).equals(algebraicData.expectedBHP768CommitToGroup);
+
+            // Run all possible operations for BHP1024.
+            expect(BHP1024Hasher.hash(finiteFieldBytes).toString()).equals(algebraicData.expectedBHP1024Hash);
+            expect(BHP1024Hasher.hashToGroup(finiteFieldBytes).toString()).equals(algebraicData.expectedBHP1024HashToGroup);
+            expect(BHP1024Hasher.commit(finiteFieldBytes, SFg.clone()).toString()).equals(algebraicData.expectedBHP1024Commit);
+            expect(BHP1024Hasher.commitToGroup(finiteFieldBytes, SFg.clone()).toString()).equals(algebraicData.expectedBHP1024CommitToGroup);
+        });
+
+        it('Check Pedersen hashers hash to expected values', () => {
+            // Create all Pedersen hashers.
+            const Pedersen64Hasher = new Pedersen64();
+            const Pedersen128Hasher = new Pedersen128();
+
+            // Create a bit array which is 2 2u32 elements concatenated.
+            const bitArray = [true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false];
+
+            // Run all possible operations for Pedersen64.
+            expect(Pedersen64Hasher.hash(bitArray).toString()).equals(algebraicData.expectedPedersen64Hash);
+            expect(Pedersen64Hasher.commit(bitArray, SFg.clone()).toString()).equals(algebraicData.expectedPedersen64Commit);
+            expect(Pedersen64Hasher.commitToGroup(bitArray, SFg.clone()).toString()).equals(algebraicData.expectedPedersen64CommitToGroup);
+
+            // Run all possible operations for Pedersen128.
+            expect(Pedersen128Hasher.hash(bitArray).toString()).equals(algebraicData.expectedPedersen128Hash);
+            expect(Pedersen128Hasher.commit(bitArray, SFg.clone()).toString()).equals(algebraicData.expectedPedersen128Commit);
+            expect(Pedersen128Hasher.commitToGroup(bitArray, SFg.clone()).toString()).equals(algebraicData.expectedPedersen128CommitToGroup);
+        });
+
+        it('Check Poseidon hashers hash to expected values', () => {
+            // Create all Poseidon hashers.
+            const Poseidon2Hasher = new Poseidon2();
+            const Poseidon4Hasher = new Poseidon4();
+            const Poseidon8Hasher = new Poseidon8();
+
+            // Run all possible operations for Poseidon2.
+            expect(Poseidon2Hasher.hash(deepCopyFieldArray(fieldArray)).toString()).equals(algebraicData.expectedPoseidon2Hash);
+            expect(Poseidon2Hasher.hashToScalar(deepCopyFieldArray(fieldArray)).toString()).equals(algebraicData.expectedPoseidon2HashToScalar);
+            expect(Poseidon2Hasher.hashToGroup(deepCopyFieldArray(fieldArray)).toString()).equals(algebraicData.expectedPoseidon2HashToGroup);
+            expect(Poseidon2Hasher.hashMany(deepCopyFieldArray(fieldArray), 2).map(field => field.toString())).deep.equals(algebraicData.expectedPoseidon2HashMany);
+
+            // Run all possible operations for Poseidon4.
+            expect(Poseidon4Hasher.hash(deepCopyFieldArray(fieldArray)).toString()).equals(algebraicData.expectedPoseidon4Hash);
+            expect(Poseidon4Hasher.hashToScalar(deepCopyFieldArray(fieldArray)).toString()).equals(algebraicData.expectedPoseidon4HashToScalar);
+            expect(Poseidon4Hasher.hashToGroup(deepCopyFieldArray(fieldArray)).toString()).equals(algebraicData.expectedPoseidon4HashToGroup);
+            expect(Poseidon4Hasher.hashMany(deepCopyFieldArray(fieldArray), 2).map(field => field.toString())).deep.equals(algebraicData.expectedPoseidon4HashMany);
+
+            // Run all possible operations for Poseidon8.
+            expect(Poseidon8Hasher.hash(deepCopyFieldArray(fieldArray)).toString()).equals(algebraicData.expectedPoseidon8Hash);
+            expect(Poseidon8Hasher.hashToScalar(deepCopyFieldArray(fieldArray)).toString()).equals(algebraicData.expectedPoseidon8HashToScalar);
+            expect(Poseidon8Hasher.hashToGroup(deepCopyFieldArray(fieldArray)).toString()).equals(algebraicData.expectedPoseidon8HashToGroup);
+            expect(Poseidon8Hasher.hashMany(deepCopyFieldArray(fieldArray), 2).map(field => field.toString())).deep.equals(algebraicData.expectedPoseidon8HashMany);
+        });
+    });
+});

sdk/tests/data/algebra.ts

@@ -0,0 +1,72 @@
+/// Chosen field generator for unit tests.
+const FieldGenerator = "6901184695964460143517399399785179769303979738604374595034454667750561389951field";
+
+const expectedBHP256Hash = "6598783590400646668520287182111940745128736688662567560889280298782004590744field";
+const expectedBHP256HashToGroup = "6598783590400646668520287182111940745128736688662567560889280298782004590744group";
+const expectedBHP256Commit = "2082593229082262381320813637490421437118190271647234845496709605556536239325field";
+const expectedBHP256CommitToGroup = "2082593229082262381320813637490421437118190271647234845496709605556536239325group";
+
+const expectedBHP512Hash = "1999822247055455701784132575168585963242270924818325055212777584340934143916field";
+const expectedBHP512HashToGroup = "1999822247055455701784132575168585963242270924818325055212777584340934143916group";
+const expectedBHP512Commit = "5702389816400555524923367597422208802601150072230907483584911172290469121501field";
+const expectedBHP512CommitToGroup = "5702389816400555524923367597422208802601150072230907483584911172290469121501group";
+
+const expectedBHP768Hash = "2151969465368594987252495420983687091399796648584310972463234119446869285487field";
+const expectedBHP768HashToGroup = "2151969465368594987252495420983687091399796648584310972463234119446869285487group";
+const expectedBHP768Commit = "6864405450086290602821044466228181619883104706596830134315601499052844411477field";
+const expectedBHP768CommitToGroup = "6864405450086290602821044466228181619883104706596830134315601499052844411477group";
+
+const expectedBHP1024Hash = "5012718612752062270473753102141489376962182387590529397014861985202772382691field";
+const expectedBHP1024HashToGroup = "5012718612752062270473753102141489376962182387590529397014861985202772382691group";
+const expectedBHP1024Commit = "7355825599810198751875041563628058158258329601754296576667945643687737135311field";
+const expectedBHP1024CommitToGroup = "7355825599810198751875041563628058158258329601754296576667945643687737135311group";
+
+const expectedPedersen64Hash = "7641648045329738245569851934154954931983769745339084901557923877960530097536field";
+const expectedPedersen64Commit = "4214712642932384902492032091870474319129850239541860097363932997605707681866field";
+const expectedPedersen64CommitToGroup = "4214712642932384902492032091870474319129850239541860097363932997605707681866group";
+
+const expectedPedersen128Hash = "2635650346747854690304767890512510318865900869251739129887484152040487384946field";
+const expectedPedersen128Commit = "2510571858482041100602183741907011481539483352792333201599869098117502813920field";
+const expectedPedersen128CommitToGroup = "2510571858482041100602183741907011481539483352792333201599869098117502813920group";
+
+// Poseidon2 (2-bit)
+const expectedPoseidon2Hash = "5077032915756006405056357976663159304886914340125619713231037384461532417432field";
+const expectedPoseidon2HashToScalar = "1458530127089875298069764695141662184472227319324352086997987884214247116184scalar";
+const expectedPoseidon2HashToGroup = "6725009305095024168741689761204333975914699402177819232581771014527031061395group";
+const expectedPoseidon2HashMany = [
+    "5077032915756006405056357976663159304886914340125619713231037384461532417432field",
+    "7556882202382565798668668067123114920984638418911135511310139766017967865048field"
+];
+
+// Poseidon4 (4-bit)
+const expectedPoseidon4Hash = "7634545961811588936484713301052408690645763622397315677026301158133701966262field";
+const expectedPoseidon4HashToScalar = "397540384479326722511526738009414449816389580794780424560202157639131363766scalar";
+const expectedPoseidon4HashToGroup = "3501730277828187397862093302382961412852320364543135222391952713144715771762group";
+const expectedPoseidon4HashMany = [
+    "7634545961811588936484713301052408690645763622397315677026301158133701966262field",
+    "6897041872403455461974187270360400367782809654597486212257448618986966168076field"
+];
+
+// Poseidon8 (8-bit)
+const expectedPoseidon8Hash = "491310798299229303453029190751493384624125693265313448104421146921465784609field";
+const expectedPoseidon8HashToScalar = "491310798299229303453029190751493384624125693265313448104421146921465784609scalar";
+const expectedPoseidon8HashToGroup = "7639970001763982540831449531477540915761314714085721616177080725803487493174group";
+const expectedPoseidon8HashMany = [
+    "491310798299229303453029190751493384624125693265313448104421146921465784609field",
+    "476244868544635089532724552855423418881253978175875838088194622836984800804field"
+];
+
+
+
+/// Choose a scalar generator for unit tests.
+const ScalarGenerator = "1774157567936692047646837016039369013254365378639847034769080448564598011047scalar";
+export { FieldGenerator, ScalarGenerator, expectedBHP512Commit, expectedBHP512CommitToGroup, expectedBHP512Hash,
+    expectedBHP512HashToGroup, expectedBHP768Commit, expectedBHP768CommitToGroup, expectedBHP768Hash,
+    expectedBHP768HashToGroup, expectedBHP1024Commit, expectedBHP1024CommitToGroup, expectedBHP1024Hash,
+    expectedBHP1024HashToGroup, expectedBHP256Commit, expectedBHP256CommitToGroup, expectedBHP256Hash,
+    expectedBHP256HashToGroup, expectedPedersen64CommitToGroup, expectedPedersen64Commit, expectedPedersen64Hash,
+    expectedPedersen128CommitToGroup, expectedPedersen128Commit, expectedPedersen128Hash, expectedPoseidon2Hash,
+    expectedPoseidon2HashToGroup, expectedPoseidon2HashToScalar, expectedPoseidon2HashMany, expectedPoseidon4Hash,
+    expectedPoseidon4HashToGroup, expectedPoseidon4HashToScalar, expectedPoseidon4HashMany, expectedPoseidon8Hash,
+    expectedPoseidon8HashToGroup, expectedPoseidon8HashToScalar, expectedPoseidon8HashMany
+};

wasm/src/algorithms/bhp/bhp1024.rs

@@ -46,6 +46,7 @@ impl BHP1024 {
     }
 
     /// Returns a BHP hash with an input hasher of 1024 bits.
+    #[wasm_bindgen(js_name = "hashToGroup")]
     pub fn hash_to_group(&self, input: Array) -> Result<Group, String> {
         let input = from_js_typed_array!(input, as_bool, "boolean")?;
         self.0.hash_uncompressed(&input).map(|group| Group::from(group)).map_err(|e| e.to_string())
@@ -58,6 +59,7 @@ impl BHP1024 {
     }
 
     /// Returns a BHP commitment with an input hasher of 1024 bits and randomizer.
+    #[wasm_bindgen(js_name = "commitToGroup")]
     pub fn commit_to_group(&self, input: Array, randomizer: Scalar) -> Result<Group, String> {
         let input = from_js_typed_array!(input, as_bool, "boolean")?;
         self.0.commit_uncompressed(&input, &randomizer).map(|field| Group::from(field)).map_err(|e| e.to_string())

wasm/src/algorithms/bhp/bhp256.rs

@@ -25,7 +25,7 @@ pub struct BHP256(BHP256Native);
 
 #[wasm_bindgen]
 impl BHP256 {
-    /// Create a BHP hasher with an input size of 256 bits
+    /// Create a BHP hasher with an input size of 256 bits.
     #[wasm_bindgen(constructor)]
     pub fn new() -> Self {
         Self(BHP256Native::setup("AleoBHP256").expect("Failed to set up BHP256"))
@@ -45,6 +45,7 @@ impl BHP256 {
     }
 
     /// Returns a BHP hash with an input hasher of 256 bits.
+    #[wasm_bindgen(js_name = "hashToGroup")]
     pub fn hash_to_group(&self, input: Array) -> Result<Group, String> {
         let input = from_js_typed_array!(input, as_bool, "boolean")?;
         self.0.hash_uncompressed(&input).map(|group| Group::from(group)).map_err(|e| e.to_string())
@@ -57,6 +58,7 @@ impl BHP256 {
     }
 
     /// Returns a BHP commitment with an input hasher of 256 bits and randomizer.
+    #[wasm_bindgen(js_name = "commitToGroup")]
     pub fn commit_to_group(&self, input: Array, randomizer: Scalar) -> Result<Group, String> {
         let input = from_js_typed_array!(input, as_bool, "boolean")?;
         self.0.commit_uncompressed(&input, &randomizer).map(|group| Group::from(group)).map_err(|e| e.to_string())

wasm/src/algorithms/bhp/bhp512.rs

@@ -46,6 +46,7 @@ impl BHP512 {
     }
 
     /// Returns a BHP hash with an input hasher of 512 bits.
+    #[wasm_bindgen(js_name = "hashToGroup")]
     pub fn hash_to_group(&self, input: Array) -> Result<Group, String> {
         let input = from_js_typed_array!(input, as_bool, "boolean")?;
         self.0.hash_uncompressed(&input).map(|group| Group::from(group)).map_err(|e| e.to_string())
@@ -58,6 +59,7 @@ impl BHP512 {
     }
 
     /// Returns a BHP commitment with an input hasher of 512 bits and randomizer.
+    #[wasm_bindgen(js_name = "commitToGroup")]
     pub fn commit_to_group(&self, input: Array, randomizer: Scalar) -> Result<Group, String> {
         let input = from_js_typed_array!(input, as_bool, "boolean")?;
         self.0.commit_uncompressed(&input, &randomizer).map(|group| Group::from(group)).map_err(|e| e.to_string())

wasm/src/algorithms/bhp/bhp768.rs

@@ -46,6 +46,7 @@ impl BHP768 {
     }
 
     /// Returns a BHP hash with an input hasher of 768 bits.
+    #[wasm_bindgen(js_name = "hashToGroup")]
     pub fn hash_to_group(&self, input: Array) -> Result<Group, String> {
         let input = from_js_typed_array!(input, as_bool, "boolean")?;
         self.0.hash_uncompressed(&input).map(|group| Group::from(group)).map_err(|e| e.to_string())
@@ -58,6 +59,7 @@ impl BHP768 {
     }
 
     /// Returns a BHP commitment with an input hasher of 768 bits and randomizer.
+    #[wasm_bindgen(js_name = "commitToGroup")]
     pub fn commit_to_group(&self, input: Array, randomizer: Scalar) -> Result<Group, String> {
         let input = from_js_typed_array!(input, as_bool, "boolean")?;
         self.0.commit_uncompressed(&input, &randomizer).map(|field| Group::from(field)).map_err(|e| e.to_string())

wasm/src/algorithms/bhp/mod.rs

@@ -67,9 +67,7 @@ mod tests {
             let fields = create_native_field_vector(Some(count));
 
             // Create both a boolean vector and boolean array.
-            let bit_vector = fields.iter()
-                .flat_map(|item| item.to_bits_le()) // Flatten all bit representations
-                .collect::<Vec<bool>>();
+            let bit_vector = fields.iter().flat_map(|item| item.to_bits_le()).collect::<Vec<bool>>();
             let bit_array = bit_vector.iter().map(|item| JsValue::from(*item)).collect::<Array>();
 
             // Hash and commit to the field element using all BHP hasher instances.

wasm/src/algorithms/pedersen/mod.rs

@@ -54,24 +54,25 @@ mod tests {
         let native_pedersen128 = Pedersen128Native::setup("AleoPedersen128");
 
         for count in [1, 2] {
+            // Create a vector of u32 elements.
             let mut numbers = Vec::with_capacity(count);
             (0..count).into_iter().for_each(|_| numbers.extend(U32::<CurrentNetwork>::new(1).to_bits_le()));
 
-            // Create both a boolean vector and boolean array.
+            // Create both a boolean vector and boolean array from a vector of u32 elements.
             let bit_vector = numbers.iter()
                 .flat_map(|item| item.to_bits_le()) // Flatten all bit representations
                 .collect::<Vec<bool>>();
             let bit_array = bit_vector.iter().map(|item| JsValue::from(*item)).collect::<Array>();
 
-            // Hash and commit to the field element using all Pedersen hasher instances.
+            // Hash and commit to the u32 elements using all Pedersen hasher instances.
             let hash_64 = pedersen64.hash(bit_array.clone()).unwrap();
             let hash_128 = pedersen128.hash(bit_array.clone()).unwrap();
             let commit_64 = pedersen64.commit(bit_array.clone(), scalar.clone()).unwrap();
             let commit_128 = pedersen128.commit(bit_array.clone(), scalar.clone()).unwrap();
             let commit_to_group_64 = pedersen64.commit_to_group(bit_array.clone(), scalar.clone()).unwrap();
             let commit_to_group_128 = pedersen128.commit_to_group(bit_array.clone(), scalar.clone()).unwrap();
 
-            // Hash and commit to the field element using all native Pedersen hasher instances.
+            // Hash and commit to the u32 elements using all native Pedersen hasher instances.
             let native_hash_64 = native_pedersen64.hash(&bit_vector).unwrap();
             let native_hash_128 = native_pedersen128.hash(&bit_vector).unwrap();
             let native_commit_64 = native_pedersen64.commit(&bit_vector, &scalar).unwrap();