rustchain-client 0.1.0

//! # rustchain-client
//!
//! An HTTP client for the [RustChain](https://rustchain.org) Proof-of-Antiquity blockchain API.
//!
//! RustChain is the first blockchain that rewards vintage hardware (PowerPC G4, IBM POWER8,
//! Pentium 4, etc.) for being old — not fast. This crate provides a typed Rust client for
//! querying the RustChain node API.
//!
//! ## Quick Start
//!
//! ```rust,no_run
//! use rustchain_client::RustChainClient;
//!
//! #[tokio::main]
//! async fn main() -> Result<(), rustchain_client::Error> {
//!     let client = RustChainClient::new("https://rustchain.org")?;
//!
//!     // Check node health
//!     let health = client.health().await?;
//!     println!("Node status: {}", health.status);
//!
//!     // Get current epoch
//!     let epoch = client.epoch().await?;
//!     println!("Current epoch: {}", epoch.epoch);
//!
//!     // List active miners
//!     let miners = client.miners().await?;
//!     println!("Active miners: {}", miners.len());
//!
//!     Ok(())
//! }
//! ```
//!
//! ## Features
//!
//! - Query node health, uptime, and version
//! - Get current epoch information and reward pools
//! - List active miners with hardware details and antiquity multipliers
//! - Check wallet balances
//! - Submit and query attestations
//! - List and vote on governance proposals
//! - Uses `rustls` for TLS (no OpenSSL dependency)
//! - Supports self-signed certificates (common on RustChain nodes)

use reqwest::Client;
use serde::{Deserialize, Serialize};

mod error;
pub use error::Error;

/// Response from the `/health` endpoint.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HealthResponse {
    /// Node status string (e.g., "healthy").
    pub status: String,
    /// Node uptime in seconds.
    #[serde(default)]
    pub uptime: Option<f64>,
    /// Software version.
    #[serde(default)]
    pub version: Option<String>,
    /// Number of connected peers.
    #[serde(default)]
    pub peers: Option<u32>,
    /// Current block height.
    #[serde(default)]
    pub block_height: Option<u64>,
}

/// Response from the `/epoch` endpoint.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EpochResponse {
    /// Current epoch number.
    pub epoch: u64,
    /// Epoch duration in seconds.
    #[serde(default)]
    pub duration_seconds: Option<u64>,
    /// Time remaining in current epoch.
    #[serde(default)]
    pub time_remaining: Option<f64>,
    /// Base reward pool for this epoch.
    #[serde(default)]
    pub reward_pool: Option<f64>,
    /// Number of active attestations this epoch.
    #[serde(default)]
    pub attestations: Option<u64>,
    /// Epoch start timestamp.
    #[serde(default)]
    pub started_at: Option<String>,
}

/// A single miner entry from the `/api/miners` endpoint.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Miner {
    /// Miner's wallet identifier.
    #[serde(alias = "miner_id")]
    pub wallet: String,
    /// Hardware architecture (e.g., "PowerPC G4", "x86_64").
    #[serde(default)]
    pub architecture: Option<String>,
    /// Antiquity multiplier (e.g., 2.5 for PowerPC G4).
    #[serde(default)]
    pub multiplier: Option<f64>,
    /// Whether this miner is currently active.
    #[serde(default)]
    pub active: Option<bool>,
    /// Last attestation timestamp.
    #[serde(default)]
    pub last_seen: Option<String>,
    /// Total RTC earned.
    #[serde(default)]
    pub total_earned: Option<f64>,
    /// Hardware platform string.
    #[serde(default)]
    pub platform: Option<String>,
}

/// Wallet balance response.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WalletBalance {
    /// Wallet/miner identifier.
    #[serde(alias = "miner_id")]
    pub wallet: String,
    /// Current balance in RTC.
    pub balance: f64,
    /// Total earned across all epochs.
    #[serde(default)]
    pub total_earned: Option<f64>,
    /// Total number of attestations submitted.
    #[serde(default)]
    pub attestation_count: Option<u64>,
}

/// Attestation submission payload.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AttestationSubmit {
    /// Miner wallet identifier.
    pub miner: String,
    /// Hardware fingerprint data.
    pub fingerprint: serde_json::Value,
    /// Optional nonce for uniqueness.
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub nonce: Option<String>,
}

/// Response after submitting an attestation.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AttestationResponse {
    /// Whether the attestation was accepted.
    #[serde(default)]
    pub accepted: Option<bool>,
    /// Status message.
    #[serde(default)]
    pub status: Option<String>,
    /// Error message if rejected.
    #[serde(default)]
    pub error: Option<String>,
    /// Epoch the attestation was recorded for.
    #[serde(default)]
    pub epoch: Option<u64>,
}

/// A governance proposal.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Proposal {
    /// Proposal ID.
    pub id: u64,
    /// Proposal title.
    pub title: String,
    /// Proposal description / rationale.
    #[serde(default)]
    pub description: Option<String>,
    /// Proposer wallet address.
    #[serde(default)]
    pub proposer: Option<String>,
    /// Current status (Draft, Active, Passed, Failed).
    #[serde(default)]
    pub status: Option<String>,
    /// Yes-vote weight.
    #[serde(default)]
    pub yes_weight: Option<f64>,
    /// No-vote weight.
    #[serde(default)]
    pub no_weight: Option<f64>,
    /// Creation timestamp.
    #[serde(default)]
    pub created_at: Option<String>,
}

/// Governance vote payload.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Vote {
    /// Proposal ID to vote on.
    pub proposal_id: u64,
    /// Voter wallet address.
    pub wallet: String,
    /// Vote direction ("yes" or "no").
    pub vote: String,
    /// Nonce for replay protection.
    pub nonce: String,
    /// Ed25519 public key (hex).
    pub public_key: String,
    /// Ed25519 signature (hex).
    pub signature: String,
}

/// Vote submission response.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct VoteResponse {
    /// Whether the vote was recorded.
    #[serde(default)]
    pub accepted: Option<bool>,
    /// Status message.
    #[serde(default)]
    pub status: Option<String>,
    /// Error details.
    #[serde(default)]
    pub error: Option<String>,
}

/// Agent Economy job listing.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentJob {
    /// Unique job identifier.
    pub job_id: String,
    /// Job title.
    #[serde(default)]
    pub title: Option<String>,
    /// Job description.
    #[serde(default)]
    pub description: Option<String>,
    /// RTC reward for completing this job.
    #[serde(default)]
    pub reward_rtc: Option<f64>,
    /// Job status (open, claimed, delivered, accepted).
    #[serde(default)]
    pub status: Option<String>,
    /// Job category.
    #[serde(default)]
    pub category: Option<String>,
    /// Poster agent name.
    #[serde(default)]
    pub posted_by: Option<String>,
}

/// Agent Economy jobs list response.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AgentJobsResponse {
    /// Whether the request succeeded.
    #[serde(default)]
    pub ok: Option<bool>,
    /// List of jobs.
    #[serde(default)]
    pub jobs: Vec<AgentJob>,
    /// Total count of matching jobs.
    #[serde(default)]
    pub total: Option<u64>,
    /// Available job categories.
    #[serde(default)]
    pub categories: Option<Vec<String>>,
}

/// The main RustChain API client.
///
/// # Example
///
/// ```rust,no_run
/// use rustchain_client::RustChainClient;
///
/// # async fn example() -> Result<(), rustchain_client::Error> {
/// let client = RustChainClient::new("https://rustchain.org")?;
/// let health = client.health().await?;
/// println!("{:?}", health);
/// # Ok(())
/// # }
/// ```
pub struct RustChainClient {
    base_url: String,
    http: Client,
}

impl RustChainClient {
    /// Create a new RustChain API client.
    ///
    /// # Arguments
    ///
    /// * `base_url` - The base URL of the RustChain node (e.g., `"https://rustchain.org"` or
    ///   `"https://50.28.86.131"`).
    ///
    /// Accepts self-signed certificates, which is common for RustChain nodes.
    pub fn new(base_url: &str) -> Result<Self, Error> {
        let http = Client::builder()
            .danger_accept_invalid_certs(true)
            .timeout(std::time::Duration::from_secs(30))
            .build()
            .map_err(Error::Http)?;

        Ok(Self {
            base_url: base_url.trim_end_matches('/').to_string(),
            http,
        })
    }

    /// Create a client with a custom `reqwest::Client`.
    pub fn with_client(base_url: &str, http: Client) -> Self {
        Self {
            base_url: base_url.trim_end_matches('/').to_string(),
            http,
        }
    }

    /// Check node health.
    ///
    /// Calls `GET /health`.
    pub async fn health(&self) -> Result<HealthResponse, Error> {
        let url = format!("{}/health", self.base_url);
        let resp = self.http.get(&url).send().await.map_err(Error::Http)?;
        let status = resp.status();
        if !status.is_success() {
            return Err(Error::Api {
                status: status.as_u16(),
                message: resp.text().await.unwrap_or_default(),
            });
        }
        resp.json().await.map_err(Error::Http)
    }

    /// Get current epoch information.
    ///
    /// Calls `GET /epoch`.
    pub async fn epoch(&self) -> Result<EpochResponse, Error> {
        let url = format!("{}/epoch", self.base_url);
        let resp = self.http.get(&url).send().await.map_err(Error::Http)?;
        let status = resp.status();
        if !status.is_success() {
            return Err(Error::Api {
                status: status.as_u16(),
                message: resp.text().await.unwrap_or_default(),
            });
        }
        resp.json().await.map_err(Error::Http)
    }

    /// List active miners on the network.
    ///
    /// Calls `GET /api/miners`.
    pub async fn miners(&self) -> Result<Vec<Miner>, Error> {
        let url = format!("{}/api/miners", self.base_url);
        let resp = self.http.get(&url).send().await.map_err(Error::Http)?;
        let status = resp.status();
        if !status.is_success() {
            return Err(Error::Api {
                status: status.as_u16(),
                message: resp.text().await.unwrap_or_default(),
            });
        }
        // The API may return miners as a top-level array or under a key
        let text = resp.text().await.map_err(Error::Http)?;
        // Try parsing as array first
        if let Ok(miners) = serde_json::from_str::<Vec<Miner>>(&text) {
            return Ok(miners);
        }
        // Try as object with "miners" key
        #[derive(Deserialize)]
        struct Wrapper {
            miners: Vec<Miner>,
        }
        let wrapper: Wrapper = serde_json::from_str(&text).map_err(Error::Json)?;
        Ok(wrapper.miners)
    }

    /// Check a wallet's RTC balance.
    ///
    /// Calls `GET /wallet/balance?miner_id={wallet}`.
    pub async fn wallet_balance(&self, wallet: &str) -> Result<WalletBalance, Error> {
        let url = format!("{}/wallet/balance?miner_id={}", self.base_url, wallet);
        let resp = self.http.get(&url).send().await.map_err(Error::Http)?;
        let status = resp.status();
        if !status.is_success() {
            return Err(Error::Api {
                status: status.as_u16(),
                message: resp.text().await.unwrap_or_default(),
            });
        }
        resp.json().await.map_err(Error::Http)
    }

    /// Submit a mining attestation.
    ///
    /// Calls `POST /attest/submit`.
    pub async fn submit_attestation(
        &self,
        attestation: &AttestationSubmit,
    ) -> Result<AttestationResponse, Error> {
        let url = format!("{}/attest/submit", self.base_url);
        let resp = self
            .http
            .post(&url)
            .json(attestation)
            .send()
            .await
            .map_err(Error::Http)?;
        let status = resp.status();
        if !status.is_success() && status.as_u16() != 429 {
            return Err(Error::Api {
                status: status.as_u16(),
                message: resp.text().await.unwrap_or_default(),
            });
        }
        resp.json().await.map_err(Error::Http)
    }

    /// List governance proposals.
    ///
    /// Calls `GET /governance/proposals`.
    pub async fn proposals(&self) -> Result<Vec<Proposal>, Error> {
        let url = format!("{}/governance/proposals", self.base_url);
        let resp = self.http.get(&url).send().await.map_err(Error::Http)?;
        let status = resp.status();
        if !status.is_success() {
            return Err(Error::Api {
                status: status.as_u16(),
                message: resp.text().await.unwrap_or_default(),
            });
        }
        let text = resp.text().await.map_err(Error::Http)?;
        if let Ok(proposals) = serde_json::from_str::<Vec<Proposal>>(&text) {
            return Ok(proposals);
        }
        #[derive(Deserialize)]
        struct Wrapper {
            proposals: Vec<Proposal>,
        }
        let wrapper: Wrapper = serde_json::from_str(&text).map_err(Error::Json)?;
        Ok(wrapper.proposals)
    }

    /// Get a single governance proposal by ID.
    ///
    /// Calls `GET /governance/proposal/{id}`.
    pub async fn proposal(&self, id: u64) -> Result<Proposal, Error> {
        let url = format!("{}/governance/proposal/{}", self.base_url, id);
        let resp = self.http.get(&url).send().await.map_err(Error::Http)?;
        let status = resp.status();
        if !status.is_success() {
            return Err(Error::Api {
                status: status.as_u16(),
                message: resp.text().await.unwrap_or_default(),
            });
        }
        resp.json().await.map_err(Error::Http)
    }

    /// Submit a governance vote.
    ///
    /// Calls `POST /governance/vote`.
    pub async fn vote(&self, vote: &Vote) -> Result<VoteResponse, Error> {
        let url = format!("{}/governance/vote", self.base_url);
        let resp = self
            .http
            .post(&url)
            .json(vote)
            .send()
            .await
            .map_err(Error::Http)?;
        let status = resp.status();
        if !status.is_success() {
            return Err(Error::Api {
                status: status.as_u16(),
                message: resp.text().await.unwrap_or_default(),
            });
        }
        resp.json().await.map_err(Error::Http)
    }

    /// List open Agent Economy jobs.
    ///
    /// Calls `GET /agent/jobs`.
    pub async fn agent_jobs(&self) -> Result<AgentJobsResponse, Error> {
        let url = format!("{}/agent/jobs", self.base_url);
        let resp = self.http.get(&url).send().await.map_err(Error::Http)?;
        let status = resp.status();
        if !status.is_success() {
            return Err(Error::Api {
                status: status.as_u16(),
                message: resp.text().await.unwrap_or_default(),
            });
        }
        resp.json().await.map_err(Error::Http)
    }

    /// Get the base URL of this client.
    pub fn base_url(&self) -> &str {
        &self.base_url
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_client_creation() {
        let client = RustChainClient::new("https://rustchain.org").unwrap();
        assert_eq!(client.base_url(), "https://rustchain.org");
    }

    #[test]
    fn test_trailing_slash_stripped() {
        let client = RustChainClient::new("https://rustchain.org/").unwrap();
        assert_eq!(client.base_url(), "https://rustchain.org");
    }

    #[test]
    fn test_health_deserialize() {
        let json = r#"{"status":"healthy","uptime":3600.5,"version":"2.2.1","peers":3}"#;
        let health: HealthResponse = serde_json::from_str(json).unwrap();
        assert_eq!(health.status, "healthy");
        assert_eq!(health.uptime, Some(3600.5));
        assert_eq!(health.version.as_deref(), Some("2.2.1"));
        assert_eq!(health.peers, Some(3));
    }

    #[test]
    fn test_epoch_deserialize() {
        let json = r#"{"epoch":42,"duration_seconds":600,"reward_pool":1.5}"#;
        let epoch: EpochResponse = serde_json::from_str(json).unwrap();
        assert_eq!(epoch.epoch, 42);
        assert_eq!(epoch.duration_seconds, Some(600));
        assert_eq!(epoch.reward_pool, Some(1.5));
    }

    #[test]
    fn test_miner_deserialize() {
        let json = r#"{"wallet":"nox-ventures","architecture":"x86_64","multiplier":1.0,"active":true}"#;
        let miner: Miner = serde_json::from_str(json).unwrap();
        assert_eq!(miner.wallet, "nox-ventures");
        assert_eq!(miner.multiplier, Some(1.0));
    }

    #[test]
    fn test_miner_alias_field() {
        let json = r#"{"miner_id":"test-wallet","architecture":"PowerPC G4","multiplier":2.5}"#;
        let miner: Miner = serde_json::from_str(json).unwrap();
        assert_eq!(miner.wallet, "test-wallet");
        assert_eq!(miner.multiplier, Some(2.5));
    }

    #[test]
    fn test_agent_job_deserialize() {
        let json = r#"{"job_id":"job_abc123","title":"Write docs","reward_rtc":5.0,"status":"open","category":"writing"}"#;
        let job: AgentJob = serde_json::from_str(json).unwrap();
        assert_eq!(job.job_id, "job_abc123");
        assert_eq!(job.reward_rtc, Some(5.0));
        assert_eq!(job.status.as_deref(), Some("open"));
    }

    #[test]
    fn test_proposal_deserialize() {
        let json = r#"{"id":1,"title":"Enable feature X","status":"Active","yes_weight":100.5,"no_weight":20.0}"#;
        let prop: Proposal = serde_json::from_str(json).unwrap();
        assert_eq!(prop.id, 1);
        assert_eq!(prop.title, "Enable feature X");
        assert_eq!(prop.yes_weight, Some(100.5));
    }
}