Pancakeswap V3 Plugin

{
  "name": "pancakeswap-v3-plugin",
  "description": "Swap tokens and manage liquidity on PancakeSwap V3 on BNB Chain, Base, and Arbitrum",
  "version": "1.0.6",
  "author": {"name": "GeoGu360", "github": "GeoGu360"},
  "homepage": "https://github.com/okx/plugin-store/tree/main/skills/pancakeswap-v3",
  "repository": "https://github.com/okx/plugin-store",
  "license": "MIT",
  "keywords": ["dex", "swap", "liquidity", "pancakeswap", "bsc", "base", "arbitrum"]
}

target/

[package]
name = "pancakeswap-v3-plugin"
version = "1.0.6"
edition = "2021"

[[bin]]
name = "pancakeswap-v3-plugin"
path = "src/main.rs"

[dependencies]
anyhow = "1"
clap = { version = "4", features = ["derive"] }
tokio = { version = "1", features = ["full"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
reqwest = { version = "0.12", features = ["json"] }
alloy-sol-types = "0.8"
alloy-primitives = "0.8"
hex = "0.4"

MIT License

Copyright (c) 2026 skylavis-sky

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.

schema_version: 1
name: pancakeswap-v3-plugin
version: "1.0.6"
description: "Swap tokens and manage concentrated liquidity on PancakeSwap V3 on BNB Chain, Base, and Arbitrum"
author:
  name: GeoGu360
  github: GeoGu360
category: dapp
tags:
  - dex
  - swap
  - liquidity
  - pancakeswap
  - bnb-chain
  - base
  - arbitrum
license: MIT
components:
  skill:
    dir: .
build:
  lang: rust
  binary_name: pancakeswap-v3-plugin
api_calls:
  - bsc-rpc.publicnode.com
  - base-rpc.publicnode.com
  - arbitrum-one-rpc.publicnode.com
  - ethereum-rpc.publicnode.com
  - linea-rpc.publicnode.com
  - api.studio.thegraph.com
  - api.thegraph.com

/// ABI calldata encoding for PancakeSwap V3 contract calls.
/// Uses alloy-sol-types for type-safe encoding.

use alloy_primitives::{Address, U256};
use alloy_sol_types::{sol, SolCall};
use anyhow::Result;

// ── Function signatures ───────────────────────────────────────────────────────

sol! {
    // ERC-20
    function approve(address spender, uint256 amount) external returns (bool);
    function allowance(address owner, address spender) external view returns (uint256);
    function decimals() external view returns (uint8);
    function symbol() external view returns (string);
    function balanceOf(address account) external view returns (uint256);

    // SmartRouter — exactInputSingle (7-field, NO deadline) — BSC / Base
    struct ExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint24  fee;
        address recipient;
        uint256 amountIn;
        uint256 amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }
    function exactInputSingle(ExactInputSingleParams params) external payable returns (uint256 amountOut);

    // SmartRouter — exactInputSingle (8-field, WITH deadline) — Arbitrum
    struct ExactInputSingleParamsWithDeadline {
        address tokenIn;
        address tokenOut;
        uint24  fee;
        address recipient;
        uint256 deadline;
        uint256 amountIn;
        uint256 amountOutMinimum;
        uint160 sqrtPriceLimitX96;
    }
    function exactInputSingleWithDeadline(ExactInputSingleParamsWithDeadline params) external payable returns (uint256 amountOut);

    // QuoterV2 — quoteExactInputSingle
    struct QuoteExactInputSingleParams {
        address tokenIn;
        address tokenOut;
        uint256 amountIn;
        uint24  fee;
        uint160 sqrtPriceLimitX96;
    }
    function quoteExactInputSingle(QuoteExactInputSingleParams params) external returns (uint256 amountOut, uint160 sqrtPriceX96After, uint32 initializedTicksCrossed, uint256 gasEstimate);

    // NonfungiblePositionManager — mint
    struct MintParams {
        address token0;
        address token1;
        uint24  fee;
        int24   tickLower;
        int24   tickUpper;
        uint256 amount0Desired;
        uint256 amount1Desired;
        uint256 amount0Min;
        uint256 amount1Min;
        address recipient;
        uint256 deadline;
    }
    function mint(MintParams params) external payable returns (uint256 tokenId, uint128 liquidity, uint256 amount0, uint256 amount1);

    // NonfungiblePositionManager — decreaseLiquidity
    struct DecreaseLiquidityParams {
        uint256 tokenId;
        uint128 liquidity;
        uint256 amount0Min;
        uint256 amount1Min;
        uint256 deadline;
    }
    function decreaseLiquidity(DecreaseLiquidityParams params) external payable returns (uint256 amount0, uint256 amount1);

    // NonfungiblePositionManager — collect
    struct CollectParams {
        uint256 tokenId;
        address recipient;
        uint128 amount0Max;
        uint128 amount1Max;
    }
    function collect(CollectParams params) external payable returns (uint256 amount0, uint256 amount1);
}

// ── ERC-20 ────────────────────────────────────────────────────────────────────

pub fn encode_approve(spender: &str, amount: u128) -> Result<String> {
    let call = approveCall {
        spender: spender.parse::<Address>()?,
        amount: U256::from(amount),
    };
    Ok(format!("0x{}", hex::encode(call.abi_encode())))
}

// ── SmartRouter ───────────────────────────────────────────────────────────────

pub fn encode_exact_input_single(
    token_in: &str,
    token_out: &str,
    fee: u32,
    recipient: &str,
    amount_in: u128,
    amount_out_minimum: u128,
    with_deadline: bool,
) -> Result<String> {
    use alloy_primitives::Uint;
    if with_deadline {
        // Arbitrum SmartRouter: selector 0x414bf389, 8-field struct with deadline
        let deadline = std::time::SystemTime::now()
            .duration_since(std::time::UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs() + 1800; // now + 30 min
        // alloy sol! generates the function as exactInputSingleWithDeadlineCall,
        // but the on-chain selector must be 0x414bf389 (exactInputSingle with deadline struct).
        // We manually encode: selector + ABI-encoded params.
        let params = ExactInputSingleParamsWithDeadline {
            tokenIn: token_in.parse::<Address>()?,
            tokenOut: token_out.parse::<Address>()?,
            fee: Uint::<24, 1>::from(fee),
            recipient: recipient.parse::<Address>()?,
            deadline: U256::from(deadline),
            amountIn: U256::from(amount_in),
            amountOutMinimum: U256::from(amount_out_minimum),
            sqrtPriceLimitX96: alloy_primitives::U160::ZERO,
        };
        use alloy_sol_types::SolValue;
        let encoded = params.abi_encode();
        // Selector for exactInputSingle((address,address,uint24,address,uint256,uint256,uint256,uint160))
        let selector = [0x41u8, 0x4b, 0xf3, 0x89];
        let mut calldata = selector.to_vec();
        calldata.extend_from_slice(&encoded);
        Ok(format!("0x{}", hex::encode(calldata)))
    } else {
        let call = exactInputSingleCall {
            params: ExactInputSingleParams {
                tokenIn: token_in.parse::<Address>()?,
                tokenOut: token_out.parse::<Address>()?,
                fee: Uint::<24, 1>::from(fee),
                recipient: recipient.parse::<Address>()?,
                amountIn: U256::from(amount_in),
                amountOutMinimum: U256::from(amount_out_minimum),
                sqrtPriceLimitX96: alloy_primitives::U160::ZERO,
            },
        };
        Ok(format!("0x{}", hex::encode(call.abi_encode())))
    }
}

// ── QuoterV2 ──────────────────────────────────────────────────────────────────

pub fn encode_quote_exact_input_single(
    token_in: &str,
    token_out: &str,
    amount_in: u128,
    fee: u32,
) -> Result<String> {
    use alloy_primitives::Uint;
    let call = quoteExactInputSingleCall {
        params: QuoteExactInputSingleParams {
            tokenIn: token_in.parse::<Address>()?,
            tokenOut: token_out.parse::<Address>()?,
            amountIn: U256::from(amount_in),
            fee: Uint::<24, 1>::from(fee),
            sqrtPriceLimitX96: alloy_primitives::U160::ZERO,
        },
    };
    Ok(format!("0x{}", hex::encode(call.abi_encode())))
}

// ── NonfungiblePositionManager ────────────────────────────────────────────────

pub fn encode_mint(
    token0: &str,
    token1: &str,
    fee: u32,
    tick_lower: i32,
    tick_upper: i32,
    amount0_desired: u128,
    amount1_desired: u128,
    amount0_min: u128,
    amount1_min: u128,
    recipient: &str,
    deadline: u64,
) -> Result<String> {
    use alloy_primitives::{Uint, Signed};
    let call = mintCall {
        params: MintParams {
            token0: token0.parse::<Address>()?,
            token1: token1.parse::<Address>()?,
            fee: Uint::<24, 1>::from(fee),
            tickLower: Signed::<24, 1>::try_from(tick_lower as i64)
                .map_err(|_| anyhow::anyhow!("tickLower out of int24 range: {}", tick_lower))?,
            tickUpper: Signed::<24, 1>::try_from(tick_upper as i64)
                .map_err(|_| anyhow::anyhow!("tickUpper out of int24 range: {}", tick_upper))?,
            amount0Desired: U256::from(amount0_desired),
            amount1Desired: U256::from(amount1_desired),
            amount0Min: U256::from(amount0_min),
            amount1Min: U256::from(amount1_min),
            recipient: recipient.parse::<Address>()?,
            deadline: U256::from(deadline),
        },
    };
    Ok(format!("0x{}", hex::encode(call.abi_encode())))
}

pub fn encode_decrease_liquidity(
    token_id: u128,
    liquidity: u128,
    amount0_min: u128,
    amount1_min: u128,
    deadline: u64,
) -> Result<String> {
    let call = decreaseLiquidityCall {
        params: DecreaseLiquidityParams {
            tokenId: U256::from(token_id),
            liquidity: liquidity as u128,
            amount0Min: U256::from(amount0_min),
            amount1Min: U256::from(amount1_min),
            deadline: U256::from(deadline),
        },
    };
    Ok(format!("0x{}", hex::encode(call.abi_encode())))
}

pub fn encode_collect(
    token_id: u128,
    recipient: &str,
) -> Result<String> {
    let call = collectCall {
        params: CollectParams {
            tokenId: U256::from(token_id),
            recipient: recipient.parse::<Address>()?,
            amount0Max: u128::MAX,
            amount1Max: u128::MAX,
        },
    };
    Ok(format!("0x{}", hex::encode(call.abi_encode())))
}

// ── Helper: sort token addresses (token0 < token1) ────────────────────────────

/// Returns (token0, token1) sorted such that token0 < token1 numerically.
pub fn sort_tokens<'a>(a: &'a str, b: &'a str) -> Result<(&'a str, &'a str)> {
    let addr_a: Address = a.parse()?;
    let addr_b: Address = b.parse()?;
    if addr_a < addr_b {
        Ok((a, b))
    } else {
        Ok((b, a))
    }
}

/// `pancakeswap add-liquidity` — mint a new V3 LP position via NonfungiblePositionManager.

use anyhow::Result;

pub struct AddLiquidityArgs {
    pub token_a: String,
    pub token_b: String,
    pub fee: u32,
    pub amount_a: String,
    pub amount_b: String,
    pub tick_lower: Option<i32>,
    pub tick_upper: Option<i32>,
    pub slippage: f64,
    pub chain: u64,
    pub dry_run: bool,
    pub confirm: bool,
}

pub async fn run(args: AddLiquidityArgs) -> Result<()> {
    let cfg = crate::config::get_chain_config(args.chain)?;

    // Resolve token symbols to addresses first
    let addr_a = crate::config::resolve_token_address(&args.token_a, args.chain)?;
    let addr_b = crate::config::resolve_token_address(&args.token_b, args.chain)?;

    // Sort tokens: token0 < token1 numerically (required by NonfungiblePositionManager)
    let (token0, token1) = crate::calldata::sort_tokens(&addr_a, &addr_b)?;
    let (amount_a_str, amount_b_str) = if token0 == addr_a.as_str() {
        (args.amount_a.as_str(), args.amount_b.as_str())
    } else {
        (args.amount_b.as_str(), args.amount_a.as_str())
    };

    let decimals0 = crate::rpc::get_decimals(token0, cfg.rpc_url).await.unwrap_or(18);
    let decimals1 = crate::rpc::get_decimals(token1, cfg.rpc_url).await.unwrap_or(18);
    let sym0 = crate::rpc::get_symbol(token0, cfg.rpc_url).await.unwrap_or_else(|_| token0.to_string());
    let sym1 = crate::rpc::get_symbol(token1, cfg.rpc_url).await.unwrap_or_else(|_| token1.to_string());

    let amount0_desired = crate::config::human_to_minimal(amount_a_str, decimals0)?;
    let amount1_desired = crate::config::human_to_minimal(amount_b_str, decimals1)?;

    if amount0_desired == 0 && amount1_desired == 0 {
        anyhow::bail!("Both amounts are zero — provide at least one non-zero amount.");
    }

    let spacing = crate::config::tick_spacing(args.fee)?;

    // Resolve tick range + fetch pool slot0 (needed for both auto-tick and slippage math)
    let pool = crate::rpc::get_pool_address(cfg.factory, token0, token1, args.fee, cfg.rpc_url).await
        .map_err(|e| anyhow::anyhow!("Could not find pool (fee {}, chain {}): {}. Try specifying --tick-lower and --tick-upper manually.", args.fee, args.chain, e))?;
    let (sqrt_price_x96, current_tick) = crate::rpc::get_slot0(&pool, cfg.rpc_url).await?;

    let (tick_lower, tick_upper) = match (args.tick_lower, args.tick_upper) {
        (Some(tl), Some(tu)) => {
            if tl % spacing != 0 || tu % spacing != 0 {
                anyhow::bail!(
                    "Ticks must be multiples of tickSpacing ({}) for fee tier {}. Got tickLower={}, tickUpper={}",
                    spacing, args.fee, tl, tu
                );
            }
            if tl >= tu {
                anyhow::bail!("tickLower ({}) must be less than tickUpper ({})", tl, tu);
            }
            (tl, tu)
        }
        (None, None) => {
            // Auto-compute: ±10% price range ≈ ±1000 ticks, aligned to tickSpacing.
            let range = 1000i32.max(spacing * 20);
            // Euclidean division so negative ticks round toward −∞ (correct alignment)
            let tl = (current_tick - range).div_euclid(spacing) * spacing;
            let tu = (current_tick + range).div_euclid(spacing) * spacing;
            println!("Auto tick range: {} to {} (current tick: {}, ±{} ticks)", tl, tu, current_tick, range);
            (tl, tu)
        }
        _ => anyhow::bail!("Provide both --tick-lower and --tick-upper, or omit both for auto ±10% range."),
    };

    // Fetch wallet address early — needed for balance check and as mint recipient
    let wallet_address = if args.dry_run {
        "0x0000000000000000000000000000000000000001".to_string()
    } else {
        crate::onchainos::get_wallet_address().await?
    };

    // Pre-flight balance check — cap desired amounts to actual wallet balance.
    // V3 math uses at most amount0_desired / amount1_desired, so if the wallet
    // holds slightly less (e.g. dust gap from a prior tx), we cap down and proceed
    // rather than bailing. If the shortfall is large (> 1%), we bail clearly.
    let (amount0_desired, amount1_desired) = if args.dry_run {
        (amount0_desired, amount1_desired)
    } else {
        let bal0 = crate::rpc::get_balance(token0, &wallet_address, cfg.rpc_url).await?;
        let bal1 = crate::rpc::get_balance(token1, &wallet_address, cfg.rpc_url).await?;

        let cap = |bal: u128, desired: u128, sym: &str, dec: u8| -> anyhow::Result<u128> {
            if bal >= desired {
                return Ok(desired);
            }
            let shortfall_pct = (desired - bal) as f64 / desired as f64 * 100.0;
            if shortfall_pct > 1.0 {
                anyhow::bail!(
                    "Insufficient {} balance: need {:.6}, have {:.6}. Add funds before adding liquidity.",
                    sym,
                    desired as f64 / 10f64.powi(dec as i32),
                    bal as f64 / 10f64.powi(dec as i32),
                );
            }
            eprintln!(
                "[pancakeswap-v3] NOTE: Requested {:.6} {} but wallet holds {:.6}. \
                 Adjusting down to available balance ({:.4}% gap).",
                desired as f64 / 10f64.powi(dec as i32),
                sym,
                bal as f64 / 10f64.powi(dec as i32),
                shortfall_pct,
            );
            Ok(bal)
        };

        let d0 = cap(bal0, amount0_desired, &sym0, decimals0)?;
        let d1 = cap(bal1, amount1_desired, &sym1, decimals1)?;
        println!(
            "Balance check OK: {:.6} {} available, {:.6} {} available",
            bal0 as f64 / 10f64.powi(decimals0 as i32), sym0,
            bal1 as f64 / 10f64.powi(decimals1 as i32), sym1,
        );
        (d0, d1)
    };

    // Compute actual deposit amounts using V3 math, then apply slippage to those.
    // V3 deposits the optimal ratio for current price — applying slippage to the
    // desired amounts produces incorrect (too-tight) minimums and causes reverts.
    let (actual0, actual1) = crate::rpc::amounts_for_add_liquidity(
        sqrt_price_x96, tick_lower, tick_upper, current_tick,
        amount0_desired, amount1_desired,
    );
    let slippage_bps = (args.slippage * 100.0) as u128;
    let amount0_min = actual0.saturating_mul(10000 - slippage_bps) / 10000;
    let amount1_min = actual1.saturating_mul(10000 - slippage_bps) / 10000;
    println!(
        "Expected deposit: {:.6} {} / {:.6} {} → min: {:.6} / {:.6} ({}% slippage)",
        actual0 as f64 / 10f64.powi(decimals0 as i32), sym0,
        actual1 as f64 / 10f64.powi(decimals1 as i32), sym1,
        amount0_min as f64 / 10f64.powi(decimals0 as i32),
        amount1_min as f64 / 10f64.powi(decimals1 as i32),
        args.slippage,
    );

    // Deadline: 20 minutes from now
    let deadline = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map(|d| d.as_secs() + 1200)
        .unwrap_or(9_999_999_999);

    println!("Add Liquidity (chain {}):", args.chain);
    println!("  Token0 (token0 < token1): {} {}", amount_a_str, sym0);
    println!("  Token1:                   {} {}", amount_b_str, sym1);
    println!("  Fee tier:                 {}%", args.fee as f64 / 10000.0);
    println!("  Tick range:               {} to {}", tick_lower, tick_upper);
    println!("  NPM:                      {}", cfg.npm);

    // Step 1: Approve token0 for NPM
    println!("\nStep 1: Approving {} for NonfungiblePositionManager...", sym0);
    eprintln!("WARNING: Approving {} {} to {} -- approving exact amount only. Use --dry-run to preview.", amount0_desired, sym0, cfg.npm);
    let approve0_calldata = crate::calldata::encode_approve(cfg.npm, amount0_desired)?;

    if args.dry_run {
        println!("  [dry-run] onchainos wallet contract-call --chain {} --to {} --input-data {}", args.chain, token0, approve0_calldata);
    } else {
        let r = crate::onchainos::wallet_contract_call(args.chain, token0, &approve0_calldata, None, None, args.dry_run, args.confirm).await?;
        let approve0_hash = crate::onchainos::extract_tx_hash(&r).to_string();
        eprintln!("  Approve {} tx: {} — waiting for confirmation...", sym0, approve0_hash);
        crate::onchainos::wait_and_check_receipt(&approve0_hash, cfg.rpc_url).await
            .map_err(|e| anyhow::anyhow!("{} approve did not confirm: {}", sym0, e))?;
    }

    // Step 2: Approve token1 for NPM
    println!("\nStep 2: Approving {} for NonfungiblePositionManager...", sym1);
    eprintln!("WARNING: Approving {} {} to {} -- approving exact amount only. Use --dry-run to preview.", amount1_desired, sym1, cfg.npm);
    let approve1_calldata = crate::calldata::encode_approve(cfg.npm, amount1_desired)?;

    if args.dry_run {
        println!("  [dry-run] onchainos wallet contract-call --chain {} --to {} --input-data {}", args.chain, token1, approve1_calldata);
    } else {
        let r = crate::onchainos::wallet_contract_call(args.chain, token1, &approve1_calldata, None, None, args.dry_run, args.confirm).await?;
        let approve1_hash = crate::onchainos::extract_tx_hash(&r).to_string();
        eprintln!("  Approve {} tx: {} — waiting for confirmation...", sym1, approve1_hash);
        crate::onchainos::wait_and_check_receipt(&approve1_hash, cfg.rpc_url).await
            .map_err(|e| anyhow::anyhow!("{} approve did not confirm: {}", sym1, e))?;
    }

    // Step 3: Mint position
    println!("\nStep 3: Minting LP position via NonfungiblePositionManager.mint...");
    println!("  Recipient:                {}", wallet_address);
    let mint_calldata = crate::calldata::encode_mint(
        token0,
        token1,
        args.fee,
        tick_lower,
        tick_upper,
        amount0_desired,
        amount1_desired,
        amount0_min,
        amount1_min,
        &wallet_address,
        deadline,
    )?;

    if args.dry_run {
        println!("  [dry-run] onchainos wallet contract-call --chain {} --to {} --input-data {}", args.chain, cfg.npm, mint_calldata);
        println!("\nDry-run complete. No transactions submitted.");
        return Ok(());
    }

    let r = crate::onchainos::wallet_contract_call(args.chain, cfg.npm, &mint_calldata, None, None, args.dry_run, args.confirm).await?;
    let tx_hash = crate::onchainos::extract_tx_hash(&r);
    println!("  Mint tx: {}", tx_hash);
    println!("  Waiting for on-chain confirmation...");
    crate::onchainos::wait_and_check_receipt(tx_hash, cfg.rpc_url).await?;
    println!("\nLP position minted successfully!");

    Ok(())
}

pub mod swap;
pub mod quote;
pub mod pools;
pub mod positions;
pub mod add_liquidity;
pub mod remove_liquidity;
pub mod quickstart;

/// `pancakeswap pools` — list pools for a token pair via PancakeV3Factory.

use anyhow::Result;

pub struct PoolsArgs {
    pub token0: String,
    pub token1: String,
    pub chain: u64,
}

pub async fn run(args: PoolsArgs) -> Result<()> {
    let cfg = crate::config::get_chain_config(args.chain)?;

    let addr0 = crate::config::resolve_token_address(&args.token0, args.chain)?;
    let addr1 = crate::config::resolve_token_address(&args.token1, args.chain)?;

    let sym0 = crate::rpc::get_symbol(&addr0, cfg.rpc_url).await.unwrap_or_else(|_| args.token0.clone());
    let sym1 = crate::rpc::get_symbol(&addr1, cfg.rpc_url).await.unwrap_or_else(|_| args.token1.clone());

    println!("Pools for {}/{} on chain {} (factory: {})", sym0, sym1, args.chain, cfg.factory);
    println!("{:<8} {:<44} {:>14} {:>12}", "Fee", "Pool Address", "Liquidity", "sqrtPrice");
    println!("{}", "-".repeat(80));

    let fee_tiers = [100u32, 500, 2500, 10000];
    let mut found = 0;

    for fee in fee_tiers {
        match crate::rpc::get_pool_address(cfg.factory, &addr0, &addr1, fee, cfg.rpc_url).await {
            Ok(pool_addr) => {
                found += 1;
                let fee_label = format!("{:.2}%", fee as f64 / 10000.0);

                // Query slot0 and liquidity — surface RPC errors explicitly
                // so agents don't mistake rate-limit failures for tick=0 bugs.
                let slot0 = crate::rpc::get_slot0(&pool_addr, cfg.rpc_url).await;
                let liq = crate::rpc::get_pool_liquidity(&pool_addr, cfg.rpc_url).await;

                match (slot0, liq) {
                    (Ok((sqrt_price, tick)), Ok(liquidity)) => {
                        let price = if sqrt_price > 0 {
                            let sq = sqrt_price as f64 / 2f64.powi(96);
                            format!("{:.4}", sq * sq)
                        } else {
                            "N/A".to_string()
                        };
                        println!(
                            "{:<8} {:<44} {:>14} {:>12}",
                            fee_label, pool_addr, liquidity, price,
                        );
                        println!("         tick: {}", tick);
                    }
                    (slot0_res, liq_res) => {
                        let err = slot0_res.err()
                            .or(liq_res.err())
                            .map(|e| e.to_string())
                            .unwrap_or_else(|| "unknown error".to_string());
                        println!(
                            "{:<8} {:<44} [RPC error — try again or check rate limits]",
                            fee_label, pool_addr,
                        );
                        println!("         error: {}", err);
                    }
                }
            }
            Err(_) => {
                // Pool doesn't exist for this fee tier — skip silently
            }
        }
    }

    if found == 0 {
        println!("No pools found for this token pair on chain {}.", args.chain);
        println!("Verify the token addresses are correct.");
    } else {
        println!("\nFound {} pool(s).", found);
    }

    Ok(())
}

/// `pancakeswap positions` — view LP positions for a wallet address.
/// Uses TheGraph subgraph for BSC; on-chain enumeration fallback for Base or if subgraph fails.

use anyhow::Result;

pub struct PositionsArgs {
    pub owner: String,
    pub chain: u64,
}

pub async fn run(args: PositionsArgs) -> Result<()> {
    let cfg = crate::config::get_chain_config(args.chain)?;

    println!("LP Positions for {} on chain {}:", args.owner, args.chain);
    println!();

    // Try subgraph first
    match query_subgraph(cfg, &args.owner).await {
        Ok(true) => return Ok(()),
        Ok(false) => {
            println!("No positions found via subgraph. Trying on-chain enumeration...");
        }
        Err(e) => {
            eprintln!("Subgraph query failed: {}. Falling back to on-chain enumeration.", e);
        }
    }

    // On-chain fallback: enumerate via NonfungiblePositionManager
    query_onchain(cfg, &args.owner).await
}

async fn query_subgraph(
    cfg: &crate::config::ChainConfig,
    owner: &str,
) -> Result<bool> {
    let resp = crate::rpc::query_positions_subgraph(cfg.subgraph_url, owner).await?;

    let positions = resp["data"]["positions"]
        .as_array()
        .ok_or_else(|| anyhow::anyhow!("Unexpected subgraph response format"))?;

    if positions.is_empty() {
        return Ok(false);
    }

    println!("Found {} position(s) via subgraph:\n", positions.len());

    for pos in positions {
        let id = pos["id"].as_str().unwrap_or("?");
        let sym0 = pos["token0"]["symbol"].as_str().unwrap_or("?");
        let sym1 = pos["token1"]["symbol"].as_str().unwrap_or("?");
        let fee = pos["feeTier"].as_str().unwrap_or("?");
        let liquidity = pos["liquidity"].as_str().unwrap_or("0");
        let tick_lower = pos["tickLower"]["tickIdx"].as_str().unwrap_or("?");
        let tick_upper = pos["tickUpper"]["tickIdx"].as_str().unwrap_or("?");
        let dep0 = pos["depositedToken0"].as_str().unwrap_or("0");
        let dep1 = pos["depositedToken1"].as_str().unwrap_or("0");
        let fee0 = pos["collectedFeesToken0"].as_str().unwrap_or("0");
        let fee1 = pos["collectedFeesToken1"].as_str().unwrap_or("0");

        println!("  Position #{}", id);
        println!("    Pair:       {}/{}", sym0, sym1);
        println!("    Fee tier:   {}%", fee.parse::<f64>().unwrap_or(0.0) / 10000.0);
        println!("    Tick range: {} to {}", tick_lower, tick_upper);
        println!("    Liquidity:  {}", liquidity);
        println!("    Deposited:  {} {} / {} {}", dep0, sym0, dep1, sym1);
        println!("    Fees coll.: {} {} / {} {}", fee0, sym0, fee1, sym1);
        println!();
    }

    Ok(true)
}

async fn query_onchain(
    cfg: &crate::config::ChainConfig,
    owner: &str,
) -> Result<()> {
    let token_ids = crate::rpc::get_token_ids_for_owner(cfg.npm, owner, cfg.rpc_url).await?;

    if token_ids.is_empty() {
        println!("No LP positions found for {} on chain {}.", owner, cfg.chain_id);
        return Ok(());
    }

    println!("Found {} position(s) on-chain:\n", token_ids.len());

    for token_id in token_ids {
        match crate::rpc::get_position(cfg.npm, token_id, cfg.rpc_url).await {
            Ok(pos) => {
                let sym0 = crate::rpc::get_symbol(&pos.token0, cfg.rpc_url).await.unwrap_or_else(|_| pos.token0.clone());
                let sym1 = crate::rpc::get_symbol(&pos.token1, cfg.rpc_url).await.unwrap_or_else(|_| pos.token1.clone());
                let dec0 = crate::rpc::get_decimals(&pos.token0, cfg.rpc_url).await.unwrap_or(18);
                let dec1 = crate::rpc::get_decimals(&pos.token1, cfg.rpc_url).await.unwrap_or(18);

                println!("  Position #{}", token_id);
                println!("    Pair:         {}/{}", sym0, sym1);
                println!("    Fee tier:     {}%", pos.fee as f64 / 10000.0);
                println!("    Tick range:   {} to {}", pos.tick_lower, pos.tick_upper);
                println!("    Liquidity:    {}", pos.liquidity);
                println!("    Owed fees:    {:.6} {} / {:.6} {}",
                    pos.tokens_owed0 as f64 / 10f64.powi(dec0 as i32), sym0,
                    pos.tokens_owed1 as f64 / 10f64.powi(dec1 as i32), sym1);
                println!();
            }
            Err(e) => {
                eprintln!("  Error fetching position #{}: {}", token_id, e);
            }
        }
    }

    Ok(())
}

/// `pancakeswap-v3 quickstart` — onboarding status and suggested first command.

use anyhow::Result;

const ABOUT: &str = "PancakeSwap V3 is the leading DEX on BNB Chain — swap tokens and provide \
    concentrated liquidity across BNB Chain, Base, Arbitrum, Ethereum, and Linea \
    with industry-low fees and deep liquidity.";

// BSC token addresses (default chain)
const USDT_BSC: &str = "0x55d398326f99059fF775485246999027B3197955"; // 18 dec
const USDC_BSC: &str = "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d"; // 18 dec

// Minimum thresholds
const MIN_BNB_GAS_WEI: u128 = 2_000_000_000_000_000; // 0.002 BNB — covers a swap tx
const MIN_TOKEN_RAW: u128 = 5_000_000_000_000_000_000; // 5 USDT/USDC (18 dec)

pub async fn run(wallet_override: Option<&str>) -> Result<()> {
    let wallet = match wallet_override {
        Some(w) => w.to_string(),
        None => crate::onchainos::get_wallet_address().await?,
    };

    eprintln!("Checking assets for {}...", &wallet[..wallet.len().min(10)]);

    let cfg = crate::config::get_chain_config(56)?; // BSC default

    // Fetch in parallel: native BNB, USDT, USDC, LP position count
    let (bnb_result, usdt_result, usdc_result, lp_result) = tokio::join!(
        crate::rpc::get_native_balance(&wallet, cfg.rpc_url),
        crate::rpc::get_balance(USDT_BSC, &wallet, cfg.rpc_url),
        crate::rpc::get_balance(USDC_BSC, &wallet, cfg.rpc_url),
        crate::rpc::get_lp_position_count(cfg.npm, &wallet, cfg.rpc_url),
    );

    let bnb_wei = bnb_result.unwrap_or(0);
    let usdt_raw = usdt_result.unwrap_or(0);
    let usdc_raw = usdc_result.unwrap_or(0);
    let lp_count = lp_result.unwrap_or(0);

    let bnb = bnb_wei as f64 / 1e18;
    let usdt = usdt_raw as f64 / 1e18;
    let usdc = usdc_raw as f64 / 1e18;
    let token_usd = usdt + usdc;

    let (status, suggestion, onboarding_steps, next_command) =
        build_suggestion(&wallet, bnb_wei, token_usd, lp_count);

    let mut out = serde_json::json!({
        "ok": true,
        "about": ABOUT,
        "wallet": wallet,
        "assets": {
            "bnb_balance":       format!("{:.6}", bnb),
            "usdt_balance":      format!("{:.4}", usdt),
            "usdc_balance":      format!("{:.4}", usdc),
            "lp_positions_bsc":  lp_count,
        },
        "status":       status,
        "suggestion":   suggestion,
        "next_command": next_command,
    });

    if !onboarding_steps.is_empty() {
        out["onboarding_steps"] = serde_json::json!(onboarding_steps);
    }

    println!("{}", serde_json::to_string_pretty(&out)?);
    Ok(())
}

fn build_suggestion(
    wallet: &str,
    bnb_wei: u128,
    token_usd: f64,
    lp_count: usize,
) -> (&'static str, &'static str, Vec<String>, String) {
    // Case 1: active LP — has positions on BSC
    if lp_count > 0 {
        return (
            "active",
            "You have active V3 LP positions on BNB Chain.",
            vec![],
            format!("pancakeswap-v3 positions --owner {} --chain 56", wallet),
        );
    }

    // Case 2: ready — has gas + tokens
    if bnb_wei >= MIN_BNB_GAS_WEI && token_usd >= 5.0 {
        let swap_amount = (token_usd * 0.9 * 100.0).floor() / 100.0;
        return (
            "ready",
            "Your wallet is funded. You can swap tokens or add liquidity on BNB Chain.",
            vec![
                "1. Check available pools for USDT/USDC:".to_string(),
                "   pancakeswap-v3 pools --token0 USDT --token1 USDC --chain 56".to_string(),
                "2. Preview a swap (no --confirm = preview only):".to_string(),
                format!("   pancakeswap-v3 swap --from USDT --to WBNB --amount {:.2} --chain 56", swap_amount.min(token_usd)),
                "3. Add --confirm to execute:".to_string(),
                format!("   pancakeswap-v3 swap --from USDT --to WBNB --amount {:.2} --chain 56 --confirm", swap_amount.min(token_usd)),
            ],
            "pancakeswap-v3 pools --token0 USDT --token1 USDC --chain 56".to_string(),
        );
    }

    // Case 3: has tokens but no gas
    if token_usd >= 5.0 {
        return (
            "needs_gas",
            "You have tokens but need BNB for gas fees. Send at least 0.002 BNB to your BSC wallet.",
            vec![
                "1. Send at least 0.002 BNB to your BSC wallet:".to_string(),
                format!("   {}", wallet),
                "2. Run quickstart again to confirm:".to_string(),
                "   pancakeswap-v3 quickstart".to_string(),
            ],
            "pancakeswap-v3 quickstart".to_string(),
        );
    }

    // Case 4: has gas but no tokens
    if bnb_wei >= MIN_BNB_GAS_WEI {
        return (
            "needs_funds",
            "You have BNB for gas but need tokens to swap or add liquidity. Send at least 5 USDT or USDC to your BSC wallet.",
            vec![
                "1. Send at least 5 USDT or USDC to your BSC wallet:".to_string(),
                format!("   {}", wallet),
                "2. Run quickstart again to confirm:".to_string(),
                "   pancakeswap-v3 quickstart".to_string(),
                "3. Then swap or add liquidity:".to_string(),
                "   pancakeswap-v3 swap --from USDT --to WBNB --amount 5 --chain 56 --confirm".to_string(),
            ],
            "pancakeswap-v3 quickstart".to_string(),
        );
    }

    // Case 5: no funds at all
    (
        "no_funds",
        "No BNB or tokens found. Send BNB (for gas) and USDT/USDC to your BSC wallet to get started.",
        vec![
            "1. Send BNB (at least 0.002) and USDT/USDC (at least 5) to your BSC wallet:".to_string(),
            format!("   {}", wallet),
            "2. Run quickstart again to confirm:".to_string(),
            "   pancakeswap-v3 quickstart".to_string(),
            "3. Preview a swap:".to_string(),
            "   pancakeswap-v3 swap --from USDT --to WBNB --amount 5 --chain 56".to_string(),
            "4. Execute with --confirm when ready.".to_string(),
        ],
        "pancakeswap-v3 quickstart".to_string(),
    )
}

/// `pancakeswap quote` — get swap quote via QuoterV2 eth_call.

use anyhow::Result;

pub struct QuoteArgs {
    pub from: String,
    pub to: String,
    pub amount: String,
    pub chain: u64,
}

pub async fn run(args: QuoteArgs) -> Result<()> {
    let cfg = crate::config::get_chain_config(args.chain)?;

    // Resolve token symbols to addresses
    let from_addr = crate::config::resolve_token_address(&args.from, args.chain)?;
    let to_addr = crate::config::resolve_token_address(&args.to, args.chain)?;

    if from_addr == to_addr {
        anyhow::bail!("tokenIn and tokenOut must be different tokens.");
    }

    // Resolve decimals for the input token
    let decimals_in = crate::rpc::get_decimals(&from_addr, cfg.rpc_url).await.unwrap_or(18);
    let decimals_out = crate::rpc::get_decimals(&to_addr, cfg.rpc_url).await.unwrap_or(18);
    let symbol_in = crate::rpc::get_symbol(&from_addr, cfg.rpc_url).await.unwrap_or_else(|_| args.from.clone());
    let symbol_out = crate::rpc::get_symbol(&to_addr, cfg.rpc_url).await.unwrap_or_else(|_| args.to.clone());

    let amount_in = crate::config::human_to_minimal(&args.amount, decimals_in)?;

    // Try fee tiers in order of liquidity popularity
    let fee_tiers = [500u32, 100, 2500, 10000];
    let mut best_amount_out = 0u128;
    let mut best_fee = 500u32;
    let mut errors = Vec::new();

    for fee in fee_tiers {
        match crate::rpc::quote_exact_input_single(
            cfg.quoter_v2,
            &from_addr,
            &to_addr,
            amount_in,
            fee,
            cfg.rpc_url,
        ).await {
            Ok(amount_out) if amount_out > best_amount_out => {
                best_amount_out = amount_out;
                best_fee = fee;
            }
            Ok(_) => {}
            Err(e) => errors.push(format!("fee={}: {}", fee, e)),
        }
    }

    if best_amount_out == 0 {
        anyhow::bail!("No liquidity path found for this token pair on chain {}. Use `pancakeswap pools` to verify pools exist.", args.chain);
    }

    let amount_out_human = best_amount_out as f64 / 10f64.powi(decimals_out as i32);
    let amount_in_human: f64 = args.amount.parse().unwrap_or(0.0);

    println!("Quote (chain {}):", args.chain);
    println!("  Input:      {} {}", args.amount, symbol_in);
    println!("  Output:     {:.6} {}", amount_out_human, symbol_out);
    println!("  Fee tier:   {}%", best_fee as f64 / 10000.0);
    println!(
        "  Rate:       1 {} = {:.6} {}",
        symbol_in,
        amount_out_human / amount_in_human,
        symbol_out
    );
    println!("  QuoterV2:   {}", cfg.quoter_v2);

    Ok(())
}

/// `pancakeswap remove-liquidity` — decrease liquidity + collect (two-step).

use anyhow::Result;

pub struct RemoveLiquidityArgs {
    pub token_id: u128,
    pub liquidity_pct: f64,   // 0–100, percentage of position liquidity to remove
    pub slippage: f64,        // slippage tolerance in percent (e.g. 0.5 = 0.5%)
    pub chain: u64,
    pub dry_run: bool,
    pub confirm: bool,
}

pub async fn run(args: RemoveLiquidityArgs) -> Result<()> {
    if args.liquidity_pct <= 0.0 || args.liquidity_pct > 100.0 {
        anyhow::bail!("liquidity-pct must be between 1 and 100 (got {}).", args.liquidity_pct);
    }

    let cfg = crate::config::get_chain_config(args.chain)?;

    // Fetch current position data to verify it exists and get liquidity
    println!("Fetching position #{} on chain {}...", args.token_id, args.chain);
    let pos = crate::rpc::get_position(cfg.npm, args.token_id, cfg.rpc_url).await?;

    if pos.liquidity == 0 && !args.dry_run {
        anyhow::bail!("Position #{} has zero liquidity. Nothing to remove.", args.token_id);
    }
    // In dry-run mode with zero liquidity, use a synthetic value to preview calldata
    let effective_liquidity = if pos.liquidity == 0 && args.dry_run { 1_000_000u128 } else { pos.liquidity };

    let sym0 = crate::rpc::get_symbol(&pos.token0, cfg.rpc_url).await.unwrap_or_else(|_| pos.token0.clone());
    let sym1 = crate::rpc::get_symbol(&pos.token1, cfg.rpc_url).await.unwrap_or_else(|_| pos.token1.clone());
    let dec0 = crate::rpc::get_decimals(&pos.token0, cfg.rpc_url).await.unwrap_or(18);
    let dec1 = crate::rpc::get_decimals(&pos.token1, cfg.rpc_url).await.unwrap_or(18);

    // Use integer arithmetic for 100% to avoid f64 precision loss on large u128 values
    // (f64 has 53-bit mantissa; a 18-digit liquidity value would round up, causing
    // decreaseLiquidity to revert with "cannot remove more than position liquidity").
    let liquidity_to_remove = if args.liquidity_pct >= 100.0 {
        effective_liquidity
    } else {
        ((effective_liquidity as u128).saturating_mul(args.liquidity_pct as u128) / 100).min(effective_liquidity)
    };

    // Bug 3 fix: compute actual token amounts from V3 liquidity math using the current
    // pool price, instead of the incorrect tokens_owed proxy used previously.
    // tokens_owed represents already-accrued fees credited to the position — it is
    // completely unrelated to the amounts returned by decreaseLiquidity, which are
    // derived from the position's liquidity and the current sqrtPrice.
    let pool = crate::rpc::get_pool_address(cfg.factory, &pos.token0, &pos.token1, pos.fee, cfg.rpc_url).await?;
    let (sqrt_price_x96, tick_current) = crate::rpc::get_slot0(&pool, cfg.rpc_url).await?;
    let (amount0_out, amount1_out) = crate::rpc::amounts_from_liquidity(
        sqrt_price_x96,
        pos.tick_lower,
        pos.tick_upper,
        tick_current,
        liquidity_to_remove,
    );

    let slippage_bps = (args.slippage * 100.0) as u128;
    let amount0_min = amount0_out.saturating_mul(10000 - slippage_bps) / 10000;
    let amount1_min = amount1_out.saturating_mul(10000 - slippage_bps) / 10000;

    println!("Remove Liquidity (chain {}):", args.chain);
    println!("  Position:     #{}", args.token_id);
    println!("  Pair:         {}/{}", sym0, sym1);
    println!("  Current tick: {} (pool sqrtPriceX96: {})", tick_current, sqrt_price_x96);
    println!("  Total liq:    {}{}", effective_liquidity, if pos.liquidity == 0 && args.dry_run { " [synthetic for dry-run]" } else { "" });
    println!("  Remove:       {}% = {}", args.liquidity_pct, liquidity_to_remove);
    println!("  Tick range:   {} to {}", pos.tick_lower, pos.tick_upper);
    println!("  Expected out: {:.6} {} / {:.6} {} (before slippage)",
        amount0_out as f64 / 10f64.powi(dec0 as i32), sym0,
        amount1_out as f64 / 10f64.powi(dec1 as i32), sym1);
    println!("  Min out:      {:.6} {} / {:.6} {} ({}% slippage)",
        amount0_min as f64 / 10f64.powi(dec0 as i32), sym0,
        amount1_min as f64 / 10f64.powi(dec1 as i32), sym1,
        args.slippage);
    println!("  Owed fees:    {:.6} {} / {:.6} {}",
        pos.tokens_owed0 as f64 / 10f64.powi(dec0 as i32), sym0,
        pos.tokens_owed1 as f64 / 10f64.powi(dec1 as i32), sym1);
    println!("  NPM:          {}", cfg.npm);

    // Deadline: 20 minutes from now
    let deadline = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .map(|d| d.as_secs() + 1200)
        .unwrap_or(9_999_999_999);

    // Fetch wallet address for use as collect recipient
    let wallet_address = if args.dry_run {
        "0x0000000000000000000000000000000000000001".to_string()
    } else {
        crate::onchainos::get_wallet_address().await?
    };

    // Step 1: decreaseLiquidity
    println!("\nStep 1: Calling decreaseLiquidity...");
    println!("  amount0Min: {:.6} {} (slippage {}%)", amount0_min as f64 / 10f64.powi(dec0 as i32), sym0, args.slippage);
    println!("  amount1Min: {:.6} {} (slippage {}%)", amount1_min as f64 / 10f64.powi(dec1 as i32), sym1, args.slippage);
    let decrease_calldata = crate::calldata::encode_decrease_liquidity(
        args.token_id,
        liquidity_to_remove,
        amount0_min,
        amount1_min,
        deadline,
    )?;

    if args.dry_run {
        println!("  [dry-run] onchainos wallet contract-call --chain {} --to {} --input-data {}", args.chain, cfg.npm, decrease_calldata);
    } else {
        let r = crate::onchainos::wallet_contract_call(args.chain, cfg.npm, &decrease_calldata, None, None, args.dry_run, args.confirm).await?;
        let decrease_hash = crate::onchainos::extract_tx_hash(&r).to_string();
        eprintln!("  decreaseLiquidity tx: {} — waiting for confirmation...", decrease_hash);
        crate::onchainos::wait_and_check_receipt(&decrease_hash, cfg.rpc_url).await
            .map_err(|e| anyhow::anyhow!("decreaseLiquidity did not confirm: {}", e))?;
    }

    // Step 2: collect — MUST always follow decreaseLiquidity
    // Note: decreaseLiquidity credits tokens to the position but does NOT transfer them.
    // collect transfers the credited tokens to the recipient.
    println!("\nStep 2: Calling collect to transfer tokens to wallet...");
    println!("  Recipient: {}", wallet_address);
    let collect_calldata = crate::calldata::encode_collect(
        args.token_id,
        &wallet_address,
    )?;

    if args.dry_run {
        println!("  [dry-run] onchainos wallet contract-call --chain {} --to {} --input-data {}", args.chain, cfg.npm, collect_calldata);
        println!("\nDry-run complete. No transactions submitted.");
        return Ok(());
    }

    let r = crate::onchainos::wallet_contract_call(args.chain, cfg.npm, &collect_calldata, None, None, args.dry_run, args.confirm).await?;
    println!("  collect tx: {}", crate::onchainos::extract_tx_hash(&r));
    println!("\nLiquidity removed and tokens collected successfully!");

    Ok(())
}

/// `pancakeswap-v3 swap` — exact-input token swap via SmartRouter.

use anyhow::Result;

pub struct SwapArgs {
    pub from: String,
    pub to: String,
    pub amount: String,
    pub slippage: f64,
    pub chain: u64,
    pub dry_run: bool,
    pub confirm: bool,
}

pub async fn run(args: SwapArgs) -> Result<()> {
    let cfg = crate::config::get_chain_config(args.chain)?;

    // Resolve token symbols to addresses
    let from_addr = crate::config::resolve_token_address(&args.from, args.chain)?;
    let to_addr = crate::config::resolve_token_address(&args.to, args.chain)?;

    if from_addr == to_addr {
        anyhow::bail!("tokenIn and tokenOut must be different tokens.");
    }

    // Resolve token metadata
    let decimals_in = crate::rpc::get_decimals(&from_addr, cfg.rpc_url).await.unwrap_or(18);
    let decimals_out = crate::rpc::get_decimals(&to_addr, cfg.rpc_url).await.unwrap_or(18);
    let symbol_in = crate::rpc::get_symbol(&from_addr, cfg.rpc_url).await.unwrap_or_else(|_| args.from.clone());
    let symbol_out = crate::rpc::get_symbol(&to_addr, cfg.rpc_url).await.unwrap_or_else(|_| args.to.clone());

    let amount_in = crate::config::human_to_minimal(&args.amount, decimals_in)?;

    if amount_in == 0 {
        anyhow::bail!("Amount must be greater than 0.");
    }

    // Fetch wallet address early so we can check balance before RPC quote calls
    let wallet_addr = crate::onchainos::get_wallet_address().await
        .unwrap_or_else(|_| "0x0000000000000000000000000000000000000000".to_string());

    // Check sufficient balance before making expensive quote RPC calls.
    // Skip in dry-run: wallet may not be connected and the calldata preview is still useful.
    if !args.dry_run {
        let balance_in = crate::rpc::get_balance(&from_addr, &wallet_addr, cfg.rpc_url).await?;
        if balance_in < amount_in {
            let have = balance_in as f64 / 10f64.powi(decimals_in as i32);
            let need = amount_in as f64 / 10f64.powi(decimals_in as i32);
            anyhow::bail!(
                "Insufficient balance: have {:.6} {}, need {:.6} {}",
                have, symbol_in, need, symbol_in
            );
        }
    }

    // Get best quote across fee tiers, verifying pool has actual liquidity
    let fee_tiers = [100u32, 500, 2500, 10000];
    let mut best_out = 0u128;
    let mut best_fee = 500u32;

    for fee in fee_tiers {
        // Verify pool exists via factory (non-zero address = pool deployed)
        let pool_exists = crate::rpc::get_pool_address(
            cfg.factory, &from_addr, &to_addr, fee, cfg.rpc_url
        ).await.is_ok();
        if !pool_exists {
            continue;
        }

        match crate::rpc::quote_exact_input_single(
            cfg.quoter_v2,
            &from_addr,
            &to_addr,
            amount_in,
            fee,
            cfg.rpc_url,
        ).await {
            Ok(out) if out > best_out => {
                best_out = out;
                best_fee = fee;
            }
            _ => {}
        }
    }

    if best_out == 0 {
        anyhow::bail!(
            "No liquidity found for {}/{} on chain {}. Use `pancakeswap-v3 pools` to verify pools exist.",
            symbol_in, symbol_out, args.chain
        );
    }

    // Apply slippage tolerance using integer arithmetic (avoids f64 precision loss on large wei values)
    // slippage is in percent (e.g. 0.5 means 0.5%), convert to bps (50 bps)
    let slippage_bps = (args.slippage * 100.0) as u128;
    let amount_out_minimum = best_out.saturating_mul(10000 - slippage_bps) / 10000;

    let amount_out_human = best_out as f64 / 10f64.powi(decimals_out as i32);
    let amount_out_min_human = amount_out_minimum as f64 / 10f64.powi(decimals_out as i32);

    println!("Swap (chain {}):", args.chain);
    println!("  From:             {} {}", args.amount, symbol_in);
    println!("  Expected output:  {:.6} {}", amount_out_human, symbol_out);
    println!("  Minimum output:   {:.6} {} ({}% slippage)", amount_out_min_human, symbol_out, args.slippage);
    println!("  Fee tier:         {}%", best_fee as f64 / 10000.0);
    println!("  SmartRouter:      {}", cfg.smart_router);

    // Preview gate: without --confirm (or with --dry-run), show intent and stop.
    if args.dry_run || !args.confirm {
        let approve_calldata = crate::calldata::encode_approve(cfg.smart_router, amount_in)?;
        let swap_calldata = crate::calldata::encode_exact_input_single(
            &from_addr,
            &to_addr,
            best_fee,
            &wallet_addr,
            amount_in,
            amount_out_minimum,
            cfg.swap_with_deadline,
        )?;
        println!("\nPreview (no transactions broadcast — add --confirm to execute):");
        println!("  Step 1 approve {} {} to SmartRouter:", args.amount, symbol_in);
        println!("    onchainos wallet contract-call --chain {} --to {} --input-data {}", args.chain, from_addr, approve_calldata);
        println!("  Step 2 swap {} {} → min {:.6} {} ({}% slippage):", args.amount, symbol_in, amount_out_min_human, symbol_out, args.slippage);
        println!("    onchainos wallet contract-call --chain {} --to {} --input-data {}", args.chain, cfg.smart_router, swap_calldata);
        return Ok(());
    }

    // Step 1: Approve SmartRouter to spend tokenIn (skip if allowance already sufficient)
    println!("\nStep 1: Approving SmartRouter to spend {}...", symbol_in);
    let approve_calldata = crate::calldata::encode_approve(cfg.smart_router, amount_in)?;

    // Check existing allowance to avoid unnecessary approve (prevents nonce conflicts)
    let allowance = crate::rpc::get_allowance(&from_addr, &wallet_addr, cfg.smart_router, cfg.rpc_url)
        .await
        .unwrap_or_else(|e| {
            eprintln!("  [warn] allowance check failed ({}), proceeding with approve.", e);
            0
        });
    if allowance >= amount_in {
        println!("  Allowance already sufficient ({}), skipping approve.", allowance);
    } else {
        let approve_result = crate::onchainos::wallet_contract_call(
            args.chain,
            &from_addr,
            &approve_calldata,
            None,
            None,
            args.dry_run,
            args.confirm,
        ).await?;
        let approve_tx = crate::onchainos::extract_tx_hash(&approve_result);
        println!("  Approve tx: {}", approve_tx);
        // Wait for approve to be confirmed on-chain before submitting swap.
        // 3s was too short for Ethereum (~12s blocks) — STF revert if swap lands first.
        crate::onchainos::wait_and_check_receipt(approve_tx, cfg.rpc_url).await?;
    }

    // Step 2: Execute swap via SmartRouter.exactInputSingle
    let recipient_placeholder = wallet_addr;

    println!("\nStep 2: Executing swap via SmartRouter.exactInputSingle...");
    let swap_calldata = crate::calldata::encode_exact_input_single(
        &from_addr,
        &to_addr,
        best_fee,
        &recipient_placeholder,
        amount_in,
        amount_out_minimum,
        cfg.swap_with_deadline,
    )?;

    let swap_result = crate::onchainos::wallet_contract_call(
        args.chain,
        cfg.smart_router,
        &swap_calldata,
        None,
        None,
        args.dry_run,
        args.confirm,
    ).await?;

    let tx_hash = crate::onchainos::extract_tx_hash(&swap_result);
    println!("  Swap tx: {}", tx_hash);
    println!("\nSwap submitted successfully!");
    println!("  Swapped {} {} -> ~{:.6} {}", args.amount, symbol_in, amount_out_human, symbol_out);

    Ok(())
}