proofgate 0.1.1

//! Type definitions for ProofGate SDK.

use serde::{Deserialize, Serialize};

/// Request for transaction validation.
#[derive(Debug, Clone, Serialize)]
pub struct ValidateRequest {
    /// Sender address (your agent's wallet)
    #[serde(rename = "from")]
    pub from: String,
    /// Target contract address
    pub to: String,
    /// Transaction calldata
    pub data: String,
    /// Value in wei (default: "0")
    #[serde(skip_serializing_if = "Option::is_none")]
    pub value: Option<String>,
    /// Guardrail ID (overrides default)
    #[serde(rename = "guardrailId", skip_serializing_if = "Option::is_none")]
    pub guardrail_id: Option<String>,
    /// Chain ID (overrides default)
    #[serde(rename = "chainId", skip_serializing_if = "Option::is_none")]
    pub chain_id: Option<u64>,
}

/// Individual check result from validation.
#[derive(Debug, Clone, Deserialize)]
pub struct ValidationCheck {
    /// Check name (e.g., "allowed_contracts", "daily_limit")
    pub name: String,
    /// Did this check pass?
    pub passed: bool,
    /// Human-readable details
    pub details: String,
    /// Severity level
    pub severity: Severity,
}

/// Severity level for validation checks.
#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum Severity {
    Info,
    Warning,
    Critical,
}

/// Validation result status.
#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "UPPERCASE")]
pub enum ValidationResult {
    Pass,
    Fail,
    Pending,
}

/// Response from transaction validation.
#[derive(Debug, Clone, Deserialize)]
pub struct ValidateResponse {
    /// Unique validation ID
    #[serde(rename = "validationId")]
    pub validation_id: String,
    /// Validation result
    pub result: ValidationResult,
    /// Human-readable reason
    pub reason: String,
    /// Evidence URI
    #[serde(rename = "evidenceUri")]
    pub evidence_uri: String,
    /// Is the transaction safe to execute?
    pub safe: bool,
    /// Detailed check results
    #[serde(default)]
    pub checks: Vec<ValidationCheck>,
    /// Chain ID validated on
    #[serde(rename = "chainId")]
    pub chain_id: u64,
    /// Was API key authenticated?
    #[serde(default)]
    pub authenticated: bool,
    /// User tier (free/pro)
    #[serde(default)]
    pub tier: String,
    /// Backend used (local/evidence-service)
    #[serde(default)]
    pub backend: String,
    /// Was proof recorded on-chain?
    #[serde(rename = "onChainRecorded", default)]
    pub on_chain_recorded: bool,
}

/// Validation statistics for an agent.
#[derive(Debug, Clone, Deserialize)]
pub struct AgentStats {
    /// Total number of validations
    #[serde(rename = "totalValidations")]
    pub total_validations: u64,
    /// Passed validations
    #[serde(rename = "passedValidations")]
    pub passed_validations: u64,
    /// Failed validations
    #[serde(rename = "failedValidations")]
    pub failed_validations: u64,
    /// Pass rate percentage
    #[serde(rename = "passRate")]
    pub pass_rate: f64,
}

/// Registration info for an agent.
#[derive(Debug, Clone, Deserialize)]
pub struct AgentRegistration {
    /// Agent name
    pub name: Option<String>,
    /// Registration timestamp
    #[serde(rename = "registeredAt")]
    pub registered_at: String,
}

/// Verification status for an agent.
#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum VerificationStatus {
    Verified,
    Registered,
    Unverified,
    Unknown,
}

/// Trust tier for an agent.
#[derive(Debug, Clone, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum TrustTier {
    Diamond,
    Gold,
    Silver,
    Bronze,
    Unverified,
}

/// Response from agent check.
#[derive(Debug, Clone, Deserialize)]
pub struct AgentCheckResponse {
    /// Wallet address (lowercase)
    pub wallet: String,
    /// Is this agent registered?
    #[serde(rename = "isRegistered")]
    pub is_registered: bool,
    /// Verification status
    #[serde(rename = "verificationStatus")]
    pub verification_status: VerificationStatus,
    /// Human-readable message
    #[serde(rename = "verificationMessage")]
    pub verification_message: String,
    /// Trust score (0-100)
    #[serde(rename = "trustScore")]
    pub trust_score: u8,
    /// Trust tier
    pub tier: TrustTier,
    /// Tier emoji
    #[serde(rename = "tierEmoji")]
    pub tier_emoji: String,
    /// Tier display name
    #[serde(rename = "tierName")]
    pub tier_name: String,
    /// Validation statistics
    pub stats: AgentStats,
    /// Registration info (if registered)
    pub registration: Option<AgentRegistration>,
    /// Safety recommendation
    pub recommendation: String,
}

/// Transaction details in evidence.
#[derive(Debug, Clone, Deserialize)]
pub struct EvidenceTransaction {
    /// Sender address
    #[serde(rename = "from")]
    pub from: String,
    /// Target address
    pub to: String,
    /// Transaction data
    pub data: String,
    /// Transaction value
    pub value: String,
}

/// Validation result in evidence.
#[derive(Debug, Clone, Deserialize)]
pub struct EvidenceResult {
    /// Validation status
    pub status: ValidationResult,
    /// Reason
    pub reason: String,
    /// Is safe
    pub safe: bool,
}

/// Agent info in evidence.
#[derive(Debug, Clone, Deserialize)]
pub struct EvidenceAgent {
    /// Agent wallet
    pub wallet: String,
    /// Agent name
    pub name: Option<String>,
    /// Is verified
    pub verified: bool,
}

/// Proof metadata in evidence.
#[derive(Debug, Clone, Deserialize)]
pub struct EvidenceProof {
    /// Was authenticated
    pub authenticated: bool,
    /// Was recorded on-chain
    #[serde(rename = "onChainRecorded")]
    pub on_chain_recorded: bool,
    /// Batch ID
    #[serde(rename = "batchId")]
    pub batch_id: Option<String>,
    /// Recorded timestamp
    #[serde(rename = "recordedAt")]
    pub recorded_at: Option<String>,
}

/// Response from evidence retrieval.
#[derive(Debug, Clone, Deserialize)]
pub struct EvidenceResponse {
    /// Validation ID
    #[serde(rename = "validationId")]
    pub validation_id: String,
    /// Timestamp
    pub timestamp: String,
    /// Chain ID
    #[serde(rename = "chainId")]
    pub chain_id: u64,
    /// Transaction details
    pub transaction: EvidenceTransaction,
    /// Validation result
    pub result: EvidenceResult,
    /// Guardrail used
    #[serde(rename = "guardrailId")]
    pub guardrail_id: Option<String>,
    /// Agent info
    pub agent: EvidenceAgent,
    /// Proof metadata
    pub proof: EvidenceProof,
}

/// Response from usage check.
#[derive(Debug, Clone, Deserialize)]
pub struct UsageResponse {
    /// Wallet address
    pub wallet: String,
    /// User tier
    pub tier: String,
    /// Validations used this month
    pub validations_used: u64,
    /// Validations limit
    pub validations_limit: u64,
    /// Daily spent in wei
    pub daily_spent_wei: String,
}