Merge pull request #779 from LIT-Protocol/ml/combine_all_signatures

add combiner for all

Author: Ansonhkg

packages/wasm/rust/Cargo.toml

@@ -11,11 +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"
+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" }
 getrandom = { version = "0.2", features = ["js"] }
 hex = "0.4"
 hd-keys-curves-wasm = { version = "1.0.1", default-features = false, features = ["k256", "p256"] }
@@ -26,9 +32,12 @@ serde_bare = "0.5"
 serde-wasm-bindgen = "0.6"
 
 elliptic-curve = "0.13"
-k256 = { version = "0.13", features = ["arithmetic"] }
-p256 = { version = "0.13", features = ["arithmetic"] }
+elliptic-curve-tools = "0.1.2"
+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 }
 
@@ -43,7 +52,6 @@ sev = { version = "2.0.2", default-features = false, features = [
 rand = "0.8"
 serde_bytes = "0.11.14"
 tsify = { version = "0.4.5", default-features = false, features = ["js"] }
-jubjub-plus = { version = "0.10.4" }
 
 web-sys = { version = "0.3", features = ["console"] }
 

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()))
 }