feat: add Starknet STARK curve signature

Cargo.toml

@@ -8,7 +8,7 @@ description = "A cryptographic signing service, used by the Axelar network"
 keywords = ["cryptography", "blockchain", "axelar", "ecdsa", "ed25519"]
 
 [dependencies]
-tofn = { version = "1.1" }
+tofn = { path = "../tofn", features = ["secp256k1", "ed25519", "stark"] }
 
 # logging
 log = { version = "0.4",default-features = false }

src/multisig/keypair.rs

@@ -1,13 +1,14 @@
 use crate::{proto::Algorithm, TofndResult};
 use anyhow::anyhow;
 use tofn::{
-    ecdsa, ed25519,
+    ecdsa, ed25519, stark,
     sdk::api::{MessageDigest, SecretRecoveryKey},
 };
 
 pub enum KeyPair {
     Ecdsa(ecdsa::KeyPair),
     Ed25519(ed25519::KeyPair),
+    Stark(stark::KeyPair),
 }
 
 impl KeyPair {
@@ -31,20 +32,29 @@ impl KeyPair {
 
                 Self::Ed25519(key_pair)
             }
+
+            Algorithm::EcdsaStark => {
+                let key_pair = stark::keygen(secret_recovery_key, session_nonce)
+                    .map_err(|_| anyhow!("Cannot generate keypair"))?;
+
+                Self::Stark(key_pair)
+            }
         })
     }
 
     pub fn encoded_verifying_key(&self) -> Vec<u8> {
         match self {
             Self::Ecdsa(key_pair) => key_pair.encoded_verifying_key().into(),
             Self::Ed25519(key_pair) => key_pair.encoded_verifying_key().into(),
+            Self::Stark(key_pair) => key_pair.encoded_verifying_key().into(),
         }
     }
 
     pub fn sign(&self, msg_to_sign: &MessageDigest) -> TofndResult<Vec<u8>> {
         match self {
             Self::Ecdsa(key_pair) => ecdsa::sign(key_pair.signing_key(), msg_to_sign),
             Self::Ed25519(key_pair) => ed25519::sign(key_pair, msg_to_sign),
+            Self::Stark(key_pair) => stark::sign(&key_pair.signing_key_bytes(), msg_to_sign),
         }
         .map_err(|_| anyhow!("signing failed"))
     }

src/multisig/tests.rs

@@ -165,6 +165,37 @@ async fn test_multisig_ed25519_keygen_sign() {
     assert!(tofn::ed25519::verify(&to_array(pub_key), &msg_digest, &signature,).unwrap());
 }
 
+#[traced_test]
+#[tokio::test]
+async fn test_multisig_stark_keygen_sign() {
+    let key = "multisig key";
+    let (mut client, shutdown_sender) = spin_test_service_and_client().await;
+
+    let request = KeygenRequest::new(key, Algorithm::EcdsaStark);
+
+    let response = client.keygen(request).await.unwrap().into_inner();
+    let pub_key = match response.keygen_response.unwrap() {
+        KeygenResponse::PubKey(pub_key) => pub_key,
+        KeygenResponse::Error(err) => {
+            panic!("Got error from keygen: {}", err);
+        }
+    };
+
+    let request = SignRequest::new(key, Algorithm::EcdsaStark);
+    let msg_digest = request.msg_to_sign.as_slice().try_into().unwrap();
+    let response = client.sign(request).await.unwrap().into_inner();
+    let signature = match response.sign_response.unwrap() {
+        SignResponse::Signature(signature) => signature,
+        SignResponse::Error(err) => {
+            panic!("Got error from sign: {}", err)
+        }
+    };
+
+    shutdown_sender.send(()).unwrap();
+
+    assert!(tofn::stark::verify(&to_array(pub_key), &msg_digest, &signature,).unwrap());
+}
+
 #[traced_test]
 #[tokio::test]
 async fn test_multisig_keygen_deterministic_and_unique_keys() {
@@ -173,7 +204,7 @@ async fn test_multisig_keygen_deterministic_and_unique_keys() {
 
     let mut seen_pub_keys = std::collections::HashSet::new();
 
-    for algorithm in [Algorithm::Ecdsa, Algorithm::Ed25519] {
+    for algorithm in [Algorithm::Ecdsa, Algorithm::Ed25519, Algorithm::EcdsaStark] {
         let request = KeygenRequest::new(key, algorithm);
 
         let response = client.keygen(request.clone()).await.unwrap().into_inner();
@@ -206,7 +237,7 @@ async fn test_multisig_only_sign() {
     let key = "multisig key";
     let (mut client, shutdown_sender) = spin_test_service_and_client().await;
 
-    for algorithm in [Algorithm::Ecdsa, Algorithm::Ed25519] {
+    for algorithm in [Algorithm::Ecdsa, Algorithm::Ed25519, Algorithm::EcdsaStark] {
         let request = SignRequest::new(key, algorithm);
         let response = client.sign(request).await.unwrap().into_inner();
         let _ = match response.sign_response.unwrap() {
@@ -226,7 +257,7 @@ async fn test_multisig_short_key_fail() {
     let key = "k"; // too short key
     let (mut client, shutdown_sender) = spin_test_service_and_client().await;
 
-    for algorithm in [Algorithm::Ecdsa, Algorithm::Ed25519] {
+    for algorithm in [Algorithm::Ecdsa, Algorithm::Ed25519, Algorithm::EcdsaStark] {
         let keygen_request = KeygenRequest::new(key, algorithm);
         let keygen_response = client.keygen(keygen_request).await.unwrap().into_inner();
 
@@ -259,7 +290,7 @@ async fn test_multisig_truncated_msg_fail() {
     let key = "key-uid";
     let (mut client, shutdown_sender) = spin_test_service_and_client().await;
 
-    for algorithm in [Algorithm::Ecdsa, Algorithm::Ed25519] {
+    for algorithm in [Algorithm::Ecdsa, Algorithm::Ed25519, Algorithm::EcdsaStark] {
         // attempt sign with truncated msg digest
         let mut request = SignRequest::new(key, algorithm);
         request.msg_to_sign = vec![32; 31];
@@ -281,7 +312,7 @@ async fn test_multisig_truncated_msg_fail() {
 async fn test_key_presence() {
     let (mut client, shutdown_sender) = spin_test_service_and_client().await;
 
-    for algorithm in [Algorithm::Ecdsa, Algorithm::Ed25519] {
+    for algorithm in [Algorithm::Ecdsa, Algorithm::Ed25519, Algorithm::EcdsaStark] {
         let presence_request = KeyPresenceRequest {
             key_uid: "key_uid".to_string(),
             pub_key: vec![],