[Feature] Expose bit, byte, and fields serialization methods for plaintext, ciphertext, records, and addresses (#1010)

* exposed plaintext.to_bits_le function

* exposed address.to_bits_le function

* added address.plaintextBitsLe function

* added bit and byte serialization methods for plaintext, ciphertext, records, and addresses

* added all serialization/deserialization methods for address, signature, plaintext, ciphertext, recordplaintext, and recordciphertext which are available from snarkVM

* removed plaintext serialization methods from address and signature

* added tests for hash functions on plaintext literal types

* added signatures to hash tests and added TryFrom field->group methods

Author: alexpitsikoulis

wasm/src/account/address.rs

@@ -14,11 +14,23 @@
 // 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::account::{PrivateKey, Signature, ViewKey};
+use crate::{
+    Field,
+    Group,
+    Plaintext,
+    account::{PrivateKey, Signature, ViewKey, compute_key::ComputeKey},
+    from_js_typed_array,
+    from_wasm_object_array,
+    js_array_from_fields,
+    native::{FieldNative, LiteralNative},
+    to_bits_array_le,
+    types::native::AddressNative,
+};
+use snarkvm_console::prelude::{FromBits, FromBytes, FromFields, ToBits, ToBytes, ToFields};
 
-use crate::{account::compute_key::ComputeKey, types::native::AddressNative};
 use core::{convert::TryFrom, fmt, ops::Deref, str::FromStr};
-use wasm_bindgen::prelude::*;
+use js_sys::{Array, Uint8Array};
+use wasm_bindgen::{convert::TryFromJsValue, prelude::*};
 
 /// Public address of an Aleo account
 #[wasm_bindgen]
@@ -50,6 +62,79 @@ impl Address {
         compute_key.address()
     }
 
+    /// Get an address from a series of bytes.
+    ///
+    /// @param {Uint8Array} bytes A left endian byte array representing the address.
+    ///
+    /// @returns {Address} The address object.
+    #[wasm_bindgen(js_name = "fromBytesLe")]
+    pub fn from_bytes_le(bytes: Uint8Array) -> Result<Self, String> {
+        let rust_bytes = bytes.to_vec();
+        let native = AddressNative::from_bytes_le(rust_bytes.as_slice()).map_err(|e| e.to_string())?;
+        Ok(Self(native))
+    }
+
+    /// Get the left endian byte array representation of the address.
+    #[wasm_bindgen(js_name = "toBytesLe")]
+    pub fn to_bytes_le(&self) -> Result<Uint8Array, String> {
+        let rust_bytes = self.0.to_bytes_le().map_err(|e| e.to_string())?;
+        Ok(Uint8Array::from(rust_bytes.as_slice()))
+    }
+
+    /// Get an address from a series of bits represented as a boolean array.
+    ///
+    /// @param {Array} bits A left endian boolean array representing the bits of the address.
+    ///
+    /// @returns {Address} The address object.
+    #[wasm_bindgen(js_name = "fromBitsLe")]
+    pub fn from_bits_le(bits: Array) -> Result<Self, String> {
+        let rust_bits = from_js_typed_array!(bits, as_bool, "boolean")?;
+        let native = AddressNative::from_bits_le(&rust_bits).map_err(|e| e.to_string())?;
+        Ok(Self(native))
+    }
+
+    /// Get the left endian boolean array representation of the bits of the address.
+    #[wasm_bindgen(js_name = "toBitsLe")]
+    pub fn to_bits_le(&self) -> Array {
+        to_bits_array_le!(self)
+    }
+
+    /// Get an address object from an array of fields.
+    ///
+    /// @param {Array} fields An array of fields.
+    ///
+    /// @returns {Plaintext} The address object.
+    #[wasm_bindgen(js_name = "fromFields")]
+    pub fn from_fields(fields: Array) -> Result<Self, String> {
+        let native_fields = from_wasm_object_array!(fields, Field)?;
+        let native = AddressNative::from_fields(&native_fields).map_err(|e| e.to_string())?;
+        Ok(Self(native))
+    }
+
+    /// Get the field array representation of the address.
+    #[wasm_bindgen(js_name = "toFields")]
+    pub fn to_fields(&self) -> Result<Array, String> {
+        let native = self.0.clone();
+        let native_fields = native.to_fields().map_err(|e| e.to_string())?;
+        Ok(js_array_from_fields!(&native_fields))
+    }
+
+    /// Get an address object from a group.
+    ///
+    /// @param {Group} group The group object.
+    ///
+    /// @returns {Address} The address object.
+    #[wasm_bindgen(js_name = "fromGroup")]
+    pub fn from_group(group: Group) -> Self {
+        Self::from(group)
+    }
+
+    /// Get the group representation of the address object.
+    #[wasm_bindgen(js_name = "toGroup")]
+    pub fn to_group(&self) -> Group {
+        Group::from(self)
+    }
+
     /// Create an aleo address object from a string representation of an address
     ///
     /// @param {string} address String representation of an addressm
@@ -67,6 +152,12 @@ impl Address {
         self.0.to_string()
     }
 
+    /// Get the plaintext representation of the address.
+    #[wasm_bindgen(js_name = "toPlaintext")]
+    pub fn to_plaintext(&self) -> Plaintext {
+        Plaintext::from(LiteralNative::Address(self.0))
+    }
+
     /// Verify a signature for a message signed by the address
     ///
     /// @param {Uint8Array} Byte array representing a message signed by the address
@@ -114,6 +205,31 @@ impl From<&Address> for AddressNative {
     }
 }
 
+impl From<AddressNative> for Group {
+    fn from(value: AddressNative) -> Self {
+        let vm_group = value.to_group();
+        Self::from(vm_group)
+    }
+}
+
+impl From<Address> for Group {
+    fn from(value: Address) -> Self {
+        Self::from(value.0)
+    }
+}
+
+impl From<&AddressNative> for Group {
+    fn from(value: &AddressNative) -> Self {
+        Self::from(value.clone())
+    }
+}
+
+impl From<&Address> for Group {
+    fn from(value: &Address) -> Self {
+        Self::from(value.0)
+    }
+}
+
 impl FromStr for Address {
     type Err = anyhow::Error;
 

wasm/src/account/signature.rs

@@ -14,9 +14,22 @@
 // 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::{Address, PrivateKey, Scalar, types::native::SignatureNative};
+use crate::{
+    Address,
+    Field,
+    Plaintext,
+    PrivateKey,
+    Scalar,
+    from_js_typed_array,
+    js_array_from_fields,
+    native::LiteralNative,
+    to_bits_array_le,
+    types::native::SignatureNative,
+};
+use snarkvm_console::prelude::{FromBits, FromBytes, ToBits, ToBytes, ToFields};
 
 use core::{fmt, ops::Deref, str::FromStr};
+use js_sys::{Array, Uint8Array};
 use rand::{SeedableRng, rngs::StdRng};
 use wasm_bindgen::prelude::*;
 
@@ -61,6 +74,51 @@ impl Signature {
         self.0.verify_bytes(address, message)
     }
 
+    /// Get a signature from a series of bytes.
+    ///
+    /// @param {Uint8Array} bytes A left endian byte array representing the signature.
+    ///
+    /// @returns {Signature} The signature object.
+    #[wasm_bindgen(js_name = "fromBytesLe")]
+    pub fn from_bytes_le(bytes: Uint8Array) -> Result<Self, String> {
+        let rust_bytes = bytes.to_vec();
+        let native = SignatureNative::from_bytes_le(rust_bytes.as_slice()).map_err(|e| e.to_string())?;
+        Ok(Self(native))
+    }
+
+    /// Get the left endian byte array representation of the signature.
+    #[wasm_bindgen(js_name = "toBytesLe")]
+    pub fn to_bytes_le(&self) -> Result<Uint8Array, String> {
+        let rust_bytes = self.0.to_bytes_le().map_err(|e| e.to_string())?;
+        Ok(Uint8Array::from(rust_bytes.as_slice()))
+    }
+
+    /// Get a signature from a series of bits represented as a boolean array.
+    ///
+    /// @param {Array} bits A left endian boolean array representing the bits of the signature.
+    ///
+    /// @returns {Signature} The signature object.
+    #[wasm_bindgen(js_name = "fromBitsLe")]
+    pub fn from_bits_le(bits: Array) -> Result<Self, String> {
+        let rust_bits = from_js_typed_array!(bits, as_bool, "boolean")?;
+        let native = SignatureNative::from_bits_le(&rust_bits).map_err(|e| e.to_string())?;
+        Ok(Self(native))
+    }
+
+    /// Get the left endian boolean array representation of the bits of the signature.
+    #[wasm_bindgen(js_name = "toBitsLe")]
+    pub fn to_bits_le(&self) -> Array {
+        to_bits_array_le!(self)
+    }
+
+    /// Get the field array representation of the signature.
+    #[wasm_bindgen(js_name = "toFields")]
+    pub fn to_fields(&self) -> Result<Array, String> {
+        let native = self.0.clone();
+        let native_fields = native.to_fields().map_err(|e| e.to_string())?;
+        Ok(js_array_from_fields!(&native_fields))
+    }
+
     /// Get a signature from a string representation of a signature
     ///
     /// @param {string} signature String representation of a signature
@@ -76,6 +134,12 @@ impl Signature {
     pub fn to_string(&self) -> String {
         self.0.to_string()
     }
+
+    /// Get the plaintext representation of the signature.
+    #[wasm_bindgen(js_name = "toPlaintext")]
+    pub fn to_plaintext(&self) -> Plaintext {
+        Plaintext::from(LiteralNative::Signature(Box::new(self.0)))
+    }
 }
 
 impl Deref for Signature {