spark_sdk/wallet/handlers/

deposit.rs

use spark_protos::spark::{
    GenerateDepositAddressRequest, QueryUnusedDepositAddressesRequest, TreeNode,
};
use tonic::Request;

use crate::{
    error::SparkSdkError,
    signer::traits::{secp256k1::KeygenMethod, SparkSigner},
    wallet::internal_handlers::traits::{
        deposit::{DepositInternalHandlers, GenerateDepositAddressSdkResponse},
        mempool::MempoolInternalHandlers,
    },
    SparkSdk,
};

impl<S: SparkSigner + Send + Sync + Clone + 'static> SparkSdk<S> {
    /// Generates a new deposit address for receiving funds into the Spark wallet.
    ///
    /// This function handles the generation of a new deposit address by:
    /// 1. Creating a new signing keypair for the deposit address
    /// 2. Requesting a deposit address from the Spark network
    /// 3. Validating the returned address and proof of possession
    ///
    /// # Returns
    ///
    /// * `Ok(GenerateDepositAddressSdkResponse)` - Contains the validated deposit address and signing public key
    /// * `Err(SparkSdkError)` - If there was an error during address generation
    ///
    /// # Errors
    ///
    /// Returns [`SparkSdkError`] if:
    /// - Failed to generate new signing keypair
    /// - Network errors when communicating with Spark operators
    /// - Address validation fails (e.g. invalid proof of possession)
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use spark_wallet_sdk::SparkSdk;
    /// # async fn example(mut sdk: SparkSdk) -> Result<(), Box<dyn std::error::Error>> {
    /// let deposit_address = sdk.generate_deposit_address().await?;
    /// println!("New deposit address: {}", deposit_address.deposit_address.address);
    /// # Ok(())
    /// # }
    /// ```
    pub async fn generate_deposit_address(
        &self,
    ) -> Result<GenerateDepositAddressSdkResponse, SparkSdkError> {
        let identity_public_key = self.get_identity_public_key().to_vec();
        let signing_public_key = self
            .signer
            .new_secp256k1_keypair(KeygenMethod::Random)?
            .to_vec();

        let mut spark_client = self.config.spark_config.get_spark_connection(None).await?;
        let mut request = tonic::Request::new(GenerateDepositAddressRequest {
            signing_public_key: signing_public_key.clone(),
            identity_public_key,
            network: self.config.spark_config.network.marshal_proto(),
        });
        self.add_authorization_header_to_request(&mut request, None);

        let response = spark_client.generate_deposit_address(request).await?;

        let response = response.into_inner();
        let deposit_address = response.deposit_address.clone().unwrap();

        self.validate_deposit_address(deposit_address, signing_public_key.clone())
            .await?;

        Ok(GenerateDepositAddressSdkResponse {
            deposit_address: response.deposit_address.unwrap(),
            signing_public_key,
        })
    }

    /// Claims any pending deposits for this wallet by:
    /// 1. Querying unused deposit addresses from Spark
    /// 2. Checking the mempool for transactions to those addresses
    /// 3. Finalizing any found deposits by creating tree nodes
    ///
    /// # Errors
    ///
    /// Returns [`SparkSdkError`] if:
    /// - Failed to connect to Spark service
    /// - Failed to query mempool
    /// - Failed to finalize deposits
    ///
    /// # Example
    ///
    /// ```no_run
    /// # use spark_wallet_sdk::SparkSdk;
    /// # async fn example(sdk: SparkSdk) -> Result<(), Box<dyn std::error::Error>> {
    /// sdk.claim_deposits().await?;
    /// # Ok(())
    /// # }
    /// ```
    pub async fn claim_deposits(&self) -> Result<(), SparkSdkError> {
        let mut spark_client = self.config.spark_config.get_spark_connection(None).await?;
        let identity_public_key = self.get_identity_public_key();

        let mut request = Request::new(QueryUnusedDepositAddressesRequest {
            identity_public_key: identity_public_key.to_vec(),
        });
        self.add_authorization_header_to_request(&mut request, None);

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

        // println!("deposits are: {:?}", deposits);

        for deposit in deposits.deposit_addresses {
            // log duration
            let time_start = std::time::Instant::now();
            let queried_tx = self
                .query_mempool_transaction(deposit.deposit_address.clone())
                .await?;
            let duration = time_start.elapsed();
            println!("[query_mempool_transaction] duration: {:?}", duration);

            let mempool_query_result = queried_tx;
            let deposit_tx = mempool_query_result.transaction;
            let vout = mempool_query_result.vout;

            println!(
                "Finalizing deposit for address: {}",
                deposit.deposit_address
            );
            let time_start = std::time::Instant::now();
            self.finalize_deposit(deposit.user_signing_public_key, deposit_tx, vout)
                .await?;
            let duration = time_start.elapsed();
            println!("[finalize_deposit duration]: {:?}", duration);

            // TODO: add a log
            println!(
                "[Claim Deposit Background Job]: Claimed deposit for address: {}",
                deposit.deposit_address
            );
        }

        Ok(())
    }

    /// Finalizes a deposit by creating a tree node and transferring it to self
    ///
    /// # Arguments
    ///
    /// * `signing_pubkey` - The public key used for signing
    /// * `deposit_tx` - The Bitcoin transaction containing the deposit
    /// * `vout` - The output index in the transaction
    ///
    /// # Errors
    ///
    /// Returns [`SparkSdkError`] if:
    /// - Failed to create tree node
    /// - Failed to transfer deposits
    ///
    /// # Returns
    ///
    /// Returns an empty vector of `TreeNode`s on success
    pub async fn finalize_deposit(
        &self,
        signing_pubkey: Vec<u8>,
        deposit_tx: bitcoin::Transaction,
        vout: u32,
    ) -> Result<Vec<TreeNode>, SparkSdkError> {
        self.create_tree(Some(deposit_tx), None, vout, 0, signing_pubkey)
            .await?;

        // transfer deposits to self
        // let leaf_ids = create_tree_response
        //     .nodes
        //     .iter()
        //     .map(|node| node.id.clone())
        //     .collect();
        // self.transfer_deposits_to_self(leaf_ids).await?;

        Ok(vec![])
    }

    async fn transfer_deposits_to_self(&self, leaf_ids: Vec<String>) -> Result<(), SparkSdkError> {
        self.transfer_leaf_ids(leaf_ids, self.get_identity_public_key().to_vec())
            .await?;

        Ok(())
    }
}