Merge pull request #989 from ProvableHQ/feat/hash-functions

[Feature] Add BHP, Pedersen, and Poseidon hash function implementations to the Provable SDK.

Author: iamalwaysuncomfortable

create-leo-app/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-leo-app",
-  "version": "0.8.5",
+  "version": "0.8.6",
   "type": "module",
   "license": "GPL-3.0",
   "collaborators": [

sdk/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@provablehq/sdk",
-  "version": "0.8.5",
+  "version": "0.8.6",
   "description": "A Software Development Kit (SDK) for Zero-Knowledge Transactions",
   "collaborators": [
     "The Provable Team"
@@ -47,7 +47,7 @@
   },
   "homepage": "https://github.com/ProvableHQ/sdk#readme",
   "dependencies": {
-    "@provablehq/wasm": "^0.8.4",
+    "@provablehq/wasm": "^0.8.6",
     "comlink": "^4.4.2",
     "core-js": "^3.40.0",
     "mime": "^4.0.6",

sdk/src/browser.ts

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

sdk/src/wasm.ts

@@ -1,5 +1,9 @@
 export {
     Address,
+    BHP256,
+    BHP512,
+    BHP768,
+    BHP1024,
     Ciphertext,
     ComputeKey,
     Execution,
@@ -8,7 +12,12 @@ export {
     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/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "aleo-wasm"
-version = "0.8.0"
+version = "0.8.6"
 authors = [ "The Provable Team" ]
 description = "WebAssembly based toolkit for developing zero-knowledge applications with Aleo"
 homepage = "https://provable.com"
@@ -99,7 +99,7 @@ default-features = false
 version = "2"
 
 [dependencies.wasm-bindgen]
-version = "0.2"
+version = "0.2.100"
 features = [ "serde-serialize" ]
 
 [dependencies.wasm-bindgen-futures]
@@ -120,7 +120,7 @@ features = [
 ]
 
 [dev-dependencies.wasm-bindgen-test]
-version = "0.3.37"
+version = "0.3.50"
 
 [dev-dependencies.gloo-timers]
 version = "0.3.0"

wasm/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@provablehq/wasm",
-  "version": "0.8.4",
+  "version": "0.8.6",
   "description": "SnarkVM WASM binaries with javascript bindings",
   "collaborators": [
     "The Provable Team"

wasm/src/algorithms/bhp/bhp1024.rs

@@ -0,0 +1,67 @@
+// Copyright (C) 2019-2025 Provable Inc.
+// This file is part of the Provable SDK library.
+
+// The Provable SDK library is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// The Provable SDK library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with the Provable SDK library. If not, see <https://www.gnu.org/licenses/>.
+
+use crate::{Field, Group, Scalar, from_js_typed_array, types::native::BHP1024Native};
+use snarkvm_console::algorithms::{Commit, CommitUncompressed, Hash};
+
+use js_sys::Array;
+use snarkvm_console::account::HashUncompressed;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+pub struct BHP1024(BHP1024Native);
+
+#[wasm_bindgen]
+impl BHP1024 {
+    /// Create a BHP hasher with an input size of 1024 bits.
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        Self(BHP1024Native::setup("AleoBHP1024").expect("Failed to set up BHP1024"))
+    }
+
+    /// Create a BHP hasher with an input size of 1024 bits with a custom domain separator.
+    pub fn setup(domain_separator: &str) -> Result<Self, String> {
+        BHP1024Native::setup(domain_separator)
+            .map(|native| Self(native))
+            .map_err(|e| format!("Failed to set up BHP1024 with domain separator {}: {}", domain_separator, e))
+    }
+
+    /// Returns the BHP hash with an input hasher of 1024 bits.
+    pub fn hash(&self, input: Array) -> Result<Field, String> {
+        let input = from_js_typed_array!(input, as_bool, "boolean")?;
+        self.0.hash(&input).map(|field| Field::from(field)).map_err(|e| e.to_string())
+    }
+
+    /// 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())
+    }
+
+    /// Returns a BHP commitment with an input hasher of 1024 bits and randomizer.
+    pub fn commit(&self, input: Array, randomizer: Scalar) -> Result<Field, String> {
+        let input = from_js_typed_array!(input, as_bool, "boolean")?;
+        self.0.commit(&input, &randomizer).map(|field| Field::from(field)).map_err(|e| e.to_string())
+    }
+
+    /// 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())
+    }
+}