quantus_cli/cli/

mod.rs

use crate::{log_error, log_print, log_success, log_verbose};
use clap::Subcommand;
use colored::Colorize;

pub mod address_format;
pub mod batch;
pub mod block;
pub mod common;
pub mod events;
pub mod generic_call;
pub mod high_security;
pub mod metadata;
pub mod multisend;
pub mod preimage;
pub mod recovery;
pub mod reversible;
pub mod runtime;
pub mod scheduler;
pub mod send;
pub mod storage;
pub mod system;
pub mod tech_collective;
pub mod transfers;
pub mod treasury;
pub mod wallet;
pub mod wormhole;

/// Main CLI commands
#[derive(Subcommand, Debug)]
pub enum Commands {
	/// Wallet management commands
	#[command(subcommand)]
	Wallet(wallet::WalletCommands),

	/// Send tokens to another account
	Send {
		/// The recipient's account address
		#[arg(short, long)]
		to: String,

		/// Amount to send (e.g., "10", "10.5", "0.0001")
		#[arg(short, long)]
		amount: String,

		/// Wallet name to send from
		#[arg(short, long)]
		from: String,

		/// Password for the wallet (or use environment variables)
		#[arg(short, long)]
		password: Option<String>,

		/// Read password from file (for scripting)
		#[arg(long)]
		password_file: Option<String>,

		/// Optional tip amount to prioritize the transaction (e.g., "1", "0.5")
		#[arg(long)]
		tip: Option<String>,

		/// Manual nonce override (use with caution - must be exact next nonce for account)
		#[arg(long)]
		nonce: Option<u32>,
	},

	/// Batch transfer commands and configuration
	#[command(subcommand)]
	Batch(batch::BatchCommands),

	/// Reversible transfer commands
	#[command(subcommand)]
	Reversible(reversible::ReversibleCommands),

	/// High-Security commands (reversible account settings)
	#[command(subcommand)]
	HighSecurity(high_security::HighSecurityCommands),

	/// Recovery commands
	#[command(subcommand)]
	Recovery(recovery::RecoveryCommands),

	/// Scheduler commands
	#[command(subcommand)]
	Scheduler(scheduler::SchedulerCommands),

	/// Direct interaction with chain storage (Sudo required for set)
	#[command(subcommand)]
	Storage(storage::StorageCommands),

	/// Tech Collective management commands
	#[command(subcommand)]
	TechCollective(tech_collective::TechCollectiveCommands),

	/// Tech Referenda management commands (for runtime upgrade proposals)
	#[command(subcommand)]
	Preimage(preimage::PreimageCommands),

	/// Treasury management commands
	#[command(subcommand)]
	Treasury(treasury::TreasuryCommands),

	/// Privacy-preserving transfer queries via Subsquid indexer
	#[command(subcommand)]
	Transfers(transfers::TransfersCommands),

	/// Runtime management commands (requires root/sudo permissions)
	#[command(subcommand)]
	Runtime(runtime::RuntimeCommands),

	/// Generic extrinsic call - call ANY pallet function!
	Call {
		/// Pallet name (e.g., "Balances")
		#[arg(long)]
		pallet: String,

		/// Call/function name (e.g., "transfer_allow_death")
		#[arg(short, long)]
		call: String,

		/// Arguments as JSON array (e.g., '["5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY",
		/// "1000000000000"]')
		#[arg(short, long)]
		args: Option<String>,

		/// Wallet name to sign with
		#[arg(short, long)]
		from: String,

		/// Password for the wallet
		#[arg(short, long)]
		password: Option<String>,

		/// Read password from file
		#[arg(long)]
		password_file: Option<String>,

		/// Optional tip amount to prioritize the transaction
		#[arg(long)]
		tip: Option<String>,

		/// Create offline extrinsic without submitting
		#[arg(long)]
		offline: bool,

		/// Output the call as hex-encoded data only
		#[arg(long)]
		call_data_only: bool,
	},

	/// Query account balance
	Balance {
		/// Account address to query (SS58 format)
		#[arg(short, long)]
		address: String,
	},

	/// Developer utilities and testing tools
	#[command(subcommand)]
	Developer(DeveloperCommands),

	/// Query events from blocks
	Events {
		/// Block number to query events from (full support)
		#[arg(long)]
		block: Option<u32>,

		/// Block hash to query events from (full support)
		#[arg(long)]
		block_hash: Option<String>,

		/// Query events from latest block
		#[arg(long)]
		latest: bool,

		/// Query events from finalized block (full support)
		#[arg(long)]
		finalized: bool,

		/// Filter events by pallet name (e.g., "Balances")
		#[arg(long)]
		pallet: Option<String>,

		/// Show raw event data
		#[arg(long)]
		raw: bool,

		/// Disable event decoding (decoding is enabled by default)
		#[arg(long)]
		no_decode: bool,
	},

	/// Query system information
	System {
		/// Show runtime version information
		#[arg(long)]
		runtime: bool,

		/// Show metadata statistics
		#[arg(long)]
		metadata: bool,

		/// Show available JSON-RPC methods exposed by the node
		#[arg(long)]
		rpc_methods: bool,
	},

	/// Explore chain metadata and available pallets/calls
	Metadata {
		/// Skip displaying documentation for calls
		#[arg(long)]
		no_docs: bool,

		/// Show only metadata statistics
		#[arg(long)]
		stats_only: bool,

		/// Filter by specific pallet name
		#[arg(long)]
		pallet: Option<String>,
	},

	/// Show version information
	Version,

	/// Check compatibility with the connected node
	CompatibilityCheck,

	/// Block management and analysis commands
	#[command(subcommand)]
	Block(block::BlockCommands),

	/// Wormhole proof generation and verification
	#[command(subcommand)]
	Wormhole(wormhole::WormholeCommands),

	/// Send random amounts to multiple addresses (total is distributed randomly)
	Multisend {
		/// Wallet name to send from
		#[arg(short, long)]
		from: String,

		/// File containing addresses (JSON array: ["addr1", "addr2", ...])
		#[arg(long, conflicts_with = "addresses")]
		addresses_file: Option<String>,

		/// Comma-separated list of recipient addresses
		#[arg(long, value_delimiter = ',', conflicts_with = "addresses_file")]
		addresses: Option<Vec<String>>,

		/// Total amount to distribute across all recipients (e.g., "1000", "100.5")
		#[arg(long)]
		total: String,

		/// Minimum amount per recipient (e.g., "10", "1.5")
		#[arg(long)]
		min: String,

		/// Maximum amount per recipient (e.g., "100", "50.5")
		#[arg(long)]
		max: String,

		/// Password for the wallet (or use environment variables)
		#[arg(short, long)]
		password: Option<String>,

		/// Read password from file (for scripting)
		#[arg(long)]
		password_file: Option<String>,

		/// Optional tip amount to prioritize the transaction (e.g., "1", "0.5")
		#[arg(long)]
		tip: Option<String>,

		/// Skip confirmation prompt (for scripting)
		#[arg(long, short = 'y')]
		yes: bool,
	},
}

/// Developer subcommands
#[derive(Subcommand, Debug)]
pub enum DeveloperCommands {
	/// Create standard test wallets (crystal_alice, crystal_bob, crystal_charlie)
	CreateTestWallets,

	/// Build wormhole circuit binaries and copy to CLI and chain directories
	BuildCircuits {
		/// Path to qp-zk-circuits repository (default: ../qp-zk-circuits)
		#[arg(long, default_value = "../qp-zk-circuits")]
		circuits_path: String,

		/// Path to chain repository (default: ../chain)
		#[arg(long, default_value = "../chain")]
		chain_path: String,

		/// Number of leaf proofs aggregated into a single proof
		#[arg(long)]
		num_leaf_proofs: usize,

		/// Skip copying to chain directory
		#[arg(long)]
		skip_chain: bool,
	},
}

/// Execute a CLI command
pub async fn execute_command(
	command: Commands,
	node_url: &str,
	verbose: bool,
	execution_mode: common::ExecutionMode,
) -> crate::error::Result<()> {
	match command {
		Commands::Wallet(wallet_cmd) => wallet::handle_wallet_command(wallet_cmd, node_url).await,
		Commands::Send { from, to, amount, password, password_file, tip, nonce } =>
			send::handle_send_command(
				from,
				to,
				&amount,
				node_url,
				password,
				password_file,
				tip,
				nonce,
				execution_mode,
			)
			.await,
		Commands::Batch(batch_cmd) =>
			batch::handle_batch_command(batch_cmd, node_url, execution_mode).await,
		Commands::Reversible(reversible_cmd) =>
			reversible::handle_reversible_command(reversible_cmd, node_url, execution_mode).await,
		Commands::HighSecurity(hs_cmd) =>
			high_security::handle_high_security_command(hs_cmd, node_url, execution_mode).await,
		Commands::Recovery(recovery_cmd) =>
			recovery::handle_recovery_command(recovery_cmd, node_url, execution_mode).await,
		Commands::Scheduler(scheduler_cmd) =>
			scheduler::handle_scheduler_command(scheduler_cmd, node_url, execution_mode).await,
		Commands::Storage(storage_cmd) =>
			storage::handle_storage_command(storage_cmd, node_url, execution_mode).await,
		Commands::TechCollective(tech_collective_cmd) =>
			tech_collective::handle_tech_collective_command(
				tech_collective_cmd,
				node_url,
				execution_mode,
			)
			.await,
		Commands::Preimage(preimage_cmd) =>
			preimage::handle_preimage_command(preimage_cmd, node_url, execution_mode).await,
		Commands::Treasury(treasury_cmd) =>
			treasury::handle_treasury_command(treasury_cmd, node_url, execution_mode).await,
		Commands::Transfers(transfers_cmd) =>
			transfers::handle_transfers_command(transfers_cmd).await,
		Commands::Runtime(runtime_cmd) =>
			runtime::handle_runtime_command(runtime_cmd, node_url, execution_mode).await,
		Commands::Call {
			pallet,
			call,
			args,
			from,
			password,
			password_file,
			tip,
			offline,
			call_data_only,
		} =>
			handle_generic_call_command(
				pallet,
				call,
				args,
				from,
				password,
				password_file,
				tip,
				offline,
				call_data_only,
				node_url,
				execution_mode,
			)
			.await,
		Commands::Balance { address } => {
			let quantus_client = crate::chain::client::QuantusClient::new(node_url).await?;

			// Resolve address (could be wallet name or SS58 address)
			let resolved_address = common::resolve_address(&address)?;

			let balance = send::get_balance(&quantus_client, &resolved_address).await?;
			let formatted_balance =
				send::format_balance_with_symbol(&quantus_client, balance).await?;
			log_print!("💰 Balance: {}", formatted_balance);
			Ok(())
		},
		Commands::Developer(dev_cmd) => handle_developer_command(dev_cmd).await,
		Commands::Events { block, block_hash, latest: _, finalized, pallet, raw, no_decode } =>
			events::handle_events_command(
				block, block_hash, finalized, pallet, raw, !no_decode, node_url,
			)
			.await,
		Commands::System { runtime, metadata, rpc_methods } => {
			if runtime || metadata || rpc_methods {
				system::handle_system_extended_command(
					node_url,
					runtime,
					metadata,
					rpc_methods,
					verbose,
				)
				.await
			} else {
				system::handle_system_command(node_url).await
			}
		},
		Commands::Metadata { no_docs, stats_only, pallet } =>
			metadata::handle_metadata_command(node_url, no_docs, stats_only, pallet).await,
		Commands::Version => {
			log_print!("CLI Version: Quantus CLI v{}", env!("CARGO_PKG_VERSION"));
			Ok(())
		},
		Commands::CompatibilityCheck => handle_compatibility_check(node_url).await,
		Commands::Block(block_cmd) => block::handle_block_command(block_cmd, node_url).await,
		Commands::Wormhole(wormhole_cmd) =>
			wormhole::handle_wormhole_command(wormhole_cmd, node_url).await,
		Commands::Multisend {
			from,
			addresses_file,
			addresses,
			total,
			min,
			max,
			password,
			password_file,
			tip,
			yes,
		} =>
			multisend::handle_multisend_command(
				from,
				node_url,
				addresses_file,
				addresses,
				total,
				min,
				max,
				password,
				password_file,
				tip,
				yes,
				execution_mode,
			)
			.await,
	}
}

/// Handle generic extrinsic call command
#[allow(clippy::too_many_arguments)]
async fn handle_generic_call_command(
	pallet: String,
	call: String,
	args: Option<String>,
	from: String,
	password: Option<String>,
	password_file: Option<String>,
	tip: Option<String>,
	offline: bool,
	call_data_only: bool,
	node_url: &str,
	execution_mode: common::ExecutionMode,
) -> crate::error::Result<()> {
	// For now, we only support live submission (not offline or call-data-only)
	if offline {
		log_error!("❌ Offline mode is not yet implemented");
		log_print!("💡 Currently only live submission is supported");
		return Ok(());
	}

	if call_data_only {
		log_error!("❌ Call-data-only mode is not yet implemented");
		log_print!("💡 Currently only live submission is supported");
		return Ok(());
	}

	let keypair = crate::wallet::load_keypair_from_wallet(&from, password, password_file)?;

	let args_vec = if let Some(args_str) = args {
		serde_json::from_str(&args_str).map_err(|e| {
			crate::error::QuantusError::Generic(format!("Invalid JSON for arguments: {e}"))
		})?
	} else {
		vec![]
	};

	generic_call::handle_generic_call(
		&pallet,
		&call,
		args_vec,
		&keypair,
		tip,
		node_url,
		execution_mode,
	)
	.await
}

/// Handle developer subcommands
pub async fn handle_developer_command(command: DeveloperCommands) -> crate::error::Result<()> {
	match command {
		DeveloperCommands::CreateTestWallets => {
			use crate::wallet::WalletManager;

			log_print!(
				"🧪 {} Creating standard test wallets...",
				"DEVELOPER".bright_magenta().bold()
			);
			log_print!("");

			let wallet_manager = WalletManager::new()?;

			// Standard test wallets with well-known names
			let test_wallets = vec![
				("crystal_alice", "Alice's test wallet for development"),
				("crystal_bob", "Bob's test wallet for development"),
				("crystal_charlie", "Charlie's test wallet for development"),
			];

			let mut created_count = 0;

			for (name, description) in test_wallets {
				log_verbose!("Creating wallet: {}", name.bright_green());

				// Create wallet with a default password for testing
				match wallet_manager.create_developer_wallet(name).await {
					Ok(wallet_info) => {
						log_success!("✅ Created {}", name.bright_green());
						log_success!("   Address: {}", wallet_info.address.bright_cyan());
						log_success!("   Description: {}", description.dimmed());
						created_count += 1;
					},
					Err(e) => {
						log_error!("❌ Failed to create {}: {}", name.bright_red(), e);
					},
				}
			}

			log_print!("");
			log_success!("🎉 Test wallet creation complete!");
			log_success!("   Created: {} wallets", created_count.to_string().bright_green());
			log_print!("");
			log_print!("💡 {} You can now use these wallets:", "TIP".bright_blue().bold());
			log_print!("   quantus send --from crystal_alice --to <address> --amount 1000");
			log_print!("   quantus send --from crystal_bob --to <address> --amount 1000");
			log_print!("   quantus send --from crystal_charlie --to <address> --amount 1000");
			log_print!("");

			Ok(())
		},
		DeveloperCommands::BuildCircuits {
			circuits_path,
			chain_path,
			num_leaf_proofs,
			skip_chain,
		} => build_wormhole_circuits(&circuits_path, &chain_path, num_leaf_proofs, skip_chain).await,
	}
}

/// Build wormhole circuit binaries and copy them to the appropriate locations
async fn build_wormhole_circuits(
	circuits_path: &str,
	chain_path: &str,
	num_leaf_proofs: usize,
	skip_chain: bool,
) -> crate::error::Result<()> {
	use std::{path::Path, process::Command};

	log_print!("Building ZK circuit binaries (num_leaf_proofs={})", num_leaf_proofs);
	log_print!("");

	let circuits_dir = Path::new(circuits_path);
	let chain_dir = Path::new(chain_path);

	// Verify circuits directory exists
	if !circuits_dir.exists() {
		return Err(crate::error::QuantusError::Generic(format!(
			"Circuits directory not found: {}",
			circuits_path
		)));
	}

	// Step 1: Build the circuit builder
	log_print!("Step 1/4: Building circuit builder...");
	let build_output = Command::new("cargo")
		.args(["build", "--release", "-p", "qp-wormhole-circuit-builder"])
		.current_dir(circuits_dir)
		.output()
		.map_err(|e| {
			crate::error::QuantusError::Generic(format!("Failed to run cargo build: {}", e))
		})?;

	if !build_output.status.success() {
		let stderr = String::from_utf8_lossy(&build_output.stderr);
		return Err(crate::error::QuantusError::Generic(format!(
			"Circuit builder compilation failed:\n{}",
			stderr
		)));
	}
	log_success!("   Done");

	// Step 2: Run the circuit builder to generate binaries
	log_print!("Step 2/4: Generating circuit binaries (this may take a while)...");
	let builder_path = circuits_dir.join("target/release/qp-wormhole-circuit-builder");
	let run_output = Command::new(&builder_path)
		.args(["--num-leaf-proofs", &num_leaf_proofs.to_string()])
		.current_dir(circuits_dir)
		.output()
		.map_err(|e| {
			crate::error::QuantusError::Generic(format!("Failed to run circuit builder: {}", e))
		})?;

	if !run_output.status.success() {
		let stderr = String::from_utf8_lossy(&run_output.stderr);
		return Err(crate::error::QuantusError::Generic(format!(
			"Circuit builder failed:\n{}",
			stderr
		)));
	}
	log_success!("   Done");

	// Step 3: Copy binaries to CLI and touch aggregator to force recompile
	log_print!("Step 3/4: Copying binaries to CLI...");
	let source_bins = circuits_dir.join("generated-bins");
	let cli_bins = Path::new("generated-bins");

	let cli_bin_files = [
		"common.bin",
		"verifier.bin",
		"prover.bin",
		"dummy_proof.bin",
		"aggregated_common.bin",
		"aggregated_verifier.bin",
		"config.json",
	];

	for file in &cli_bin_files {
		let src = source_bins.join(file);
		let dst = cli_bins.join(file);
		std::fs::copy(&src, &dst).map_err(|e| {
			crate::error::QuantusError::Generic(format!("Failed to copy {} to CLI: {}", file, e))
		})?;
		log_verbose!("   Copied {}", file);
	}

	// Touch aggregator lib.rs to force cargo to recompile it
	let aggregator_lib = circuits_dir.join("wormhole/aggregator/src/lib.rs");
	if aggregator_lib.exists() {
		if let Ok(file) = std::fs::OpenOptions::new().write(true).open(&aggregator_lib) {
			let _ = file.set_modified(std::time::SystemTime::now());
		}
	}
	log_success!("   Done");

	// Step 4: Copy binaries to chain directory (if not skipped)
	if !skip_chain {
		log_print!("Step 4/4: Copying binaries to chain...");

		if !chain_dir.exists() {
			log_error!("   Chain directory not found: {}", chain_path);
			log_print!("   Use --skip-chain to skip this step");
		} else {
			let chain_bins = chain_dir.join("pallets/wormhole");

			let chain_bin_files =
				["aggregated_common.bin", "aggregated_verifier.bin", "config.json"];

			for file in &chain_bin_files {
				let src = source_bins.join(file);
				let dst = chain_bins.join(file);
				std::fs::copy(&src, &dst).map_err(|e| {
					crate::error::QuantusError::Generic(format!(
						"Failed to copy {} to chain: {}",
						file, e
					))
				})?;
				log_verbose!("   Copied {}", file);
			}

			// Touch pallet lib.rs to force cargo to recompile it
			let pallet_lib = chain_bins.join("src/lib.rs");
			if pallet_lib.exists() {
				if let Ok(file) = std::fs::OpenOptions::new().write(true).open(&pallet_lib) {
					let _ = file.set_modified(std::time::SystemTime::now());
				}
			}
			log_success!("   Done");
		}
	} else {
		log_print!("Step 4/4: Skipping chain copy (--skip-chain)");
	}

	log_print!("");
	log_success!("Circuit build complete!");
	log_print!("");
	if !skip_chain {
		log_print!("{}", "Next steps:".bright_blue().bold());
		log_print!("  1. Rebuild chain: cd {} && cargo build --release", chain_path);
		log_print!("  2. Restart the chain node");
		log_print!("");
	}

	Ok(())
}

/// Handle compatibility check command
async fn handle_compatibility_check(node_url: &str) -> crate::error::Result<()> {
	log_print!("🔍 Compatibility Check");
	log_print!("🔗 Connecting to: {}", node_url.bright_cyan());
	log_print!("");

	// Connect to the node
	let quantus_client = crate::chain::client::QuantusClient::new(node_url).await?;

	// Get runtime version
	let runtime_version = runtime::get_runtime_version(quantus_client.client()).await?;

	// Get system info for additional details
	let chain_info = system::get_complete_chain_info(node_url).await?;

	log_print!("📋 Version Information:");
	log_print!("   • CLI Version: {}", env!("CARGO_PKG_VERSION").bright_green());
	log_print!(
		"   • Runtime Spec Version: {}",
		runtime_version.spec_version.to_string().bright_yellow()
	);
	log_print!(
		"   • Runtime Impl Version: {}",
		runtime_version.impl_version.to_string().bright_blue()
	);
	log_print!(
		"   • Transaction Version: {}",
		runtime_version.transaction_version.to_string().bright_magenta()
	);

	if let Some(name) = &chain_info.chain_name {
		log_print!("   • Chain Name: {}", name.bright_cyan());
	}

	log_print!("");

	// Check compatibility
	let is_compatible = crate::config::is_runtime_compatible(runtime_version.spec_version);

	log_print!("🔍 Compatibility Analysis:");
	log_print!("   • Supported Runtime Versions: {:?}", crate::config::COMPATIBLE_RUNTIME_VERSIONS);
	log_print!("   • Current Runtime Version: {}", runtime_version.spec_version);

	if is_compatible {
		log_success!("✅ COMPATIBLE - This CLI version supports the connected node");
		log_print!("   • All features should work correctly");
		log_print!("   • You can safely use all CLI commands");
	} else {
		log_error!("❌ INCOMPATIBLE - This CLI version may not work with the connected node");
		log_print!("   • Some features may not work correctly");
		log_print!("   • Consider updating the CLI or connecting to a compatible node");
		log_print!("   • Supported versions: {:?}", crate::config::COMPATIBLE_RUNTIME_VERSIONS);
	}

	log_print!("");
	log_print!("💡 Tip: Use 'quantus version' for quick version check");
	log_print!("💡 Tip: Use 'quantus system --runtime' for detailed system info");

	Ok(())
}