spark_sdk/wallet/handlers/

init.rs

use std::sync::Arc;

use crate::{
    error::SparkSdkError,
    signer::traits::SparkSigner,
    wallet::{
        config::WalletConfig,
        internal_handlers::traits::{
            authenticate::AuthenticateInternalHandlers, leaves::LeavesInternalHandlers,
        },
        leaf_manager::LeafManager,
    },
    SparkNetwork, SparkSdk,
};

impl<S: SparkSigner + Send + Sync + Clone + 'static> SparkSdk<S> {
    /// Creates a new instance of the Spark SDK.
    ///
    /// This is the main entry point for interacting with the Spark protocol. It initializes the SDK with
    /// the provided network configuration, signer implementation, and optional data storage path.
    ///
    /// # Arguments
    ///
    /// * `network` - The Spark network to connect to (e.g. Regtest or Mainnet)
    /// * `signer` - Implementation of the SparkSigner trait wrapped in Arc<RwLock> for thread-safe access
    /// * `data_path` - Optional path to store wallet data. If None, defaults to WALLET_DB_PATH
    ///
    /// # Returns
    ///
    /// Returns a Result containing either:
    /// * The initialized SparkSdk instance
    /// * A SparkSdkError if initialization fails
    ///
    /// # Examples
    ///
    /// ```no_run
    /// use spark_wallet_sdk::{SparkSdk, SparkNetwork, DefaultSigner};
    /// use std::sync::Arc;
    /// use parking_lot::RwLock;
    ///
    /// async fn init_sdk() {
    ///     let signer = Arc::new(RwLock::new(DefaultSigner::new().unwrap()));
    ///     let sdk = SparkSdk::new(
    ///         SparkNetwork::Regtest,
    ///         signer,
    ///         None
    ///     ).await.unwrap();
    /// }
    /// ```
    pub async fn new(network: SparkNetwork, signer: Arc<S>) -> Result<Self, SparkSdkError> {
        let config = WalletConfig::new(network).await?;
        let leaf_manager = Arc::new(LeafManager::new());
        let session = Arc::new(parking_lot::RwLock::new(Vec::new()));

        let sdk = Self {
            config,
            identity_public_key: Arc::new(signer.get_identity_public_key()?),
            signer: signer.clone(),
            leaf_manager,
            session,
        };

        let sessions = sdk.authenticate().await?;
        let mut write = sdk.session.write();
        *write = sessions;
        drop(write);

        let sdk_clone = sdk.clone();

        // refresh BTC leaves
        sdk_clone.fetch_owned_leaves_from_spark().await?;

        // refresh tokens

        // make a background job to claim deposits
        tokio::spawn(async move {
            let mut interval = tokio::time::interval(std::time::Duration::from_secs(10));
            loop {
                interval.tick().await;
                let claimed_deposits = sdk_clone.claim_deposits().await;
                // // TODO: add a log
                // if !claimed_deposits.is_ok() {
                //     let error = claimed_deposits.err().unwrap();
                //     println!(
                //         "[Claim Deposit Background Job]: Failed to claim deposits: {}",
                //         error
                //     );
                // } else {
                //     println!(
                //         "[Claim Deposit Background Job]: Claimed pending deposits successfully. If there was no pending deposits, did not claim anything."
                //     );
                // }
            }
        });

        // make a background job to claim transfers
        let sdk_clone = sdk.clone();
        tokio::spawn(async move {
            let mut interval = tokio::time::interval(std::time::Duration::from_secs(10));
            loop {
                interval.tick().await;
                let claimed_transfers = sdk_clone.claim_transfers().await;
                if !claimed_transfers.is_ok() {
                    println!(
                        "[Claim Transfer Background Job] Failed to claim transfers: {}",
                        claimed_transfers.err().unwrap()
                    );
                } else {
                    println!(
                        "[Claim Transfer Background Job] Claimed pending transfers successfully. If there was no pending transfers, did not claim anything."
                    );
                }
            }
        });

        Ok(sdk)
    }

    /// Returns the identity public key of the wallet.
    ///
    /// The identity public key is a 33-byte compressed secp256k1 public key that uniquely identifies
    /// this wallet instance. It is used for authentication and authorization with Spark operators.
    /// This key is generated when the wallet is first created and remains constant throughout the
    /// wallet's lifetime.
    ///
    /// The identity public key serves several purposes:
    /// - Authenticates the wallet with Spark operators during API calls
    /// - Used in deposit address generation to prove ownership
    /// - Required for validating operator signatures
    /// - Helps prevent unauthorized access to wallet funds
    ///
    /// # Returns
    /// A byte slice containing the 33-byte compressed secp256k1 public key in SEC format.
    /// The first byte is either 0x02 or 0x03 (the parity), followed by the 32-byte X coordinate.
    ///
    /// # Examples
    /// ```no_run
    /// # use spark_wallet_sdk::{SparkSdk, SparkNetwork, DefaultSigner};
    /// # use std::sync::Arc;
    /// # use parking_lot::RwLock;
    /// # async fn example() {
    /// let signer = Arc::new(RwLock::new(DefaultSigner::new().unwrap()));
    /// let sdk = SparkSdk::new(SparkNetwork::Regtest, signer, None).await.unwrap();
    ///
    /// let pubkey = sdk.get_identity_public_key();
    /// assert_eq!(pubkey.len(), 33);
    /// # }
    /// ```
    pub fn get_identity_public_key(&self) -> &[u8] {
        &self.identity_public_key
    }

    /// Returns the Bitcoin network that this wallet is connected to.
    ///
    /// The network determines which Spark operators the wallet communicates with and which Bitcoin network
    /// (mainnet or regtest) is used for transactions.
    ///
    /// # Network Types
    /// - [`SparkNetwork::Mainnet`] - Production Bitcoin mainnet environment
    /// - [`SparkNetwork::Regtest`] - Testing environment using Lightspark's regtest network
    ///
    /// The network is set when creating the wallet and cannot be changed after initialization.
    /// All transactions and addresses will be created for the configured network.
    ///
    /// # Returns
    /// Returns a [`SparkNetwork`] enum indicating whether this is a mainnet or regtest wallet.
    ///
    /// # Examples
    /// ```no_run
    /// # use spark_wallet_sdk::{SparkSdk, SparkNetwork, DefaultSigner};
    /// # use std::sync::Arc;
    /// # use parking_lot::RwLock;
    /// # async fn example() {
    /// let signer = Arc::new(RwLock::new(DefaultSigner::new().unwrap()));
    /// let sdk = SparkSdk::new(SparkNetwork::Regtest, signer, None).await.unwrap();
    ///
    /// assert_eq!(sdk.get_network(), SparkNetwork::Regtest);
    /// # }
    /// ```
    pub fn get_network(&self) -> SparkNetwork {
        self.config.spark_config.network
    }
}