fnzero_safe/

operations.rs

//! Solana Operations Interactive Menu
//!
//! Provides interactive Solana operations using encrypted keystore
//! 提供使用加密 keystore 的交互式 Solana 操作

use solana_sdk::signature::Keypair;
#[cfg(any(feature = "solana-ops", feature = "sol-trade-sdk"))]
use std::io::{self, Write};

#[cfg(any(feature = "solana-ops", feature = "sol-trade-sdk"))]
use colored::*;
#[cfg(any(feature = "solana-ops", feature = "sol-trade-sdk"))]
use solana_sdk::bs58;
#[cfg(any(feature = "solana-ops", feature = "sol-trade-sdk"))]
use solana_sdk::pubkey::Pubkey;
#[cfg(any(feature = "solana-ops", feature = "sol-trade-sdk"))]
use solana_sdk::signer::Signer;
#[cfg(any(feature = "solana-ops", feature = "sol-trade-sdk"))]
use std::str::FromStr;

#[cfg(feature = "solana-ops")]
use crate::solana_utils::{lamports_to_sol, SolanaClient, SolanaClientSdk};

#[cfg(any(feature = "solana-ops", feature = "sol-trade-sdk"))]
use solana_client::rpc_client::RpcClient;

#[cfg(any(feature = "solana-ops", feature = "sol-trade-sdk"))]
const DEFAULT_RPC_URL: &str = "https://api.mainnet-beta.solana.com";
#[cfg(feature = "solana-ops")]
const DEVNET_RPC_URL: &str = "https://api.devnet.solana.com";

/// Language for UI
#[derive(Clone, Copy, PartialEq)]
pub enum Language {
    English,
    Chinese,
}

/// Read user input with default value
#[cfg(any(feature = "solana-ops", feature = "sol-trade-sdk"))]
fn read_input(prompt: &str, default: &str) -> String {
    print!("{}", prompt);
    io::stdout().flush().unwrap();

    let mut input = String::new();
    io::stdin().read_line(&mut input).unwrap();
    let input = input.trim();

    if input.is_empty() && !default.is_empty() {
        default.to_string()
    } else {
        input.to_string()
    }
}

/// Show Solana operations menu
#[cfg(feature = "solana-ops")]
pub fn show_operations_menu(keypair: &Keypair, language: Language) -> Result<(), String> {
    loop {
        println!(
            "\n{}",
            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
        );
        if language == Language::English {
            println!(
                "  {} - Solana Operations",
                "🔧 FnzSafe".bright_yellow().bold()
            );
        } else {
            println!("  {} - Solana 操作", "🔧 FnzSafe".bright_yellow().bold());
        }
        println!(
            "{}",
            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
        );

        println!(
            "\n{}",
            if language == Language::English {
                "Current Wallet:"
            } else {
                "当前钱包:"
            }
            .bright_green()
        );
        println!("  📍 {}", keypair.pubkey().to_string().bright_white());

        println!(
            "\n{}",
            if language == Language::English {
                "Available Operations:"
            } else {
                "可用操作:"
            }
            .bright_green()
        );

        if language == Language::English {
            println!("  {}  Check SOL Balance", "1.".bright_cyan());
            println!("  {}  Transfer SOL", "2.".bright_cyan());
            println!("  {}  Create WSOL ATA", "3.".bright_cyan());
            println!("  {}  Wrap SOL → WSOL", "4.".bright_cyan());
            println!("  {}  Unwrap WSOL → SOL", "5.".bright_cyan());
            println!("  {}  Transfer SPL Token", "6.".bright_cyan());
            println!("  {}  Create Nonce Account", "7.".bright_cyan());
            println!("  {}  Back to Main Menu", "0.".bright_cyan());
        } else {
            println!("  {}  查询 SOL 余额", "1.".bright_cyan());
            println!("  {}  转账 SOL", "2.".bright_cyan());
            println!("  {}  创建 WSOL ATA 账户", "3.".bright_cyan());
            println!("  {}  包装 SOL → WSOL", "4.".bright_cyan());
            println!("  {}  解包 WSOL → SOL", "5.".bright_cyan());
            println!("  {}  转账 SPL 代币", "6.".bright_cyan());
            println!("  {}  创建 Nonce 账户", "7.".bright_cyan());
            println!("  {}  返回主菜单", "0.".bright_cyan());
        }

        let prompt = if language == Language::English {
            "\nSelect option [0-7]: "
        } else {
            "\n请输入选项 [0-7]: "
        };

        let choice = read_input(prompt, "");

        match choice.as_str() {
            "1" => check_balance(keypair, language)?,
            "2" => transfer_sol(keypair, language)?,
            "3" => create_wsol_ata(keypair, language)?,
            "4" => wrap_sol(keypair, language)?,
            "5" => unwrap_sol(keypair, language)?,
            "6" => transfer_token(keypair, language)?,
            "7" => create_nonce_account(keypair, language)?,
            "0" => {
                if language == Language::English {
                    println!("\n{}", "Returning to main menu...".bright_green());
                } else {
                    println!("\n{}", "返回主菜单...".bright_green());
                }
                return Ok(());
            }
            _ => {
                let msg = if language == Language::English {
                    "❌ Invalid option, please try again"
                } else {
                    "❌ 无效选项，请重试"
                };
                println!("\n{}", msg.red());
            }
        }
    }
}

/// Placeholder for non-solana-ops builds
#[cfg(not(feature = "solana-ops"))]
pub fn show_operations_menu(_keypair: &Keypair, language: Language) -> Result<(), String> {
    let msg = if language == Language::English {
        "❌ Solana operations require the 'solana-ops' feature. Please rebuild with: cargo build --features solana-ops"
    } else {
        "❌ Solana 操作需要 'solana-ops' 功能。请使用以下命令重新编译: cargo build --features solana-ops"
    };
    Err(msg.to_string())
}

#[cfg(feature = "solana-ops")]
pub fn check_balance(keypair: &Keypair, language: Language) -> Result<(), String> {
    println!(
        "\n{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );
    if language == Language::English {
        println!("  {}", "📊 Check SOL Balance".bright_yellow().bold());
    } else {
        println!("  {}", "📊 查询 SOL 余额".bright_yellow().bold());
    }
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );

    let network_prompt = if language == Language::English {
        "\nSelect network:\n  1. Mainnet\n  2. Devnet\nChoice [1]: "
    } else {
        "\n选择网络:\n  1. 主网 (Mainnet)\n  2. 测试网 (Devnet)\n选择 [1]: "
    };

    let network = read_input(network_prompt, "1");
    let rpc_url = if network == "2" {
        DEVNET_RPC_URL
    } else {
        DEFAULT_RPC_URL
    };

    if language == Language::English {
        println!(
            "\n🔍 Checking balance on {}...",
            if network == "2" { "Devnet" } else { "Mainnet" }
        );
    } else {
        println!(
            "\n🔍 正在查询{}余额...",
            if network == "2" {
                "测试网"
            } else {
                "主网"
            }
        );
    }

    let client = SolanaClient::new(rpc_url.to_string());
    match client.get_sol_balance(&keypair.pubkey()) {
        Ok(balance) => {
            let sol = lamports_to_sol(balance);
            println!("\n{}", "✅ Balance:".bright_green());
            println!("  💰 {} SOL", sol.to_string().bright_white().bold());
            println!("  📊 {} lamports", balance.to_string().bright_white());
            Ok(())
        }
        Err(e) => {
            let msg = if language == Language::English {
                format!("❌ Failed to fetch balance: {}", e)
            } else {
                format!("❌ 查询余额失败: {}", e)
            };
            Err(msg)
        }
    }
}

#[cfg(feature = "solana-ops")]
pub fn transfer_sol(keypair: &Keypair, language: Language) -> Result<(), String> {
    println!(
        "\n{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );
    if language == Language::English {
        println!("  {}", "💸 Transfer SOL".bright_yellow().bold());
    } else {
        println!("  {}", "💸 转账 SOL".bright_yellow().bold());
    }
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );

    let network_prompt = if language == Language::English {
        "\nSelect network:\n  1. Mainnet\n  2. Devnet\nChoice [1]: "
    } else {
        "\n选择网络:\n  1. 主网 (Mainnet)\n  2. 测试网 (Devnet)\n选择 [1]: "
    };

    let network = read_input(network_prompt, "1");
    let rpc_url = if network == "2" {
        DEVNET_RPC_URL
    } else {
        DEFAULT_RPC_URL
    };

    let recipient_prompt = if language == Language::English {
        "\nRecipient address: "
    } else {
        "\n接收地址: "
    };
    let recipient_str = read_input(recipient_prompt, "");

    let recipient = Pubkey::from_str(&recipient_str).map_err(|_| {
        if language == Language::English {
            "❌ Invalid recipient address".to_string()
        } else {
            "❌ 无效的接收地址".to_string()
        }
    })?;

    let amount_prompt = if language == Language::English {
        "Amount (SOL): "
    } else {
        "金额 (SOL): "
    };
    let amount_str = read_input(amount_prompt, "");
    let amount_sol: f64 = amount_str.parse().map_err(|_| {
        if language == Language::English {
            "❌ Invalid amount".to_string()
        } else {
            "❌ 无效的金额".to_string()
        }
    })?;

    let amount_lamports = (amount_sol * 1_000_000_000.0) as u64;

    println!("\n{}", "📋 Transaction Summary:".bright_yellow());
    println!("  From: {}", keypair.pubkey().to_string().bright_white());
    println!("  To: {}", recipient.to_string().bright_white());
    println!(
        "  Amount: {} SOL",
        amount_sol.to_string().bright_white().bold()
    );

    let confirm_prompt = if language == Language::English {
        "\nConfirm transaction? (yes/no) [no]: "
    } else {
        "\n确认交易? (yes/no) [no]: "
    };
    let confirm = read_input(confirm_prompt, "no");

    if confirm.to_lowercase() != "yes" {
        let msg = if language == Language::English {
            "❌ Transaction cancelled"
        } else {
            "❌ 交易已取消"
        };
        println!("\n{}", msg.red());
        return Ok(());
    }

    if language == Language::English {
        println!("\n🚀 Sending transaction...");
    } else {
        println!("\n🚀 正在发送交易...");
    }

    let client = SolanaClient::new(rpc_url.to_string());
    match client.transfer_sol(keypair, &recipient, amount_lamports) {
        Ok(signature) => {
            println!("\n{}", "✅ Transfer successful!".bright_green().bold());
            println!("  📝 Signature: {}", signature.to_string().bright_white());
            let explorer_url = if network == "2" {
                format!(
                    "https://explorer.solana.com/tx/{}?cluster=devnet",
                    signature
                )
            } else {
                format!("https://explorer.solana.com/tx/{}", signature)
            };
            println!("  🔗 Explorer: {}", explorer_url.bright_blue());
            Ok(())
        }
        Err(e) => {
            let msg = if language == Language::English {
                format!("❌ Transfer failed: {}", e)
            } else {
                format!("❌ 转账失败: {}", e)
            };
            Err(msg)
        }
    }
}

/// Helper: Run async code, handling both sync and async contexts
#[cfg(feature = "solana-ops")]
fn run_async<F, T>(future: F) -> T
where
    F: std::future::Future<Output = T>,
{
    // Try to get current runtime handle
    match tokio::runtime::Handle::try_current() {
        Ok(handle) => {
            // We're already in a runtime, use block_in_place
            tokio::task::block_in_place(|| handle.block_on(future))
        }
        Err(_) => {
            // No runtime exists, create a new one
            let rt = tokio::runtime::Runtime::new().expect("Failed to create runtime");
            rt.block_on(future)
        }
    }
}

/// Helper: Calculate and print WSOL ATA address
#[cfg(feature = "solana-ops")]
fn print_wsol_ata_address(owner: &Pubkey, language: Language, _use_seed: bool) {
    use sol_trade_sdk::common::fast_fn::get_associated_token_address_with_program_id_fast;

    let wsol_mint = Pubkey::from_str("So11111111111111111111111111111111111111112").unwrap();
    let token_program = Pubkey::from_str("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA").unwrap();

    // SDK 强制对 WSOL 使用标准 ATA（不支持 seed 优化）
    let ata = get_associated_token_address_with_program_id_fast(owner, &wsol_mint, &token_program);

    println!(
        "\n{}",
        if language == Language::English {
            "📍 WSOL ATA Address:"
        } else {
            "📍 WSOL ATA 地址:"
        }
        .bright_yellow()
    );
    println!("  {}", ata.to_string().bright_white().bold());
}

#[cfg(feature = "solana-ops")]
pub fn create_wsol_ata(keypair: &Keypair, language: Language) -> Result<(), String> {
    println!(
        "\n{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );
    if language == Language::English {
        println!("  {}", "🏦 Create WSOL ATA Account".bright_yellow().bold());
    } else {
        println!("  {}", "🏦 创建 WSOL ATA 账户".bright_yellow().bold());
    }
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );

    let network_prompt = if language == Language::English {
        "\nSelect network:\n  1. Mainnet\n  2. Devnet\nChoice [1]: "
    } else {
        "\n选择网络:\n  1. 主网 (Mainnet)\n  2. 测试网 (Devnet)\n选择 [1]: "
    };

    let network = read_input(network_prompt, "1");
    let rpc_url = if network == "2" {
        DEVNET_RPC_URL
    } else {
        DEFAULT_RPC_URL
    };

    // WSOL 强制使用标准 ATA（SDK 设计）
    let use_seed_optimize = false;

    // 打印WSOL ATA地址
    print_wsol_ata_address(&keypair.pubkey(), language, use_seed_optimize);

    // 检查账号是否已存在
    if language == Language::English {
        println!("\n🔍 Checking if account already exists...");
    } else {
        println!("\n🔍 检查账号是否已存在...");
    }

    let client_sdk = SolanaClientSdk::new(rpc_url.to_string(), use_seed_optimize);
    let wsol_balance = client_sdk.get_wsol_balance(&keypair.pubkey()).unwrap_or(0);

    // 如果能查到余额（即使是0），说明账号已存在
    let rpc_client = RpcClient::new(rpc_url.to_string());
    let wsol_mint = Pubkey::from_str("So11111111111111111111111111111111111111112").unwrap();
    let token_program = Pubkey::from_str("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA").unwrap();

    let ata = {
        use sol_trade_sdk::common::fast_fn::get_associated_token_address_with_program_id_fast;
        get_associated_token_address_with_program_id_fast(
            &keypair.pubkey(),
            &wsol_mint,
            &token_program,
        )
    };

    let account_exists = rpc_client.get_account(&ata).is_ok();

    if account_exists {
        println!(
            "\n{}",
            "ℹ️  WSOL ATA account already exists!"
                .bright_yellow()
                .bold()
        );
        println!(
            "  💰 Balance: {} lamports ({} SOL)",
            wsol_balance.to_string().bright_white(),
            lamports_to_sol(wsol_balance).to_string().bright_white()
        );

        if language == Language::English {
            println!("\n✅ Account is ready to use. No need to create.");
        } else {
            println!("\n✅ 账号已准备就绪，无需创建。");
        }
        return Ok(());
    }

    println!(
        "\n{}",
        if language == Language::English {
            "ℹ️  Account does not exist. Creating new WSOL ATA..."
        } else {
            "ℹ️  账号不存在，将创建新的 WSOL ATA..."
        }
        .bright_yellow()
    );

    let confirm_prompt = if language == Language::English {
        "\nConfirm operation? (yes/no) [no]: "
    } else {
        "\n确认操作? (yes/no) [no]: "
    };
    let confirm = read_input(confirm_prompt, "no");

    if confirm.to_lowercase() != "yes" {
        let msg = if language == Language::English {
            "❌ Operation cancelled"
        } else {
            "❌ 操作已取消"
        };
        println!("\n{}", msg.red());
        return Ok(());
    }

    if language == Language::English {
        println!("\n🚀 Creating WSOL ATA...");
    } else {
        println!("\n🚀 正在创建 WSOL ATA...");
    }

    // 使用run_async执行异步操作
    match run_async(client_sdk.create_wsol_ata(keypair)) {
        Ok(signature) => {
            println!(
                "\n{}",
                "✅ WSOL ATA created successfully!".bright_green().bold()
            );
            println!("  📝 Signature: {}", signature.to_string().bright_white());
            let explorer_url = if network == "2" {
                format!(
                    "https://explorer.solana.com/tx/{}?cluster=devnet",
                    signature
                )
            } else {
                format!("https://explorer.solana.com/tx/{}", signature)
            };
            println!("  🔗 Explorer: {}", explorer_url.bright_blue());
            Ok(())
        }
        Err(e) => {
            let msg = if language == Language::English {
                format!("❌ Creation failed: {}", e)
            } else {
                format!("❌ 创建失败: {}", e)
            };
            Err(msg)
        }
    }
}

#[cfg(feature = "solana-ops")]
pub fn wrap_sol(keypair: &Keypair, language: Language) -> Result<(), String> {
    println!(
        "\n{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );
    if language == Language::English {
        println!("  {}", "🔄 Wrap SOL → WSOL".bright_yellow().bold());
    } else {
        println!("  {}", "🔄 包装 SOL → WSOL".bright_yellow().bold());
    }
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );

    let network_prompt = if language == Language::English {
        "\nSelect network:\n  1. Mainnet\n  2. Devnet\nChoice [1]: "
    } else {
        "\n选择网络:\n  1. 主网 (Mainnet)\n  2. 测试网 (Devnet)\n选择 [1]: "
    };

    let network = read_input(network_prompt, "1");
    let rpc_url = if network == "2" {
        DEVNET_RPC_URL
    } else {
        DEFAULT_RPC_URL
    };

    // WSOL 强制使用标准 ATA（SDK 设计）
    let use_seed_optimize = false;

    // 打印WSOL ATA地址
    print_wsol_ata_address(&keypair.pubkey(), language, use_seed_optimize);

    let amount_prompt = if language == Language::English {
        "\nAmount to wrap (SOL): "
    } else {
        "\n包装金额 (SOL): "
    };
    let amount_str = read_input(amount_prompt, "");
    let amount_sol: f64 = amount_str.parse().map_err(|_| {
        if language == Language::English {
            "❌ Invalid amount".to_string()
        } else {
            "❌ 无效的金额".to_string()
        }
    })?;

    let amount_lamports = (amount_sol * 1_000_000_000.0) as u64;

    println!("\n{}", "📋 Operation Summary:".bright_yellow());
    println!(
        "  Wrap: {} SOL → WSOL",
        amount_sol.to_string().bright_white().bold()
    );

    let confirm_prompt = if language == Language::English {
        "\nConfirm operation? (yes/no) [no]: "
    } else {
        "\n确认操作? (yes/no) [no]: "
    };
    let confirm = read_input(confirm_prompt, "no");

    if confirm.to_lowercase() != "yes" {
        let msg = if language == Language::English {
            "❌ Operation cancelled"
        } else {
            "❌ 操作已取消"
        };
        println!("\n{}", msg.red());
        return Ok(());
    }

    if language == Language::English {
        println!("\n🚀 Wrapping SOL...");
    } else {
        println!("\n🚀 正在包装 SOL...");
    }

    // 使用SolanaClientSdk调用sol-trade-sdk
    let client = SolanaClientSdk::new(rpc_url.to_string(), use_seed_optimize);

    // 使用run_async执行异步操作
    match run_async(client.wrap_sol(keypair, amount_lamports)) {
        Ok(signature) => {
            println!("\n{}", "✅ Wrap successful!".bright_green().bold());
            println!("  📝 Signature: {}", signature.to_string().bright_white());
            let explorer_url = if network == "2" {
                format!(
                    "https://explorer.solana.com/tx/{}?cluster=devnet",
                    signature
                )
            } else {
                format!("https://explorer.solana.com/tx/{}", signature)
            };
            println!("  🔗 Explorer: {}", explorer_url.bright_blue());
            Ok(())
        }
        Err(e) => {
            let msg = if language == Language::English {
                format!("❌ Wrap failed: {}", e)
            } else {
                format!("❌ 包装失败: {}", e)
            };
            Err(msg)
        }
    }
}

#[cfg(feature = "solana-ops")]
pub fn unwrap_sol(keypair: &Keypair, language: Language) -> Result<(), String> {
    println!(
        "\n{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );
    if language == Language::English {
        println!("  {}", "🔄 Unwrap WSOL → SOL".bright_yellow().bold());
    } else {
        println!("  {}", "🔄 解包 WSOL → SOL".bright_yellow().bold());
    }
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );

    let network_prompt = if language == Language::English {
        "\nSelect network:\n  1. Mainnet\n  2. Devnet\nChoice [1]: "
    } else {
        "\n选择网络:\n  1. 主网 (Mainnet)\n  2. 测试网 (Devnet)\n选择 [1]: "
    };

    let network = read_input(network_prompt, "1");
    let rpc_url = if network == "2" {
        DEVNET_RPC_URL
    } else {
        DEFAULT_RPC_URL
    };

    // WSOL 强制使用标准 ATA（SDK 设计）
    let use_seed_optimize = false;

    // 打印WSOL ATA地址
    print_wsol_ata_address(&keypair.pubkey(), language, use_seed_optimize);

    // 询问是否指定金额
    let amount_prompt = if language == Language::English {
        "\nUnwrap amount (in SOL, leave empty for ALL): "
    } else {
        "\n解包金额（单位: SOL，留空则解包全部）: "
    };
    let amount_input = read_input(amount_prompt, "");
    let amount_input = amount_input.trim();

    let (is_partial, amount_lamports) = if amount_input.is_empty() {
        // 解包全部
        println!(
            "\n{}",
            if language == Language::English {
                "ℹ️  Will unwrap ALL WSOL back to SOL"
            } else {
                "ℹ️  将解包所有 WSOL 回 SOL"
            }
            .bright_yellow()
        );
        (false, 0)
    } else {
        // 解包指定金额
        let amount_sol: f64 = amount_input.parse().map_err(|_| {
            if language == Language::English {
                "❌ Invalid amount".to_string()
            } else {
                "❌ 无效的金额".to_string()
            }
        })?;

        if amount_sol <= 0.0 {
            return Err(if language == Language::English {
                "❌ Amount must be greater than 0".to_string()
            } else {
                "❌ 金额必须大于 0".to_string()
            });
        }

        let lamports = (amount_sol * 1_000_000_000.0) as u64;
        println!(
            "\n{}",
            if language == Language::English {
                format!("ℹ️  Will unwrap {} SOL from WSOL", amount_sol)
            } else {
                format!("ℹ️  将从 WSOL 解包 {} SOL", amount_sol)
            }
            .bright_yellow()
        );
        (true, lamports)
    };

    let confirm_prompt = if language == Language::English {
        "\nConfirm operation? (yes/no) [no]: "
    } else {
        "\n确认操作? (yes/no) [no]: "
    };
    let confirm = read_input(confirm_prompt, "no");

    if confirm.to_lowercase() != "yes" {
        let msg = if language == Language::English {
            "❌ Operation cancelled"
        } else {
            "❌ 操作已取消"
        };
        println!("\n{}", msg.red());
        return Ok(());
    }

    if language == Language::English {
        println!("\n🚀 Unwrapping WSOL...");
    } else {
        println!("\n🚀 正在解包 WSOL...");
    }

    // 使用SolanaClientSdk调用sol-trade-sdk
    let client = SolanaClientSdk::new(rpc_url.to_string(), use_seed_optimize);

    // 使用run_async执行异步操作
    let result = if is_partial {
        run_async(client.unwrap_sol_partial(keypair, amount_lamports))
    } else {
        run_async(client.unwrap_sol(keypair))
    };

    match result {
        Ok(signature) => {
            println!("\n{}", "✅ Unwrap successful!".bright_green().bold());
            println!("  📝 Signature: {}", signature.to_string().bright_white());
            let explorer_url = if network == "2" {
                format!(
                    "https://explorer.solana.com/tx/{}?cluster=devnet",
                    signature
                )
            } else {
                format!("https://explorer.solana.com/tx/{}", signature)
            };
            println!("  🔗 Explorer: {}", explorer_url.bright_blue());
            Ok(())
        }
        Err(e) => {
            let msg = if language == Language::English {
                format!("❌ Unwrap failed: {}", e)
            } else {
                format!("❌ 解包失败: {}", e)
            };
            Err(msg)
        }
    }
}

#[cfg(feature = "solana-ops")]
/// Close WSOL ATA account and reclaim rent
pub fn close_wsol_ata(keypair: &Keypair, language: Language) -> Result<(), String> {
    println!(
        "\n{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );
    if language == Language::English {
        println!("  {}", "🗑️  Close WSOL ATA Account".bright_yellow().bold());
    } else {
        println!("  {}", "🗑️  关闭 WSOL ATA 账号".bright_yellow().bold());
    }
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );

    let network_prompt = if language == Language::English {
        "\nSelect network:\n  1. Mainnet\n  2. Devnet\nChoice [1]: "
    } else {
        "\n选择网络:\n  1. 主网 (Mainnet)\n  2. 测试网 (Devnet)\n选择 [1]: "
    };

    let network = read_input(network_prompt, "1");
    let rpc_url = if network == "2" {
        DEVNET_RPC_URL
    } else {
        DEFAULT_RPC_URL
    };

    // WSOL 强制使用标准 ATA（SDK 设计）
    let use_seed_optimize = false;

    // 打印WSOL ATA地址
    print_wsol_ata_address(&keypair.pubkey(), language, use_seed_optimize);

    println!(
        "\n{}",
        if language == Language::English {
            "ℹ️  This operation will:"
        } else {
            "ℹ️  此操作将:"
        }
        .bright_yellow()
        .bold()
    );

    if language == Language::English {
        println!("     • Unwrap ALL WSOL back to SOL automatically");
        println!("     • Close the WSOL ATA account");
        println!("     • Reclaim rent (~0.00203928 SOL) to your wallet");
    } else {
        println!("     • 自动将所有 WSOL 解包回 SOL");
        println!("     • 关闭 WSOL ATA 账号");
        println!("     • 回收租金 (~0.00203928 SOL) 到您的钱包");
    }

    println!(
        "\n{}",
        if language == Language::English {
            "💰 All SOL (unwrapped WSOL + rent) will be returned to your wallet!"
        } else {
            "�� 所有 SOL（解包的 WSOL + 租金）将返回到您的钱包!"
        }
        .green()
        .bold()
    );

    let confirm_prompt = if language == Language::English {
        "\nConfirm operation? (yes/no) [no]: "
    } else {
        "\n确认操作? (yes/no) [no]: "
    };
    let confirm = read_input(confirm_prompt, "no");

    if confirm.to_lowercase() != "yes" {
        let msg = if language == Language::English {
            "❌ Operation cancelled"
        } else {
            "❌ 操作已取消"
        };
        println!("\n{}", msg.red());
        return Ok(());
    }

    if language == Language::English {
        println!("\n🚀 Closing WSOL ATA account...");
    } else {
        println!("\n🚀 正在关闭 WSOL ATA 账号...");
    }

    // 使用SolanaClientSdk调用sol-trade-sdk
    let client = SolanaClientSdk::new(rpc_url.to_string(), use_seed_optimize);

    // 使用run_async执行异步操作
    match run_async(client.unwrap_sol(keypair)) {
        Ok(signature) => {
            println!(
                "\n{}",
                "✅ WSOL ATA closed successfully!".bright_green().bold()
            );
            println!("  📝 Signature: {}", signature.to_string().bright_white());
            let explorer_url = if network == "2" {
                format!(
                    "https://explorer.solana.com/tx/{}?cluster=devnet",
                    signature
                )
            } else {
                format!("https://explorer.solana.com/tx/{}", signature)
            };
            println!("  🔗 Explorer: {}", explorer_url.bright_blue());
            println!(
                "\n{}",
                if language == Language::English {
                    "💰 Rent reclaimed to your wallet!"
                } else {
                    "💰 租金已返还到您的钱包!"
                }
                .green()
            );
            Ok(())
        }
        Err(e) => {
            let msg = if language == Language::English {
                format!("❌ Close failed: {}", e)
            } else {
                format!("❌ 关闭失败: {}", e)
            };
            Err(msg)
        }
    }
}

#[cfg(feature = "solana-ops")]
pub fn transfer_token(keypair: &Keypair, language: Language) -> Result<(), String> {
    println!(
        "\n{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );
    if language == Language::English {
        println!("  {}", "💎 Transfer SPL Token".bright_yellow().bold());
    } else {
        println!("  {}", "💎 转账 SPL 代币".bright_yellow().bold());
    }
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );

    let network_prompt = if language == Language::English {
        "\nSelect network:\n  1. Mainnet\n  2. Devnet\nChoice [1]: "
    } else {
        "\n选择网络:\n  1. 主网 (Mainnet)\n  2. 测试网 (Devnet)\n选择 [1]: "
    };

    let network = read_input(network_prompt, "1");
    let rpc_url = if network == "2" {
        DEVNET_RPC_URL
    } else {
        DEFAULT_RPC_URL
    };

    let mint_prompt = if language == Language::English {
        "\nToken Mint address: "
    } else {
        "\n代币 Mint 地址: "
    };
    let mint_str = read_input(mint_prompt, "");

    let mint = Pubkey::from_str(&mint_str).map_err(|_| {
        if language == Language::English {
            "❌ Invalid mint address".to_string()
        } else {
            "❌ 无效的 Mint 地址".to_string()
        }
    })?;

    let recipient_prompt = if language == Language::English {
        "Recipient address: "
    } else {
        "接收地址: "
    };
    let recipient_str = read_input(recipient_prompt, "");

    let recipient = Pubkey::from_str(&recipient_str).map_err(|_| {
        if language == Language::English {
            "❌ Invalid recipient address".to_string()
        } else {
            "❌ 无效的接收地址".to_string()
        }
    })?;

    let amount_prompt = if language == Language::English {
        "Amount (smallest units): "
    } else {
        "金额 (最小单位): "
    };
    let amount_str = read_input(amount_prompt, "");
    let amount: u64 = amount_str.parse().map_err(|_| {
        if language == Language::English {
            "❌ Invalid amount".to_string()
        } else {
            "❌ 无效的金额".to_string()
        }
    })?;

    println!("\n{}", "📋 Transaction Summary:".bright_yellow());
    println!("  From: {}", keypair.pubkey().to_string().bright_white());
    println!("  To: {}", recipient.to_string().bright_white());
    println!("  Token: {}", mint.to_string().bright_white());
    println!(
        "  Amount: {} (smallest units)",
        amount.to_string().bright_white().bold()
    );

    let confirm_prompt = if language == Language::English {
        "\nConfirm transaction? (yes/no) [no]: "
    } else {
        "\n确认交易? (yes/no) [no]: "
    };
    let confirm = read_input(confirm_prompt, "no");

    if confirm.to_lowercase() != "yes" {
        let msg = if language == Language::English {
            "❌ Transaction cancelled"
        } else {
            "❌ 交易已取消"
        };
        println!("\n{}", msg.red());
        return Ok(());
    }

    if language == Language::English {
        println!("\n🚀 Sending transaction...");
    } else {
        println!("\n🚀 正在发送交易...");
    }

    let client = SolanaClient::new(rpc_url.to_string());
    match client.transfer_token(keypair, &recipient, &mint, amount) {
        Ok(signature) => {
            println!("\n{}", "✅ Transfer successful!".bright_green().bold());
            println!("  📝 Signature: {}", signature.to_string().bright_white());
            let explorer_url = if network == "2" {
                format!(
                    "https://explorer.solana.com/tx/{}?cluster=devnet",
                    signature
                )
            } else {
                format!("https://explorer.solana.com/tx/{}", signature)
            };
            println!("  🔗 Explorer: {}", explorer_url.bright_blue());
            Ok(())
        }
        Err(e) => {
            let msg = if language == Language::English {
                format!("❌ Transfer failed: {}", e)
            } else {
                format!("❌ 转账失败: {}", e)
            };
            Err(msg)
        }
    }
}

#[cfg(feature = "solana-ops")]
pub fn create_nonce_account(keypair: &Keypair, language: Language) -> Result<(), String> {
    println!(
        "\n{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );
    if language == Language::English {
        println!("  {}", "🔑 Create Nonce Account".bright_yellow().bold());
    } else {
        println!("  {}", "🔑 创建 Nonce 账户".bright_yellow().bold());
    }
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_cyan()
    );

    let network_prompt = if language == Language::English {
        "\nSelect network:\n  1. Mainnet\n  2. Devnet\nChoice [1]: "
    } else {
        "\n选择网络:\n  1. 主网 (Mainnet)\n  2. 测试网 (Devnet)\n选择 [1]: "
    };

    let network = read_input(network_prompt, "1");
    let rpc_url = if network == "2" {
        DEVNET_RPC_URL
    } else {
        DEFAULT_RPC_URL
    };

    println!(
        "\n{}",
        if language == Language::English {
            "ℹ️  A nonce account will be created for durable transactions"
        } else {
            "ℹ️  将创建一个用于持久交易的 Nonce 账户"
        }
        .bright_yellow()
    );

    println!(
        "{}",
        if language == Language::English {
            "ℹ️  This requires ~0.00144 SOL for rent exemption"
        } else {
            "ℹ️  这需要约 0.00144 SOL 用于租金豁免"
        }
        .bright_yellow()
    );

    let confirm_prompt = if language == Language::English {
        "\nConfirm creation? (yes/no) [no]: "
    } else {
        "\n确认创建? (yes/no) [no]: "
    };
    let confirm = read_input(confirm_prompt, "no");

    if confirm.to_lowercase() != "yes" {
        let msg = if language == Language::English {
            "❌ Operation cancelled"
        } else {
            "❌ 操作已取消"
        };
        println!("\n{}", msg.red());
        return Ok(());
    }

    if language == Language::English {
        println!("\n🚀 Creating nonce account...");
    } else {
        println!("\n🚀 正在创建 Nonce 账户...");
    }

    let client = SolanaClient::new(rpc_url.to_string());
    match client.create_nonce_account(keypair) {
        Ok((nonce_pubkey, signature)) => {
            println!(
                "\n{}",
                "✅ Nonce account created successfully!"
                    .bright_green()
                    .bold()
            );
            println!(
                "  🔑 Nonce Account: {}",
                nonce_pubkey.to_string().bright_white().bold()
            );
            println!("  📝 Signature: {}", signature.to_string().bright_white());
            let explorer_url = if network == "2" {
                format!(
                    "https://explorer.solana.com/address/{}?cluster=devnet",
                    nonce_pubkey
                )
            } else {
                format!("https://explorer.solana.com/address/{}", nonce_pubkey)
            };
            println!("  🔗 Explorer: {}", explorer_url.bright_blue());
            println!(
                "\n{}",
                if language == Language::English {
                    "💡 Save this nonce account address for future use!"
                } else {
                    "💡 请保存此 Nonce 账户地址以供将来使用！"
                }
                .bright_yellow()
            );
            Ok(())
        }
        Err(e) => {
            let msg = if language == Language::English {
                format!("❌ Creation failed: {}", e)
            } else {
                format!("❌ 创建失败: {}", e)
            };
            Err(msg)
        }
    }
}

/// Entry point for Solana operations from interactive menu
/// Prompts for keystore file and password, then shows operations menu
pub fn show_solana_operations_menu(language: crate::interactive::Language) -> Result<(), String> {
    #[cfg(feature = "solana-ops")]
    {
        use crate::KeyManager;

        // Convert language from interactive module to operations module
        let ops_language = match language {
            crate::interactive::Language::English => Language::English,
            crate::interactive::Language::Chinese => Language::Chinese,
        };

        // Prompt for keystore file
        let file_prompt = if ops_language == Language::English {
            "Keystore file path (default: keystore.json): "
        } else {
            "Keystore 文件路径 (默认: keystore.json): "
        };

        let file_path = read_input(file_prompt, "keystore.json");

        // Check if file exists
        if !std::path::Path::new(&file_path).exists() {
            let err_msg = if ops_language == Language::English {
                format!("❌ File not found: {}", file_path)
            } else {
                format!("❌ 文件不存在: {}", file_path)
            };
            return Err(err_msg);
        }

        // Prompt for password
        let password_prompt = if ops_language == Language::English {
            "Enter password: "
        } else {
            "请输入密码: "
        };

        print!("{}", password_prompt);
        io::stdout().flush().map_err(|e| e.to_string())?;
        let password =
            rpassword::read_password().map_err(|e| format!("Failed to read password: {}", e))?;

        // Load keystore
        let keystore_json = std::fs::read_to_string(&file_path).map_err(|e| {
            if ops_language == Language::English {
                format!("❌ Failed to read file: {}", e)
            } else {
                format!("❌ 读取文件失败: {}", e)
            }
        })?;

        let keypair =
            KeyManager::keypair_from_encrypted_json(&keystore_json, &password).map_err(|e| {
                if ops_language == Language::English {
                    format!("❌ Failed to decrypt keystore: {}", e)
                } else {
                    format!("❌ 解密 keystore 失败: {}", e)
                }
            })?;

        println!(
            "\n{}",
            if ops_language == Language::English {
                "✅ Wallet unlocked successfully!"
            } else {
                "✅ 钱包解锁成功！"
            }
            .bright_green()
        );

        // Run synchronous operations menu
        show_operations_menu(&keypair, ops_language)
    }

    #[cfg(not(feature = "solana-ops"))]
    {
        let _ = language; // Suppress unused variable warning
        Err("Solana operations require the 'solana-ops' feature".to_string())
    }
}

/// PumpSwap 交互式卖出
#[cfg(feature = "sol-trade-sdk")]
pub fn pumpswap_sell_interactive(keypair: &Keypair, language: Language) -> Result<(), String> {
    println!(
        "\n{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
    );
    if language == Language::English {
        println!("  {}", "🔥 PumpSwap Sell Tokens".bright_magenta().bold());
    } else {
        println!("  {}", "🔥 PumpSwap 卖出代币".bright_magenta().bold());
    }
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
    );

    println!(
        "\n{}",
        if language == Language::English {
            "Current Wallet:"
        } else {
            "当前钱包:"
        }
        .bright_green()
    );
    println!("  📍 {}", keypair.pubkey().to_string().bright_white());

    // Step 1: 输入 RPC URL（可选）
    println!();
    let rpc_prompt = if language == Language::English {
        format!("RPC URL (default: {}): ", DEFAULT_RPC_URL)
    } else {
        format!("RPC URL (默认: {}): ", DEFAULT_RPC_URL)
    };
    let rpc_url = read_input(&rpc_prompt, DEFAULT_RPC_URL);

    // Step 2: 询问是否使用 seed 优化
    println!();
    if language == Language::English {
        println!("{}", "🔧 Seed Optimization Configuration".bright_cyan());
        println!("   Seed optimization is used to create optimized ATA addresses");
        println!("   If your token ATA was created using the standard method, choose 'no'");
        println!("   If unsure, it's recommended to choose 'no'");
    } else {
        println!("{}", "🔧 Seed 优化配置".bright_cyan());
        println!("   Seed 优化用于创建优化的 ATA 地址，可以节省交易费用");
        println!("   如果你的代币 ATA 是通过标准方式创建的，请选择 'no'");
        println!("   如果不确定，建议选择 'yes'（默认）");
    }

    print!(
        "\n{} ",
        if language == Language::English {
            "❓ Enable Seed Optimization? (yes/no, default: yes):"
        } else {
            "❓ 启用 Seed 优化? (yes/no, 默认 yes):"
        }
        .yellow()
    );
    io::stdout().flush().map_err(|e| e.to_string())?;

    let mut seed_input = String::new();
    io::stdin()
        .read_line(&mut seed_input)
        .map_err(|e| e.to_string())?;
    let seed_input_trimmed = seed_input.trim().to_lowercase();
    // 默认为 yes：空输入或 yes/y 都启用，只有明确输入 no/n 才禁用
    let use_seed =
        seed_input_trimmed.is_empty() || seed_input_trimmed == "yes" || seed_input_trimmed == "y";

    if use_seed {
        println!(
            "{}",
            if language == Language::English {
                "✅ Seed optimization enabled"
            } else {
                "✅ 已启用 Seed 优化"
            }
            .green()
        );
    } else {
        println!(
            "{}",
            if language == Language::English {
                "✅ Using standard ATA"
            } else {
                "✅ 使用标准 ATA"
            }
            .green()
        );
    }

    // Step 3: 输入 token mint 地址（支持多个，用逗号或空格分割）
    println!();
    if language == Language::English {
        println!(
            "{}",
            "💡 You can enter multiple mint addresses separated by commas or spaces".bright_cyan()
        );
        println!("   Tokens will be sold in the order entered");
    } else {
        println!(
            "{}",
            "💡 可以输入多个 Mint 地址，用逗号或空格分割".bright_cyan()
        );
        println!("   将按输入顺序依次卖出");
    }

    let mint_prompt = if language == Language::English {
        "\nToken Mint Address(es): "
    } else {
        "\n代币 Mint 地址: "
    };
    print!("{}", mint_prompt.yellow());
    io::stdout().flush().map_err(|e| e.to_string())?;

    let mut mint_input = String::new();
    io::stdin()
        .read_line(&mut mint_input)
        .map_err(|e| e.to_string())?;
    let mint_input = mint_input.trim();

    if mint_input.is_empty() {
        return Err(if language == Language::English {
            "Token mint address cannot be empty".to_string()
        } else {
            "代币 Mint 地址不能为空".to_string()
        });
    }

    // 解析多个 mint 地址（支持逗号和空格分割）
    let mint_addresses: Vec<String> = mint_input
        .split(|c: char| c == ',' || c.is_whitespace())
        .map(|s| s.trim())
        .filter(|s| !s.is_empty())
        .map(|s| s.to_string())
        .collect();

    if mint_addresses.is_empty() {
        return Err(if language == Language::English {
            "No valid mint addresses found".to_string()
        } else {
            "未找到有效的 Mint 地址".to_string()
        });
    }

    // 验证所有 mint 地址格式
    for (idx, mint) in mint_addresses.iter().enumerate() {
        if let Err(e) = Pubkey::from_str(mint) {
            return Err(if language == Language::English {
                format!("Invalid mint address #{}: {} (error: {})", idx + 1, mint, e)
            } else {
                format!("无效的 Mint 地址 #{}: {} (错误: {})", idx + 1, mint, e)
            });
        }
    }

    // 显示将要处理的 mint 地址
    println!();
    if language == Language::English {
        println!(
            "{}",
            format!("📋 Found {} token(s) to sell:", mint_addresses.len()).bright_green()
        );
    } else {
        println!(
            "{}",
            format!("📋 找到 {} 个代币待卖出:", mint_addresses.len()).bright_green()
        );
    }
    for (idx, mint) in mint_addresses.iter().enumerate() {
        println!("   {}. {}", idx + 1, mint.bright_white());
    }

    // Step 4: 使用默认滑点 99%
    let slippage = 9900u64;
    println!();
    if language == Language::English {
        println!("📊 Slippage tolerance: {}%", slippage as f64 / 100.0);
    } else {
        println!("📊 滑点容忍度: {}%", slippage as f64 / 100.0);
    }

    // Step 4.5: 批量卖出前统一确认
    let total_mints = mint_addresses.len();
    if total_mints > 1 {
        println!();
        if language == Language::English {
            println!(
                "{}",
                format!("⚠️  You are about to sell {} tokens", total_mints)
                    .yellow()
                    .bold()
            );
            println!("   All tokens will be sold automatically without individual confirmation");
        } else {
            println!(
                "{}",
                format!("⚠️  您即将卖出 {} 个代币", total_mints)
                    .yellow()
                    .bold()
            );
            println!("   所有代币将自动卖出，不会逐个确认");
        }

        print!(
            "\n{}",
            if language == Language::English {
                "❓ Confirm batch sell? (yes/no, default: yes): "
            } else {
                "❓ 确认批量卖出? (yes/no, 默认 yes): "
            }
            .yellow()
        );
        io::stdout().flush().map_err(|e| e.to_string())?;

        let mut confirm = String::new();
        io::stdin()
            .read_line(&mut confirm)
            .map_err(|e| e.to_string())?;
        let confirm_trimmed = confirm.trim().to_lowercase();

        if confirm_trimmed == "no" || confirm_trimmed == "n" {
            return Err(if language == Language::English {
                "❌ Batch sell cancelled".to_string()
            } else {
                "❌ 批量卖出已取消".to_string()
            });
        }
    }

    // Step 5: 循环处理每个 mint 地址
    // 批量卖出时跳过单个确认（skip_confirmation=true）
    let skip_confirmation = total_mints > 1;
    for (idx, mint) in mint_addresses.iter().enumerate() {
        println!();
        println!(
            "{}",
            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
        );
        if language == Language::English {
            println!(
                "{}",
                format!("🚀 Processing token {}/{}", idx + 1, total_mints).bright_blue()
            );
            println!("   Mint: {}", mint.bright_white());
        } else {
            println!(
                "{}",
                format!("🚀 处理第 {}/{} 个代币", idx + 1, total_mints).bright_blue()
            );
            println!("   Mint: {}", mint.bright_white());
        }
        println!(
            "{}",
            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
        );

        // 使用当前 tokio runtime 执行异步操作
        let result = match tokio::runtime::Handle::try_current() {
            Ok(handle) => {
                // 在当前运行时中执行
                let keypair_b58 = bs58::encode(keypair.to_bytes()).into_string();
                let mint_clone = mint.to_string();
                let rpc_url_clone = rpc_url.clone();

                std::thread::spawn(move || {
                    let keypair_clone = Keypair::from_base58_string(&keypair_b58);
                    handle.block_on(async move {
                        crate::solana_utils::pumpswap_sell::handle_pumpswap_sell_no_prompt(
                            &keypair_clone,
                            &mint_clone,
                            &rpc_url_clone,
                            slippage,
                            use_seed,
                            language,
                            skip_confirmation, // 传入 skip_confirmation 参数
                        )
                        .await
                    })
                })
                .join()
                .map_err(|_| "Thread panicked".to_string())?
            }
            Err(_) => {
                // 没有运行时，创建新的
                let rt = tokio::runtime::Runtime::new().map_err(|e| e.to_string())?;
                rt.block_on(async {
                    crate::solana_utils::pumpswap_sell::handle_pumpswap_sell_no_prompt(
                        keypair,
                        mint,
                        &rpc_url,
                        slippage,
                        use_seed,
                        language,
                        skip_confirmation, // 传入 skip_confirmation 参数
                    )
                    .await
                })
            }
        };

        // 处理结果
        match result {
            Ok(_) => {
                if language == Language::English {
                    println!(
                        "\n{}",
                        format!("✅ Token {}/{} sold successfully", idx + 1, total_mints)
                            .bright_green()
                    );
                } else {
                    println!(
                        "\n{}",
                        format!("✅ 第 {}/{} 个代币卖出成功", idx + 1, total_mints).bright_green()
                    );
                }
            }
            Err(e) => {
                if language == Language::English {
                    println!(
                        "\n{}",
                        format!("❌ Token {}/{} failed: {}", idx + 1, total_mints, e).bright_red()
                    );
                    println!("   Continuing with next token...");
                } else {
                    println!(
                        "\n{}",
                        format!("❌ 第 {}/{} 个代币卖出失败: {}", idx + 1, total_mints, e)
                            .bright_red()
                    );
                    println!("   继续处理下一个代币...");
                }
            }
        }

        // 如果不是最后一个，添加延迟
        if idx < total_mints - 1 {
            println!();
            if language == Language::English {
                println!("⏳ Waiting 2 seconds before next transaction...");
            } else {
                println!("⏳ 等待 2 秒后处理下一个交易...");
            }
            std::thread::sleep(std::time::Duration::from_secs(2));
        }
    }

    // 所有交易完成
    println!();
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
    );
    if language == Language::English {
        println!("{}", "🎉 All transactions completed!".bright_green().bold());
    } else {
        println!("{}", "🎉 所有交易已完成！".bright_green().bold());
    }
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
    );

    Ok(())
}

#[cfg(not(feature = "sol-trade-sdk"))]
pub fn pumpswap_sell_interactive(_keypair: &Keypair, language: Language) -> Result<(), String> {
    Err(if language == Language::English {
        "PumpSwap sell requires 'sol-trade-sdk' feature. Please rebuild with:\ncargo build --release --features sol-trade-sdk".to_string()
    } else {
        "PumpSwap 卖出需要 'sol-trade-sdk' 功能。请使用以下命令重新编译:\ncargo build --release --features sol-trade-sdk".to_string()
    })
}

/// Pump.fun 内盘（bonding curve）交互式卖出
#[cfg(feature = "sol-trade-sdk")]
pub fn pumpfun_sell_interactive(keypair: &Keypair, language: Language) -> Result<(), String> {
    println!(
        "\n{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
    );
    if language == Language::English {
        println!(
            "  {}",
            "🔥 Pump.fun Bonding Curve Sell".bright_magenta().bold()
        );
    } else {
        println!("  {}", "🔥 Pump.fun 内盘卖出代币".bright_magenta().bold());
    }
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
    );

    println!(
        "\n{}",
        if language == Language::English {
            "Current Wallet:"
        } else {
            "当前钱包:"
        }
        .bright_green()
    );
    println!("  📍 {}", keypair.pubkey().to_string().bright_white());

    let rpc_prompt = if language == Language::English {
        format!("RPC URL (default: {}): ", DEFAULT_RPC_URL)
    } else {
        format!("RPC URL (默认: {}): ", DEFAULT_RPC_URL)
    };
    let rpc_url = read_input(&rpc_prompt, DEFAULT_RPC_URL);

    println!();
    if language == Language::English {
        println!("{}", "🔧 Seed Optimization Configuration".bright_cyan());
        println!("   If your token ATA was created using the standard method, choose 'no'");
        println!("   If unsure, it's recommended to choose 'no'");
    } else {
        println!("{}", "🔧 Seed 优化配置".bright_cyan());
        println!("   如果你的代币 ATA 是通过标准方式创建的，请选择 'no'");
        println!("   如果不确定，建议选择 'yes'（默认）");
    }

    print!(
        "\n{} ",
        if language == Language::English {
            "❓ Enable Seed Optimization? (yes/no, default: yes):"
        } else {
            "❓ 启用 Seed 优化? (yes/no, 默认 yes):"
        }
        .yellow()
    );
    io::stdout().flush().map_err(|e| e.to_string())?;

    let mut seed_input = String::new();
    io::stdin()
        .read_line(&mut seed_input)
        .map_err(|e| e.to_string())?;
    let seed_input_trimmed = seed_input.trim().to_lowercase();
    let use_seed =
        seed_input_trimmed.is_empty() || seed_input_trimmed == "yes" || seed_input_trimmed == "y";

    if language == Language::English {
        println!(
            "{}",
            "💡 You can enter multiple mint addresses separated by commas or spaces".bright_cyan()
        );
    } else {
        println!(
            "{}",
            "💡 可以输入多个 Mint 地址，用逗号或空格分割".bright_cyan()
        );
    }

    let mint_prompt = if language == Language::English {
        "\nToken Mint Address(es): "
    } else {
        "\n代币 Mint 地址: "
    };
    print!("{}", mint_prompt.yellow());
    io::stdout().flush().map_err(|e| e.to_string())?;

    let mut mint_input = String::new();
    io::stdin()
        .read_line(&mut mint_input)
        .map_err(|e| e.to_string())?;
    let mint_input = mint_input.trim();

    if mint_input.is_empty() {
        return Err(if language == Language::English {
            "Token mint address cannot be empty".to_string()
        } else {
            "代币 Mint 地址不能为空".to_string()
        });
    }

    let mint_addresses: Vec<String> = mint_input
        .split(|c: char| c == ',' || c.is_whitespace())
        .map(|s| s.trim())
        .filter(|s| !s.is_empty())
        .map(|s| s.to_string())
        .collect();

    if mint_addresses.is_empty() {
        return Err(if language == Language::English {
            "No valid mint addresses found".to_string()
        } else {
            "未找到有效的 Mint 地址".to_string()
        });
    }

    for (idx, mint) in mint_addresses.iter().enumerate() {
        if let Err(e) = Pubkey::from_str(mint) {
            return Err(if language == Language::English {
                format!("Invalid mint address #{}: {} (error: {})", idx + 1, mint, e)
            } else {
                format!("无效的 Mint 地址 #{}: {} (错误: {})", idx + 1, mint, e)
            });
        }
    }

    println!();
    if language == Language::English {
        println!(
            "{}",
            format!("📋 Found {} token(s) to sell:", mint_addresses.len()).bright_green()
        );
    } else {
        println!(
            "{}",
            format!("📋 找到 {} 个代币待卖出:", mint_addresses.len()).bright_green()
        );
    }
    for (idx, mint) in mint_addresses.iter().enumerate() {
        println!("   {}. {}", idx + 1, mint.bright_white());
    }

    let slippage = 9900u64;
    println!();
    if language == Language::English {
        println!("📊 Slippage tolerance: {}%", slippage as f64 / 100.0);
    } else {
        println!("📊 滑点容忍度: {}%", slippage as f64 / 100.0);
    }

    let total_mints = mint_addresses.len();
    if total_mints > 1 {
        println!();
        if language == Language::English {
            println!(
                "{}",
                format!("⚠️  You are about to sell {} tokens", total_mints)
                    .yellow()
                    .bold()
            );
        } else {
            println!(
                "{}",
                format!("⚠️  您即将卖出 {} 个代币", total_mints)
                    .yellow()
                    .bold()
            );
        }

        print!(
            "\n{}",
            if language == Language::English {
                "❓ Confirm batch sell? (yes/no, default: yes): "
            } else {
                "❓ 确认批量卖出? (yes/no, 默认 yes): "
            }
            .yellow()
        );
        io::stdout().flush().map_err(|e| e.to_string())?;

        let mut confirm = String::new();
        io::stdin()
            .read_line(&mut confirm)
            .map_err(|e| e.to_string())?;
        let confirm_trimmed = confirm.trim().to_lowercase();

        if confirm_trimmed == "no" || confirm_trimmed == "n" {
            return Err(if language == Language::English {
                "❌ Batch sell cancelled".to_string()
            } else {
                "❌ 批量卖出已取消".to_string()
            });
        }
    }

    let skip_confirmation = total_mints > 1;
    for (idx, mint) in mint_addresses.iter().enumerate() {
        println!();
        println!(
            "{}",
            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
        );
        if language == Language::English {
            println!(
                "{}",
                format!("🚀 Processing token {}/{}", idx + 1, total_mints).bright_blue()
            );
            println!("   Mint: {}", mint.bright_white());
        } else {
            println!(
                "{}",
                format!("🚀 处理第 {}/{} 个代币", idx + 1, total_mints).bright_blue()
            );
            println!("   Mint: {}", mint.bright_white());
        }
        println!(
            "{}",
            "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
        );

        let result = match tokio::runtime::Handle::try_current() {
            Ok(handle) => {
                let keypair_b58 = bs58::encode(keypair.to_bytes()).into_string();
                let mint_clone = mint.to_string();
                let rpc_url_clone = rpc_url.clone();

                std::thread::spawn(move || {
                    let keypair_clone = Keypair::from_base58_string(&keypair_b58);
                    handle.block_on(async move {
                        crate::solana_utils::pumpfun_sell::handle_pumpfun_sell_no_prompt(
                            &keypair_clone,
                            &mint_clone,
                            &rpc_url_clone,
                            slippage,
                            use_seed,
                            language,
                            skip_confirmation,
                        )
                        .await
                    })
                })
                .join()
                .map_err(|_| "Thread panicked".to_string())?
            }
            Err(_) => {
                let rt = tokio::runtime::Runtime::new().map_err(|e| e.to_string())?;
                rt.block_on(async {
                    crate::solana_utils::pumpfun_sell::handle_pumpfun_sell_no_prompt(
                        keypair,
                        mint,
                        &rpc_url,
                        slippage,
                        use_seed,
                        language,
                        skip_confirmation,
                    )
                    .await
                })
            }
        };

        match result {
            Ok(_) => {
                if language == Language::English {
                    println!(
                        "\n{}",
                        format!("✅ Token {}/{} sold successfully", idx + 1, total_mints)
                            .bright_green()
                    );
                } else {
                    println!(
                        "\n{}",
                        format!("✅ 第 {}/{} 个代币卖出成功", idx + 1, total_mints).bright_green()
                    );
                }
            }
            Err(e) => {
                if language == Language::English {
                    println!(
                        "\n{}",
                        format!("❌ Token {}/{} failed: {}", idx + 1, total_mints, e).bright_red()
                    );
                } else {
                    println!(
                        "\n{}",
                        format!("❌ 第 {}/{} 个代币卖出失败: {}", idx + 1, total_mints, e)
                            .bright_red()
                    );
                }
            }
        }

        if idx < total_mints - 1 {
            println!();
            std::thread::sleep(std::time::Duration::from_secs(2));
        }
    }

    println!();
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
    );
    if language == Language::English {
        println!("{}", "🎉 All transactions completed!".bright_green().bold());
    } else {
        println!("{}", "🎉 所有交易已完成！".bright_green().bold());
    }
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
    );

    Ok(())
}

/// Pump (Pump.fun) 返现：查询余额 → 显示 → 确认 → 领取（原生 SOL）
#[cfg(feature = "sol-trade-sdk")]
pub fn pumpfun_cashback_interactive(keypair: &Keypair, language: Language) -> Result<(), String> {
    use sol_trade_sdk::{common::TradeConfig, SolanaTrade};
    use solana_commitment_config::CommitmentConfig;
    use std::sync::Arc;

    println!(
        "\n{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
    );
    if language == Language::English {
        println!(
            "  {}",
            "💰 Pump (Pump.fun) Cashback – View & Claim"
                .bright_magenta()
                .bold()
        );
        println!(
            "  {}",
            "   Cashback is native SOL from trading on Pump.fun.".bright_white()
        );
    } else {
        println!(
            "  {}",
            "💰 Pump (Pump.fun) 返现 – 查看与领取"
                .bright_magenta()
                .bold()
        );
        println!(
            "  {}",
            "   返现为在 Pump.fun 交易累积的原生 SOL。".bright_white()
        );
    }
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
    );

    println!(
        "\n{}",
        if language == Language::English {
            "Current Wallet:"
        } else {
            "当前钱包:"
        }
        .bright_green()
    );
    println!("  📍 {}", keypair.pubkey().to_string().bright_white());

    let rpc_prompt = if language == Language::English {
        format!("RPC URL (default: {}): ", DEFAULT_RPC_URL)
    } else {
        format!("RPC URL (默认: {}): ", DEFAULT_RPC_URL)
    };
    let rpc_url = read_input(&rpc_prompt, DEFAULT_RPC_URL);

    // Step 1: 查询 UserVolumeAccumulator PDA 余额
    if language == Language::English {
        println!("\n{}", "🔍 Querying cashback balance...".bright_cyan());
    } else {
        println!("\n{}", "🔍 正在查询返现余额...".bright_cyan());
    }

    let pda = sol_trade_sdk::instruction::utils::pumpfun::get_user_volume_accumulator_pda(
        &keypair.pubkey(),
    )
    .ok_or_else(|| {
        if language == Language::English {
            "Failed to derive UserVolumeAccumulator PDA".to_string()
        } else {
            "无法派生 UserVolumeAccumulator PDA 地址".to_string()
        }
    })?;

    let rpc_client = RpcClient::new(rpc_url.clone());
    let pda_balance_lamports = rpc_client.get_balance(&pda).unwrap_or(0);
    let rent_exempt_min: u64 = 890_880;
    let claimable_lamports = pda_balance_lamports.saturating_sub(rent_exempt_min);
    let claimable_sol = claimable_lamports as f64 / 1_000_000_000.0;

    // Step 2: 显示余额
    println!(
        "\n{}",
        if language == Language::English {
            "📊 Cashback Info:"
        } else {
            "📊 返现信息:"
        }
        .bright_yellow()
    );
    println!("  PDA: {}", pda.to_string().bright_white());
    if language == Language::English {
        println!(
            "  PDA Balance: {} lamports ({:.9} SOL)",
            pda_balance_lamports,
            pda_balance_lamports as f64 / 1e9
        );
        println!(
            "  Claimable:   {} lamports ({:.9} SOL)",
            claimable_lamports, claimable_sol
        );
    } else {
        println!(
            "  PDA 余额:    {} lamports ({:.9} SOL)",
            pda_balance_lamports,
            pda_balance_lamports as f64 / 1e9
        );
        println!(
            "  可领取:      {} lamports ({:.9} SOL)",
            claimable_lamports, claimable_sol
        );
    }

    if claimable_lamports == 0 {
        if language == Language::English {
            println!(
                "\n{}",
                "ℹ️  No cashback available to claim.".bright_yellow()
            );
        } else {
            println!("\n{}", "ℹ️  暂无可领取的返现。".bright_yellow());
        }
        return Ok(());
    }

    // Step 3: 确认是否领取
    let confirm_prompt = if language == Language::English {
        format!("\nClaim {:.9} SOL? (yes/no) [no]: ", claimable_sol)
    } else {
        format!("\n领取 {:.9} SOL? (yes/no) [no]: ", claimable_sol)
    };
    let confirm = read_input(&confirm_prompt, "no");

    if confirm.to_lowercase() != "yes" {
        let msg = if language == Language::English {
            "❌ Claim cancelled"
        } else {
            "❌ 已取消领取"
        };
        println!("\n{}", msg.red());
        return Ok(());
    }

    // Step 4: 执行领取
    if language == Language::English {
        println!("\n{}", "🚀 Claiming...".bright_cyan());
    } else {
        println!("\n{}", "🚀 正在领取...".bright_cyan());
    }

    let sig = match tokio::runtime::Handle::try_current() {
        Ok(handle) => {
            let keypair_b58 = bs58::encode(keypair.to_bytes()).into_string();
            let rpc_url_clone = rpc_url.clone();
            std::thread::spawn(move || {
                let kp = Keypair::from_base58_string(&keypair_b58);
                let payer = Arc::new(kp);
                let config = TradeConfig::builder(
                    rpc_url_clone.clone(),
                    vec![sol_trade_sdk::swqos::SwqosConfig::Default(rpc_url_clone)],
                    CommitmentConfig::confirmed(),
                )
                .create_wsol_ata_on_startup(false)
                .use_seed_optimize(false)
                .check_min_tip(false)
                .log_enabled(false)
                .swqos_cores_from_end(false)
                .mev_protection(false)
                .build();
                handle.block_on(async move {
                    let client = SolanaTrade::new(payer, config).await;
                    client
                        .claim_cashback_pumpfun()
                        .await
                        .map_err(|e| e.to_string())
                })
            })
            .join()
            .map_err(|_| "Thread panicked".to_string())??
        }
        Err(_) => {
            let payer = Arc::new(keypair.insecure_clone());
            let config = TradeConfig::builder(
                rpc_url.clone(),
                vec![sol_trade_sdk::swqos::SwqosConfig::Default(rpc_url)],
                CommitmentConfig::confirmed(),
            )
            .create_wsol_ata_on_startup(false)
            .use_seed_optimize(false)
            .check_min_tip(false)
            .log_enabled(false)
            .swqos_cores_from_end(false)
            .mev_protection(false)
            .build();
            let rt = tokio::runtime::Runtime::new().map_err(|e| e.to_string())?;
            let client = rt.block_on(SolanaTrade::new(payer, config));
            rt.block_on(client.claim_cashback_pumpfun())
                .map_err(|e| e.to_string())?
        }
    };

    if language == Language::English {
        println!("{}", "✅ Claim successful!".bright_green().bold());
        println!("Signature: {}", sig.yellow());
        println!("Explorer: https://solscan.io/tx/{}", sig);
    } else {
        println!("{}", "✅ 领取成功！".bright_green().bold());
        println!("签名: {}", sig.yellow());
        println!("浏览器: https://solscan.io/tx/{}", sig);
    }
    Ok(())
}

/// PumpSwap 返现：查询余额 → 显示 → 确认 → 领取（WSOL）
#[cfg(feature = "sol-trade-sdk")]
pub fn pumpswap_cashback_interactive(keypair: &Keypair, language: Language) -> Result<(), String> {
    use sol_trade_sdk::{common::TradeConfig, SolanaTrade};
    use solana_commitment_config::CommitmentConfig;
    use std::sync::Arc;

    println!(
        "\n{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
    );
    if language == Language::English {
        println!(
            "  {}",
            "💰 PumpSwap Cashback – View & Claim"
                .bright_magenta()
                .bold()
        );
        println!(
            "  {}",
            "   Cashback is WSOL from trading on PumpSwap.".bright_white()
        );
    } else {
        println!(
            "  {}",
            "💰 PumpSwap 返现 – 查看与领取".bright_magenta().bold()
        );
        println!(
            "  {}",
            "   返现为在 PumpSwap 交易累积的 WSOL。".bright_white()
        );
    }
    println!(
        "{}",
        "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━".bright_magenta()
    );

    println!(
        "\n{}",
        if language == Language::English {
            "Current Wallet:"
        } else {
            "当前钱包:"
        }
        .bright_green()
    );
    println!("  📍 {}", keypair.pubkey().to_string().bright_white());

    let rpc_prompt = if language == Language::English {
        format!("RPC URL (default: {}): ", DEFAULT_RPC_URL)
    } else {
        format!("RPC URL (默认: {}): ", DEFAULT_RPC_URL)
    };
    let rpc_url = read_input(&rpc_prompt, DEFAULT_RPC_URL);

    // Step 1: 查询 PumpSwap UserVolumeAccumulator 的 WSOL ATA 余额
    if language == Language::English {
        println!("\n{}", "🔍 Querying cashback balance...".bright_cyan());
    } else {
        println!("\n{}", "🔍 正在查询返现余额...".bright_cyan());
    }

    let wsol_ata =
        sol_trade_sdk::instruction::utils::pumpswap::get_user_volume_accumulator_wsol_ata(
            &keypair.pubkey(),
        )
        .ok_or_else(|| {
            if language == Language::English {
                "Failed to derive PumpSwap UserVolumeAccumulator WSOL ATA".to_string()
            } else {
                "无法派生 PumpSwap UserVolumeAccumulator WSOL ATA 地址".to_string()
            }
        })?;

    let rpc_client = RpcClient::new(rpc_url.clone());
    let claimable_lamports = match rpc_client.get_token_account_balance(&wsol_ata) {
        Ok(balance) => balance.amount.parse::<u64>().unwrap_or(0),
        Err(_) => 0,
    };
    let claimable_sol = claimable_lamports as f64 / 1_000_000_000.0;

    // Step 2: 显示余额
    println!(
        "\n{}",
        if language == Language::English {
            "📊 Cashback Info:"
        } else {
            "📊 返现信息:"
        }
        .bright_yellow()
    );
    println!("  WSOL ATA: {}", wsol_ata.to_string().bright_white());
    if language == Language::English {
        println!(
            "  Claimable: {} lamports ({:.9} SOL)",
            claimable_lamports, claimable_sol
        );
    } else {
        println!(
            "  可领取:   {} lamports ({:.9} SOL)",
            claimable_lamports, claimable_sol
        );
    }

    if claimable_lamports == 0 {
        if language == Language::English {
            println!(
                "\n{}",
                "ℹ️  No cashback available to claim.".bright_yellow()
            );
        } else {
            println!("\n{}", "ℹ️  暂无可领取的返现。".bright_yellow());
        }
        return Ok(());
    }

    // Step 3: 确认是否领取
    let confirm_prompt = if language == Language::English {
        format!("\nClaim {:.9} SOL (WSOL)? (yes/no) [no]: ", claimable_sol)
    } else {
        format!("\n领取 {:.9} SOL (WSOL)? (yes/no) [no]: ", claimable_sol)
    };
    let confirm = read_input(&confirm_prompt, "no");

    if confirm.to_lowercase() != "yes" {
        let msg = if language == Language::English {
            "❌ Claim cancelled"
        } else {
            "❌ 已取消领取"
        };
        println!("\n{}", msg.red());
        return Ok(());
    }

    // Step 4: 执行领取
    if language == Language::English {
        println!("\n{}", "🚀 Claiming...".bright_cyan());
    } else {
        println!("\n{}", "🚀 正在领取...".bright_cyan());
    }

    let sig = match tokio::runtime::Handle::try_current() {
        Ok(handle) => {
            let keypair_b58 = bs58::encode(keypair.to_bytes()).into_string();
            let rpc_url_clone = rpc_url.clone();
            std::thread::spawn(move || {
                let kp = Keypair::from_base58_string(&keypair_b58);
                let payer = Arc::new(kp);
                let config = TradeConfig::builder(
                    rpc_url_clone.clone(),
                    vec![sol_trade_sdk::swqos::SwqosConfig::Default(rpc_url_clone)],
                    CommitmentConfig::confirmed(),
                )
                .create_wsol_ata_on_startup(false)
                .use_seed_optimize(false)
                .check_min_tip(false)
                .log_enabled(false)
                .swqos_cores_from_end(false)
                .mev_protection(false)
                .build();
                handle.block_on(async move {
                    let client = SolanaTrade::new(payer, config).await;
                    client
                        .claim_cashback_pumpswap()
                        .await
                        .map_err(|e| e.to_string())
                })
            })
            .join()
            .map_err(|_| "Thread panicked".to_string())??
        }
        Err(_) => {
            let payer = Arc::new(keypair.insecure_clone());
            let config = TradeConfig::builder(
                rpc_url.clone(),
                vec![sol_trade_sdk::swqos::SwqosConfig::Default(rpc_url)],
                CommitmentConfig::confirmed(),
            )
            .create_wsol_ata_on_startup(false)
            .use_seed_optimize(false)
            .check_min_tip(false)
            .log_enabled(false)
            .swqos_cores_from_end(false)
            .mev_protection(false)
            .build();
            let rt = tokio::runtime::Runtime::new().map_err(|e| e.to_string())?;
            let client = rt.block_on(SolanaTrade::new(payer, config));
            rt.block_on(client.claim_cashback_pumpswap())
                .map_err(|e| e.to_string())?
        }
    };

    if language == Language::English {
        println!("{}", "✅ Claim successful!".bright_green().bold());
        println!("Signature: {}", sig.yellow());
        println!("Explorer: https://solscan.io/tx/{}", sig);
    } else {
        println!("{}", "✅ 领取成功！".bright_green().bold());
        println!("签名: {}", sig.yellow());
        println!("浏览器: https://solscan.io/tx/{}", sig);
    }
    Ok(())
}

#[cfg(not(feature = "sol-trade-sdk"))]
pub fn pumpfun_sell_interactive(_keypair: &Keypair, language: Language) -> Result<(), String> {
    Err(if language == Language::English {
        "Pump.fun sell requires 'sol-trade-sdk' feature. Please rebuild with:\ncargo build --release --features sol-trade-sdk".to_string()
    } else {
        "Pump.fun 内盘卖出需要 'sol-trade-sdk' 功能。请使用以下命令重新编译:\ncargo build --release --features sol-trade-sdk".to_string()
    })
}

#[cfg(not(feature = "sol-trade-sdk"))]
pub fn pumpfun_cashback_interactive(_keypair: &Keypair, language: Language) -> Result<(), String> {
    Err(if language == Language::English {
        "Pump cashback requires 'sol-trade-sdk' feature.".to_string()
    } else {
        "Pump 返现需要 'sol-trade-sdk' 功能。".to_string()
    })
}

#[cfg(not(feature = "sol-trade-sdk"))]
pub fn pumpswap_cashback_interactive(_keypair: &Keypair, language: Language) -> Result<(), String> {
    Err(if language == Language::English {
        "PumpSwap cashback requires 'sol-trade-sdk' feature.".to_string()
    } else {
        "PumpSwap 返现需要 'sol-trade-sdk' 功能。".to_string()
    })
}