saorsa_node/payment/

verifier.rs

//! Payment verifier with LRU cache and EVM verification.
//!
//! This is the core payment verification logic for saorsa-node.
//! All new data requires EVM payment on Arbitrum (no free tier).

use crate::error::{Error, Result};
use crate::payment::cache::{VerifiedCache, XorName};
use ant_evm::ProofOfPayment;
use evmlib::Network as EvmNetwork;
use tracing::{debug, info, warn};

/// Configuration for EVM payment verification.
#[derive(Debug, Clone)]
pub struct EvmVerifierConfig {
    /// EVM network to use (Arbitrum One, Arbitrum Sepolia, etc.)
    pub network: EvmNetwork,
    /// Whether EVM verification is enabled.
    pub enabled: bool,
}

impl Default for EvmVerifierConfig {
    fn default() -> Self {
        Self {
            network: EvmNetwork::ArbitrumOne,
            enabled: true,
        }
    }
}

/// Configuration for the payment verifier.
///
/// All new data requires EVM payment on Arbitrum. The cache stores
/// previously verified payments to avoid redundant on-chain lookups.
#[derive(Debug, Clone)]
pub struct PaymentVerifierConfig {
    /// EVM verifier configuration.
    pub evm: EvmVerifierConfig,
    /// Cache capacity (number of `XorName` values to cache).
    pub cache_capacity: usize,
}

impl Default for PaymentVerifierConfig {
    fn default() -> Self {
        Self {
            evm: EvmVerifierConfig::default(),
            cache_capacity: 100_000,
        }
    }
}

/// Status returned by payment verification.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PaymentStatus {
    /// Data was found in local cache - previously paid.
    CachedAsVerified,
    /// New data - payment required.
    PaymentRequired,
    /// Payment was provided and verified.
    PaymentVerified,
}

impl PaymentStatus {
    /// Returns true if the data can be stored (cached or payment verified).
    #[must_use]
    pub fn can_store(&self) -> bool {
        matches!(self, Self::CachedAsVerified | Self::PaymentVerified)
    }

    /// Returns true if this status indicates the data was already paid for.
    #[must_use]
    pub fn is_cached(&self) -> bool {
        matches!(self, Self::CachedAsVerified)
    }
}

/// Main payment verifier for saorsa-node.
///
/// Uses:
/// 1. LRU cache for fast lookups of previously verified `XorName` values
/// 2. EVM payment verification for new data (always required)
pub struct PaymentVerifier {
    /// LRU cache of verified `XorName` values.
    cache: VerifiedCache,
    /// Configuration.
    config: PaymentVerifierConfig,
}

impl PaymentVerifier {
    /// Create a new payment verifier.
    #[must_use]
    pub fn new(config: PaymentVerifierConfig) -> Self {
        let cache = VerifiedCache::with_capacity(config.cache_capacity);

        info!(
            "Payment verifier initialized (cache_capacity={}, evm_enabled={})",
            config.cache_capacity, config.evm.enabled
        );

        Self { cache, config }
    }

    /// Check if payment is required for the given `XorName`.
    ///
    /// This is the main entry point for payment verification:
    /// 1. Check LRU cache (fast path)
    /// 2. If not cached, payment is required
    ///
    /// # Arguments
    ///
    /// * `xorname` - The content-addressed name of the data
    ///
    /// # Returns
    ///
    /// * `PaymentStatus::CachedAsVerified` - Found in local cache (previously paid)
    /// * `PaymentStatus::PaymentRequired` - Not cached (payment required)
    pub fn check_payment_required(&self, xorname: &XorName) -> PaymentStatus {
        // Check LRU cache (fast path)
        if self.cache.contains(xorname) {
            debug!("Data {} found in verified cache", hex::encode(xorname));
            return PaymentStatus::CachedAsVerified;
        }

        // Not in cache - payment required
        debug!(
            "Data {} not in cache - payment required",
            hex::encode(xorname)
        );
        PaymentStatus::PaymentRequired
    }

    /// Verify that a PUT request has valid payment.
    ///
    /// This is the complete payment verification flow:
    /// 1. Check if data is in cache (previously paid)
    /// 2. If not, verify the provided payment proof
    ///
    /// # Arguments
    ///
    /// * `xorname` - The content-addressed name of the data
    /// * `payment_proof` - Optional payment proof (required if not in cache)
    ///
    /// # Returns
    ///
    /// * `Ok(PaymentStatus)` - Verification succeeded
    /// * `Err(Error::Payment)` - No payment and not cached, or payment invalid
    ///
    /// # Errors
    ///
    /// Returns an error if payment is required but not provided, or if payment is invalid.
    pub async fn verify_payment(
        &self,
        xorname: &XorName,
        payment_proof: Option<&[u8]>,
    ) -> Result<PaymentStatus> {
        // First check if payment is required
        let status = self.check_payment_required(xorname);

        match status {
            PaymentStatus::CachedAsVerified => {
                // No payment needed - already in cache
                Ok(status)
            }
            PaymentStatus::PaymentRequired => {
                // Payment is required - verify the proof
                match payment_proof {
                    Some(proof) => {
                        if proof.is_empty() {
                            return Err(Error::Payment("Empty payment proof".to_string()));
                        }

                        // Deserialize the ProofOfPayment
                        let payment: ProofOfPayment =
                            rmp_serde::from_slice(proof).map_err(|e| {
                                Error::Payment(format!("Failed to deserialize payment proof: {e}"))
                            })?;

                        // Verify the payment using EVM
                        self.verify_evm_payment(xorname, &payment).await?;

                        // Cache the verified xorname
                        self.cache.insert(*xorname);

                        Ok(PaymentStatus::PaymentVerified)
                    }
                    None => {
                        // No payment provided
                        Err(Error::Payment(format!(
                            "Payment required for new data {}",
                            hex::encode(xorname)
                        )))
                    }
                }
            }
            PaymentStatus::PaymentVerified => {
                // This shouldn't happen from check_payment_required
                Ok(status)
            }
        }
    }

    /// Get cache statistics.
    #[must_use]
    pub fn cache_stats(&self) -> crate::payment::cache::CacheStats {
        self.cache.stats()
    }

    /// Get the number of cached entries.
    #[must_use]
    pub fn cache_len(&self) -> usize {
        self.cache.len()
    }

    /// Check if EVM verification is enabled.
    #[must_use]
    pub fn evm_enabled(&self) -> bool {
        self.config.evm.enabled
    }

    /// Verify an EVM payment proof.
    ///
    /// This verifies that:
    /// 1. All quote signatures are valid
    /// 2. The payment was made on-chain
    async fn verify_evm_payment(&self, xorname: &XorName, payment: &ProofOfPayment) -> Result<()> {
        debug!(
            "Verifying EVM payment for {} with {} quotes",
            hex::encode(xorname),
            payment.peer_quotes.len()
        );

        // Skip EVM verification if disabled
        if !self.config.evm.enabled {
            warn!("EVM verification disabled - accepting payment without on-chain check");
            return Ok(());
        }

        // Verify quote signatures first (doesn't require network)
        for (encoded_peer_id, quote) in &payment.peer_quotes {
            let peer_id = encoded_peer_id
                .to_peer_id()
                .map_err(|e| Error::Payment(format!("Invalid peer ID in payment proof: {e}")))?;

            if !quote.check_is_signed_by_claimed_peer(peer_id) {
                return Err(Error::Payment(format!(
                    "Quote signature invalid for peer {peer_id}"
                )));
            }
        }

        // Get the payment digest for on-chain verification
        let payment_digest = payment.digest();

        if payment_digest.is_empty() {
            return Err(Error::Payment("Payment has no quotes".to_string()));
        }

        // Verify on-chain payment
        // Note: We pass empty owned_quote_hashes because we're not a node claiming payment,
        // we just want to verify the payment is valid
        let owned_quote_hashes = vec![];
        match evmlib::contract::payment_vault::verify_data_payment(
            &self.config.evm.network,
            owned_quote_hashes,
            payment_digest,
        )
        .await
        {
            Ok(_amount) => {
                info!("EVM payment verified for {}", hex::encode(xorname));
                Ok(())
            }
            Err(evmlib::contract::payment_vault::error::Error::PaymentInvalid) => {
                Err(Error::Payment(format!(
                    "Payment verification failed on-chain for {}",
                    hex::encode(xorname)
                )))
            }
            Err(e) => Err(Error::Payment(format!(
                "EVM verification error for {}: {e}",
                hex::encode(xorname)
            ))),
        }
    }
}

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

    fn create_test_verifier() -> PaymentVerifier {
        let config = PaymentVerifierConfig {
            evm: EvmVerifierConfig {
                enabled: false, // Disabled for tests
                ..Default::default()
            },
            cache_capacity: 100,
        };
        PaymentVerifier::new(config)
    }

    #[test]
    fn test_payment_required_for_new_data() {
        let verifier = create_test_verifier();
        let xorname = [1u8; 32];

        // All uncached data requires payment
        let status = verifier.check_payment_required(&xorname);
        assert_eq!(status, PaymentStatus::PaymentRequired);
    }

    #[test]
    fn test_cache_hit() {
        let verifier = create_test_verifier();
        let xorname = [1u8; 32];

        // Manually add to cache
        verifier.cache.insert(xorname);

        // Should return CachedAsVerified
        let status = verifier.check_payment_required(&xorname);
        assert_eq!(status, PaymentStatus::CachedAsVerified);
    }

    #[tokio::test]
    async fn test_verify_payment_without_proof() {
        let verifier = create_test_verifier();
        let xorname = [1u8; 32];

        // Should fail without payment proof
        let result = verifier.verify_payment(&xorname, None).await;
        assert!(result.is_err());
    }

    #[tokio::test]
    async fn test_verify_payment_with_proof() {
        let verifier = create_test_verifier();
        let xorname = [1u8; 32];

        // Create a valid (but empty) ProofOfPayment
        let proof = ProofOfPayment {
            peer_quotes: vec![],
        };
        let proof_bytes = rmp_serde::to_vec(&proof).expect("should serialize");

        // Should succeed with a valid proof when EVM verification is disabled
        // Note: With EVM verification disabled, even empty proofs pass
        let result = verifier.verify_payment(&xorname, Some(&proof_bytes)).await;
        assert!(result.is_ok(), "Expected Ok, got: {result:?}");
        assert_eq!(result.expect("verified"), PaymentStatus::PaymentVerified);
    }

    #[tokio::test]
    async fn test_verify_payment_cached() {
        let verifier = create_test_verifier();
        let xorname = [1u8; 32];

        // Add to cache
        verifier.cache.insert(xorname);

        // Should succeed without payment (cached)
        let result = verifier.verify_payment(&xorname, None).await;
        assert!(result.is_ok());
        assert_eq!(result.expect("cached"), PaymentStatus::CachedAsVerified);
    }

    #[test]
    fn test_payment_status_can_store() {
        assert!(PaymentStatus::CachedAsVerified.can_store());
        assert!(PaymentStatus::PaymentVerified.can_store());
        assert!(!PaymentStatus::PaymentRequired.can_store());
    }

    #[test]
    fn test_payment_status_is_cached() {
        assert!(PaymentStatus::CachedAsVerified.is_cached());
        assert!(!PaymentStatus::PaymentVerified.is_cached());
        assert!(!PaymentStatus::PaymentRequired.is_cached());
    }
}