spark_rust/

error.rs

use bitcoin::secp256k1;
use lightning_invoice::ParseOrSemanticError;
use std::io;
use thiserror::Error;
use tonic::codegen::http::uri::InvalidUri;

// Re-export all errors from subcategories defined below
pub use self::crypto::CryptoError;
pub use self::internal::InternalError;
pub use self::io_error::IoError;
pub use self::network::NetworkError;
pub use self::transaction::TransactionError;
pub use self::validation::ValidationError;
pub use self::wallet::WalletError;

/// Main error enum that wraps all subcategory errors
#[derive(Debug, Error)]
pub enum SparkSdkError {
    #[error(transparent)]
    Network(#[from] NetworkError),

    #[error(transparent)]
    Wallet(#[from] WalletError),

    #[error(transparent)]
    Crypto(#[from] CryptoError),

    #[error(transparent)]
    Validation(#[from] ValidationError),

    #[error(transparent)]
    Transaction(#[from] TransactionError),

    #[error(transparent)]
    Io(#[from] IoError),

    #[error(transparent)]
    Internal(#[from] InternalError),

    #[error("General error: {0}")]
    General(String),
}

// Network error subcategory
pub mod network {
    use super::*;

    #[derive(Debug, Error)]
    pub enum NetworkError {
        #[error("Transport error: {0}")]
        Transport(#[from] tonic::transport::Error),

        #[error("HTTP error: {0}")]
        Http(#[from] reqwest::Error),

        #[error("Status error: {0}")]
        Status(#[from] tonic::Status),

        #[error("Invalid URI: {0}")]
        InvalidUri(#[from] InvalidUri),

        #[error("Invalid URL: {url}")]
        InvalidUrl {
            url: String,
            details: Option<String>,
        },

        #[error("RPC connection error with endpoint: {uri}")]
        RpcConnection {
            uri: String,
            details: Option<String>,
        },

        #[error("Bitcoin RPC error: {0}")]
        BitcoinRpc(String),

        #[error("Invalid GraphQL operation: {0}")]
        InvalidGraphQLOperation(String),

        #[error("GraphQL error with query: {0}")]
        GraphQL(String),

        #[error("GraphQL request failed: {status_code}")]
        GraphQLRequestFailed { status_code: u16 },

        #[error("Faucet request failed with status: {status_code}")]
        FaucetRequestFailed { status_code: u16 },

        #[error("Invalid response from server")]
        InvalidResponse,
    }
}

// Wallet error subcategory
pub mod wallet {
    use super::*;

    #[derive(Debug, Error)]
    pub enum WalletError {
        #[error("No leaves found for wallet")]
        NoLeavesFound,

        #[error("No leaf with exact amount")]
        NoLeafWithExactAmount,

        #[error("Leaf selection failed: insufficient funds")]
        LeafSelectionInsufficientFunds,

        #[error("Leaf selection failed: no suitable leaves available")]
        LeafSelectionNoSuitableLeaves,

        #[error("Leaf not found with id: {0}")]
        LeafNotFound(String),

        #[error("Leaf is not Bitcoin type: {leaf_id}")]
        LeafIsNotBitcoin { leaf_id: String },

        #[error("Leaf already exists in wallet: {leaf_id}")]
        LeafAlreadyExistsInWallet { leaf_id: String },

        #[error("Leaf not available for use: {leaf_id}")]
        LeafNotAvailableForUse { leaf_id: String },

        #[error("Leaf not using expected lock. Expected: {expected}, Found: {actual}")]
        LeafNotUsingExpectedLock { expected: String, actual: String },

        #[error("Leaf not found in wallet: {leaf_id}")]
        LeafNotFoundInWallet { leaf_id: String },

        #[error("Invalid account: {account_id}")]
        InvalidAccount { account_id: String },

        #[error("Cooperative exit failed: {reason}")]
        CooperativeExit { reason: String },
    }
}

// Crypto error subcategory
pub mod crypto {
    use super::*;

    #[derive(Debug, Error)]
    pub enum CryptoError {
        #[error("Signature error: {0}")]
        Secp256k1(#[from] secp256k1::Error),

        #[error("FROST signing failed with job id: {job_id}")]
        FrostSigning { job_id: String },

        #[error("FROST aggregation failed")]
        FrostAggregation,

        #[error("Invalid hash: {hash}")]
        InvalidHash { hash: String },

        #[error("Decryption failed")]
        Decryption,

        #[error("Secret key not found for public key: {public_key}")]
        SecretKeyNotFound { public_key: String },

        #[error("Missing keyshare information")]
        MissingKeyshareInfo,

        #[error("Could not find FROST signature with job id: {job_id}")]
        FrostSignatureNotFound { job_id: String },

        #[error("Invalid key type: {key_type}")]
        InvalidKeyType { key_type: String },

        #[error("Invalid seed")]
        InvalidSeed,

        #[error("Child key derivation failed with path: {derivation_path}")]
        ChildKeyDerivationError { derivation_path: String },

        #[error("Missing root node signature shares")]
        MissingRootNodeSignatureShares,

        #[error("Invalid crypto input: {field}")]
        InvalidInput { field: String },
    }
}

// Validation error subcategory
pub mod validation {
    use super::*;

    #[derive(Debug, Error)]
    pub enum ValidationError {
        #[error("Invalid configuration: {parameter}")]
        Config { parameter: String },

        #[error("Invalid input: {field}")]
        InvalidInput { field: String },

        #[error("Invalid argument: {argument}")]
        InvalidArgument { argument: String },

        #[error("Invalid address: {address}")]
        InvalidAddress { address: String },

        #[error("Deposit address validation failed: {address}")]
        DepositAddressValidationFailed { address: String },

        #[error("Deposit transaction not found in network: {txid}")]
        DepositTransactionNotFoundInNetwork { txid: String },

        #[error("Invalid keyshare config with id: {config_id}")]
        InvalidKeyshareConfig { config_id: String },

        #[error("Invalid sequence number: {sequence}")]
        InvalidSequence { sequence: u64 },

        #[error("Invalid UUID: {0}")]
        InvalidUuid(#[from] uuid::Error),

        #[error("Invalid Bolt11 invoice: {0}")]
        InvalidBolt11Invoice(String),

        #[cfg(feature = "integration-tests")]
        #[error("Transfer claim did not update balance")]
        TransferClaimDidNotUpdateBalance,
    }
}

// Transaction error subcategory
pub mod transaction {
    use super::*;

    #[derive(Debug, Error)]
    pub enum TransactionError {
        #[error("Transfer failed: {reason}")]
        Transfer { reason: String },

        #[error("Invalid bitcoin transaction: {0}")]
        InvalidBitcoinTransaction(String),

        #[error("Invalid token transaction: {0}")]
        InvalidTokenTransaction(String),

        #[error("Invalid deposit transaction: {0}")]
        InvalidDepositTx(String),
    }
}

// IO error subcategory
pub mod io_error {

    use super::*;

    #[derive(Debug, Error)]
    pub enum IoError {
        #[error("IO error: {0}")]
        Io(#[from] io::Error),

        #[error("JSON serialization error: {0}")]
        SerdeJson(#[from] serde_json::Error),

        #[error("Hex decoding error: {0}")]
        Decoding(#[from] hex::FromHexError),

        #[error("Bolt11 invoice decoding error: {0}")]
        Bolt11InvoiceDecoding(String),
    }
}

// Internal error subcategory
pub mod internal {
    use super::*;

    #[derive(Debug, Error)]
    pub enum InternalError {
        #[error("Initialization failed: {component}")]
        Initialization { component: String },

        #[error("Tree creation failed: {reason}")]
        TreeCreation { reason: String },

        #[error("Test database query error: {query}")]
        TestDatabaseQuery { query: String },

        #[error("Async task failed: {task}")]
        AsyncTask { task: String },
    }
}

// Implement From traits for common conversions
impl From<String> for SparkSdkError {
    fn from(s: String) -> Self {
        Self::General(s)
    }
}

impl From<&str> for SparkSdkError {
    fn from(s: &str) -> Self {
        Self::General(s.to_string())
    }
}

// Add direct conversion from tonic transport errors
impl From<tonic::transport::Error> for SparkSdkError {
    fn from(err: tonic::transport::Error) -> Self {
        Self::Network(NetworkError::Transport(err))
    }
}

// Add direct conversion from secp256k1 errors
impl From<secp256k1::Error> for SparkSdkError {
    fn from(err: secp256k1::Error) -> Self {
        Self::Crypto(CryptoError::Secp256k1(err))
    }
}

// Add manual conversion from ParseOrSemanticError
impl From<ParseOrSemanticError> for IoError {
    fn from(err: ParseOrSemanticError) -> Self {
        Self::Bolt11InvoiceDecoding(err.to_string())
    }
}