spark_sdk/wallet/internal_handlers/implementations/

transfer.rs

use crate::common_types::types::frost::FrostSigningCommitments;
use crate::common_types::types::AbsoluteLockTime;
use crate::common_types::types::EcdsaSignature;
use crate::common_types::types::OutPoint;
use crate::common_types::types::PublicKey;
use crate::common_types::types::ScriptBuf;
use crate::common_types::types::Secp256k1;
use crate::common_types::types::Secp256k1Message;
use crate::common_types::types::SecretKey;
use crate::common_types::types::TransactionVersion;
use crate::common_types::types::TxIn;
use crate::common_types::types::Uuid;
use crate::common_types::types::Witness;
use crate::error::SparkSdkError;
use crate::signer::traits::SparkSigner;
use crate::wallet::internal_handlers::traits::transfer::LeafKeyTweak;
use crate::wallet::internal_handlers::traits::transfer::LeafRefundSigningData;
use crate::wallet::internal_handlers::traits::transfer::TransferInternalHandlers;
use crate::wallet::internal_handlers::utils::bitcoin_tx_from_bytes;
use crate::wallet::internal_handlers::utils::parsers::parse_public_key;
use crate::wallet::internal_handlers::utils::serialize_bitcoin_transaction;
use crate::wallet::leaf_manager::LeafNode;
use crate::wallet::utils::sequence::next_sequence;
use crate::SparkSdk;
use spark_cryptography::secret_sharing::secret_sharing::VerifiableSecretShare;
use spark_protos::common::SignatureIntent;
use spark_protos::common::SigningCommitment as ProtoSigningCommitment;
use spark_protos::spark::ClaimLeafKeyTweak;
use spark_protos::spark::ClaimTransferTweakKeysRequest;
use spark_protos::spark::CompleteSendTransferRequest;
use spark_protos::spark::FinalizeNodeSignaturesRequest;
use spark_protos::spark::LeafRefundTxSigningJob;
use spark_protos::spark::SendLeafKeyTweak;
use spark_protos::spark::SigningJob;
use spark_protos::spark::StartSendTransferRequest;
use spark_protos::spark::Transfer;
use spark_protos::spark::TreeNode;
use std::collections::HashMap;

// external crates
use sha256::digest;
use tonic::async_trait;

#[async_trait]
impl<S: SparkSigner + Send + Sync + Clone + 'static> TransferInternalHandlers<S> for SparkSdk<S> {
    /// Top-level transfer execution function, given the leaves to transfer. The function expects the leaves to be in [`LeafKeyTweak`] format.
    ///
    /// # Arguments
    ///
    /// * `leaves` - A vector of [`LeafKeyTweak`] objects representing the leaves to transfer.
    /// * `receiver_identity_pubkey` - The public key of the receiver.
    /// * `expiry_time` - The expiry time of the transfer.
    ///
    /// # Returns
    ///
    /// A [`Transfer`] object representing the transfer. This is an auto-converted protobuf object that is returned by the Spark API as the last step of the transfer for the sender.
    async fn start_send_transfer(
        &self,
        leaves: &Vec<LeafKeyTweak>,
        receiver_identity_pubkey: Vec<u8>,
        expiry_time: u64,
    ) -> Result<Transfer, SparkSdkError> {
        // Send the transfer, get the refund signatures, and aggregate by adding yours.
        let (transfer, refund_signatures) = self
            .send_transfer_sign_refunds(leaves, receiver_identity_pubkey, expiry_time)
            .await?;

        // Send the transfer, get the tweak keys, and send them.
        let transfer = self
            .send_transfer_tweak_key(transfer, leaves, &refund_signatures)
            .await?;

        Ok(transfer)
    }

    async fn send_transfer_tweak_key(
        &self,
        transfer: Transfer,
        leaves: &Vec<LeafKeyTweak>,
        refund_signature_map: &HashMap<String, Vec<u8>>,
    ) -> Result<Transfer, SparkSdkError> {
        // Prepare the key tweaks for the transfer.
        let key_tweak_input_map =
            self.prepare_send_transfer_key_tweaks(&transfer, leaves, refund_signature_map)?;

        let mut updated_transfer: Option<Transfer> = None;

        for operator in &self.config.spark_config.spark_operators {
            let mut spark_client = self
                .config
                .spark_config
                .get_spark_connection(Some(operator.id))
                .await?;

            let mut request = tonic::Request::new(CompleteSendTransferRequest {
                transfer_id: transfer.id.clone(),
                owner_identity_public_key: self.get_identity_public_key().to_vec(),
                leaves_to_send: key_tweak_input_map[&operator.frost_identifier].clone(),
            });

            self.add_authorization_header_to_request(&mut request, Some(operator.id));

            let response = spark_client
                .complete_send_transfer(request)
                .await?
                .into_inner();

            match &updated_transfer {
                None => updated_transfer = response.transfer,
                Some(existing) => {
                    if !self.compare_transfers(existing, &response.transfer.unwrap()) {
                        return Err(SparkSdkError::TransferError(
                            "Inconsistent transfer responses from operators".into(),
                        ));
                    }
                }
            }
        }

        Ok(updated_transfer.unwrap())
    }

    async fn send_transfer_sign_refunds(
        &self,
        leaves: &Vec<LeafKeyTweak>,
        receiver_identity_pubkey: Vec<u8>,
        expiry_time: u64,
    ) -> Result<(Transfer, HashMap<String, Vec<u8>>), SparkSdkError> {
        // Generate a new transfer ID.
        let transfer_id = Uuid::now_v7().to_string();

        // Prepare signing data for each leaf
        let mut leaf_data_map = HashMap::new();
        for leaf_key in leaves {
            let commitments = self.signer.new_frost_signing_noncepair()?;
            let node_tx = bitcoin_tx_from_bytes(&leaf_key.leaf.node_tx)?;

            let secp = Secp256k1::new();

            println!(
                "[send_transfer_sign_refunds] here in loop x -- 1: {:?}",
                hex::encode(&leaf_key.old_signing_private_key)
            );

            let signing_secret_key = bitcoin::secp256k1::SecretKey::from_slice(
                &leaf_key.old_signing_private_key.clone(),
            )?;
            let signing_public_key = signing_secret_key.public_key(&secp).serialize().to_vec();

            println!(
                "[send_transfer_sign_refunds] here in loop x -- 2: {:?}",
                hex::encode(&signing_public_key)
            );

            let leaf_refund_signing_data = LeafRefundSigningData {
                signing_public_key,
                receiving_pubkey: receiver_identity_pubkey.clone(),
                commitment: frost_commitment_to_proto_commitment(&commitments)?,
                tx: node_tx,
                refund_tx: None,
                vout: leaf_key.leaf.vout,
            };
            leaf_data_map.insert(leaf_key.leaf.id.clone(), leaf_refund_signing_data);
        }

        println!("[send_transfer_sign_refunds] here 2");

        // Create the signing jobs needed for the transfer.
        let signing_jobs = self.prepare_refund_so_signing_jobs(leaves, &mut leaf_data_map)?;

        // Send the first transfer request as the sender.
        let mut client = self.config.spark_config.get_spark_connection(None).await?;
        let mut request = tonic::Request::new(StartSendTransferRequest {
            transfer_id: transfer_id.clone(),
            leaves_to_send: signing_jobs,
            owner_identity_public_key: self.get_identity_public_key().to_vec(),
            receiver_identity_public_key: receiver_identity_pubkey,
            expiry_time: Some(prost_types::Timestamp {
                seconds: expiry_time as i64,
                nanos: 0,
            }),
        });

        println!("[send_transfer_sign_refunds] here 3");

        self.add_authorization_header_to_request(&mut request, None);
        let response = client.start_send_transfer(request).await?.into_inner();
        let transfer = response.transfer.unwrap(); // `transfer` is always Some.

        println!("[send_transfer_sign_refunds] here 4");

        // Sign the refunds and aggregate signatures combining your and Spark Operators' signatures. This will give you the signature for the transfer transaction to be sent to the receiver.
        let signing_results = response.signing_results;
        let signatures =
            self.signer
                .sign_transfer_refunds(&leaf_data_map, &signing_results, vec![])?;

        println!("[send_transfer_sign_refunds] here 5");

        // Create a map of node IDs to signatures.
        let mut signature_map = HashMap::new();
        for leaf_signature in signatures {
            signature_map.insert(leaf_signature.node_id, leaf_signature.refund_tx_signature);
        }

        println!("[send_transfer_sign_refunds] here 6");

        Ok((transfer, signature_map))
    }

    fn prepare_send_transfer_key_tweaks(
        &self,
        transfer: &Transfer,
        leaves: &Vec<LeafKeyTweak>,
        refund_signature_map: &HashMap<String, Vec<u8>>,
    ) -> Result<HashMap<String, Vec<SendLeafKeyTweak>>, SparkSdkError> {
        let mut leaves_tweaks_map = HashMap::new();
        for leaf in leaves {
            // Get the refund signature
            let leaf_refund_signature = refund_signature_map[&leaf.leaf.id].clone();

            // Get the tweaks for this leaf by preparing the key tweak data
            let leaf_tweaks = self.prepare_single_send_transfer_key_tweak(
                &transfer.id,
                leaf,
                &transfer.receiver_identity_public_key,
                &leaf_refund_signature,
            )?;

            // Add the tweaks to the map, grouped by identifier
            for (identifier, leaf_tweak) in leaf_tweaks {
                leaves_tweaks_map
                    .entry(identifier)
                    .or_insert_with(Vec::new)
                    .push(leaf_tweak);
            }
        }

        Ok(leaves_tweaks_map)
    }

    fn prepare_single_send_transfer_key_tweak(
        &self,
        transfer_id: &str,
        leaf: &LeafKeyTweak,
        receiver_pubkey: &Vec<u8>,
        refund_signature: &Vec<u8>,
    ) -> Result<HashMap<String, SendLeafKeyTweak>, SparkSdkError> {
        let secp = Secp256k1::new();
        let publickey = bitcoin::secp256k1::SecretKey::from_slice(&leaf.old_signing_private_key)
            .unwrap()
            .public_key(&secp)
            .serialize()
            .to_vec();
        let tweaked_public_key = self.signer.subtract_secret_keys_given_pubkeys(
            &publickey,
            &leaf.new_signing_public_key,
            true,
        )?;

        // Split the secret key that belongs to the tweaked public key.
        let shares = self
            .signer
            .split_from_public_key_with_verifiable_secret_sharing(
                tweaked_public_key,
                self.config.spark_config.threshold as usize,
                self.config.spark_config.spark_operators.len(),
            )?;

        let mut pubkey_shares_tweak = HashMap::new();
        for operator in &self.config.spark_config.spark_operators {
            let share = find_share(&shares, operator.id.into())?;

            let share_scalar =
                SecretKey::from_slice(&share.secret_share.share.to_bytes().to_vec())?;
            let pubkey_tweak = PublicKey::from_secret_key(&Secp256k1::new(), &share_scalar);
            pubkey_shares_tweak.insert(
                operator.frost_identifier.clone(),
                pubkey_tweak.serialize().to_vec(),
            );
        }

        // Generate signature over payload
        // First, let's encrypt the new signing private key using ECIES
        let secret_cipher = self
            .signer
            .encrypt_secret_key_with_ecies(receiver_pubkey, &leaf.new_signing_public_key)?;

        // Now we'll create the payload exactly as in the Go code by concatenating:
        // 1. leaf ID
        // 2. transfer ID
        // 3. encrypted secret (secret_cipher)
        let payload = [
            leaf.leaf.id.as_bytes(), // leaf ID bytes
            transfer_id.as_bytes(),  // transfer ID bytes
            &secret_cipher,          // encrypted secret bytes
        ]
        .concat();

        // Sign the hash using ECDSA with our identity private key
        // Note: We use the raw hash bytes directly, no hex encoding needed
        let signature = self
            .signer
            .sign_message_ecdsa_with_identity_key(payload, true)?;
        // let signature = signature.serialize_der().to_vec();

        let mut leaf_tweaks_map = HashMap::new();
        for operator in &self.config.spark_config.spark_operators {
            let share = find_share(&shares, operator.id.into())?;
            leaf_tweaks_map.insert(
                operator.frost_identifier.clone(),
                SendLeafKeyTweak {
                    leaf_id: leaf.leaf.id.clone(),
                    secret_share_tweak: Some(spark_protos::spark::SecretShare {
                        secret_share: share.secret_share.share.to_bytes().to_vec(),
                        proofs: share.proofs.clone(),
                    }),
                    pubkey_shares_tweak: pubkey_shares_tweak.clone(),
                    secret_cipher: secret_cipher.clone(),
                    signature: signature.clone(),
                    refund_signature: refund_signature.to_vec(),
                },
            );
        }

        Ok(leaf_tweaks_map)
    }

    fn prepare_refund_so_signing_jobs(
        &self,
        leaves: &Vec<LeafKeyTweak>,
        leaf_data_map: &mut HashMap<String, LeafRefundSigningData>,
    ) -> Result<Vec<LeafRefundTxSigningJob>, SparkSdkError> {
        let mut signing_jobs = Vec::new();

        for leaf in leaves {
            let refund_signing_data = leaf_data_map
                .get_mut(&leaf.leaf.id)
                .ok_or_else(|| SparkSdkError::InvalidInput("Leaf data not found".into()))?;

            let signing_pubkey = PublicKey::from_slice(&refund_signing_data.signing_public_key)?;
            let refund_tx =
                self.create_refund_tx(&leaf.leaf, &refund_signing_data.receiving_pubkey)?;
            let refund_bytes = serialize_bitcoin_transaction(&refund_tx)?;

            refund_signing_data.refund_tx = Some(refund_tx);

            let refund_commitment_proto = refund_signing_data.commitment.clone();

            signing_jobs.push(LeafRefundTxSigningJob {
                leaf_id: leaf.leaf.id.clone(),
                refund_tx_signing_job: Some(SigningJob {
                    signing_public_key: signing_pubkey.serialize().to_vec(),
                    raw_tx: refund_bytes,
                    signing_nonce_commitment: Some(refund_commitment_proto),
                }),
            });
        }

        Ok(signing_jobs)
    }

    fn create_refund_tx(
        &self,
        leaf: &TreeNode,
        receiving_pubkey: &Vec<u8>,
    ) -> Result<bitcoin::Transaction, SparkSdkError> {
        let node_tx = bitcoin_tx_from_bytes(&leaf.node_tx)?;
        let refund_tx = bitcoin_tx_from_bytes(&leaf.refund_tx)?;

        let mut new_refund_tx = bitcoin::Transaction {
            version: TransactionVersion::TWO,
            lock_time: AbsoluteLockTime::ZERO,
            input: vec![],
            output: vec![],
        };

        let sequence = next_sequence(refund_tx.input[0].sequence.0);
        let sequence = bitcoin::Sequence(sequence);

        new_refund_tx.input.push(TxIn {
            previous_output: OutPoint {
                txid: node_tx.compute_txid(),
                vout: 0,
            },
            script_sig: ScriptBuf::default(),
            sequence,
            witness: Witness::default(),
        });

        let secp = Secp256k1::new();
        let pubkey = PublicKey::from_slice(receiving_pubkey)?;
        let addr = bitcoin::Address::p2tr(
            &secp,
            pubkey.x_only_public_key().0,
            None,
            self.config.spark_config.network.to_bitcoin_network(),
        );

        new_refund_tx.output.push(bitcoin::TxOut {
            value: node_tx.output[0].value,
            script_pubkey: addr.script_pubkey(),
        });

        Ok(new_refund_tx)
    }

    // Helper methods
    fn compare_transfers(&self, t1: &Transfer, t2: &Transfer) -> bool {
        t1.id == t2.id
            && t1.receiver_identity_public_key == t2.receiver_identity_public_key
            && t1.status == t2.status
            && t1.total_value == t2.total_value
            && t1.expiry_time.as_ref().map(|t| t.seconds)
                == t2.expiry_time.as_ref().map(|t| t.seconds)
            && t1.leaves.len() == t2.leaves.len()
    }

    async fn claim_finalize_incoming_transfer(
        &self,
        transfer: &Transfer,
        leaves: &Vec<LeafKeyTweak>,
    ) -> Result<(), SparkSdkError> {
        // First tweak the keys
        self.claim_transfer_tweak_keys(transfer, leaves).await?;

        // Then sign the refunds
        let signatures = self.claim_transfer_sign_refunds(transfer, leaves).await?;

        // Finally, finalize the transfer
        self.finalize_transfer(&signatures).await?;

        let mut leaf_nodes = vec![];
        for (leaf, _) in leaves.iter().zip(signatures.iter()) {
            let leaf_node = LeafNode::new(
                leaf.leaf.id.clone(),
                leaf.leaf.tree_id.clone(),
                leaf.leaf.value,
                leaf.leaf.parent_node_id.clone(),
                leaf.leaf.vout,
                leaf.leaf.verifying_public_key.clone(),
                leaf.new_signing_public_key.clone(),
                // signature.node_tx_signature.clone(),
                // signature.refund_tx_signature.clone(),
                leaf.leaf.node_tx.clone(),
                leaf.leaf.refund_tx.clone(),
                None,
                vec![],
                vec![],
            );

            leaf_nodes.push(leaf_node);
        }

        self.leaf_manager.insert_leaves_in_batch(leaf_nodes)?;

        Ok(())
    }

    async fn claim_transfer_tweak_keys(
        &self,
        transfer: &Transfer,
        leaves: &Vec<LeafKeyTweak>,
    ) -> Result<(), SparkSdkError> {
        let leaves_tweaks_map = self.prepare_claim_leaves_key_tweaks(leaves)?;

        for operator in &self.config.spark_config.spark_operators {
            let mut spark_client = self
                .config
                .spark_config
                .get_spark_connection(Some(operator.id))
                .await?;

            let request = ClaimTransferTweakKeysRequest {
                transfer_id: transfer.id.clone(),
                owner_identity_public_key: self.get_identity_public_key().to_vec(),
                leaves_to_receive: leaves_tweaks_map[&operator.frost_identifier].clone(),
            };
            let mut tonic_request = tonic::Request::new(request);
            self.add_authorization_header_to_request(&mut tonic_request, Some(operator.id));

            let response = spark_client.claim_transfer_tweak_keys(tonic_request).await;
            response?;
        }

        Ok(())
    }

    fn prepare_claim_leaves_key_tweaks(
        &self,
        leaves: &Vec<LeafKeyTweak>,
    ) -> Result<HashMap<String, Vec<ClaimLeafKeyTweak>>, SparkSdkError> {
        let mut leaves_tweaks_map = HashMap::new();

        for leaf in leaves {
            let leaf_tweaks = self.prepare_claim_leaf_key_tweaks(&leaf)?;

            for (identifier, leaf_tweak) in leaf_tweaks {
                leaves_tweaks_map
                    .entry(identifier)
                    .or_insert_with(Vec::new)
                    .push(leaf_tweak);
            }
        }

        println!("Prepared claim leaves key tweaks.");

        Ok(leaves_tweaks_map)
    }

    fn prepare_claim_leaf_key_tweaks(
        &self,
        leaf: &LeafKeyTweak,
    ) -> Result<HashMap<String, ClaimLeafKeyTweak>, SparkSdkError> {
        let secp = Secp256k1::new();
        let tweaked_public_key = self.signer.subtract_secret_keys_given_pubkeys(
            &bitcoin::secp256k1::SecretKey::from_slice(&leaf.old_signing_private_key)
                .unwrap()
                .public_key(&secp)
                .serialize()
                .to_vec(),
            &leaf.new_signing_public_key,
            true,
        )?;

        let shares = self
            .signer
            .split_from_public_key_with_verifiable_secret_sharing(
                tweaked_public_key,
                // &minus_one.to_be_bytes().to_vec(),
                self.config.spark_config.threshold as usize,
                self.config.spark_config.spark_operators.len(),
            )
            .unwrap();

        let mut pubkey_shares_tweak = HashMap::new();
        for operator in &self.config.spark_config.spark_operators {
            let share = find_share(&shares, operator.id.into())?;

            // This part comes from Spark cryptography, so the secret key is in the code.
            let share_scalar =
                SecretKey::from_slice(&share.secret_share.share.to_bytes().to_vec())?;
            let pubkey_tweak = PublicKey::from_secret_key(&Secp256k1::new(), &share_scalar);
            pubkey_shares_tweak.insert(
                operator.frost_identifier.clone(),
                pubkey_tweak.serialize().to_vec(),
            );
        }

        let mut leaf_tweaks_map = HashMap::new();
        for operator in &self.config.spark_config.spark_operators {
            let share = find_share(&shares, operator.id.into())?;

            leaf_tweaks_map.insert(
                operator.frost_identifier.clone(),
                ClaimLeafKeyTweak {
                    leaf_id: leaf.leaf.id.clone(),
                    secret_share_tweak: Some(spark_protos::spark::SecretShare {
                        secret_share: share.secret_share.share.to_bytes().to_vec(),
                        proofs: share.proofs.clone(),
                    }),
                    pubkey_shares_tweak: pubkey_shares_tweak.clone(),
                },
            );
        }

        Ok(leaf_tweaks_map)
    }

    async fn claim_transfer_sign_refunds(
        &self,
        transfer: &Transfer,
        leaf_keys: &Vec<LeafKeyTweak>,
    ) -> Result<Vec<spark_protos::spark::NodeSignatures>, SparkSdkError> {
        // Create a map to store refund signing data for each leaf
        let mut leaf_data_map = HashMap::new();

        for leaf_key in leaf_keys {
            // For each leaf key, we create the signing data using the new private key
            let new_public_key = leaf_key.new_signing_public_key.clone();

            let commitments = self.signer.new_frost_signing_noncepair()?;

            // Deserialize the transaction from raw bytes
            let tx = match bitcoin::consensus::deserialize(&leaf_key.leaf.node_tx) {
                Ok(tx) => tx,
                Err(e) => {
                    return Err(SparkSdkError::InvalidInput(format!(
                        "Failed to deserialize transaction: {}",
                        e
                    )));
                }
            };

            // Store all the necessary data for signing
            leaf_data_map.insert(
                leaf_key.leaf.id.clone(),
                LeafRefundSigningData {
                    signing_public_key: new_public_key.to_vec(),
                    receiving_pubkey: new_public_key.to_vec(),
                    commitment: frost_commitment_to_proto_commitment(&commitments)?,
                    tx,
                    refund_tx: None,
                    vout: leaf_key.leaf.vout,
                },
            );
        }

        // Prepare the signing jobs for each leaf
        let signing_jobs = self.prepare_refund_so_signing_jobs(&leaf_keys, &mut leaf_data_map)?;

        // Request signing of refunds
        let mut spark_client = self.config.spark_config.get_spark_connection(None).await?;
        let request = spark_protos::spark::ClaimTransferSignRefundsRequest {
            transfer_id: transfer.id.clone(),
            owner_identity_public_key: self.get_identity_public_key().to_vec(),
            signing_jobs,
        };
        let mut tonic_request = tonic::Request::new(request);
        self.add_authorization_header_to_request(&mut tonic_request, None);

        let response = spark_client
            .claim_transfer_sign_refunds(tonic_request)
            .await?
            .into_inner();

        // Process the signing results and generate final signatures
        self.signer
            .sign_transfer_refunds(&leaf_data_map, &response.signing_results, vec![])
    }

    async fn finalize_transfer(
        &self,
        signatures: &[spark_protos::spark::NodeSignatures],
    ) -> Result<(), SparkSdkError> {
        let mut spark_client = self.config.spark_config.get_spark_connection(None).await?;
        let request = FinalizeNodeSignaturesRequest {
            intent: SignatureIntent::Transfer as i32,
            node_signatures: signatures.to_vec(),
        };
        let mut tonic_request = tonic::Request::new(request);
        self.add_authorization_header_to_request(&mut tonic_request, None);

        spark_client.finalize_node_signatures(tonic_request).await?;

        Ok(())
    }

    async fn verify_pending_transfer(
        &self,
        transfer: &spark_protos::spark::Transfer,
    ) -> Result<HashMap<String, Vec<u8>>, SparkSdkError> {
        // Create the map for leafID -> decrypted leaf private key
        let mut leaf_privkey_map = HashMap::new();

        // 1) Parse the sender's public key
        let secp = Secp256k1::new();
        let sender_pubkey = parse_public_key(&transfer.sender_identity_public_key)?;

        // 2) For each leaf, verify the signature, then decrypt the secret
        for leaf in &transfer.leaves {
            // Parse signature from DER
            let signature = EcdsaSignature::from_der(&leaf.signature).map_err(|e| {
                SparkSdkError::InvalidInput(format!("Failed to parse DER signature: {e}"))
            })?;

            // Create the message to verify: leaf.Leaf.Id + transfer.Id + leaf.SecretCipher
            let mut payload = leaf
                .leaf
                .as_ref()
                .map(|l| l.id.clone())
                .unwrap_or_default()
                .into_bytes();
            payload.extend_from_slice(transfer.id.as_bytes());
            payload.extend_from_slice(&leaf.secret_cipher);

            // Hash the payload
            let payload_hash_hex = digest(&payload);
            let payload_hash_bytes = hex::decode(payload_hash_hex).map_err(|e| {
                SparkSdkError::InvalidInput(format!("Failed to decode hex payload hash: {e}"))
            })?;

            // Build secp256k1 message and verify ECDSA signature
            let msg = Secp256k1Message::from_digest_slice(&payload_hash_bytes).map_err(|e| {
                SparkSdkError::InvalidInput(format!(
                    "Failed to create message for signature verify: {e}"
                ))
            })?;

            secp.verify_ecdsa(&msg, &signature, &sender_pubkey)
                .map_err(|e| {
                    SparkSdkError::InvalidInput(format!("Failed to verify signature: {e}"))
                })?;

            // Decrypt secret cipher with our identity key (assuming the SparkSigner can do ECIES decryption)
            let leaf_secret = self
                .signer
                .decrypt_secret_key_with_ecies(&leaf.secret_cipher)?;

            // Record the decrypted leaf secret (private key) in the map
            if let Some(leaf_node) = &leaf.leaf {
                leaf_privkey_map.insert(leaf_node.id.clone(), leaf_secret);
            }
        }

        Ok(leaf_privkey_map)
    }
}

fn find_share(
    shares: &Vec<VerifiableSecretShare>,
    operator_id: u64,
) -> Result<VerifiableSecretShare, SparkSdkError> {
    let target_index = k256::Scalar::from(operator_id + 1);
    shares
        .iter()
        .find(|s| s.secret_share.index == target_index)
        .cloned()
        .ok_or_else(|| SparkSdkError::InvalidInput("Share not found".into()))
}

fn frost_commitment_to_proto_commitment(
    commitments: &FrostSigningCommitments,
) -> Result<ProtoSigningCommitment, SparkSdkError> {
    let hiding = commitments.hiding().serialize().unwrap();
    let binding = commitments.binding().serialize().unwrap();

    Ok(ProtoSigningCommitment { hiding, binding })
}