parser.rs

use clap::{Parser, Subcommand, ValueEnum};
use std::fmt;

#[derive(Clone, Debug, ValueEnum, Default, PartialEq, Eq)]
pub enum Network {
    #[default]
    Mainnet,
    Testnet,
    Devnet,
    Localnet,
}

impl Network {
    /// Parse a persisted network name back into a `Network`, accepting the
    /// same spellings the CLI flag does. Anything unrecognized is `None` so
    /// callers fall back to the default instead of guessing.
    pub fn from_config_str(value: &str) -> Option<Network> {
        match value.trim().to_ascii_lowercase().as_str() {
            "mainnet" => Some(Network::Mainnet),
            "testnet" => Some(Network::Testnet),
            "devnet" => Some(Network::Devnet),
            "localnet" => Some(Network::Localnet),
            _ => None,
        }
    }
}

impl fmt::Display for Network {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        let s = match self {
            Network::Mainnet => "mainnet",
            Network::Testnet => "testnet",
            Network::Devnet => "devnet",
            Network::Localnet => "localnet",
        };
        f.write_str(s)
    }
}

impl std::str::FromStr for Network {
    type Err = String;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        match s.to_lowercase().as_str() {
            "mainnet" => Ok(Network::Mainnet),
            "testnet" => Ok(Network::Testnet),
            "devnet" => Ok(Network::Devnet),
            "localnet" => Ok(Network::Localnet),
            _ => Err(format!("Unknown network: {}", s)),
        }
    }
}

#[derive(Parser)]
#[command(name = "txio")]
#[command(version = env!("CARGO_PKG_VERSION"))]
#[command(about = "txio: The Universal Multi-Chain Blockchain Terminal", long_about = None)]
pub struct Cli {
    #[command(subcommand)]
    pub command: Commands,

    /// Enable verbose output
    #[arg(short, long, global = true)]
    pub verbose: bool,

    /// Pretty print JSON output
    #[arg(short, long, global = true)]
    pub pretty: bool,

    /// Override the default RPC URL
    #[arg(long, global = true)]
    pub rpc_url: Option<String>,

    /// Select the network to use (overrides the persisted default). When
    /// omitted, the last network chosen via `switch --network` is used;
    /// with no persisted choice this defaults to Mainnet.
    #[arg(short, long, global = true, value_enum)]
    pub network: Option<Network>,

    /// Load environment overrides from an explicit file (opt-in; no upward search).
    /// Without this flag, a `./.env` in the current directory is NOT loaded.
    #[arg(long, global = true, value_name = "PATH")]
    pub env_file: Option<std::path::PathBuf>,
}

#[derive(Subcommand)]
pub enum Commands {
    /// List all supported chains
    Chains,

    /// Switch the default chain and/or the persisted default network
    Switch {
        /// Target blockchain to switch to
        chain: Option<String>,

        /// Target network to switch to (e.g. mainnet, testnet, devnet, localnet)
        #[arg(long, value_enum)]
        network: Option<Network>,
    },

    /// Login to your txio account
    Login,

    /// Logout from your txio account
    Logout,

    /// Show current CLI status (chain, network, login state, RPC health)
    Status,

    /// Manage CLI configuration key-value settings
    Config {
        #[command(subcommand)]
        action: ConfigAction,
    },

    /// Manage user profiles
    Profile {
        #[command(subcommand)]
        action: ProfileAction,
    },

    /// Manage wallets
    Wallet {
        #[command(subcommand)]
        action: WalletAction,
    },

    /// Generate shell completion scripts
    Completion { shell: clap_complete::Shell },

    /// Launch interactive console
    Console,

    /// Sui blockchain commands
    Sui {
        #[command(subcommand)]
        command: ChainCommand,
    },

    /// Ethereum blockchain commands
    #[command(alias = "eth")]
    Ethereum {
        #[command(subcommand)]
        command: ChainCommand,
    },

    /// Solana blockchain commands
    #[command(alias = "sol")]
    Solana {
        #[command(subcommand)]
        command: ChainCommand,
    },

    /// Aptos blockchain commands
    Aptos {
        #[command(subcommand)]
        command: ChainCommand,
    },

    /// Soroban/Stellar blockchain commands
    #[command(alias = "stellar")]
    Soroban {
        #[command(subcommand)]
        command: ChainCommand,
    },

    /// Database and Admin commands
    Db {
        #[command(subcommand)]
        action: DbAction,
    },
}

#[derive(Subcommand)]
pub enum ChainCommand {
    /// Call a raw RPC method
    Call {
        #[arg(short, long)]
        method: String,
        #[arg(short, long)]
        params: Option<String>,
    },
    /// Check balance for an address
    Balance { address: String },
    /// Fetch a transaction by hash or digest
    #[command(alias = "hash")]
    Tx { hash: String },
    /// Inspect an object or account by ID
    #[command(alias = "account")]
    Object { id: String },
    /// Get recent transaction history for an address
    History {
        address: String,
        /// Maximum number of transactions to return
        #[arg(short, long, default_value_t = 10)]
        limit: u32,
    },
    /// Get the current gas price / reference fee
    Gas,
    /// Get the latest block, checkpoint, or ledger (or by number)
    Block {
        /// Block number / checkpoint sequence / slot to fetch
        #[arg(short, long)]
        number: Option<u64>,
    },
}

#[derive(Subcommand)]
pub enum ConfigAction {
    /// List all configuration settings
    List,
    /// Get a specific configuration value
    Get { key: String },
    /// Set a configuration value
    Set { key: String, value: String },
    /// Remove a configuration key
    Unset { key: String },
}

#[derive(Subcommand)]
pub enum ProfileAction {
    Add,
    List,
    Remove { name: String },
}

#[derive(Subcommand)]
pub enum WalletAction {
    Import,
    List,
    New,
}

#[derive(Subcommand)]
pub enum DbAction {
    /// List all registered users
    ListUsers,
    /// Delete a user by email (admin only)
    DeleteUser { email: String },
    /// Show database statistics (users, RPC call count)
    Stats,
    /// List recent RPC call logs
    ListLogs {
        /// Maximum number of log entries to show
        #[arg(short, long, default_value_t = 20)]
        limit: u64,
    },
}