spark_config/

lib.rs

#![doc = include_str!("../README.md")]

use std::{collections::BTreeMap, fs::File, hash::Hash, io::Read, path::Path, str::FromStr};

use anyhow::Result;
use frost_secp256k1_tr::Identifier;
#[cfg(feature = "with-serde")]
use serde::{Deserialize, Serialize};
use url::Url;

/// Bitcoin network.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
#[cfg_attr(feature = "with-serde", derive(serde::Serialize, serde::Deserialize))]
pub enum BitcoinNetwork {
    /// Mainnet.
    Mainnet,

    /// Regtest.
    Regtest,

    /// Signet.
    Signet,

    /// Testnet.
    Testnet,
}

impl BitcoinNetwork {
    /// Converts the BitcoinNetwork to a bitcoin::Network.
    ///
    /// This function is only available if the `bitcoin-conversion` feature is enabled.
    #[cfg(feature = "bitcoin-conversion")]
    pub fn as_bitcoin_network(&self) -> bitcoin::Network {
        match self {
            BitcoinNetwork::Mainnet => bitcoin::Network::Bitcoin,
            BitcoinNetwork::Regtest => bitcoin::Network::Regtest,
            BitcoinNetwork::Signet => bitcoin::Network::Signet,
            BitcoinNetwork::Testnet => bitcoin::Network::Testnet,
        }
    }
}

/// Spark operator configuration.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "with-serde", derive(serde::Serialize, serde::Deserialize))]
pub struct SparkOperatorConfig {
    id: u32,

    base_url: String,

    identity_public_key: String,

    frost_identifier: Identifier,

    running_authority: String,

    #[cfg_attr(feature = "with-serde", serde(default))]
    is_coordinator: Option<bool>,
}

impl SparkOperatorConfig {
    /// Gets the base URL for the Spark operator.
    pub fn base_url(&self) -> &str {
        &self.base_url
    }

    /// Gets the identity public key for the Spark operator.
    pub fn identity_public_key(&self) -> &str {
        &self.identity_public_key
    }

    /// Gets the running authority for the Spark operator.
    pub fn running_authority(&self) -> &str {
        &self.running_authority
    }

    /// Gets the Frost identifier for the Spark operator.
    pub fn frost_identifier(&self) -> &Identifier {
        &self.frost_identifier
    }
}

/// Spark Service Provider configuration.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "with-serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ServiceProviderConfig {
    base_url: String,

    schema_endpoint: String,

    identity_public_key: String,

    running_authority: String,
}

impl ServiceProviderConfig {
    /// Gets the endpoint for the Service Provider.
    pub fn endpoint(&self) -> Url {
        self.force_url()
    }

    /// Gets the identity public key for the Service Provider.
    pub fn identity_public_key(&self) -> String {
        self.identity_public_key.clone()
    }

    /// Gets the running authority for the Service Provider.
    pub fn running_authority(&self) -> String {
        self.running_authority.clone()
    }

    fn force_url(&self) -> Url {
        Url::parse(&format!("{}/{}", self.base_url, self.schema_endpoint)).unwrap()
    }
}

/// Mempool configuration.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "with-serde", derive(serde::Serialize, serde::Deserialize))]
pub struct MempoolConfig {
    base_url: String,
    username: String,
    password: String,
}

impl MempoolConfig {
    /// Gets the base URL for Mempool.
    pub fn base_url(&self) -> &str {
        &self.base_url
    }

    /// Gets the username for Mempool authentication.
    pub fn username(&self) -> &str {
        &self.username
    }

    /// Gets the password for Mempool authentication.
    pub fn password(&self) -> &str {
        &self.password
    }
}

/// Electrs configuration.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "with-serde", derive(serde::Serialize, serde::Deserialize))]
pub struct ElectrsConfig {
    base_url: String,
    username: String,
    password: String,
}

impl ElectrsConfig {
    /// Gets the base URL for Electrs.
    pub fn base_url(&self) -> &str {
        &self.base_url
    }

    /// Gets the username for Electrs authentication.
    pub fn username(&self) -> &str {
        &self.username
    }

    /// Gets the password for Electrs authentication.
    pub fn password(&self) -> &str {
        &self.password
    }
}

/// LRC20 Node configuration.
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "with-serde", derive(serde::Serialize, serde::Deserialize))]
pub struct Lrc20NodeConfig {
    base_url: String,
}

impl Lrc20NodeConfig {
    /// Gets the base URL for the LRC20 Node.
    pub fn base_url(&self) -> &str {
        &self.base_url
    }
}

/// Spark configuration.
#[cfg_attr(
    feature = "with-serde",
    derive(Debug, PartialEq, Serialize, Deserialize)
)]
pub struct SparkConfig<K: Clone + Eq + Hash + Ord + FromStr + ToString>
where
    <K as FromStr>::Err: std::fmt::Debug,
{
    bitcoin_network: BitcoinNetwork,

    operators: Vec<SparkOperatorConfig>,
    ssp_pool: BTreeMap<K, ServiceProviderConfig>,

    electrs: Option<ElectrsConfig>,

    lrc20_node: Option<Lrc20NodeConfig>,

    mempool: Option<MempoolConfig>,
}

impl<K: Clone + Eq + Hash + Ord + FromStr + ToString> SparkConfig<K>
where
    <K as FromStr>::Err: std::fmt::Debug,
{
    /// Create a new Spark config.
    fn new(
        bitcoin_network: BitcoinNetwork,
        mempool: Option<MempoolConfig>,
        electrs: Option<ElectrsConfig>,
        lrc20_node: Option<Lrc20NodeConfig>,
        ssp_pool: BTreeMap<K, ServiceProviderConfig>,
        operators: Vec<SparkOperatorConfig>,
    ) -> Self {
        Self {
            bitcoin_network,
            mempool,
            electrs,
            lrc20_node,
            ssp_pool,
            operators,
        }
    }

    /// Parses Spark config from TOML file.
    #[cfg(feature = "with-serde")]
    pub fn from_toml_file(path: &str) -> Result<Self> {
        // Check if path is absolute
        let config_path = if Path::new(path).is_absolute() {
            path.to_string()
        } else {
            // If relative, try to use from HOME directory first
            let home_dir = std::env::var("HOME").unwrap_or_else(|_| ".".to_string());
            format!("{}/{}", home_dir, path)
        };

        let mut file = File::open(&config_path)
            .map_err(|_| anyhow::anyhow!("Failed to open config file at {}", config_path))?;

        let mut contents = String::new();
        file.read_to_string(&mut contents)
            .map_err(|e| anyhow::anyhow!("Failed to read config file: {}", e))?;

        #[derive(Deserialize)]
        struct RawConfig {
            bitcoin_network: BitcoinNetwork,
            operators: Vec<SparkOperatorConfig>,
            ssp_pool: BTreeMap<String, ServiceProviderConfig>,
            mempool: Option<MempoolConfig>,
            electrs: Option<ElectrsConfig>,
            lrc20_node: Option<Lrc20NodeConfig>,
        }

        let raw_config: RawConfig = toml::from_str(&contents).expect("Failed to parse config");

        // Validate the operators
        for operator in &raw_config.operators {
            if operator.identity_public_key.len() != 66 {
                // Public keys are typically 33 bytes, represented as 66 hex characters.
                anyhow::bail!(
                    "Invalid identity public key length for operator {}: Expected 66 hex \
                     characters, found {}",
                    operator.id,
                    operator.identity_public_key.len()
                );
            }
            // TODO: Add base_url validation for operators if needed
        }

        // Parse and validate the SSP pool
        let mut ssp_pool = BTreeMap::new();
        for (key_str, value) in raw_config.ssp_pool {
            // Validate URL
            let base_url = value.base_url.trim();
            let schema_endpoint = value.schema_endpoint.trim();
            let full_url_str = format!("{}/{}", base_url, schema_endpoint);
            if Url::parse(&full_url_str).is_err() {
                panic!(
                    "Invalid URL combination for SSP {}: {}",
                    key_str, full_url_str
                );
            }

            // Validate identity public key length
            if value.identity_public_key.len() != 66 {
                // Public keys are typically 33 bytes, represented as 66 hex characters.
                panic!(
                    "Invalid identity public key length for SSP {}: Expected 66 hex characters, \
                     found {}",
                    key_str,
                    value.identity_public_key.len()
                );
            }

            let key: K = key_str
                .parse()
                .expect(&format!("Failed to parse key: {}", key_str));
            // Use the validated value (original value, not the trimmed copies)
            ssp_pool.insert(key, value);
        }
        if ssp_pool.is_empty() {
            tracing::warn!(
                "No Service Provider configuration found. With the current config, you cannot use \
                 Spark for Lightning or swaps. This can introduce functionality issues."
            );
        }

        Ok(Self::new(
            raw_config.bitcoin_network,
            raw_config.mempool,
            raw_config.electrs,
            raw_config.lrc20_node,
            ssp_pool,
            raw_config.operators,
        ))
    }

    /// Get Spark operators.
    pub fn operators(&self) -> &Vec<SparkOperatorConfig> {
        &self.operators
    }

    /// Get Bitcoin network.
    pub fn bitcoin_network(&self) -> BitcoinNetwork {
        self.bitcoin_network
    }

    /// Get Mempool base URL.
    pub fn mempool_base_url(&self) -> Option<&str> {
        self.mempool.as_ref().map(|config| config.base_url())
    }

    /// Get Mempool username.
    pub fn mempool_username(&self) -> Option<&str> {
        self.mempool.as_ref().map(|config| config.username())
    }

    /// Get Mempool password.
    pub fn mempool_password(&self) -> Option<&str> {
        self.mempool.as_ref().map(|config| config.password())
    }

    /// Get Mempool authentication.
    pub fn mempool_auth(&self) -> Option<(&str, &str)> {
        if let Some(config) = &self.mempool {
            Some((config.username(), config.password()))
        } else {
            None
        }
    }

    /// Get Electrs base URL.
    pub fn electrs_base_url(&self) -> Option<&str> {
        self.electrs.as_ref().map(|config| config.base_url())
    }

    /// Get Electrs authentication.
    pub fn electrs_auth(&self) -> Option<(&str, &str)> {
        if let Some(config) = &self.electrs {
            Some((config.username(), config.password()))
        } else {
            None
        }
    }

    /// Get Bitcoin base URL (alias for electrs_base_url).
    pub fn bitcoin_base_url(&self) -> Option<&str> {
        self.electrs_base_url()
    }

    /// Get LRC20 Node base URL.
    pub fn lrc20_node_url(&self) -> Option<&str> {
        self.lrc20_node.as_ref().map(|config| config.base_url())
    }

    /// Returns the endpoint for the SSP for the given key.
    pub fn ssp_endpoint(&self, key: &K) -> Option<Url> {
        self.ssp_pool.get(key).map(|ssp| ssp.endpoint())
    }

    /// Returns the coordinator operator config, if one is designated.
    pub fn coordinator_operator(&self) -> Option<&SparkOperatorConfig> {
        self.operators
            .iter()
            .find(|op| op.is_coordinator == Some(true))
    }
}