quorum-sdk 0.1.0

Official Rust SDK for Quorum routing intelligence on Solana
Documentation
#[derive(Debug)]
pub enum QuorumError {
    Http(reqwest::Error),
    Api { status: u16, message: String },
    Serialization(String),
    InvalidResponse(String),
    UrlParse(String),
    MaxRetriesExceeded {
        attempts: usize,
        last_error: String,
    },
    WebSocket(String),
}

impl std::fmt::Display for QuorumError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let msg = match self {
            QuorumError::Http(e) => {
                let clean = crate::utils::sanitize_text(&e.to_string());
                format!("network request to Quorum API failed: {clean}")
            }
            QuorumError::Api { status, message } => {
                let clean = crate::utils::sanitize_text(message);
                format!("Quorum API returned status {status}: {clean}")
            }
            QuorumError::Serialization(e) => {
                format!("failed to serialize transaction: {e}")
            }
            QuorumError::InvalidResponse(e) => {
                let clean = crate::utils::sanitize_text(e);
                format!("could not parse Quorum API response: {clean}")
            }
            QuorumError::UrlParse(e) => {
                let clean = crate::utils::sanitize_text(e);
                format!("invalid endpoint URL: {clean}")
            }
            QuorumError::MaxRetriesExceeded { attempts, last_error } => {
                let clean = crate::utils::sanitize_text(last_error);
                format!("max retries ({attempts}) exceeded: {clean}")
            }
            QuorumError::WebSocket(e) => {
                let clean = crate::utils::sanitize_text(e);
                format!("WebSocket error: {clean}")
            }
        };
        f.write_str(&msg)
    }
}

impl std::error::Error for QuorumError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            QuorumError::Http(e) => Some(e),
            _ => None,
        }
    }
}

impl From<reqwest::Error> for QuorumError {
    fn from(err: reqwest::Error) -> Self {
        QuorumError::Http(err)
    }
}