feat: clean ecdsa wasm

Author: FedericoAmura

packages/core/src/lib/lit-core.ts

@@ -23,7 +23,6 @@ import {
   STAKING_STATES_VALUES,
   UnknownError,
   version,
-  LitEcdsaVariantType,
 } from '@lit-protocol/constants';
 import { LitContracts } from '@lit-protocol/contracts-sdk';
 import { checkSevSnpAttestation, computeHDPubKey } from '@lit-protocol/crypto';
@@ -1230,28 +1229,20 @@ export class LitCore {
   };
 
   /**
-   * Calculates an HD public key from a given keyId
-   * The curve type or signature type is assumed to be k256 unless provided
+   * Calculates an K256 HD public key from a given keyId
+   *
    * @param keyId
-   * @param {LitEcdsaVariantType} sigType
    * @returns {string} public key
    */
-  computeHDPubKey = async (
-    keyId: string,
-    sigType: LitEcdsaVariantType = LIT_CURVE.EcdsaK256Sha256
-  ): Promise<string> => {
+  computeHDPubKey = async (keyId: string): Promise<string> => {
     if (!this.hdRootPubkeys) {
       logError('root public keys not found, have you connected to the nodes?');
       throw new LitNodeClientNotReadyError(
         {},
         'root public keys not found, have you connected to the nodes?'
       );
     }
-    return await computeHDPubKey(
-      this.hdRootPubkeys as string[],
-      keyId,
-      sigType
-    );
+    return await computeHDPubKey(this.hdRootPubkeys as string[], keyId);
   };
 
   /**

packages/crypto/src/lib/crypto.ts

@@ -13,8 +13,6 @@ import { sha384, sha512 } from '@noble/hashes/sha512';
 import {
   CurveTypeNotFoundError,
   InvalidParamType,
-  LIT_CURVE,
-  LitEcdsaVariantType,
   NetworkError,
   NoValidShares,
   UnknownError,
@@ -49,7 +47,6 @@ import {
   BlsSignatureShareJsonString,
   blsVerify,
   ecdsaDeriveKey,
-  EcdsaVariant,
   sevSnpGetVcekUrl,
   sevSnpVerify,
   unifiedCombineAndVerify,
@@ -107,21 +104,6 @@ export const encrypt = async (
   );
 };
 
-/**
- * Decrypt ciphertext using BLS signature shares.
- *
- * @param ciphertextBase64 base64-encoded string of the ciphertext to decrypt
- * @param shares hex-encoded array of the BLS signature shares
- * @returns Uint8Array of the decrypted data
- */
-export const decryptWithSignatureShares = async (
-  ciphertextBase64: string,
-  shares: BlsSignatureShare[]
-): Promise<Uint8Array> => {
-  const sigShares = toJSONShares(shares);
-  return doDecrypt(ciphertextBase64, sigShares);
-};
-
 /**
  * Verify and decrypt ciphertext using BLS signature shares.
  *
@@ -194,12 +176,6 @@ export const verifySignature = async (
   await blsVerify(publicKey, message, signature);
 };
 
-const ecdsaSigntureTypeMap: Record<LitEcdsaVariantType, EcdsaVariant> = {
-  [LIT_CURVE.EcdsaK256Sha256]: 'K256',
-  [LIT_CURVE.EcdsaP256Sha256]: 'P256',
-  [LIT_CURVE.EcdsaP384Sha384]: 'P384',
-};
-
 const parseCombinedSignature = (
   combinedSignature: CombinedLitNodeSignature
 ): CleanLitNodeSignature => {
@@ -290,35 +266,14 @@ export const combinePKPSignNodeShares = async (
 
 export const computeHDPubKey = async (
   pubkeys: string[],
-  keyId: string,
-  sigType: LitEcdsaVariantType
+  keyId: string
 ): Promise<string> => {
-  const variant = ecdsaSigntureTypeMap[sigType];
-
-  if (
-    ![
-      LIT_CURVE.EcdsaK256Sha256,
-      LIT_CURVE.EcdsaP256Sha256,
-      LIT_CURVE.EcdsaP384Sha384,
-    ].includes(sigType)
-  ) {
-    throw new InvalidParamType(
-      {
-        info: {
-          sigType,
-        },
-      },
-      `Non supported signature type`
-    );
-  }
-
   // a bit of preprocessing to remove characters which will cause our wasm module to reject the values.
   pubkeys = pubkeys.map((value: string) => {
     return value.replace('0x', '');
   });
   keyId = keyId.replace('0x', '');
   const preComputedPubkey = await ecdsaDeriveKey(
-    variant,
     Buffer.from(keyId, 'hex'),
     pubkeys.map((hex: string) => Buffer.from(hex, 'hex'))
   );

packages/wasm/rust/Cargo.toml

@@ -22,13 +22,11 @@ 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"] }
 lit-bls-wasm = { git = "https://github.com/LIT-Protocol/lit-bls-wasm" }
 serde = "1.0"
 serde_json = "1.0"
-serde_bare = "0.5"
 serde-wasm-bindgen = "0.6"
 
 elliptic-curve = "0.13"
@@ -39,10 +37,6 @@ 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 }
-
-console_error_panic_hook = { version = "0.1.7", optional = true }
-wasm-bindgen-futures = "0.4.40"
 js-sys = "0.3.67"
 
 sev = { version = "2.0.2", default-features = false, features = [
@@ -53,15 +47,10 @@ rand = "0.8"
 serde_bytes = "0.11.14"
 tsify = { version = "0.4.5", default-features = false, features = ["js"] }
 
-web-sys = { version = "0.3", features = ["console"] }
 
 [dev-dependencies]
-wasm-bindgen-test = "0.3.34"
-ciborium = "0.2"
 k256 = "0.13"
 rand = "0.8"
-rand_chacha = "0.3"
-digest = "0.10"
 
 [profile.release]
 opt-level = "z"

packages/wasm/rust/src/ecdsa.rs

@@ -11,23 +11,12 @@ use elliptic_curve::{
 use hd_keys_curves_wasm::{HDDerivable, HDDeriver};
 use js_sys::Uint8Array;
 use k256::Secp256k1;
-use p256::NistP256;
-use p384::NistP384;
-use serde::Deserialize;
 use serde_bytes::Bytes;
 use tsify::Tsify;
 use wasm_bindgen::{prelude::*, JsError};
 
 use crate::abi::{from_js, into_js, into_uint8array, JsResult};
 
-#[derive(Tsify, Deserialize)]
-#[tsify(from_wasm_abi)]
-pub enum EcdsaVariant {
-    K256,
-    P256,
-    P384,
-}
-
 struct Ecdsa<C>(C);
 
 trait HdCtx {
@@ -38,14 +27,6 @@ impl HdCtx for Secp256k1 {
     const CTX: &'static [u8] = b"LIT_HD_KEY_ID_K256_XMD:SHA-256_SSWU_RO_NUL_";
 }
 
-impl HdCtx for NistP256 {
-    const CTX: &'static [u8] = b"LIT_HD_KEY_ID_P256_XMD:SHA-256_SSWU_RO_NUL_";
-}
-
-impl HdCtx for NistP384 {
-    const CTX: &'static [u8] = b"LIT_HD_KEY_ID_P384_XMD:SHA-384_SSWU_RO_NUL_";
-}
-
 #[wasm_bindgen]
 extern "C" {
     #[wasm_bindgen(typescript_type = "[Uint8Array, Uint8Array, number]")]
@@ -260,98 +241,10 @@ where
     }
 }
 
-/// Perform all three functions at once
-#[wasm_bindgen(js_name = "ecdsaCombineAndVerifyWithDerivedKey")]
-pub fn ecdsa_combine_and_verify_with_derived_key(
-    variant: EcdsaVariant,
-    pre_signature: Uint8Array,
-    signature_shares: Vec<Uint8Array>,
-    message_hash: Uint8Array,
-    id: Uint8Array,
-    public_keys: Vec<Uint8Array>,
-) -> JsResult<EcdsaSignature> {
-    match variant {
-        EcdsaVariant::K256 => Ecdsa::<Secp256k1>::combine_and_verify_with_derived_key(
-            pre_signature,
-            signature_shares,
-            message_hash,
-            id,
-            public_keys,
-        ),
-        EcdsaVariant::P256 => Ecdsa::<NistP256>::combine_and_verify_with_derived_key(
-            pre_signature,
-            signature_shares,
-            message_hash,
-            id,
-            public_keys,
-        ),
-        EcdsaVariant::P384 => todo!(),
-    }
-}
-
-/// Perform combine and verify with a specified public key
-#[wasm_bindgen(js_name = "ecdsaCombineAndVerify")]
-pub fn ecdsa_combine_and_verify(
-    variant: EcdsaVariant,
-    pre_signature: Uint8Array,
-    signature_shares: Vec<Uint8Array>,
-    message_hash: Uint8Array,
-    public_key: Uint8Array,
-) -> JsResult<EcdsaSignature> {
-    match variant {
-        EcdsaVariant::K256 => Ecdsa::<Secp256k1>::combine_and_verify_with_specified_key(
-            pre_signature,
-            signature_shares,
-            message_hash,
-            public_key,
-        ),
-        EcdsaVariant::P256 => Ecdsa::<NistP256>::combine_and_verify_with_specified_key(
-            pre_signature,
-            signature_shares,
-            message_hash,
-            public_key,
-        ),
-        EcdsaVariant::P384 => todo!(),
-    }
-}
-
-/// Combine ECDSA signatures shares
-#[wasm_bindgen(js_name = "ecdsaCombine")]
-pub fn ecdsa_combine(
-    variant: EcdsaVariant,
-    presignature: Uint8Array,
-    signature_shares: Vec<Uint8Array>,
-) -> JsResult<EcdsaSignature> {
-    match variant {
-        EcdsaVariant::K256 => Ecdsa::<Secp256k1>::combine(presignature, signature_shares),
-        EcdsaVariant::P256 => Ecdsa::<NistP256>::combine(presignature, signature_shares),
-        EcdsaVariant::P384 => todo!(),
-    }
-}
-
-#[wasm_bindgen(js_name = "ecdsaVerify")]
-pub fn ecdsa_verify(
-    variant: EcdsaVariant,
-    message_hash: Uint8Array,
-    public_key: Uint8Array,
-    signature: EcdsaSignature,
-) -> JsResult<()> {
-    match variant {
-        EcdsaVariant::K256 => Ecdsa::<Secp256k1>::verify(message_hash, public_key, signature),
-        EcdsaVariant::P256 => Ecdsa::<NistP256>::verify(message_hash, public_key, signature),
-        EcdsaVariant::P384 => todo!(),
-    }
-}
-
 #[wasm_bindgen(js_name = "ecdsaDeriveKey")]
 pub fn ecdsa_derive_key(
-    variant: EcdsaVariant,
     id: Uint8Array,
     public_keys: Vec<Uint8Array>,
 ) -> JsResult<Uint8Array> {
-    match variant {
-        EcdsaVariant::K256 => Ecdsa::<Secp256k1>::derive_key(id, public_keys),
-        EcdsaVariant::P256 => Ecdsa::<NistP256>::derive_key(id, public_keys),
-        EcdsaVariant::P384 => todo!(),
-    }
+    Ecdsa::<Secp256k1>::derive_key(id, public_keys)
 }