Add remaining available hash functionality

Author: iamalwaysuncomfortable

wasm/src/algorithms/bhp/bhp1024.rs

@@ -14,31 +14,52 @@
 // You should have received a copy of the GNU General Public License
 // along with the Aleo SDK library. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::{Field, Scalar, from_js_typed_array, types::native::BHP1024Native};
-use snarkvm_console::algorithms::{Commit, Hash};
+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"))
     }
 
-    /// Hash an array of booleans.
+    /// 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())
     }
 
-    /// Commit to an array of booleans.
+    /// Returns a BHP hash with an input hasher of 1024 bits.
+    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.
+    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

@@ -14,8 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with the Aleo SDK library. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::{Field, Scalar, from_js_typed_array, types::native::BHP256Native};
-use snarkvm_console::algorithms::{Commit, Hash};
+use crate::{Field, Group, Scalar, from_js_typed_array, types::native::BHP256Native};
+use snarkvm_console::algorithms::{Commit, CommitUncompressed, Hash, HashUncompressed};
 
 use js_sys::Array;
 use wasm_bindgen::prelude::*;
@@ -25,20 +25,40 @@ pub struct BHP256(BHP256Native);
 
 #[wasm_bindgen]
 impl BHP256 {
+    /// 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"))
     }
 
-    /// Hash an array of booleans.
+    /// Create a BHP hasher with an input size of 256 bits with a custom domain separator.
+    pub fn setup(domain_separator: &str) -> Result<Self, String> {
+        BHP256Native::setup(domain_separator)
+            .map(|native| Self(native))
+            .map_err(|e| format!("Failed to set up BHP256 with domain separator {}: {}", domain_separator, e))
+    }
+
+    /// Returns the BHP hash with an input hasher of 256 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())
     }
 
-    /// Commit to an array of booleans.
+    /// Returns a BHP hash with an input hasher of 256 bits.
+    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 256 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 256 bits and randomizer.
+    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

@@ -14,31 +14,52 @@
 // You should have received a copy of the GNU General Public License
 // along with the Aleo SDK library. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::{Field, Scalar, from_js_typed_array, types::native::BHP512Native};
-use snarkvm_console::algorithms::{Commit, Hash};
+use crate::{Field, Group, Scalar, from_js_typed_array, types::native::BHP512Native};
+use snarkvm_console::algorithms::{Commit, CommitUncompressed, Hash};
 
 use js_sys::Array;
+use snarkvm_console::account::HashUncompressed;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
 pub struct BHP512(BHP512Native);
 
 #[wasm_bindgen]
 impl BHP512 {
+    /// Create a BHP hasher with an input size of 512 bits.
     #[wasm_bindgen(constructor)]
     pub fn new() -> Self {
         Self(BHP512Native::setup("AleoBHP512").expect("Failed to set up BHP512"))
     }
 
-    /// Hash an array of booleans.
+    /// Create a BHP hasher with an input size of 512 bits with a custom domain separator.
+    pub fn setup(domain_separator: &str) -> Result<Self, String> {
+        BHP512Native::setup(domain_separator)
+            .map(|native| Self(native))
+            .map_err(|e| format!("Failed to set up BHP512 with domain separator {}: {}", domain_separator, e))
+    }
+
+    /// Returns the BHP hash with an input hasher of 512 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())
     }
 
-    /// Commit to an array of booleans.
+    /// Returns a BHP hash with an input hasher of 512 bits.
+    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 512 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 512 bits and randomizer.
+    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

@@ -14,31 +14,52 @@
 // You should have received a copy of the GNU General Public License
 // along with the Aleo SDK library. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::{Field, Scalar, from_js_typed_array, types::native::BHP768Native};
-use snarkvm_console::algorithms::{Commit, Hash};
+use crate::{Field, Group, Scalar, from_js_typed_array, types::native::BHP768Native};
+use snarkvm_console::algorithms::{Commit, CommitUncompressed, Hash};
 
 use js_sys::Array;
+use snarkvm_console::account::HashUncompressed;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen]
 pub struct BHP768(BHP768Native);
 
 #[wasm_bindgen]
 impl BHP768 {
+    /// Create a BHP hasher with an input size of 768 bits.
     #[wasm_bindgen(constructor)]
     pub fn new() -> Self {
         Self(BHP768Native::setup("AleoBHP768").expect("Failed to set up BHP768"))
     }
 
-    /// Hash an array of booleans.
+    /// Create a BHP hasher with an input size of 768 bits with a custom domain separator.
+    pub fn setup(domain_separator: &str) -> Result<Self, String> {
+        BHP768Native::setup(domain_separator)
+            .map(|native| Self(native))
+            .map_err(|e| format!("Failed to set up BHP768 with domain separator {}: {}", domain_separator, e))
+    }
+
+    /// Returns the BHP hash with an input hasher of 768 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())
     }
 
-    /// Commit to an array of booleans.
+    /// Returns a BHP hash with an input hasher of 768 bits.
+    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 768 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 768 bits and randomizer.
+    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

@@ -31,11 +31,12 @@ mod tests {
     use super::*;
     use crate::{
         Field,
+        Group,
         Scalar,
         test::create_native_field_vector,
         types::native::{BHP256Native, BHP512Native, BHP768Native, BHP1024Native},
     };
-    use snarkvm_console::algorithms::{Commit, Hash, ToBits};
+    use snarkvm_console::algorithms::{Commit, CommitUncompressed, Hash, HashUncompressed, ToBits};
 
     use js_sys::Array;
     use wasm_bindgen::JsValue;
@@ -76,30 +77,54 @@ mod tests {
             let hash_512 = bhp512.hash(bit_array.clone()).unwrap();
             let hash_768 = bhp768.hash(bit_array.clone()).unwrap();
             let hash_1024 = bhp1024.hash(bit_array.clone()).unwrap();
+            let hash_to_group_256 = bhp256.hash_to_group(bit_array.clone()).unwrap();
+            let hash_to_group_512 = bhp512.hash_to_group(bit_array.clone()).unwrap();
+            let hash_to_group_768 = bhp768.hash_to_group(bit_array.clone()).unwrap();
+            let hash_to_group_1024 = bhp1024.hash_to_group(bit_array.clone()).unwrap();
             let commit_256 = bhp256.commit(bit_array.clone(), scalar.clone()).unwrap();
             let commit_512 = bhp512.commit(bit_array.clone(), scalar.clone()).unwrap();
             let commit_768 = bhp768.commit(bit_array.clone(), scalar.clone()).unwrap();
             let commit_1024 = bhp1024.commit(bit_array.clone(), scalar.clone()).unwrap();
+            let commit_to_group_256 = bhp256.commit_to_group(bit_array.clone(), scalar.clone()).unwrap();
+            let commit_to_group_512 = bhp512.commit_to_group(bit_array.clone(), scalar.clone()).unwrap();
+            let commit_to_group_768 = bhp768.commit_to_group(bit_array.clone(), scalar.clone()).unwrap();
+            let commit_to_group_1024 = bhp1024.commit_to_group(bit_array.clone(), scalar.clone()).unwrap();
 
             // Hash and commit to the field element using all native BHP hasher instances.
             let native_hash_256 = native_bhp256.hash(&bit_vector).unwrap();
             let native_hash_512 = native_bhp512.hash(&bit_vector).unwrap();
             let native_hash_768 = native_bhp768.hash(&bit_vector).unwrap();
             let native_hash_1024 = native_bhp1024.hash(&bit_vector).unwrap();
+            let native_hash_to_group_256 = native_bhp256.hash_uncompressed(&bit_vector).unwrap();
+            let native_hash_to_group_512 = native_bhp512.hash_uncompressed(&bit_vector).unwrap();
+            let native_hash_to_group_768 = native_bhp768.hash_uncompressed(&bit_vector).unwrap();
+            let native_hash_to_group_1024 = native_bhp1024.hash_uncompressed(&bit_vector).unwrap();
             let native_commit_256 = native_bhp256.commit(&bit_vector, &scalar).unwrap();
             let native_commit_512 = native_bhp512.commit(&bit_vector, &scalar).unwrap();
             let native_commit_768 = native_bhp768.commit(&bit_vector, &scalar).unwrap();
             let native_commit_1024 = native_bhp1024.commit(&bit_vector, &scalar).unwrap();
+            let native_commit_to_group_256 = native_bhp256.commit_uncompressed(&bit_vector, &scalar).unwrap();
+            let native_commit_to_group_512 = native_bhp512.commit_uncompressed(&bit_vector, &scalar).unwrap();
+            let native_commit_to_group_768 = native_bhp768.commit_uncompressed(&bit_vector, &scalar).unwrap();
+            let native_commit_to_group_1024 = native_bhp1024.commit_uncompressed(&bit_vector, &scalar).unwrap();
 
             // Assert native and exported results are equal.
             assert_eq!(hash_256, Field::from(native_hash_256));
             assert_eq!(hash_512, Field::from(native_hash_512));
             assert_eq!(hash_768, Field::from(native_hash_768));
             assert_eq!(hash_1024, Field::from(native_hash_1024));
+            assert_eq!(hash_to_group_256, Group::from(native_hash_to_group_256));
+            assert_eq!(hash_to_group_512, Group::from(native_hash_to_group_512));
+            assert_eq!(hash_to_group_768, Group::from(native_hash_to_group_768));
+            assert_eq!(hash_to_group_1024, Group::from(native_hash_to_group_1024));
             assert_eq!(commit_256, Field::from(native_commit_256));
             assert_eq!(commit_512, Field::from(native_commit_512));
             assert_eq!(commit_768, Field::from(native_commit_768));
             assert_eq!(commit_1024, Field::from(native_commit_1024));
+            assert_eq!(commit_to_group_256, Group::from(native_commit_to_group_256));
+            assert_eq!(commit_to_group_512, Group::from(native_commit_to_group_512));
+            assert_eq!(commit_to_group_768, Group::from(native_commit_to_group_768));
+            assert_eq!(commit_to_group_1024, Group::from(native_commit_to_group_1024));
         }
     }
 }

wasm/src/algorithms/pedersen/mod.rs

@@ -25,11 +25,11 @@ mod tests {
     use super::*;
     use crate::{
         Field,
+        Group,
         Scalar,
-        test::create_native_field_vector,
         types::native::{Pedersen64Native, Pedersen128Native},
     };
-    use snarkvm_console::algorithms::{Commit, Hash, ToBits};
+    use snarkvm_console::algorithms::{Commit, CommitUncompressed, Hash, ToBits};
 
     use crate::types::native::CurrentNetwork;
     use js_sys::Array;
@@ -68,18 +68,24 @@ mod tests {
             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.
             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();
             let native_commit_128 = native_pedersen128.commit(&bit_vector, &scalar).unwrap();
+            let native_commit_to_group_64 = native_pedersen64.commit_uncompressed(&bit_vector, &scalar).unwrap();
+            let native_commit_to_group_128 = native_pedersen128.commit_uncompressed(&bit_vector, &scalar).unwrap();
 
             // Assert native and exported results are equal.
             assert_eq!(hash_64, Field::from(native_hash_64));
             assert_eq!(hash_128, Field::from(native_hash_128));
             assert_eq!(commit_64, Field::from(native_commit_64));
             assert_eq!(commit_128, Field::from(native_commit_128));
+            assert_eq!(commit_to_group_64, Group::from(native_commit_to_group_64));
+            assert_eq!(commit_to_group_128, Group::from(native_commit_to_group_128));
         }
     }
 }

wasm/src/algorithms/pedersen/pedersen128.rs

@@ -14,8 +14,8 @@
 // You should have received a copy of the GNU General Public License
 // along with the Aleo SDK library. If not, see <https://www.gnu.org/licenses/>.
 
-use crate::{Field, Scalar, from_js_typed_array, types::native::Pedersen128Native};
-use snarkvm_console::algorithms::{Commit, Hash};
+use crate::{Field, Group, Scalar, from_js_typed_array, types::native::Pedersen128Native};
+use snarkvm_console::algorithms::{Commit, CommitUncompressed, Hash};
 
 use js_sys::Array;
 use wasm_bindgen::prelude::*;
@@ -25,20 +25,32 @@ pub struct Pedersen128(Pedersen128Native);
 
 #[wasm_bindgen]
 impl Pedersen128 {
+    /// Create a Pedersen64 hasher for a given (up to) 128-bit input.
     #[wasm_bindgen(constructor)]
     pub fn new() -> Self {
         Self(Pedersen128Native::setup("AleoPedersen128"))
     }
 
-    /// Hash an array of fields.
+    /// Create a Pedersen64 hasher for a given (up to) 128-bit input with a custom domain separator.
+    pub fn setup(domain_separator: &str) -> Self {
+        Self(Pedersen128Native::setup(domain_separator))
+    }
+
+    /// Returns the Pedersen hash for a given (up to) 64-bit input.
     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())
     }
 
-    /// Commit to an array of booleans.
+    /// Returns a Pedersen commitment for the given (up to) 128-bit input 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 Pedersen commitment for the given (up to) 128-bit input and randomizer.
+    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())
+    }
 }