add tests for combine_and_verify that also print the results

Signed-off-by: Michael Lodder <[email protected]>

Author: mikelodder7

packages/wasm/rust/Cargo.toml

@@ -11,13 +11,17 @@ repository = "https://github.com/LIT-Protocol/js-sdk"
 crate-type = ["cdylib", "rlib"]
 
 [features]
+default = ["verify-only"]
+verify-only = ["lit-frost/verify_only"]
+test-shares = ["lit-frost/default", "vsss-rs"]
 
 [dependencies]
 wasm-bindgen = { version = "0.2", features = ["serde-serialize"] }
 blsful = { version = "3.0.0-pre8", default-features = false, features = ["rust"] }
+base64_light = "0.1.5"
 ecdsa = "0.16.9"
 generic-array = "1.1.1"
-lit-frost = { git = "https://github.com/LIT-Protocol/lit-frost.git", features = ["verify_only"] }
+lit-frost = { git = "https://github.com/LIT-Protocol/lit-frost.git" }
 getrandom = { version = "0.2", features = ["js"] }
 hex = "0.4"
 hd-keys-curves-wasm = { version = "1.0.1", default-features = false, features = ["k256", "p256"] }
@@ -33,6 +37,7 @@ k256 = { version = "0.13", features = ["arithmetic", "serde"] }
 p256 = { version = "0.13", features = ["arithmetic", "serde"] }
 p384 = { version = "0.13", features = ["arithmetic", "serde"] }
 sha2 = "0.10"
+vsss-rs = { version = "5.1.0", optional = true }
 
 wee_alloc = { version = "0.4.5", optional = true }
 

packages/wasm/rust/src/bls.rs

@@ -1,14 +1,11 @@
-use wasm_bindgen::prelude::*;
+use base64_light::{base64_decode, base64_encode_bytes};
 use js_sys::Uint8Array;
-use serde::{ Deserialize };
-use base64_light::{ base64_decode, base64_encode_bytes };
-use tsify::Tsify;
 use lit_bls_wasm::{
-  encrypt,
-  decrypt_with_signature_shares,
-  combine_signature_shares,
-  verify_signature,
+    combine_signature_shares, decrypt_with_signature_shares, encrypt, verify_signature,
 };
+use serde::Deserialize;
+use tsify::Tsify;
+use wasm_bindgen::prelude::*;
 
 type JsResult<T> = Result<T, JsValue>;
 
@@ -17,102 +14,94 @@ type JsResult<T> = Result<T, JsValue>;
 // -----------------------------------------------------------------------
 #[wasm_bindgen(js_name = "blsCombine")]
 pub fn bls_combine(signature_shares: JsValue) -> Result<String, String> {
-  let shares: Vec<String> = serde_wasm_bindgen
-    ::from_value(signature_shares)
-    .map_err(|e| format!("Failed to parse shares: {}", e))?;
+    let shares: Vec<String> = serde_wasm_bindgen::from_value(signature_shares)
+        .map_err(|e| format!("Failed to parse shares: {}", e))?;
 
-  let combined_signature = combine_signature_shares(
-    serde_wasm_bindgen::to_value(&shares).unwrap()
-  ).map_err(|e| format!("Failed to combine signature shares: {}", e))?;
+    let combined_signature =
+        combine_signature_shares(serde_wasm_bindgen::to_value(&shares).unwrap())
+            .map_err(|e| format!("Failed to combine signature shares: {}", e))?;
 
-  Ok(combined_signature)
+    Ok(combined_signature)
 }
 
 // -----------------------------------------------------------------------
 // 2. blsVerify
 // -----------------------------------------------------------------------
 #[wasm_bindgen(js_name = "blsVerify")]
 pub fn bls_verify(
-  public_key: Uint8Array, // buffer, but will be converted to hex string
-  message: Uint8Array, // buffer, but will be converted to hex string
-  signature: String // this is the result from bls_combine. It's a hex string
+    public_key: Uint8Array, // buffer, but will be converted to hex string
+    message: Uint8Array,    // buffer, but will be converted to hex string
+    signature: String,      // this is the result from bls_combine. It's a hex string
 ) -> JsResult<()> {
-  // check if signature is a valid hex string
-  if !signature.chars().all(|c| c.is_ascii_hexdigit()) {
-    return Err(JsValue::from_str("Signature must be a hex string"));
-  }
-  // convert public_key to hex string
-  let public_key_hex = hex::encode(public_key.to_vec());
-
-  // convert message to base64 string
-  let message_base64 = base64_encode_bytes(&message.to_vec());
-
-  // Validate all inputs are hex
-  if !public_key_hex.chars().all(|c| c.is_ascii_hexdigit()) {
-    return Err(JsValue::from_str("Public key must be a hex string"));
-  }
-
-  if !signature.chars().all(|c| c.is_ascii_hexdigit()) {
-    return Err(JsValue::from_str("Signature must be a hex string"));
-  }
-
-  let signature_bytes = hex
-    ::decode(&signature)
-    .map_err(|e|
-      JsValue::from_str(&format!("Failed to decode signature hex: {}", e))
-    )?;
-
-  let signature_base64 = base64_encode_bytes(&signature_bytes);
-
-  verify_signature(&public_key_hex, &message_base64, &signature_base64).map_err(
-    |e| JsValue::from_str(&format!("Verification failed: {}", e))
-  )
+    // check if signature is a valid hex string
+    if !signature.chars().all(|c| c.is_ascii_hexdigit()) {
+        return Err(JsValue::from_str("Signature must be a hex string"));
+    }
+    // convert public_key to hex string
+    let public_key_hex = hex::encode(public_key.to_vec());
+
+    // convert message to base64 string
+    let message_base64 = base64_encode_bytes(&message.to_vec());
+
+    // Validate all inputs are hex
+    if !public_key_hex.chars().all(|c| c.is_ascii_hexdigit()) {
+        return Err(JsValue::from_str("Public key must be a hex string"));
+    }
+
+    if !signature.chars().all(|c| c.is_ascii_hexdigit()) {
+        return Err(JsValue::from_str("Signature must be a hex string"));
+    }
+
+    let signature_bytes = hex::decode(&signature)
+        .map_err(|e| JsValue::from_str(&format!("Failed to decode signature hex: {}", e)))?;
+
+    let signature_base64 = base64_encode_bytes(&signature_bytes);
+
+    verify_signature(&public_key_hex, &message_base64, &signature_base64)
+        .map_err(|e| JsValue::from_str(&format!("Verification failed: {}", e)))
 }
 
 // -----------------------------------------------------------------------
 // 3. blsEncrypt
 // -----------------------------------------------------------------------
 #[wasm_bindgen(js_name = "blsEncrypt")]
 pub fn bls_encrypt(
-  encryption_key: Uint8Array,
-  message: Uint8Array,
-  identity: Uint8Array
+    encryption_key: Uint8Array,
+    message: Uint8Array,
+    identity: Uint8Array,
 ) -> JsResult<Uint8Array> {
-  let encryption_key_hex = hex::encode(encryption_key.to_vec());
-  let message_base64 = base64_encode_bytes(&message.to_vec());
-  let identity_base64 = base64_encode_bytes(&identity.to_vec());
+    let encryption_key_hex = hex::encode(encryption_key.to_vec());
+    let message_base64 = base64_encode_bytes(&message.to_vec());
+    let identity_base64 = base64_encode_bytes(&identity.to_vec());
 
-  let ciphertext = encrypt(
-    &encryption_key_hex,
-    &message_base64,
-    &identity_base64
-  ).map_err(|e| JsValue::from_str(&format!("Encryption failed: {}", e)))?;
+    let ciphertext = encrypt(&encryption_key_hex, &message_base64, &identity_base64)
+        .map_err(|e| JsValue::from_str(&format!("Encryption failed: {}", e)))?;
 
-  let decoded_ciphertext = base64_decode(&ciphertext);
+    let decoded_ciphertext = base64_decode(&ciphertext);
 
-  Ok(Uint8Array::from(decoded_ciphertext.as_slice()))
+    Ok(Uint8Array::from(decoded_ciphertext.as_slice()))
 }
 
 // -----------------------------------------------------------------------
 // 4. blsDecrypt
 // -----------------------------------------------------------------------
 #[wasm_bindgen(js_name = "blsDecrypt")]
 pub fn bls_decrypt(
-  ciphertext: Uint8Array,
-  signature_shares: JsValue // this is the result from bls_combine. It's a hex string
+    ciphertext: Uint8Array,
+    signature_shares: JsValue, // this is the result from bls_combine. It's a hex string
 ) -> JsResult<Uint8Array> {
-  let ciphertext_base64 = base64_encode_bytes(&ciphertext.to_vec());
+    let ciphertext_base64 = base64_encode_bytes(&ciphertext.to_vec());
 
-  let shares: Vec<String> = serde_wasm_bindgen
-    ::from_value(signature_shares)
-    .map_err(|e| format!("[blsDecrypt] Failed to parse shares: {}", e))?;
+    let shares: Vec<String> = serde_wasm_bindgen::from_value(signature_shares)
+        .map_err(|e| format!("[blsDecrypt] Failed to parse shares: {}", e))?;
 
-  let plaintext = decrypt_with_signature_shares(
-    &ciphertext_base64,
-    serde_wasm_bindgen::to_value(&shares).unwrap()
-  ).map_err(|e| JsValue::from_str(&format!("Decryption failed: {}", e)))?;
+    let plaintext = decrypt_with_signature_shares(
+        &ciphertext_base64,
+        serde_wasm_bindgen::to_value(&shares).unwrap(),
+    )
+    .map_err(|e| JsValue::from_str(&format!("Decryption failed: {}", e)))?;
 
-  let decoded_plaintext = base64_decode(&plaintext);
+    let decoded_plaintext = base64_decode(&plaintext);
 
-  Ok(Uint8Array::from(decoded_plaintext.as_slice()))
+    Ok(Uint8Array::from(decoded_plaintext.as_slice()))
 }

packages/wasm/rust/src/combine.rs

@@ -51,48 +51,52 @@ pub struct SignedDataOutput {
 }
 
 #[derive(Deserialize)]
-enum SignableOutput {
+#[cfg_attr(feature = "test-shares", derive(Serialize))]
+pub(crate) enum SignableOutput {
     EcdsaSignedMessageShare(EcdsaSignedMessageShare),
     FrostSignedMessageShare(FrostSignedMessageShare),
     BlsSignedMessageShare(BlsSignedMessageShare),
 }
 
 #[derive(Clone, Deserialize)]
-struct EcdsaSignedMessageShare {
-    digest: String,
-    result: String,
-    share_id: String,
-    peer_id: String,
-    signature_share: String,
-    big_r: String,
-    compressed_public_key: String,
-    public_key: String,
-    sig_type: String,
+#[cfg_attr(feature = "test-shares", derive(Serialize))]
+pub(crate) struct EcdsaSignedMessageShare {
+    pub(crate) digest: String,
+    pub(crate) result: String,
+    pub(crate) share_id: String,
+    pub(crate) peer_id: String,
+    pub(crate) signature_share: String,
+    pub(crate) big_r: String,
+    pub(crate) compressed_public_key: String,
+    pub(crate) public_key: String,
+    pub(crate) sig_type: String,
 }
 
 #[derive(Deserialize)]
-struct FrostSignedMessageShare {
-    message: String,
-    result: String,
-    share_id: String,
-    peer_id: String,
-    signature_share: String,
-    signing_commitments: String,
-    verifying_share: String,
-    public_key: String,
-    sig_type: String,
+#[cfg_attr(feature = "test-shares", derive(Serialize))]
+pub(crate) struct FrostSignedMessageShare {
+    pub(crate) message: String,
+    pub(crate) result: String,
+    pub(crate) share_id: String,
+    pub(crate) peer_id: String,
+    pub(crate) signature_share: String,
+    pub(crate) signing_commitments: String,
+    pub(crate) verifying_share: String,
+    pub(crate) public_key: String,
+    pub(crate) sig_type: String,
 }
 
 #[derive(Deserialize)]
-struct BlsSignedMessageShare {
-    message: String,
-    result: String,
-    peer_id: String,
-    share_id: String,
-    signature_share: String,
-    verifying_share: String,
-    public_key: String,
-    sig_type: String,
+#[cfg_attr(feature = "test-shares", derive(Serialize))]
+pub(crate) struct BlsSignedMessageShare {
+    pub(crate) message: String,
+    pub(crate) result: String,
+    pub(crate) peer_id: String,
+    pub(crate) share_id: String,
+    pub(crate) signature_share: String,
+    pub(crate) verifying_share: String,
+    pub(crate) public_key: String,
+    pub(crate) sig_type: String,
 }
 
 /// A signature share
@@ -174,7 +178,7 @@ where
     }
 }
 
-fn x_coordinate<C>(point: &C::ProjectivePoint) -> C::Scalar
+pub(crate) fn x_coordinate<C>(point: &C::ProjectivePoint) -> C::Scalar
 where
     C: PrimeCurve + CurveArithmetic,
 {

packages/wasm/rust/src/lib.rs

@@ -3,6 +3,8 @@ pub mod bls;
 mod combine;
 pub mod ecdsa;
 pub mod sev_snp;
+#[cfg(feature = "test-shares")]
+pub mod test;
 
 use wasm_bindgen::prelude::*;