spark_sdk/signer/

default_signer.rs

// std
use std::collections::HashMap;
use std::sync::Arc;

// super
use super::traits::ecdsa::SparkSignerEcdsa;
use super::traits::ecies::SparkSignerEcies;
use super::traits::frost::SparkSignerFrost;
use super::traits::frost_signing::SparkSignerFrostSigning;
use super::traits::secp256k1::KeygenMethod;
use super::traits::secp256k1::SparkSignerSecp256k1;
use super::traits::shamir::SparkSignerShamir;
use super::traits::SparkSigner;

// crates
use crate::constants::spark::frost::FROST_USER_IDENTIFIER;
use crate::constants::spark::frost::FROST_USER_KEY_PACKAGE_MIN_SIGNERS;
use crate::constants::spark::frost::FROST_USER_SIGNING_ROLE;
use crate::constants::spark::IDENTITY_KEYPAIR_INDEX;
use crate::error::SparkSdkError;
use crate::wallet::internal_handlers::traits::create_tree::DepositAddressTree;
use crate::wallet::internal_handlers::traits::transfer::LeafKeyTweak;
use crate::wallet::internal_handlers::traits::transfer::LeafRefundSigningData;
use crate::wallet::internal_handlers::utils::bitcoin_tx_from_bytes;
use crate::wallet::internal_handlers::utils::next_sequence;
use crate::wallet::internal_handlers::utils::parsers::parse_secret_key;
use crate::wallet::internal_handlers::utils::serialize_bitcoin_transaction;
use crate::wallet::utils::bitcoin::sighash_from_tx;
use crate::wallet::utils::transaction::ephemeral_anchor_output;
use crate::SparkNetwork;

// crates::common_types
use crate::common_types::types::frost::FrostNonce;
use crate::common_types::types::frost::FrostNonceCommitment;
use crate::common_types::types::frost::FrostSigningCommitments;
use crate::common_types::types::frost::FrostSigningNonces;
use crate::common_types::types::hex_decode;
use crate::common_types::types::hex_encode;
use crate::common_types::types::ChildNumber;
use crate::common_types::types::HashbrownMap;
use crate::common_types::types::RwLock;
use crate::common_types::types::Secp256k1;
use crate::common_types::types::Secp256k1Message;
use crate::common_types::types::SparkRange;
use crate::common_types::types::Transaction;
use crate::common_types::types::Uuid;
use crate::common_types::types::XPrv;
use crate::common_types::types::U256;
use crate::common_types::types::{PublicKey, SecretKey};

// external spark crates
use spark_cryptography::key_arithmetic::subtract_secret_keys;
use spark_cryptography::secp256k1::CURVE_ORDER;
use spark_cryptography::secret_sharing::secret_sharing::split_secret_with_proofs;
use spark_cryptography::secret_sharing::secret_sharing::VerifiableSecretShare;
use spark_cryptography::signing::aggregate_frost;
use spark_cryptography::signing::sign_frost;
use spark_protos::common::SigningCommitment as SparkOperatorCommitment;
use spark_protos::frost::AggregateFrostRequest;
use spark_protos::frost::AggregateFrostResponse;
use spark_protos::frost::FrostSigningJob;
use spark_protos::frost::SignFrostRequest;
use spark_protos::frost::SignFrostResponse;
use spark_protos::spark::LeafRefundTxSigningResult;
use spark_protos::spark::NodeSignatures;
use spark_protos::spark::RequestedSigningCommitments;
use spark_protos::spark::SigningKeyshare;
use spark_protos::spark::SigningResult;

// external crates
use bip32::DerivationPath;
use k256::elliptic_curve::bigint::Encoding;
use tonic::async_trait;

/// A default, in-memory signer for Spark v1. Depending on the feature flags, it
/// may store either a master seed (for self-signing) or remote wallet connection
/// details (for third-party signing).
///
/// - If the `self-signing` feature is enabled, this signer keeps a `master_seed`
///   and derives keypairs to carry out signing operations.
/// - If the `self-signing` feature is **not** enabled, this signer relies on a
///   remote wallet by storing a connection URL and an API key.
/// - Keys are held in memory and not persisted unless a future update is made
///   to store them to disk.
/// - Nonce commitments for each signing round remain ephemeral in memory,
///   which is typically sufficient for short-lived signing sessions.
#[derive(Clone)]
pub struct DefaultSigner {
    /// The master seed for self-signing.
    #[cfg(feature = "self-signing")]
    master_seed: Vec<u8>,

    /// The remote wallet's connection URL (for non-self-signing).
    #[cfg(not(feature = "self-signing"))]
    pub wallet_connection_url: String,

    /// The remote wallet's connection API key (for non-self-signing).
    #[cfg(not(feature = "self-signing"))]
    pub wallet_connection_api_key: String,

    /// Index used for deriving new keypairs. The signer increments this after each
    /// derived keypair to ensure unique keys.
    pub derivation_index: Arc<RwLock<u32>>,

    /// A map of references to nonce commitments, stored as strings. These are used
    /// per signing round and can remain in memory until the round completes.
    pub nonce_commitments: Arc<RwLock<HashbrownMap<String, String>>>,

    /// A map from public keys to secret keys, stored in memory only. This is necessary
    /// for self-signing or for local caching if not using remote keys.
    pub public_keys_to_secret_keys: Arc<RwLock<HashbrownMap<String, String>>>,

    /// The network that the signer is operating on.
    pub network: SparkNetwork,
}

impl SparkSignerSecp256k1 for DefaultSigner {
    fn get_identity_public_key(&self) -> Result<Vec<u8>, SparkSdkError> {
        let master_seed_bytes = self.load_master_seed()?;
        let master_seed = derive_master_key_from_path(&master_seed_bytes, &self.network)?;
        let identity_key = derive_child_key(&master_seed, IDENTITY_KEYPAIR_INDEX)?;

        Ok(identity_key.public_key().to_bytes().to_vec())
    }

    #[allow(private_interfaces)]
    fn new_secp256k1_keypair(&self, keygen_method: KeygenMethod) -> Result<Vec<u8>, SparkSdkError> {
        let secret_key_bytes = match keygen_method {
            KeygenMethod::Uuid(uuid) => {
                let parsed_uuid = Uuid::parse_str(&uuid)?;
                let key = self.derive_signing_key_from_leaf(parsed_uuid)?;
                key
            }
            KeygenMethod::Random => {
                let key = SecretKey::new(&mut SparkRange);
                key.secret_bytes().to_vec()
            }
        };

        let public_key = secret_key_to_public_key(&secret_key_bytes)?;
        self.insert_to_keypair_map(public_key.clone(), secret_key_bytes)?;

        Ok(public_key)
    }

    fn insert_secp256k1_keypair_from_secret_key<T: AsRef<[u8]>>(
        &self,
        secret_key_bytes: T,
    ) -> Result<Vec<u8>, SparkSdkError> {
        let secp = Secp256k1::new();
        let secret_key = SecretKey::from_slice(&secret_key_bytes.as_ref())?;
        let public_key = PublicKey::from_secret_key(&secp, &secret_key);

        self.insert_to_keypair_map(public_key.serialize(), secret_key.secret_bytes())?;

        Ok(public_key.serialize().to_vec())
    }

    fn subtract_secret_keys_given_pubkeys<T: AsRef<[u8]>, U: AsRef<[u8]>>(
        &self,
        target_pubkey: T,
        source_pubkey: U,
        save_new_key: bool,
    ) -> Result<Vec<u8>, SparkSdkError> {
        if target_pubkey.as_ref() == source_pubkey.as_ref() {
            return Err(SparkSdkError::InvalidInput(
                "Target and source public keys are the same".into(),
            ));
        }

        let target_secret_key = self.get_secret_key_from_pubkey(&target_pubkey)?;
        let source_secret_key = self.get_secret_key_from_pubkey(&source_pubkey)?;

        let result_secret_key = subtract_secret_keys(&target_secret_key, &source_secret_key)?;

        let result_public_key = secret_key_to_public_key(&result_secret_key)?;

        if save_new_key {
            self.insert_to_keypair_map(result_public_key.clone(), result_secret_key)?;
        }

        Ok(result_public_key)
    }

    fn sensitive_expose_secret_key_from_pubkey<T: AsRef<[u8]>>(
        &self,
        public_key: T,
        delete_after_exposing: bool,
    ) -> Result<Vec<u8>, SparkSdkError> {
        let secret_key = self.get_secret_key_from_pubkey(&public_key)?;

        if delete_after_exposing {
            self.evict_from_keypair_map(public_key)?;
        }

        Ok(secret_key)
    }
}

#[cfg(test)]
mod default_signer_secp256k1_tests {
    use super::*;
    use crate::error::SparkSdkError;

    use bip32::Language;

    type WrappedSigner = Arc<DefaultSigner>;

    const TEST_NETWORK: SparkNetwork = SparkNetwork::Regtest;

    // Helper function to create a DefaultSigner for testing secp256k1 operations.
    async fn create_default_signer() -> Result<WrappedSigner, SparkSdkError> {
        let rng = SparkRange;
        let mnemonic = bip32::Mnemonic::random(rng, Language::English);
        let master_seed = mnemonic.to_seed("").as_bytes().to_vec();
        let signer = DefaultSigner::from_master_seed(&master_seed, TEST_NETWORK).await?;

        Ok(signer)
    }

    #[tokio::test]
    #[cfg(feature = "self-signing")]
    async fn test_get_identity_public_key() -> Result<(), SparkSdkError> {
        let signer = create_default_signer().await?;
        signer
            .get_identity_public_key()
            .expect("failed to get identity pk");

        Ok(())
    }

    #[tokio::test]
    async fn test_new_secp256k1_keypair() -> Result<(), SparkSdkError> {
        let signer = create_default_signer().await?;
        let pubkey = signer.new_secp256k1_keypair(KeygenMethod::Random)?;
        assert_eq!(pubkey.len(), 33);

        let identity_pubkey = signer.get_identity_public_key()?;
        assert_ne!(identity_pubkey, pubkey);

        let current_derivation_index = signer.derivation_index.read().clone();
        assert_eq!(current_derivation_index, IDENTITY_KEYPAIR_INDEX + 1);

        Ok(())
    }

    #[tokio::test]
    async fn test_insert_secp256k1_keypair_from_secret_key() -> Result<(), SparkSdkError> {
        let signer = create_default_signer().await?;
        // generate a random secret key to insert
        let secret_key = {
            let sk = SecretKey::new(&mut SparkRange);
            sk.secret_bytes().to_vec()
        };

        let pubkey = signer.insert_secp256k1_keypair_from_secret_key(&secret_key)?;
        assert_eq!(pubkey.len(), 33);

        // verify that the secret key exists in the signer space
        let retrieved_secret_key =
            signer.sensitive_expose_secret_key_from_pubkey(&pubkey, false)?;
        assert_eq!(retrieved_secret_key, secret_key);

        Ok(())
    }

    #[tokio::test]
    async fn test_subtract_secret_keys_given_pubkeys() -> Result<(), SparkSdkError> {
        let signer = create_default_signer().await?;

        // create two new keypairs
        let pubkey_1 = signer.new_secp256k1_keypair(KeygenMethod::Random)?;
        let pubkey_2 = signer.new_secp256k1_keypair(KeygenMethod::Random)?;

        // do subtraction
        let new_pubkey = signer.subtract_secret_keys_given_pubkeys(&pubkey_1, &pubkey_2, true)?;

        // check that new_pubkey is 33 bytes
        assert_eq!(new_pubkey.len(), 33);

        // try exposing the new key's secret key
        let _ = signer.sensitive_expose_secret_key_from_pubkey(&new_pubkey, false)?;

        Ok(())
    }

    #[tokio::test]
    #[ignore]
    async fn test_sensitive_expose_secret_key_from_pubkey() -> Result<(), SparkSdkError> {
        let signer = create_default_signer().await?;

        // create a new keypair
        let pubkey = signer.new_secp256k1_keypair(KeygenMethod::Random)?;
        // expose the secret key, then check that it is indeed 32 bytes
        let secret_key = signer.sensitive_expose_secret_key_from_pubkey(&pubkey, false)?;
        assert_eq!(secret_key.len(), 32);

        // now expose and delete
        let _ = signer.sensitive_expose_secret_key_from_pubkey(&pubkey, true)?;

        // retrieving again should fail
        let retrieve_again = signer.sensitive_expose_secret_key_from_pubkey(&pubkey, false);

        match retrieve_again {
            Err(SparkSdkError::SecretKeyNotFound(msg)) if msg.contains("Secret key not found") => {
                ()
            }
            _ => panic!("Expected error: 'Secret key not found' after deletion"),
        }

        Ok(())
    }
}

const SPLIT_SECRET_ERROR: &str = "Failed to split secret: ";
#[async_trait]
impl SparkSignerShamir for DefaultSigner {
    fn split_with_verifiable_secret_sharing(
        &self,
        message: Vec<u8>,
        threshold: usize,
        num_shares: usize,
    ) -> Result<Vec<VerifiableSecretShare>, SparkSdkError> {
        // get the field modulus
        // TODO: Ensure that subtracting 1 is correct.
        let raw = hex_decode(CURVE_ORDER).unwrap();
        let u = U256::from_be_slice(&raw);
        let minus_one = u.saturating_sub(&U256::ONE); // subtract 1 so that it's definitely in range
        let field_modulus = minus_one.to_be_bytes().to_vec();

        // Get the shares
        let shares = split_secret_with_proofs(&message, &field_modulus, threshold, num_shares)
            .map_err(|e| SparkSdkError::InvalidInput(format!("{} {}", SPLIT_SECRET_ERROR, e)))?;

        Ok(shares)
    }

    fn split_from_public_key_with_verifiable_secret_sharing(
        &self,
        public_key: Vec<u8>,
        threshold: usize,
        num_shares: usize,
    ) -> Result<Vec<VerifiableSecretShare>, SparkSdkError> {
        let secret_key = self.get_secret_key_from_pubkey(&public_key)?;
        let shares =
            self.split_with_verifiable_secret_sharing(secret_key, threshold, num_shares)?;
        Ok(shares)
    }
}

#[cfg(test)]
mod default_signer_shamir_tests {
    use super::*;
    use crate::error::SparkSdkError;
    use bip32::Language;
    use rand::rngs::OsRng;
    use std::sync::Arc;

    type WrappedSigner = Arc<DefaultSigner>;

    const TEST_NETWORK: SparkNetwork = SparkNetwork::Regtest;

    // Helper function to create a DefaultSigner for testing Shamir (similar to `create_default_signer()` in the secp256k1 tests).
    // This leverages the same approach of generating a random mnemonic for self-signing.
    async fn create_shamir_test_signer() -> Result<WrappedSigner, SparkSdkError> {
        let rng = OsRng;
        let mnemonic = bip32::Mnemonic::random(rng, Language::English);
        let master_seed = mnemonic.to_seed("").as_bytes().to_vec();
        let signer = DefaultSigner::from_master_seed(&master_seed, TEST_NETWORK).await?;
        Ok(signer)
    }

    #[tokio::test]
    #[cfg(feature = "self-signing")]
    #[ignore]
    async fn test_split_with_verifiable_secret_sharing() -> Result<(), SparkSdkError> {
        let signer = create_shamir_test_signer().await?;
        let message = b"hello world".to_vec();

        // For demonstration: 2-of-3 threshold scheme.
        let threshold = 2;
        let num_shares = 3;

        // Attempt to split the secret.
        let shares = signer.split_with_verifiable_secret_sharing(message, threshold, num_shares)?;

        // We expect exactly 'num_shares' shares.
        assert_eq!(shares.len(), num_shares);

        Ok(())
    }
}

impl SparkSignerEcdsa for DefaultSigner {
    fn sign_message_ecdsa_with_identity_key<T: AsRef<[u8]>>(
        &self,
        message: T,
        apply_hashing: bool,
    ) -> Result<Vec<u8>, SparkSdkError> {
        // Create a SHA256 hash of the payload
        // Using SHA256::digest gives us the hash directly, similar to Go's sha256.Sum256
        let payload_hash = if apply_hashing {
            sha256::digest(message.as_ref())
        } else {
            hex::encode(message.as_ref())
        };
        let message = Secp256k1Message::from_digest_slice(&hex::decode(&payload_hash).unwrap())?;

        // Get the identity secret key
        let identity_key = self.get_identity_secret_key()?;
        let secret_key = SecretKey::from_slice(&identity_key).unwrap();

        let secp = Secp256k1::new();
        let signature = secp.sign_ecdsa(&message, &secret_key);

        Ok(signature.serialize_der().to_vec())
    }

    fn sign_message_ecdsa_with_key<T: AsRef<[u8]>>(
        &self,
        message: T,
        public_key_for_signing_key: &[u8],
        apply_hashing: bool,
    ) -> Result<Vec<u8>, SparkSdkError> {
        let payload_hash = if apply_hashing {
            sha256::digest(message.as_ref())
        } else {
            hex::encode(message.as_ref())
        };

        let secret_key_bytes = self.get_secret_key_from_pubkey(&public_key_for_signing_key)?;
        let secret_key = SecretKey::from_slice(&secret_key_bytes).unwrap();
        let secp = Secp256k1::new();

        let message = Secp256k1Message::from_digest_slice(&hex::decode(&payload_hash).unwrap())?;

        let signature = secp.sign_ecdsa(&message, &secret_key);
        Ok(signature.serialize_der().to_vec())
    }
}

#[cfg(test)]
mod default_signer_ecdsa_tests {
    use super::*;
    use crate::common_types::types::Digest;
    use crate::common_types::types::EcdsaSignature;
    use crate::common_types::types::Secp256k1Message;
    use crate::common_types::types::Sha256;
    use bip32::Language;

    type WrappedSigner = Arc<DefaultSigner>;

    const TEST_NETWORK: SparkNetwork = SparkNetwork::Regtest;

    // Helper function to create a DefaultSigner for testing ECDSA operations.
    async fn create_ecdsa_test_signer() -> Result<WrappedSigner, SparkSdkError> {
        let rng = SparkRange;
        let mnemonic = bip32::Mnemonic::random(rng, Language::English);
        let master_seed = mnemonic.to_seed("").as_bytes().to_vec();
        let signer = DefaultSigner::from_master_seed(&master_seed, TEST_NETWORK).await?;
        Ok(signer)
    }

    #[tokio::test]
    #[cfg(feature = "self-signing")]
    async fn test_sign_message_ecdsa_with_identity_key() -> Result<(), SparkSdkError> {
        let signer = create_ecdsa_test_signer().await?;

        // prepare and sign message
        let message = b"this is a test message";
        let signature_der = signer.sign_message_ecdsa_with_identity_key(message, true)?;

        // basic checks on the returned signature
        // typical maximum DER-encoded ECDSA signature is ~72 bytes:
        let sig_len = signature_der.len();
        assert!(
            (64..=72).contains(&sig_len),
            "ECDSA signature must be between 64 and 72 bytes, got {}",
            sig_len
        );

        // verify the signature externally
        let identity_pk = signer.get_identity_public_key()?;
        let msg_hash = Sha256::digest(message);
        let message_for_verify = Secp256k1Message::from_digest_slice(&msg_hash)
            .map_err(|e| SparkSdkError::InvalidInput(format!("Failed to parse message: {e}")))?;

        let parsed_sig = EcdsaSignature::from_der(&signature_der).map_err(|e| {
            SparkSdkError::InvalidInput(format!("Failed to parse DER signature: {e}"))
        })?;

        let pubkey = PublicKey::from_slice(&identity_pk)
            .map_err(|e| SparkSdkError::InvalidInput(format!("Failed to parse public key: {e}")))?;

        // perform verification
        let ctx = Secp256k1::verification_only();
        ctx.verify_ecdsa(&message_for_verify, &parsed_sig, &pubkey)
            .map_err(|_e| {
                SparkSdkError::InvalidInput("Signature verification failed".to_string())
            })?;

        Ok(())
    }

    #[tokio::test]
    #[cfg(feature = "self-signing")]
    async fn test_sign_message_ecdsa_with_key() -> Result<(), SparkSdkError> {
        use rand::thread_rng;

        // Generate a new keypair
        let secp = Secp256k1::new();
        let mut rng = thread_rng();
        let keypair = bitcoin::secp256k1::Keypair::new(&secp, &mut rng);

        // Create the signer
        let signer = create_ecdsa_test_signer().await?;

        // Add the keypair to the signer
        signer.insert_to_keypair_map(
            keypair.public_key().serialize(),
            keypair.secret_key().secret_bytes(),
        )?;

        let message = b"this is a test message";
        let signature_der =
            signer.sign_message_ecdsa_with_key(message, &keypair.public_key().serialize(), true)?;

        assert!(
            (64..=72).contains(&signature_der.len()),
            "ECDSA signature must be between 64 and 72 bytes, got {}",
            signature_der.len()
        );

        Ok(())
    }
}

impl SparkSignerEcies for DefaultSigner {
    fn encrypt_secret_key_with_ecies<T, U>(
        &self,
        receiver_public_key: T,
        pubkey_for_sk_to_encrypt: U,
    ) -> Result<Vec<u8>, SparkSdkError>
    where
        T: AsRef<[u8]>,
        U: AsRef<[u8]>,
    {
        let secret_key = self.get_secret_key_from_pubkey(&pubkey_for_sk_to_encrypt)?;
        let ciphertext = ecies::encrypt(&receiver_public_key.as_ref(), &secret_key)
            .map_err(|e| SparkSdkError::InvalidInput(format!("Failed to encrypt: {}", e)))?;

        Ok(ciphertext)
    }

    fn decrypt_secret_key_with_ecies<T>(&self, ciphertext: T) -> Result<Vec<u8>, SparkSdkError>
    where
        T: AsRef<[u8]>,
    {
        // get the identity secret key
        let identity_secret_key = self.get_identity_secret_key()?;

        ecies::decrypt(&identity_secret_key, ciphertext.as_ref())
            .map_err(|e| SparkSdkError::InvalidInput(format!("Failed to decrypt: {}", e)))
    }
}

#[cfg(test)]
mod default_signer_ecies_tests {
    use super::*;
    use crate::error::SparkSdkError;
    use bip32::Language;
    use rand::rngs::OsRng;
    use std::sync::Arc;

    type WrappedSigner = Arc<DefaultSigner>;

    const TEST_NETWORK: SparkNetwork = SparkNetwork::Regtest;

    // Helper function to create a DefaultSigner for testing ECIES operations.
    async fn create_ecies_test_signer() -> Result<WrappedSigner, SparkSdkError> {
        let mnemonic = bip32::Mnemonic::random(OsRng, Language::English);
        let master_seed = mnemonic.to_seed("").as_bytes().to_vec();
        let signer = DefaultSigner::from_master_seed(&master_seed, TEST_NETWORK).await?;
        Ok(signer)
    }

    #[tokio::test]
    #[cfg(feature = "self-signing")]
    async fn test_ecies_encrypt_decrypt_round_trip() -> Result<(), SparkSdkError> {
        // create the signer

        use crate::signer::traits::secp256k1::KeygenMethod;
        let signer = create_ecies_test_signer().await?;

        // create an ephemeral keypair to encrypt
        let ephemeral_pubkey = signer.new_secp256k1_keypair(KeygenMethod::Random)?;
        let ephemeral_privkey =
            signer.sensitive_expose_secret_key_from_pubkey(&ephemeral_pubkey, false)?;

        // get the signer's identity public key as the encryption "receiver"
        let receiver_pubkey = signer.get_identity_public_key()?;

        // encrypt the ephemeral secret key using ECIES
        let ciphertext =
            signer.encrypt_secret_key_with_ecies(&receiver_pubkey, &ephemeral_pubkey)?;

        // 5. Decrypt the ciphertext (using the signer's identity secret key)
        let decrypted_key = signer.decrypt_secret_key_with_ecies(&ciphertext)?;

        // 6. Verify the decrypted key matches the original ephemeral secret key
        assert_eq!(
            decrypted_key, ephemeral_privkey,
            "Decrypted key did not match the original"
        );

        Ok(())
    }
}

#[async_trait]
impl SparkSignerFrost for DefaultSigner {
    fn new_frost_signing_noncepair(&self) -> Result<FrostSigningCommitments, SparkSdkError> {
        let mut rng = SparkRange;
        let binding_sk = SecretKey::new(&mut rng);
        let hiding_sk = SecretKey::new(&mut rng);

        let binding = FrostNonce::deserialize(&binding_sk.secret_bytes()).unwrap();
        let hiding = FrostNonce::deserialize(&hiding_sk.secret_bytes()).unwrap();

        let nonces = frost_secp256k1_tr::round1::SigningNonces::from_nonces(hiding, binding);
        let commitments = nonces.commitments();

        let nonces_bytes = nonces.serialize().unwrap();
        let commitment_bytes = commitments.serialize().unwrap();

        self.insert_to_noncepair_map(commitment_bytes, nonces_bytes)?;

        Ok(commitments.clone())
    }

    fn sensitive_expose_nonces_from_commitments<T>(
        &self,
        signing_commitments: &T,
    ) -> Result<FrostSigningNonces, SparkSdkError>
    where
        T: AsRef<[u8]>,
    {
        let signing_commitment_hex = hex_encode(signing_commitments.as_ref());
        let signing_nonces = self
            .nonce_commitments
            .read()
            .get(&signing_commitment_hex)
            .cloned()
            .ok_or_else(|| {
                SparkSdkError::InvalidInput("Nonce commitments not found".to_string())
            })?;

        let signing_nonces_bytes = hex_decode(signing_nonces).unwrap();
        let signing_nonces = FrostSigningNonces::deserialize(&signing_nonces_bytes).unwrap(); // This is a safe unwrap
        Ok(signing_nonces)
    }

    fn sensitive_create_if_not_found_expose_nonces_from_commitments(
        &self,
        signing_commitments: Option<&[u8]>,
    ) -> Result<FrostSigningNonces, SparkSdkError> {
        let commitments = if signing_commitments.is_none() {
            let commitments = self.new_frost_signing_noncepair()?;
            commitments.serialize().unwrap().clone()
        } else {
            signing_commitments.unwrap().to_vec()
        };
        let signing_nonces = self.sensitive_expose_nonces_from_commitments(&commitments)?;
        Ok(signing_nonces)
    }
}

// mod default_signer_frost_tests {}

impl SparkSignerFrostSigning for DefaultSigner {
    fn sign_frost(
        &self,
        signing_jobs: Vec<FrostSigningJob>,
    ) -> Result<SignFrostResponse, SparkSdkError> {
        let marhsalized_request = SignFrostRequest {
            signing_jobs,
            role: FROST_USER_SIGNING_ROLE,
        };
        sign_frost(&marhsalized_request)
            .map_err(|e| SparkSdkError::FrostSigningError(e.to_string()))
    }

    fn aggregate_frost(
        &self,
        request: AggregateFrostRequest,
    ) -> Result<AggregateFrostResponse, SparkSdkError> {
        aggregate_frost(&request).map_err(|e| SparkSdkError::FrostAggregationError(e.to_string()))
    }

    fn sign_created_tree_in_bfs_order(
        &self,
        tx: Transaction,
        vout: u32,
        internal_tree_root: Arc<RwLock<DepositAddressTree>>,
        request_tree_root: spark_protos::spark::CreationNode,
        creation_result_tree_root: spark_protos::spark::CreationResponseNode,
    ) -> Result<(Vec<NodeSignatures>, Vec<Vec<u8>>), SparkSdkError> {
        #[derive(Clone)]
        struct QueueItem {
            parent_tx: Transaction,
            vout: u32,
            internal_node: Arc<RwLock<DepositAddressTree>>,
            creation_node: spark_protos::spark::CreationNode,
            creation_response_node: spark_protos::spark::CreationResponseNode,
        }

        let mut queue = std::collections::VecDeque::new();
        let mut node_signatures = vec![];

        queue.push_back(QueueItem {
            parent_tx: tx,
            vout,
            internal_node: internal_tree_root,
            creation_node: request_tree_root,
            creation_response_node: creation_result_tree_root,
        });

        let mut signing_public_keys = vec![];

        while let Some(current) = queue.pop_front() {
            let node_prevout_index = current.vout as usize;
            let node_signing_input_index = 0;

            // prepare sign data
            let internal_node = current.internal_node.read().clone();
            let creation_node = current.creation_node.clone();
            let node_signing_job = creation_node.node_tx_signing_job.clone().unwrap();
            let serialized_node_transaction = node_signing_job.raw_tx;
            let user_node_commitments = node_signing_job.signing_nonce_commitment.clone().unwrap();
            let (spark_node_signature_shares, spark_node_public_shares, _, spark_node_commitments) =
                get_signature_data_from_signing_result(
                    &current.creation_response_node.node_tx_signing_result,
                )?;

            let signing_job = self.prepare_frost_signing_job(
                internal_node.signing_public_key.clone(),
                Some(serialize_marshalized_frost_commitments(
                    &user_node_commitments,
                )?),
                spark_node_commitments.clone(),
                serialized_node_transaction.clone(),
                node_prevout_index,
                node_signing_input_index,
                &current.parent_tx.clone(),
                vec![],
                internal_node.verification_key.clone().unwrap(),
            )?;

            // sign
            let node_signature = self.sign_frost(vec![signing_job.clone()]).unwrap();
            let user_node_signature_share = node_signature.results[&signing_job.job_id]
                .signature_share
                .clone();

            let aggregate_response = self
                .aggregate_frost(spark_protos::frost::AggregateFrostRequest {
                    message: signing_job.message,
                    signature_shares: spark_node_signature_shares,
                    public_shares: spark_node_public_shares,
                    verifying_key: signing_job.verifying_key.clone(),
                    commitments: spark_node_commitments,
                    user_commitments: signing_job.user_commitments,
                    user_public_key: signing_job.verifying_key,
                    user_signature_share: user_node_signature_share,
                    adaptor_public_key: vec![],
                })
                .unwrap();

            let mut node_signature = spark_protos::spark::NodeSignatures {
                node_id: current.creation_response_node.node_id.clone(),
                node_tx_signature: aggregate_response.signature,
                ..Default::default()
            };

            // Handle refund transaction if present
            if let Some(refund_signing_job) = current.creation_node.refund_tx_signing_job {
                // these are constants for tree creation
                let refund_prevout_index = 0;
                let refund_signing_input_index = 0 as usize;

                // prepare signing data
                let serialized_refund_transaction = refund_signing_job.raw_tx;
                let user_refund_commitments = refund_signing_job.signing_nonce_commitment.unwrap();
                let (
                    spark_refund_signature_shares,
                    spark_refund_public_shares,
                    _,
                    spark_refund_commitments,
                ) = get_signature_data_from_signing_result(
                    &current.creation_response_node.refund_tx_signing_result,
                )?;

                let refund_signing_job = self.prepare_frost_signing_job(
                    internal_node.signing_public_key,
                    Some(serialize_marshalized_frost_commitments(
                        &user_refund_commitments,
                    )?),
                    spark_refund_commitments.clone(),
                    serialized_refund_transaction,
                    refund_prevout_index,
                    refund_signing_input_index,
                    &bitcoin_tx_from_bytes(&serialized_node_transaction)?,
                    vec![],
                    internal_node.verification_key.clone().unwrap(),
                )?;

                let refund_signature = self.sign_frost(vec![refund_signing_job.clone()])?;
                let user_refund_signature_share = refund_signature.results
                    [&refund_signing_job.job_id]
                    .signature_share
                    .clone();

                let aggregate_response = self
                    .aggregate_frost(spark_protos::frost::AggregateFrostRequest {
                        message: refund_signing_job.message,
                        signature_shares: spark_refund_signature_shares,
                        public_shares: spark_refund_public_shares,
                        verifying_key: refund_signing_job.verifying_key.clone(),
                        commitments: spark_refund_commitments,
                        user_commitments: refund_signing_job.user_commitments,
                        user_public_key: refund_signing_job.verifying_key,
                        user_signature_share: user_refund_signature_share,
                        adaptor_public_key: vec![],
                    })
                    .unwrap();

                node_signature.refund_tx_signature = aggregate_response.signature;
            }
            node_signatures.push(node_signature);

            // Push children to queue maintaining BFS order
            for (i, child) in current.creation_node.children.into_iter().enumerate() {
                queue.push_back(QueueItem {
                    parent_tx: bitcoin_tx_from_bytes(&serialized_node_transaction)?,
                    vout: i as u32,
                    internal_node: current.internal_node.read().children[i].clone(),
                    creation_node: child,
                    creation_response_node: current.creation_response_node.children[i].clone(),
                });
            }

            signing_public_keys.push(current.internal_node.read().signing_public_key.clone());
        }

        Ok((node_signatures, signing_public_keys))
    }

    fn sign_transfer_refunds(
        &self,
        leaf_data_map: &HashMap<String, LeafRefundSigningData>,
        operator_signing_results: &Vec<LeafRefundTxSigningResult>,
        adaptor_public_key: Vec<u8>,
    ) -> Result<Vec<spark_protos::spark::NodeSignatures>, SparkSdkError> {
        let mut user_signing_jobs = Vec::new();
        let mut job_to_aggregate_request_map = HashMap::new();
        let mut job_to_leaf_map = HashMap::new();

        for operator_result in operator_signing_results {
            let signing_input_index = 0;
            let prevout_to_use = 0;

            // TODO: this is an internal error if not found -- change the error to a client-side internal error
            let leaf_data = leaf_data_map
                .get(&operator_result.leaf_id)
                .ok_or_else(|| SparkSdkError::InvalidInput("Leaf data not found".into()))?;

            // prepare signing data
            let refund_tx_ = leaf_data.refund_tx.as_ref().unwrap();
            let serialized_refund_tx = serialize_bitcoin_transaction(&refund_tx_)?;

            let (
                spark_refund_signature_shares,
                spark_refund_public_shares,
                _,
                spark_refund_commitments,
            ) = get_signature_data_from_signing_result(&operator_result.refund_tx_signing_result)?;

            let commitment_hiding = leaf_data.commitment.hiding.clone();
            let commitment_binding = leaf_data.commitment.binding.clone();
            let signing_commitments = frost_secp256k1_tr::round1::SigningCommitments::new(
                FrostNonceCommitment::deserialize(&commitment_hiding).unwrap(),
                FrostNonceCommitment::deserialize(&commitment_binding).unwrap(),
            );

            // Calculate refund transaction sighash
            let signing_job = self.prepare_frost_signing_job(
                leaf_data.signing_public_key.clone(),
                Some(signing_commitments.serialize().unwrap()),
                spark_refund_commitments.clone(),
                serialized_refund_tx,
                prevout_to_use,
                signing_input_index,
                &leaf_data.tx,
                adaptor_public_key.clone(),
                operator_result.verifying_key.clone(),
            )?;
            let signing_job_id = signing_job.job_id.clone();
            user_signing_jobs.push(signing_job.clone());

            job_to_leaf_map.insert(signing_job_id.clone(), operator_result.leaf_id.clone());

            // TODO: structure
            let user_public_key = PublicKey::from_slice(&leaf_data.signing_public_key)
                .unwrap()
                .serialize()
                .to_vec();

            job_to_aggregate_request_map.insert(
                signing_job_id.clone(),
                AggregateFrostRequest {
                    message: signing_job.message,
                    signature_shares: spark_refund_signature_shares,
                    public_shares: spark_refund_public_shares,
                    verifying_key: operator_result.verifying_key.clone(),
                    commitments: spark_refund_commitments,
                    user_commitments: signing_job.user_commitments,
                    user_public_key,
                    user_signature_share: vec![],
                    adaptor_public_key: vec![],
                },
            );
        }

        // Get user signatures
        let user_signatures = self.sign_frost(user_signing_jobs)?;

        // Process signatures and create node signatures
        let mut node_signatures = Vec::new();
        for (job_id, user_signature) in user_signatures.results {
            let mut request = job_to_aggregate_request_map
                .remove(&job_id)
                .ok_or_else(|| SparkSdkError::InvalidInput("Job ID not found".into()))?;

            request.user_signature_share = user_signature.signature_share;

            let response = match self.aggregate_frost(request) {
                Ok(response) => response,
                Err(e) => {
                    return Err(SparkSdkError::InvalidInput(format!(
                        "Failed to aggregate refund: {}",
                        e
                    )));
                }
            };

            node_signatures.push(spark_protos::spark::NodeSignatures {
                node_id: job_to_leaf_map[&job_id].clone(),
                refund_tx_signature: response.signature,
                node_tx_signature: vec![],
            });
        }

        Ok(node_signatures)
    }

    fn sign_for_lightning_swap(
        &self,
        leaves: &Vec<LeafKeyTweak>,
        signing_commitments: &Vec<RequestedSigningCommitments>,
        receiver_identity_pubkey: PublicKey,
    ) -> Result<
        (
            SignFrostResponse,
            Vec<Vec<u8>>,
            Vec<ProtoSigningCommitments>,
        ),
        SparkSdkError,
    > {
        let mut signing_jobs = Vec::new();
        let mut refund_txs = vec![];

        let mut user_commitments = Vec::with_capacity(leaves.len());

        for (i, leaf) in leaves.iter().enumerate() {
            let node_tx = bitcoin_tx_from_bytes(&leaf.leaf.node_tx)?;

            let node_outpoint = bitcoin::OutPoint {
                txid: node_tx.compute_txid(),
                vout: 0,
            };

            let current_refund_tx = bitcoin_tx_from_bytes(&leaf.leaf.refund_tx)?;

            let next_sequence = next_sequence(current_refund_tx.input[0].sequence.0);

            let amount_sats = node_tx.output[0].value;

            let refund_tx = create_refund_tx(
                next_sequence,
                node_outpoint,
                amount_sats,
                &receiver_identity_pubkey,
                self.network.to_bitcoin_network(),
            )?;

            let refund_tx_buf = serialize_bitcoin_transaction(&refund_tx)?;
            refund_txs.push(refund_tx_buf);

            let sighash = sighash_from_tx(&refund_tx, 0, &node_tx.output[0])?;

            let user_commitment = self.new_frost_signing_noncepair()?;
            let user_nonce = self
                .sensitive_expose_nonces_from_commitments(&user_commitment.serialize().unwrap())?;

            let marshalized_frost_nonces = marshal_frost_nonces(&user_nonce)?;
            let marshalized_frost_commitments = marshal_frost_commitments(&user_commitment)?;

            user_commitments.push(marshalized_frost_commitments.clone());

            let signing_secret_key =
                self.sensitive_expose_secret_key_from_pubkey(&leaf.new_signing_public_key, false)?;
            let key_package = create_user_key_package(&signing_secret_key);

            signing_jobs.push(FrostSigningJob {
                job_id: leaf.leaf.id.clone(),
                message: sighash.to_vec(),
                key_package: Some(key_package),
                verifying_key: leaf.leaf.verifying_public_key.clone(),
                nonce: Some(marshalized_frost_nonces),
                user_commitments: Some(marshalized_frost_commitments),
                commitments: signing_commitments[i].signing_nonce_commitments.clone(),
                adaptor_public_key: vec![],
            });
        }

        // sign
        let signing_results = self.sign_frost(signing_jobs)?;

        Ok((signing_results, refund_txs, user_commitments))
    }
}

#[async_trait]
impl SparkSigner for DefaultSigner {
    type WrappedSigner = Arc<Self>;

    /// Creates a new wallet from a mnemonic (BIP-39).
    ///  - Converts the mnemonic to a 64-byte seed
    ///  - Calls `from_seed` to do the rest
    async fn from_mnemonic(
        mnemonic: &str,
        network: SparkNetwork,
    ) -> Result<Self::WrappedSigner, SparkSdkError> {
        // Generate the BIP-39 seed
        let seed = bip32::Mnemonic::new(mnemonic, bip32::Language::English)
            .map_err(|e| SparkSdkError::InvalidInput(e.to_string()))?
            .to_seed("");
        let seed_bytes = seed.as_bytes().to_vec();

        Self::from_master_seed(&seed_bytes, network).await
    }

    #[cfg(feature = "self-signing")]
    async fn from_master_seed(
        master_seed: &[u8],
        network: SparkNetwork,
    ) -> Result<Self::WrappedSigner, SparkSdkError> {
        let derivation_index = IDENTITY_KEYPAIR_INDEX + 1; // 0 + 1, where 0 is for the identity keypair
        let wrapped_derivation_index = Arc::new(RwLock::new(derivation_index));

        let nonce_commitments = HashbrownMap::new();
        let public_keys_to_secret_keys = HashbrownMap::new();

        let commitments_map = Arc::new(RwLock::new(nonce_commitments));
        let public_keys_map = Arc::new(RwLock::new(public_keys_to_secret_keys));

        Ok(Arc::new(Self {
            master_seed: master_seed.to_vec(),
            derivation_index: wrapped_derivation_index,
            nonce_commitments: commitments_map,
            public_keys_to_secret_keys: public_keys_map,
            network,
        }))
    }

    #[cfg(not(feature = "self-signing"))]
    async fn new_remote(
        signer_url: &str,
        wallet_id: &str,
        user_public_key_hex: &str,
    ) -> Result<Self::WrappedSigner, SparkSdkError> {
        todo!()
    }

    fn derive_signing_key_from_leaf(&self, leaf_id: Uuid) -> Result<Vec<u8>, SparkSdkError> {
        let master_seed = derive_master_key_from_path(&self.master_seed, &self.network)?;
        let child_index = derive_child_index_from_leaf(leaf_id);

        let key = derive_child_key(&master_seed, child_index)?;
        let secret_key = key.private_key().to_bytes().to_vec();

        Ok(secret_key)
    }
}

const INVALID_SECRET_KEY_ERROR: &str =
    "Could not find secret key in the signer space. Public key used as the index: ";
impl DefaultSigner {
    pub(crate) fn load_master_seed(&self) -> Result<Vec<u8>, SparkSdkError> {
        Ok(self.master_seed.clone())
    }

    pub(crate) fn get_identity_secret_key(&self) -> Result<Vec<u8>, SparkSdkError> {
        let master_seed_bytes = self.load_master_seed()?;
        let master_seed = derive_master_key_from_path(&master_seed_bytes, &self.network)?;
        let identity_key = derive_child_key(&master_seed, IDENTITY_KEYPAIR_INDEX)?;

        Ok(identity_key.private_key().to_bytes().to_vec())
    }

    pub(crate) fn get_secret_key_from_pubkey<T: AsRef<[u8]>>(
        &self,
        public_key: &T,
    ) -> Result<Vec<u8>, SparkSdkError> {
        let public_key_hex = hex_encode(public_key);
        let secret_key_hex = self
            .public_keys_to_secret_keys
            .read()
            .get(&public_key_hex)
            .cloned()
            .ok_or_else(|| {
                SparkSdkError::InvalidInput(format!(
                    "{} {}",
                    INVALID_SECRET_KEY_ERROR, public_key_hex
                ))
            })?;

        Ok(hex_decode(&secret_key_hex).unwrap())
    }

    pub(crate) fn insert_to_keypair_map<T: AsRef<[u8]>, U: AsRef<[u8]>>(
        &self,
        public_key: T,
        secret_key: U,
    ) -> Result<(), SparkSdkError> {
        let public_key_hex = hex_encode(public_key);
        let secret_key_hex = hex_encode(secret_key);
        self.public_keys_to_secret_keys
            .write()
            .insert(public_key_hex, secret_key_hex);

        Ok(())
    }

    pub(crate) fn evict_from_keypair_map<T: AsRef<[u8]>>(
        &self,
        public_key: T,
    ) -> Result<(), SparkSdkError> {
        let public_key_hex = hex_encode(public_key);
        self.public_keys_to_secret_keys
            .write()
            .remove(&public_key_hex);

        Ok(())
    }

    pub(crate) fn insert_to_noncepair_map<T: AsRef<[u8]>, U: AsRef<[u8]>>(
        &self,
        nonce_commitment: T,
        nonce: U,
    ) -> Result<(), SparkSdkError> {
        let nonce_commitment_hex = hex_encode(nonce_commitment);
        let nonce_hex = hex_encode(nonce);

        self.nonce_commitments
            .write()
            .insert(nonce_commitment_hex.clone(), nonce_hex.clone());

        Ok(())
    }

    /// Prepares a FROST signing job for a node transaction by assembling all required components.
    ///
    /// # Arguments
    /// * `signing_public_key` - The public key corresponding to the secret key that will be used for signing
    /// * `user_frost_commitments` - The user's FROST nonce commitments in serialized form. If user has no commitments at the time, pass in None, and the function will generate them.
    /// * `spark_frost_commitments` - Map of operator IDs to their FROST commitments
    /// * `serialized_bitcoin_tx` - The Bitcoin transaction to be signed in serialized form
    /// * `prevout_to_use` - Index of the previous output being spent
    /// * `signing_input_index` - Index of the input being signed
    /// * `parent_tx` - The parent transaction containing the output being spent
    /// * `adaptor_public_key` - Public key used for adaptor signatures (if any)
    /// * `verifying_key` - The verification key for the FROST signing session
    ///
    /// # Returns
    /// A [`FrostSigningJob`] containing:
    /// - A unique job ID
    /// - The message to be signed (transaction sighash)
    /// - The key package containing signing material
    /// - The verification key
    /// - Marshaled nonces and commitments from both user and operators
    /// - The adaptor public key
    ///
    /// # Errors
    /// Returns [`SparkSdkError`] if:
    /// - Secret key exposure fails
    /// - Nonce exposure fails
    /// - Marshaling of nonces/commitments fails
    /// - Transaction decoding fails
    /// - Sighash calculation fails
    fn prepare_frost_signing_job<T: AsRef<[u8]>>(
        &self,
        signing_public_key: T,
        user_frost_commitments: Option<Vec<u8>>,
        spark_frost_commitments: HashMap<String, SparkOperatorCommitment>,
        serialized_bitcoin_tx: Vec<u8>,
        prevout_to_use: usize,
        signing_input_index: usize,
        parent_tx: &Transaction,
        adaptor_public_key: Vec<u8>,
        verifying_key: Vec<u8>,
    ) -> Result<FrostSigningJob, SparkSdkError> {
        let job_id = generate_signing_job_id();

        // expose the secret key, expose and marshal signing nonces
        let signing_secret_key =
            self.sensitive_expose_secret_key_from_pubkey(signing_public_key, false)?;
        let frost_nonces = self.sensitive_create_if_not_found_expose_nonces_from_commitments(
            user_frost_commitments.as_deref(),
        )?;
        let marshalized_frost_nonces = marshal_frost_nonces(&frost_nonces)?;

        let marshalized_frost_commitments = marshal_frost_commitments(&frost_nonces.commitments())?;

        let key_package = create_user_key_package(&signing_secret_key);
        let transaction = bitcoin_tx_from_bytes(&serialized_bitcoin_tx)?;

        let sighash = sighash_from_tx(
            &transaction,
            signing_input_index,
            &parent_tx.output[prevout_to_use],
        )?;
        let message = sighash.to_vec();

        Ok(FrostSigningJob {
            job_id,
            message,
            key_package: Some(key_package),
            verifying_key,
            nonce: Some(marshalized_frost_nonces),
            commitments: spark_frost_commitments,
            user_commitments: Some(marshalized_frost_commitments),
            adaptor_public_key: adaptor_public_key,
        })
    }
}

fn secret_key_to_public_key<T: AsRef<[u8]>>(secret_key: T) -> Result<Vec<u8>, SparkSdkError> {
    let secp = Secp256k1::new();
    let secret_key = parse_secret_key(&secret_key.as_ref().to_vec())?;
    let public_key = PublicKey::from_secret_key(&secp, &secret_key);

    Ok(public_key.serialize().to_vec())
}

/// Utility function to derive a key from path
const INVALID_DERIVATION_PATH_ERROR: &str = "failed to derive key for path: ";
fn derive_master_key_from_path(
    master_seed: &[u8],
    network: &SparkNetwork,
) -> Result<XPrv, SparkSdkError> {
    let path = match network {
        SparkNetwork::Mainnet => "m/44'/0'/0'/1/0",
        SparkNetwork::Regtest => "m/44'/1'/0'/1/0",
    };

    let derivation_path: DerivationPath = path
        .parse()
        .map_err(|e| SparkSdkError::InvalidInput(format!("Invalid derivation path: {}", e)))?;

    XPrv::derive_from_path(master_seed, &derivation_path).map_err(|e| {
        SparkSdkError::InvalidInput(format!("{} {}", INVALID_DERIVATION_PATH_ERROR, e))
    })
}

/// Utility function to derive a child key from a master seed.
const INVALID_CHILD_INDEX_ERROR: &str =
    "failed to create child index in the derivation path for index: ";
fn derive_child_key(master_seed: &XPrv, child_index: u32) -> Result<XPrv, SparkSdkError> {
    let child_number = ChildNumber::new(child_index, true).map_err(|_| {
        SparkSdkError::InvalidInput(format!("{} {}", INVALID_CHILD_INDEX_ERROR, child_index))
    })?;

    let child_key = master_seed.derive_child(child_number).map_err(|e| {
        SparkSdkError::InvalidInput(format!("{} {}", INVALID_DERIVATION_PATH_ERROR, e))
    })?;
    Ok(child_key)
}

// #[cfg(test)]
// pub fn post_test_cleanup(filepath: &PathBuf) -> Result<(), SparkSdkError> {
//     std::fs::remove_file(filepath)
//         .map_err(|e| SparkSdkError::IoError(format!("{} {}", REMOVE_FILE_ERROR, e)))?;

//     Ok(())
// }

// Creates a user frost signing key package from a signing secret key.
pub(crate) fn create_user_key_package(
    signing_secret_key: &[u8],
) -> spark_protos::frost::KeyPackage {
    let user_identifier = FROST_USER_IDENTIFIER;
    let secp = Secp256k1::new();
    let secret_key = SecretKey::from_slice(signing_secret_key).unwrap();
    let public_key = PublicKey::from_secret_key(&secp, &secret_key);

    let mut public_shares = HashMap::new();
    public_shares.insert(user_identifier.to_string(), public_key.serialize().to_vec());

    spark_protos::frost::KeyPackage {
        identifier: user_identifier.to_string(),
        secret_share: signing_secret_key.to_vec(),
        public_shares,
        public_key: public_key.serialize().to_vec(),
        min_signers: FROST_USER_KEY_PACKAGE_MIN_SIGNERS,
    }
}

use spark_protos::common::SigningCommitment as ProtoSigningCommitments;
pub(crate) fn marshal_frost_commitments(
    commitments: &FrostSigningCommitments,
) -> Result<ProtoSigningCommitments, SparkSdkError> {
    let hiding = commitments.hiding().serialize().unwrap();
    let binding = commitments.binding().serialize().unwrap();

    Ok(ProtoSigningCommitments { hiding, binding })
}

pub(crate) fn _unmarshal_frost_commitments(
    commitment: &ProtoSigningCommitments,
) -> Result<FrostSigningCommitments, SparkSdkError> {
    let hiding = commitment.hiding.clone();
    let binding = commitment.binding.clone();

    let hiding_nonce = FrostNonceCommitment::deserialize(&hiding).unwrap();
    let binding_nonce = FrostNonceCommitment::deserialize(&binding).unwrap();

    Ok(FrostSigningCommitments::new(hiding_nonce, binding_nonce))
}

use spark_protos::frost::SigningNonce as ProtoSigningNonce;
pub(crate) fn marshal_frost_nonces(
    nonce: &FrostSigningNonces,
) -> Result<ProtoSigningNonce, SparkSdkError> {
    let hiding = nonce.hiding().serialize();
    let binding = nonce.binding().serialize();

    Ok(ProtoSigningNonce { hiding, binding })
}

pub(crate) fn _unmarshal_frost_nonces(
    nonce: &ProtoSigningNonce,
) -> Result<FrostSigningNonces, SparkSdkError> {
    let hiding_nonce = FrostNonce::deserialize(&nonce.hiding).unwrap();
    let binding_nonce = FrostNonce::deserialize(&nonce.binding).unwrap();

    Ok(FrostSigningNonces::from_nonces(hiding_nonce, binding_nonce))
}

fn serialize_marshalized_frost_commitments(
    commitments: &ProtoSigningCommitments,
) -> Result<Vec<u8>, SparkSdkError> {
    let hiding = commitments.hiding.clone();
    let binding = commitments.binding.clone();

    let prefix_hex = "00230f8ab3";
    let hiding_hex = hex_encode(&hiding);
    let binding_hex = hex_encode(&binding);

    let commitments_hex = format!("{}{}{}", prefix_hex, hiding_hex, binding_hex);
    Ok(hex_decode(&commitments_hex).unwrap())
}

#[cfg(test)]
mod frost_to_proto_conversions_test {
    use super::*;

    #[test]
    fn test_frost_to_proto_conversions() {
        let hiding_sk = SecretKey::new(&mut rand::thread_rng());
        let binding_sk = SecretKey::new(&mut rand::thread_rng());
        let hiding_sk_bytes = hiding_sk.secret_bytes().to_vec();
        let binding_sk_bytes = binding_sk.secret_bytes().to_vec();

        let hiding_nonce = FrostNonce::deserialize(&hiding_sk_bytes).unwrap();
        let binding_nonce = FrostNonce::deserialize(&binding_sk_bytes).unwrap();

        // Create nonces and commitments
        let frost_nonces = FrostSigningNonces::from_nonces(hiding_nonce, binding_nonce);
        let frost_commitments = frost_nonces.commitments();

        // Marshal and unmarshal nonces
        let marshalized_nonces = marshal_frost_nonces(&frost_nonces).unwrap();
        let unmarshalized_nonces = _unmarshal_frost_nonces(&marshalized_nonces).unwrap();

        // Marshal and unmarshal commitments
        let marshalized_commitments = marshal_frost_commitments(&frost_commitments).unwrap();
        let unmarshalized_commitments =
            _unmarshal_frost_commitments(&marshalized_commitments).unwrap();

        // Assert that the nonces and commitments are the same
        assert_eq!(frost_nonces, unmarshalized_nonces);
        assert_eq!(frost_commitments, &unmarshalized_commitments);
    }
}

fn generate_signing_job_id() -> String {
    Uuid::now_v7().to_string()
}

type SignatureSharesType = HashMap<String, Vec<u8>>;
type PublicSharesType = HashMap<String, Vec<u8>>;
type SigningKeyshareType = Option<SigningKeyshare>;
type SigningCommitmentsType = HashMap<String, SparkOperatorCommitment>;

/// Extracts signature data components from a FROST signing result.
///
/// # Arguments
/// * `signing_result` - The optional signing result containing signature shares, public keys,
///                     keyshare and commitments
///
/// # Returns
/// A tuple containing:
/// * `SignatureSharesType` - Map of participant IDs to their signature shares
/// * `PublicSharesType` - Map of participant IDs to their public key shares
/// * `SigningKeyshareType` - Optional signing keyshare data
/// * `SigningCommitmentsType` - Map of participant IDs to their signing commitments
///
/// # Errors
/// Returns a `SparkSdkError` if the signing result is `None` or invalid
fn get_signature_data_from_signing_result(
    signing_result: &Option<SigningResult>,
) -> Result<
    (
        SignatureSharesType,
        PublicSharesType,
        SigningKeyshareType,
        SigningCommitmentsType,
    ),
    SparkSdkError,
> {
    let signing_result = signing_result.clone().unwrap();
    let signature_shares = signing_result.signature_shares;
    let public_shares = signing_result.public_keys;
    let signing_keyshare = signing_result.signing_keyshare;
    let commitments = signing_result.signing_nonce_commitments;

    Ok((
        signature_shares,
        public_shares,
        signing_keyshare,
        commitments,
    ))
}

fn create_refund_tx(
    sequence: u32,
    node_outpoint: bitcoin::OutPoint,
    amount_sats: bitcoin::Amount,
    receiving_pubkey: &bitcoin::secp256k1::PublicKey,
    network: bitcoin::Network,
) -> Result<bitcoin::Transaction, SparkSdkError> {
    let mut new_refund_tx = bitcoin::Transaction {
        version: bitcoin::transaction::Version::TWO,
        lock_time: bitcoin::absolute::LockTime::ZERO,
        input: vec![],
        output: vec![],
    };

    new_refund_tx.input.push(bitcoin::TxIn {
        previous_output: node_outpoint,
        script_sig: bitcoin::ScriptBuf::default(),
        sequence: bitcoin::Sequence(sequence),
        witness: bitcoin::Witness::default(),
    });

    let secp: bitcoin::key::Secp256k1<bitcoin::secp256k1::All> =
        bitcoin::secp256k1::Secp256k1::new();
    let addr = bitcoin::Address::p2tr(&secp, receiving_pubkey.x_only_public_key().0, None, network);
    let refund_pk_script = addr.script_pubkey();

    new_refund_tx.output.push(bitcoin::TxOut {
        value: amount_sats,
        script_pubkey: refund_pk_script,
    });

    new_refund_tx.output.push(ephemeral_anchor_output());

    Ok(new_refund_tx)
}

use sha2::{Digest, Sha256};
fn derive_child_index_from_leaf(leaf_id: Uuid) -> u32 {
    // Convert UUID to bytes and hash it
    let mut hasher = Sha256::new();
    hasher.update(leaf_id.as_bytes());
    let hash = hasher.finalize();

    // Sum up 8 u32 values from the hash (similar to the JS implementation)
    let mut amount: u32 = 0;
    for i in 0..8 {
        let start = i * 4;
        let end = start + 4;
        let chunk = &hash[start..end];
        let value = u32::from_be_bytes(chunk.try_into().unwrap());
        amount = amount.wrapping_add(value) % 0x80000000;
    }

    amount
    // // Add hardened key offset (0x80000000) to match BIP32 derivation
    // amount.wrapping_add(0x80000000)
}