Aerodrome Slipstream

{
  "name": "aerodrome-slipstream-plugin",
  "description": "Swap tokens and manage concentrated liquidity positions on Aerodrome Slipstream (CLMM) on Base",
  "version": "0.2.1",
  "author": {
    "name": "skylavis-sky",
    "github": "skylavis-sky"
  },
  "homepage": "https://aerodrome.finance",
  "repository": "https://github.com/skylavis-sky/onchainos-plugins",
  "license": "MIT",
  "keywords": [
    "dex",
    "amm",
    "concentrated-liquidity",
    "clmm",
    "aerodrome",
    "base",
    "liquidity",
    "defi"
  ]
}

/target/

[package]
name = "aerodrome-slipstream-plugin"
version = "0.2.1"
edition = "2021"

[[bin]]
name = "aerodrome-slipstream-plugin"
path = "src/main.rs"

[dependencies]
clap = { version = "4", features = ["derive"] }
reqwest = { version = "0.12", features = ["json"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "1", features = ["full"] }
anyhow = "1"
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: aerodrome-slipstream-plugin
version: "0.2.1"
description: "Swap tokens and manage concentrated liquidity positions on Aerodrome Slipstream (CLMM) on Base. Supports 9 commands: swap, quote, pools, prices, positions, mint, add/remove liquidity, collect fees."
author:
  name: skylavis-sky
  github: skylavis-sky
category: dapp
tags:
  - aerodrome
  - concentrated-liquidity
  - base
  - clmm
  - defi
license: MIT

components:
  skill:
    dir: .

build:
  lang: rust
  binary_name: aerodrome-slipstream-plugin

api_calls:
  - "https://mainnet.base.org"

use clap::Args;
use tokio::time::{sleep, Duration};
use crate::config::{build_approve_calldata, nfpm, rpc_url, token_symbol, unix_now, CHAIN_ID};
use crate::onchainos::{extract_tx_hash, resolve_wallet, wallet_contract_call};
use crate::rpc::{format_amount, get_allowance, get_decimals, nfpm_positions, parse_human_amount};

#[derive(Args)]
pub struct AddLiquidityArgs {
    /// NFT token ID of the existing position
    #[arg(long)]
    pub token_id: u128,
    /// Additional amount of token0 to add (human-readable)
    #[arg(long)]
    pub amount0: String,
    /// Additional amount of token1 to add (human-readable)
    #[arg(long)]
    pub amount1: String,
    /// Slippage tolerance % (default: 0.5%)
    #[arg(long, default_value = "0.5")]
    pub slippage: f64,
    /// Deadline in minutes (default: 20)
    #[arg(long, default_value = "20")]
    pub deadline_minutes: u64,
    /// Broadcast the transaction. Without this flag, prints a preview only.
    #[arg(long)]
    pub confirm: bool,
    /// Build calldata without calling onchainos
    #[arg(long)]
    pub dry_run: bool,
}

/// NFPM.increaseLiquidity(IncreaseLiquidityParams) — selector 0x219f5d17
/// Params: tokenId(uint256), amount0Desired(uint256), amount1Desired(uint256), amount0Min(uint256), amount1Min(uint256), deadline(uint256)
fn build_increase_liquidity(
    token_id: u128,
    amount0_desired: u128, amount1_desired: u128,
    amount0_min: u128, amount1_min: u128,
    deadline: u64,
) -> String {
    format!(
        "0x219f5d17{}{}{}{}{}{}",
        format!("{:0>64x}", token_id),
        format!("{:0>64x}", amount0_desired),
        format!("{:0>64x}", amount1_desired),
        format!("{:0>64x}", amount0_min),
        format!("{:0>64x}", amount1_min),
        format!("{:0>64x}", deadline),
    )
}

pub async fn run(args: AddLiquidityArgs) -> anyhow::Result<()> {
    let rpc = rpc_url();
    let nfpm_addr = nfpm();

    let pos = nfpm_positions(nfpm_addr, args.token_id, rpc).await?;
    let dec0 = get_decimals(&pos.token0, rpc).await.unwrap_or(18);
    let dec1 = get_decimals(&pos.token1, rpc).await.unwrap_or(18);
    let sym0 = token_symbol(&pos.token0).to_string();
    let sym1 = token_symbol(&pos.token1).to_string();

    let amount0_desired = parse_human_amount(&args.amount0, dec0)?;
    let amount1_desired = parse_human_amount(&args.amount1, dec1)?;
    // For LP positions, the NFPM adjusts actual token ratios based on current pool price.
    // Fixed-percentage minimums cause PSC failures when ratios differ from desired.
    let amount0_min: u128 = 0;
    let amount1_min: u128 = 0;

    let recipient = if args.dry_run {
        "0x0000000000000000000000000000000000000000".to_string()
    } else {
        resolve_wallet(CHAIN_ID)?
    };

    let deadline = unix_now() + args.deadline_minutes * 60;
    let calldata = build_increase_liquidity(
        args.token_id, amount0_desired, amount1_desired, amount0_min, amount1_min, deadline,
    );

    let preview = serde_json::json!({
        "preview": true,
        "action": "add-liquidity",
        "token_id": args.token_id,
        "token0": sym0,
        "token1": sym1,
        "tick_lower": pos.tick_lower,
        "tick_upper": pos.tick_upper,
        "amount0_desired": format_amount(amount0_desired, dec0),
        "amount1_desired": format_amount(amount1_desired, dec1),
        "chain": "Base (8453)"
    });

    if !args.confirm && !args.dry_run {
        println!("{}", serde_json::to_string_pretty(&preview)?);
        eprintln!("\nAdd --confirm to increase liquidity in position {}.", args.token_id);
        return Ok(());
    }

    if !args.dry_run {
        let allow0 = get_allowance(&pos.token0, &recipient, nfpm_addr, rpc).await?;
        if allow0 < amount0_desired {
            eprintln!("[aerodrome-slipstream-plugin] Approving {} for NFPM...", sym0);
            let approve0 = build_approve_calldata(nfpm_addr, amount0_desired);
            let r = wallet_contract_call(CHAIN_ID, &pos.token0, &approve0, true, false, Some(&recipient)).await?;
            eprintln!("[aerodrome-slipstream-plugin] Approve {} tx: {}", sym0, extract_tx_hash(&r));
            sleep(Duration::from_secs(5)).await;
        }
        let allow1 = get_allowance(&pos.token1, &recipient, nfpm_addr, rpc).await?;
        if allow1 < amount1_desired {
            eprintln!("[aerodrome-slipstream-plugin] Approving {} for NFPM...", sym1);
            let approve1 = build_approve_calldata(nfpm_addr, amount1_desired);
            let r = wallet_contract_call(CHAIN_ID, &pos.token1, &approve1, true, false, Some(&recipient)).await?;
            eprintln!("[aerodrome-slipstream-plugin] Approve {} tx: {}", sym1, extract_tx_hash(&r));
            sleep(Duration::from_secs(5)).await;
        }
    }

    let result = wallet_contract_call(CHAIN_ID, nfpm_addr, &calldata, true, args.dry_run, Some(&recipient)).await?;
    let tx_hash = extract_tx_hash(&result);

    let mut out = serde_json::json!({
        "ok": true,
        "action": "add-liquidity",
        "token_id": args.token_id,
        "amount0_desired": format_amount(amount0_desired, dec0),
        "amount1_desired": format_amount(amount1_desired, dec1),
        "tx_hash": tx_hash,
        "explorer": format!("https://basescan.org/tx/{}", tx_hash),
    });
    if args.dry_run {
        out["dry_run"] = serde_json::json!(true);
    }
    println!("{}", serde_json::to_string_pretty(&out)?);
    Ok(())
}

use clap::Args;
use crate::config::{nfpm, rpc_url, token_symbol, CHAIN_ID};
use crate::onchainos::{extract_tx_hash, resolve_wallet, wallet_contract_call};
use crate::rpc::{format_amount, get_decimals, nfpm_positions};

#[derive(Args)]
pub struct BurnPositionArgs {
    /// NFT token ID of the position to burn
    #[arg(long)]
    pub token_id: u128,
    /// Broadcast the transaction. Without this flag, prints a preview only.
    #[arg(long)]
    pub confirm: bool,
    /// Build calldata without calling onchainos
    #[arg(long)]
    pub dry_run: bool,
}

/// NFPM.burn(tokenId) — selector 0x42966c68
/// Destroys the NFT for a position that has zero liquidity and zero uncollected fees.
fn build_burn(token_id: u128) -> String {
    format!("0x42966c68{}", format!("{:0>64x}", token_id))
}

pub async fn run(args: BurnPositionArgs) -> anyhow::Result<()> {
    let rpc = rpc_url();
    let nfpm_addr = nfpm();

    let pos = nfpm_positions(nfpm_addr, args.token_id, rpc).await?;

    // Validate preconditions — contract will revert if these aren't met, so catch early
    if pos.liquidity > 0 {
        let dec0 = get_decimals(&pos.token0, rpc).await.unwrap_or(18);
        let dec1 = get_decimals(&pos.token1, rpc).await.unwrap_or(18);
        let sym0 = token_symbol(&pos.token0);
        let sym1 = token_symbol(&pos.token1);
        anyhow::bail!(
            "Position {} still has liquidity ({} units). \
             Run `remove-liquidity --token-id {} --percent 100` first, then burn.\n\
             Token pair: {}/{}, ticks: [{}, {}]\n\
             Uncollected fees: {} {}, {} {}",
            args.token_id, pos.liquidity, args.token_id,
            sym0, sym1, pos.tick_lower, pos.tick_upper,
            format_amount(pos.tokens_owed0, dec0), sym0,
            format_amount(pos.tokens_owed1, dec1), sym1,
        );
    }
    if pos.tokens_owed0 > 0 || pos.tokens_owed1 > 0 {
        let dec0 = get_decimals(&pos.token0, rpc).await.unwrap_or(18);
        let dec1 = get_decimals(&pos.token1, rpc).await.unwrap_or(18);
        let sym0 = token_symbol(&pos.token0);
        let sym1 = token_symbol(&pos.token1);
        anyhow::bail!(
            "Position {} has uncollected fees ({} {}, {} {}). \
             Run `collect-fees --token-id {}` first, then burn.",
            args.token_id,
            format_amount(pos.tokens_owed0, dec0), sym0,
            format_amount(pos.tokens_owed1, dec1), sym1,
            args.token_id,
        );
    }

    let sym0 = token_symbol(&pos.token0).to_string();
    let sym1 = token_symbol(&pos.token1).to_string();
    let calldata = build_burn(args.token_id);

    let wallet = if args.dry_run {
        "0x0000000000000000000000000000000000000000".to_string()
    } else {
        resolve_wallet(CHAIN_ID)?
    };

    let preview = serde_json::json!({
        "preview": true,
        "action": "burn-position",
        "token_id": args.token_id,
        "token0": sym0,
        "token1": sym1,
        "tick_lower": pos.tick_lower,
        "tick_upper": pos.tick_upper,
        "wallet": wallet,
        "note": "This permanently destroys the NFT. The position has zero liquidity and zero fees.",
        "chain": "Base (8453)"
    });

    if !args.confirm && !args.dry_run {
        println!("{}", serde_json::to_string_pretty(&preview)?);
        eprintln!("\nAdd --confirm to permanently burn position {}.", args.token_id);
        return Ok(());
    }

    let result = wallet_contract_call(CHAIN_ID, nfpm_addr, &calldata, true, args.dry_run, Some(&wallet)).await?;
    let tx_hash = extract_tx_hash(&result);

    let mut out = serde_json::json!({
        "ok": true,
        "action": "burn-position",
        "token_id": args.token_id,
        "token0": sym0,
        "token1": sym1,
        "tx_hash": tx_hash,
        "explorer": format!("https://basescan.org/tx/{}", tx_hash),
    });
    if args.dry_run {
        out["dry_run"] = serde_json::json!(true);
    }
    println!("{}", serde_json::to_string_pretty(&out)?);
    Ok(())
}

use clap::Args;
use crate::config::{nfpm, rpc_url, token_symbol, CHAIN_ID, pad_address};
use crate::onchainos::{extract_tx_hash, resolve_wallet, wallet_contract_call};
use crate::rpc::{format_amount, get_decimals, nfpm_positions};

#[derive(Args)]
pub struct CollectFeesArgs {
    /// NFT token ID of the position to collect fees from
    #[arg(long)]
    pub token_id: u128,
    /// Broadcast the transaction. Without this flag, prints a preview only.
    #[arg(long)]
    pub confirm: bool,
    /// Build calldata without calling onchainos
    #[arg(long)]
    pub dry_run: bool,
}

/// NFPM.collect(CollectParams) — selector 0xfc6f7865
fn build_collect(token_id: u128, recipient: &str) -> String {
    format!(
        "0xfc6f7865{}{}{}{}",
        format!("{:0>64x}", token_id),
        pad_address(recipient),
        format!("{:0>64x}", u128::MAX), // amount0Max = type(uint128).max
        format!("{:0>64x}", u128::MAX), // amount1Max = type(uint128).max
    )
}

pub async fn run(args: CollectFeesArgs) -> anyhow::Result<()> {
    let rpc = rpc_url();
    let nfpm_addr = nfpm();

    let pos = nfpm_positions(nfpm_addr, args.token_id, rpc).await?;

    let dec0 = get_decimals(&pos.token0, rpc).await.unwrap_or(18);
    let dec1 = get_decimals(&pos.token1, rpc).await.unwrap_or(18);
    let sym0 = token_symbol(&pos.token0).to_string();
    let sym1 = token_symbol(&pos.token1).to_string();

    if pos.tokens_owed0 == 0 && pos.tokens_owed1 == 0 {
        println!("{}", serde_json::to_string_pretty(&serde_json::json!({
            "token_id": args.token_id,
            "message": "No uncollected fees for this position.",
            "uncollected_fees_token0": "0",
            "uncollected_fees_token1": "0"
        }))?);
        return Ok(());
    }

    let recipient = if args.dry_run {
        "0x0000000000000000000000000000000000000000".to_string()
    } else {
        resolve_wallet(CHAIN_ID)?
    };

    let calldata = build_collect(args.token_id, &recipient);

    let preview = serde_json::json!({
        "preview": true,
        "action": "collect-fees",
        "token_id": args.token_id,
        "uncollected_fees_token0": format!("{} {}", format_amount(pos.tokens_owed0, dec0), sym0),
        "uncollected_fees_token1": format!("{} {}", format_amount(pos.tokens_owed1, dec1), sym1),
        "recipient": recipient,
        "chain": "Base (8453)"
    });

    if !args.confirm && !args.dry_run {
        println!("{}", serde_json::to_string_pretty(&preview)?);
        eprintln!("\nAdd --confirm to collect fees from position {}.", args.token_id);
        return Ok(());
    }

    let result = wallet_contract_call(CHAIN_ID, nfpm_addr, &calldata, true, args.dry_run, Some(&recipient)).await?;
    let tx_hash = extract_tx_hash(&result);

    let mut out = serde_json::json!({
        "ok": true,
        "action": "collect-fees",
        "token_id": args.token_id,
        "collected_token0": format_amount(pos.tokens_owed0, dec0),
        "collected_token1": format_amount(pos.tokens_owed1, dec1),
        "token0_symbol": sym0,
        "token1_symbol": sym1,
        "tx_hash": tx_hash,
        "explorer": format!("https://basescan.org/tx/{}", tx_hash),
    });
    if args.dry_run {
        out["dry_run"] = serde_json::json!(true);
    }
    println!("{}", serde_json::to_string_pretty(&out)?);
    Ok(())
}

use clap::Args;
use tokio::time::{sleep, Duration};
use crate::config::{
    build_approve_calldata, cl_factory, nfpm, resolve_token,
    rpc_url, token_symbol, unix_now, CHAIN_ID, pad_address,
};
use crate::onchainos::{extract_tx_hash, resolve_wallet, wallet_contract_call};
use crate::rpc::{cl_get_pool, format_amount, get_allowance, get_decimals, parse_human_amount, pool_slot0};

#[derive(Args)]
pub struct MintPositionArgs {
    /// First token (symbol or address)
    #[arg(long)]
    pub token_a: String,
    /// Second token (symbol or address)
    #[arg(long)]
    pub token_b: String,
    /// Tick spacing of the pool (e.g. 100 for ~0.3% fee tier)
    #[arg(long)]
    pub tick_spacing: i32,
    /// Lower tick of the range
    #[arg(long)]
    pub tick_lower: i32,
    /// Upper tick of the range
    #[arg(long)]
    pub tick_upper: i32,
    /// Desired amount of token_a to deposit (human-readable)
    #[arg(long)]
    pub amount_a: String,
    /// Desired amount of token_b to deposit (human-readable)
    #[arg(long)]
    pub amount_b: String,
    /// Slippage tolerance % (default: 0.5%)
    #[arg(long, default_value = "0.5")]
    pub slippage: f64,
    /// Deadline in minutes (default: 20)
    #[arg(long, default_value = "20")]
    pub deadline_minutes: u64,
    /// Broadcast the transaction. Without this flag, prints a preview only.
    #[arg(long)]
    pub confirm: bool,
    /// Build calldata without calling onchainos
    #[arg(long)]
    pub dry_run: bool,
}

/// NFPM.mint(MintParams) — selector 0xb5007d1f
///
/// MintParams struct ABI order (12 fields):
///   address token0          (32 bytes)
///   address token1          (32 bytes)
///   int24   tickSpacing     (32 bytes)
///   int24   tickLower       (32 bytes)
///   int24   tickUpper       (32 bytes)
///   uint256 amount0Desired  (32 bytes)
///   uint256 amount1Desired  (32 bytes)
///   uint256 amount0Min      (32 bytes)
///   uint256 amount1Min      (32 bytes)
///   address recipient       (32 bytes)
///   uint256 deadline        (32 bytes)
///   uint160 sqrtPriceX96    (32 bytes) — 0 for existing pools
fn build_mint_calldata(
    token0: &str, token1: &str,
    tick_spacing: i32, tick_lower: i32, tick_upper: i32,
    amount0_desired: u128, amount1_desired: u128,
    amount0_min: u128, amount1_min: u128,
    recipient: &str, deadline: u64,
) -> String {
    // ABI requires int24 to be 256-bit sign-extended: SIGNEXTEND(2,x)==x must hold.
    // Negative values need all upper bytes set to 0xFF, not 0x00.
    let encode_int = |v: i32| {
        if v >= 0 {
            format!("{:064x}", v as u64)
        } else {
            // Sign-extend the 32-bit representation to 256 bits (fill upper 28 bytes with FF)
            format!("ffffffffffffffffffffffffffffffffffffffffffffffffffffffff{:08x}", v as u32)
        }
    };
    format!(
        "0xb5007d1f{}{}{}{}{}{}{}{}{}{}{}{}",
        pad_address(token0),
        pad_address(token1),
        encode_int(tick_spacing),
        encode_int(tick_lower),
        encode_int(tick_upper),
        format!("{:0>64x}", amount0_desired),
        format!("{:0>64x}", amount1_desired),
        format!("{:0>64x}", amount0_min),
        format!("{:0>64x}", amount1_min),
        pad_address(recipient),
        format!("{:0>64x}", deadline),
        format!("{:0>64x}", 0u128),   // sqrtPriceX96 = 0 (use existing pool price)
    )
}


pub async fn run(args: MintPositionArgs) -> anyhow::Result<()> {
    let rpc = rpc_url();
    let factory = cl_factory();
    let nfpm_addr = nfpm();

    let token_a = resolve_token(&args.token_a);
    let token_b = resolve_token(&args.token_b);
    let sym_a = if token_symbol(&token_a) != "UNKNOWN" { token_symbol(&token_a).to_string() } else { args.token_a.clone() };
    let sym_b = if token_symbol(&token_b) != "UNKNOWN" { token_symbol(&token_b).to_string() } else { args.token_b.clone() };

    // M1: Validate tick range ordering
    if args.tick_lower >= args.tick_upper {
        anyhow::bail!(
            "Invalid tick range: --tick-lower ({}) must be less than --tick-upper ({}).",
            args.tick_lower, args.tick_upper
        );
    }

    // M2: Validate tick alignment against tick spacing
    if args.tick_lower % args.tick_spacing != 0 {
        anyhow::bail!(
            "--tick-lower {} is not aligned to tick spacing {}. \
             Use a multiple of {} (e.g. {}).",
            args.tick_lower, args.tick_spacing, args.tick_spacing,
            (args.tick_lower / args.tick_spacing) * args.tick_spacing
        );
    }
    if args.tick_upper % args.tick_spacing != 0 {
        anyhow::bail!(
            "--tick-upper {} is not aligned to tick spacing {}. \
             Use a multiple of {} (e.g. {}).",
            args.tick_upper, args.tick_spacing, args.tick_spacing,
            (args.tick_upper / args.tick_spacing) * args.tick_spacing
        );
    }

    // Verify pool exists
    let zero = "0x0000000000000000000000000000000000000000";
    let pool = cl_get_pool(factory, &token_a, &token_b, args.tick_spacing, rpc).await?;
    if pool == zero {
        anyhow::bail!("No Slipstream CL pool found for {}/{} with tick_spacing={}. Use `pools --token-a {} --token-b {}` to find available pools.",
            sym_a, sym_b, args.tick_spacing, args.token_a, args.token_b);
    }

    // Determine pool token order by address comparison (token0 < token1 by address)
    let (token0, token1, amount0_desired, amount1_desired, dec0, dec1, sym0, sym1) =
        if token_a.to_lowercase() < token_b.to_lowercase() {
            let d0 = get_decimals(&token_a, rpc).await.unwrap_or(18);
            let d1 = get_decimals(&token_b, rpc).await.unwrap_or(18);
            let a0 = parse_human_amount(&args.amount_a, d0)?;
            let a1 = parse_human_amount(&args.amount_b, d1)?;
            (token_a.clone(), token_b.clone(), a0, a1, d0, d1, sym_a.clone(), sym_b.clone())
        } else {
            let d0 = get_decimals(&token_b, rpc).await.unwrap_or(18);
            let d1 = get_decimals(&token_a, rpc).await.unwrap_or(18);
            let a0 = parse_human_amount(&args.amount_b, d0)?;
            let a1 = parse_human_amount(&args.amount_a, d1)?;
            (token_b.clone(), token_a.clone(), a0, a1, d0, d1, sym_b.clone(), sym_a.clone())
        };

    // For LP minting, both token amounts are adjusted internally by the NFPM based on the
    // current price and tick range. Setting fixed percentage minimums on both amounts causes
    // PSC (price slippage check) failures when the actual ratio differs from the desired ratio.
    // The slippage flag is shown in the preview for informational purposes only.
    let amount0_min: u128 = 0;
    let amount1_min: u128 = 0;

    // Current price for context
    let (_, current_tick) = pool_slot0(&pool, rpc).await.unwrap_or((0, 0));

    let recipient = if args.dry_run {
        zero.to_string()
    } else {
        resolve_wallet(CHAIN_ID)?
    };

    let deadline = unix_now() + args.deadline_minutes * 60;
    let calldata = build_mint_calldata(
        &token0, &token1, args.tick_spacing,
        args.tick_lower, args.tick_upper,
        amount0_desired, amount1_desired,
        amount0_min, amount1_min,
        &recipient, deadline,
    );

    let in_range = current_tick >= args.tick_lower && current_tick < args.tick_upper;

    // Preview
    let preview = serde_json::json!({
        "preview": true,
        "action": "mint-position",
        "pool": pool,
        "token0": sym0,
        "token1": sym1,
        "tick_spacing": args.tick_spacing,
        "tick_lower": args.tick_lower,
        "tick_upper": args.tick_upper,
        "current_tick": current_tick,
        "in_range": in_range,
        "amount0_desired": format_amount(amount0_desired, dec0),
        "amount1_desired": format_amount(amount1_desired, dec1),
        "note_amounts": "Actual amounts consumed depend on current pool price; desired values are maximums",
        "recipient": recipient,
        "chain": "Base (8453)"
    });

    if !args.confirm && !args.dry_run {
        println!("{}", serde_json::to_string_pretty(&preview)?);
        eprintln!("\nAdd --confirm to mint this position.");
        return Ok(());
    }

    // Approve token0 for NFPM
    if !args.dry_run {
        let allow0 = get_allowance(&token0, &recipient, nfpm_addr, rpc).await?;
        if allow0 < amount0_desired {
            eprintln!("[aerodrome-slipstream-plugin] Approving {} for NonfungiblePositionManager...", sym0);
            let approve0 = build_approve_calldata(nfpm_addr, amount0_desired);
            let r = wallet_contract_call(CHAIN_ID, &token0, &approve0, true, false, Some(&recipient)).await?;
            eprintln!("[aerodrome-slipstream-plugin] Approve {} tx: {}", sym0, extract_tx_hash(&r));
            sleep(Duration::from_secs(5)).await;
        }
        // Approve token1 for NFPM
        let allow1 = get_allowance(&token1, &recipient, nfpm_addr, rpc).await?;
        if allow1 < amount1_desired {
            eprintln!("[aerodrome-slipstream-plugin] Approving {} for NonfungiblePositionManager...", sym1);
            let approve1 = build_approve_calldata(nfpm_addr, amount1_desired);
            let r = wallet_contract_call(CHAIN_ID, &token1, &approve1, true, false, Some(&recipient)).await?;
            eprintln!("[aerodrome-slipstream-plugin] Approve {} tx: {}", sym1, extract_tx_hash(&r));
            sleep(Duration::from_secs(5)).await;
        }
    }

    // Mint position
    let result = wallet_contract_call(CHAIN_ID, nfpm_addr, &calldata, true, args.dry_run, Some(&recipient)).await?;
    let tx_hash = extract_tx_hash(&result);

    let mut out = serde_json::json!({
        "ok": true,
        "action": "mint-position",
        "token0": sym0,
        "token1": sym1,
        "tick_spacing": args.tick_spacing,
        "tick_lower": args.tick_lower,
        "tick_upper": args.tick_upper,
        "in_range": in_range,
        "amount0_desired": format_amount(amount0_desired, dec0),
        "amount1_desired": format_amount(amount1_desired, dec1),
        "tx_hash": tx_hash,
        "explorer": format!("https://basescan.org/tx/{}", tx_hash),
        "note": "Check `positions` to see your new token_id"
    });
    if args.dry_run {
        out["dry_run"] = serde_json::json!(true);
    }
    println!("{}", serde_json::to_string_pretty(&out)?);
    Ok(())
}

pub mod add_liquidity;
pub mod burn_position;
pub mod collect_fees;
pub mod mint_position;
pub mod pools;
pub mod positions;
pub mod prices;
pub mod quote;
pub mod remove_liquidity;
pub mod swap;

use clap::Args;
use crate::config::{cl_factory, common_tick_spacings, resolve_token, rpc_url, token_symbol};
use crate::rpc::{cl_get_pool, get_decimals, pool_fee, pool_liquidity, pool_tick_spacing, sqrt_price_to_human, pool_slot0};

#[derive(Args)]
pub struct PoolsArgs {
    /// First token (symbol or address, e.g. WETH, USDC)
    #[arg(long)]
    pub token_a: String,
    /// Second token (symbol or address)
    #[arg(long)]
    pub token_b: String,
}

pub async fn run(args: PoolsArgs) -> anyhow::Result<()> {
    let rpc = rpc_url();
    let factory = cl_factory();
    let token_a = resolve_token(&args.token_a);
    let token_b = resolve_token(&args.token_b);

    let sym_a = if token_symbol(&token_a) != "UNKNOWN" { token_symbol(&token_a).to_string() } else { token_a[..6].to_string() + "..." };
    let sym_b = if token_symbol(&token_b) != "UNKNOWN" { token_symbol(&token_b).to_string() } else { token_b[..6].to_string() + "..." };

    println!("Searching Aerodrome Slipstream CL pools for {}/{} on Base...", sym_a, sym_b);

    // Determine token0/token1 order by address comparison (Uniswap V3 / Aerodrome CL invariant).
    // The factory always stores the pool with token0 < token1 lexicographically.
    let (token0, token1, dec0, dec1) = if token_a.to_lowercase() < token_b.to_lowercase() {
        let d0 = get_decimals(&token_a, rpc).await.unwrap_or(18);
        let d1 = get_decimals(&token_b, rpc).await.unwrap_or(18);
        (token_a.clone(), token_b.clone(), d0, d1)
    } else {
        let d0 = get_decimals(&token_b, rpc).await.unwrap_or(18);
        let d1 = get_decimals(&token_a, rpc).await.unwrap_or(18);
        (token_b.clone(), token_a.clone(), d0, d1)
    };

    let mut found = 0;
    let mut results = vec![];

    for &ts in common_tick_spacings() {
        let pool = cl_get_pool(factory, &token_a, &token_b, ts, rpc).await?;
        let zero = "0x0000000000000000000000000000000000000000";
        if pool == zero || pool.to_lowercase() == zero {
            continue;
        }

        let liq = pool_liquidity(&pool, rpc).await.unwrap_or(0);
        let fee = pool_fee(&pool, rpc).await.unwrap_or(0);
        let actual_ts = pool_tick_spacing(&pool, rpc).await.unwrap_or(ts);

        let price = if let Ok((sp, _)) = pool_slot0(&pool, rpc).await {
            sqrt_price_to_human(sp, dec0, dec1)
        } else { 0.0 };

        let fee_pct = fee as f64 / 10000.0;
        results.push(serde_json::json!({
            "pool": pool,
            "tick_spacing": actual_ts,
            "fee_bps": fee,
            "fee_pct": format!("{:.4}%", fee_pct),
            "liquidity": liq.to_string(),
            "price_token1_per_token0": format!("{:.6}", price),
            "token0": token0,
            "token1": token1,
        }));
        found += 1;
    }

    if found == 0 {
        println!("No Slipstream CL pools found for {}/{}.", sym_a, sym_b);
        println!("Tip: check if these tokens have liquidity in Aerodrome AMM (classic pools) instead.");
    } else {
        println!("{}", serde_json::to_string_pretty(&results)?);
    }
    Ok(())
}

use clap::Args;
use crate::config::{cl_factory, nfpm, rpc_url, token_symbol, CHAIN_ID};
use crate::onchainos::resolve_wallet;
use crate::rpc::{cl_get_pool, get_decimals, format_amount, nft_balance_of, nft_token_of_owner_by_index, nfpm_positions, pool_slot0};

#[derive(Args)]
pub struct PositionsArgs {
    /// Wallet address (default: active onchainos wallet)
    #[arg(long)]
    pub wallet: Option<String>,
}

pub async fn run(args: PositionsArgs) -> anyhow::Result<()> {
    let rpc = rpc_url();
    let nfpm_addr = nfpm();

    let owner = match args.wallet {
        Some(w) => w,
        None => resolve_wallet(CHAIN_ID)?,
    };

    if !owner.starts_with("0x") || owner.len() != 42 {
        anyhow::bail!("Invalid wallet address '{}'. Expected a 0x-prefixed 20-byte hex address (42 chars).", owner);
    }

    println!("Fetching Aerodrome Slipstream positions for {}...", &owner[..10]);

    let count = nft_balance_of(nfpm_addr, &owner, rpc).await?;
    if count == 0 {
        println!("{}", serde_json::to_string_pretty(&serde_json::json!({
            "wallet": owner,
            "positions": [],
            "message": "No Slipstream LP positions found."
        }))?);
        return Ok(());
    }

    let mut positions = vec![];
    for i in 0..count {
        let token_id = nft_token_of_owner_by_index(nfpm_addr, &owner, i, rpc).await?;
        match nfpm_positions(nfpm_addr, token_id, rpc).await {
            Ok(pos) => {
                let dec0 = get_decimals(&pos.token0, rpc).await.unwrap_or(18);
                let dec1 = get_decimals(&pos.token1, rpc).await.unwrap_or(18);
                let sym0 = token_symbol(&pos.token0);
                let sym1 = token_symbol(&pos.token1);

                // Look up current tick for in_range check
                let in_range = if let Ok(pool) = cl_get_pool(cl_factory(), &pos.token0, &pos.token1, pos.tick_spacing, rpc).await {
                    if let Ok((_, current_tick)) = pool_slot0(&pool, rpc).await {
                        current_tick >= pos.tick_lower && current_tick < pos.tick_upper
                    } else { false }
                } else { false };

                positions.push(serde_json::json!({
                    "token_id": token_id,
                    "token0": pos.token0,
                    "token0_symbol": sym0,
                    "token1": pos.token1,
                    "token1_symbol": sym1,
                    "tick_spacing": pos.tick_spacing,
                    "tick_lower": pos.tick_lower,
                    "tick_upper": pos.tick_upper,
                    "liquidity": pos.liquidity.to_string(),
                    "in_range": in_range,
                    "uncollected_fees_token0": format_amount(pos.tokens_owed0, dec0),
                    "uncollected_fees_token1": format_amount(pos.tokens_owed1, dec1),
                }));
            }
            Err(e) => {
                eprintln!("Warning: could not fetch position {}: {}", token_id, e);
            }
        }
    }

    println!("{}", serde_json::to_string_pretty(&serde_json::json!({
        "wallet": owner,
        "count": count,
        "positions": positions,
        "chain": "Base (8453)"
    }))?);
    Ok(())
}

use clap::Args;
use crate::config::{cl_factory, common_tick_spacings, resolve_token, rpc_url, token_symbol};
use crate::rpc::{cl_get_pool, get_decimals, pool_slot0, sqrt_price_to_human, pool_liquidity};

#[derive(Args)]
pub struct PricesArgs {
    /// Base token (e.g. WETH)
    #[arg(long)]
    pub token_in: String,
    /// Quote token (e.g. USDC)
    #[arg(long)]
    pub token_out: String,
    /// Tick spacing to use (default: auto-select most liquid)
    #[arg(long)]
    pub tick_spacing: Option<i32>,
}

pub async fn run(args: PricesArgs) -> anyhow::Result<()> {
    let rpc = rpc_url();
    let factory = cl_factory();
    let token_in = resolve_token(&args.token_in);
    let token_out = resolve_token(&args.token_out);

    let sym_in  = if token_symbol(&token_in) != "UNKNOWN"  { token_symbol(&token_in).to_string()  } else { args.token_in.clone() };
    let sym_out = if token_symbol(&token_out) != "UNKNOWN" { token_symbol(&token_out).to_string() } else { args.token_out.clone() };

    let dec_in  = get_decimals(&token_in, rpc).await.unwrap_or(18);
    let dec_out = get_decimals(&token_out, rpc).await.unwrap_or(6);

    let tick_spacings: Vec<i32> = match args.tick_spacing {
        Some(ts) => vec![ts],
        None => common_tick_spacings().to_vec(),
    };

    let zero = "0x0000000000000000000000000000000000000000";
    let mut best_pool = String::new();
    let mut best_liq: u128 = 0;
    let mut best_ts = 0i32;

    for ts in &tick_spacings {
        let pool = cl_get_pool(factory, &token_in, &token_out, *ts, rpc).await?;
        if pool == zero { continue; }
        let liq = pool_liquidity(&pool, rpc).await.unwrap_or(0);
        if liq > best_liq {
            best_liq = liq;
            best_pool = pool.clone();
            best_ts = *ts;
        }
    }

    if best_pool.is_empty() {
        anyhow::bail!("No Slipstream CL pool found for {}/{}", sym_in, sym_out);
    }

    let (sqrt_price, tick) = pool_slot0(&best_pool, rpc).await?;

    // Determine if token_in is token0 or token1 of the pool
    // The price from slot0 is always token1/token0. If token_in is token1, invert.
    use crate::rpc::pool_token0;
    let pool_t0 = pool_token0(&best_pool, rpc).await?;
    let (d0, d1, invert) = if pool_t0.to_lowercase() == token_in.to_lowercase() {
        (dec_in, dec_out, false)
    } else {
        (dec_out, dec_in, true)
    };

    let price_raw = sqrt_price_to_human(sqrt_price, d0, d1);
    let price = if invert && price_raw > 0.0 { 1.0 / price_raw } else { price_raw };

    println!("{}", serde_json::to_string_pretty(&serde_json::json!({
        "pair": format!("{}/{}", sym_in, sym_out),
        "price": format!("{:.6} {} per {}", price, sym_out, sym_in),
        "pool": best_pool,
        "tick_spacing": best_ts,
        "current_tick": tick,
        "liquidity": best_liq.to_string(),
        "chain": "Base (8453)"
    }))?);
    Ok(())
}

use clap::Args;
use crate::config::{cl_factory, common_tick_spacings, quoter, resolve_token, rpc_url, token_symbol};
use crate::rpc::{cl_get_pool, get_decimals, format_amount, parse_human_amount};

#[derive(Args)]
pub struct QuoteArgs {
    /// Input token (symbol or address)
    #[arg(long)]
    pub token_in: String,
    /// Output token (symbol or address)
    #[arg(long)]
    pub token_out: String,
    /// Amount in (human-readable, e.g. "0.1" for 0.1 WETH)
    #[arg(long)]
    pub amount_in: String,
    /// Specific tick spacing to quote (default: auto-select best)
    #[arg(long)]
    pub tick_spacing: Option<i32>,
}

/// Quoter.quoteExactInputSingle(QuoteExactInputSingleParams memory params)
/// Struct fields (all static → encoded inline, no offset pointer):
///   address tokenIn, address tokenOut, uint256 amountIn, int24 tickSpacing, uint160 sqrtPriceLimitX96
/// Selector: keccak("quoteExactInputSingle((address,address,uint256,int24,uint160))") = 0x9e7defe6
pub async fn get_quote(
    token_in: &str,
    token_out: &str,
    amount_in: u128,
    tick_spacing: i32,
    rpc: &str,
) -> anyhow::Result<u128> {
    let quoter_addr = quoter();
    let ta = format!("{:0>64}", token_in.trim_start_matches("0x").to_lowercase());
    let tb = format!("{:0>64}", token_out.trim_start_matches("0x").to_lowercase());
    let amt = format!("{:0>64x}", amount_in);
    let ts = format!("{:0>64x}", tick_spacing as u64);
    let limit = format!("{:0>64x}", 0u64); // sqrtPriceLimitX96 = 0 means no limit
    let data = format!("0x9e7defe6{}{}{}{}{}", ta, tb, amt, ts, limit);
    let hex = crate::rpc::eth_call(quoter_addr, &data, rpc).await?;
    // Returns (uint256 amountOut, ...) — first 32 bytes is amountOut
    let clean = hex.trim_start_matches("0x");
    if clean.len() < 64 {
        anyhow::bail!("Quoter returned no data for this pool/amount");
    }
    Ok(u128::from_str_radix(&clean[..64], 16).unwrap_or(0))
}

pub async fn run(args: QuoteArgs) -> anyhow::Result<()> {
    let rpc = rpc_url();
    let factory = cl_factory();
    let token_in = resolve_token(&args.token_in);
    let token_out = resolve_token(&args.token_out);

    let sym_in  = if token_symbol(&token_in) != "UNKNOWN"  { token_symbol(&token_in).to_string()  } else { args.token_in.clone() };
    let sym_out = if token_symbol(&token_out) != "UNKNOWN" { token_symbol(&token_out).to_string() } else { args.token_out.clone() };

    let dec_in  = get_decimals(&token_in, rpc).await.unwrap_or(18);
    let dec_out = get_decimals(&token_out, rpc).await.unwrap_or(6);
    let amount_raw = parse_human_amount(&args.amount_in, dec_in)?;

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

    let zero = "0x0000000000000000000000000000000000000000";
    let tick_spacings: Vec<i32> = match args.tick_spacing {
        Some(ts) => vec![ts],
        None => common_tick_spacings().to_vec(),
    };

    let mut best_out: u128 = 0;
    let mut best_ts = 0i32;

    for ts in &tick_spacings {
        // Verify pool exists before trying to quote
        let pool = cl_get_pool(factory, &token_in, &token_out, *ts, rpc).await?;
        if pool == zero { continue; }

        match get_quote(&token_in, &token_out, amount_raw, *ts, rpc).await {
            Ok(out) if out > best_out => {
                best_out = out;
                best_ts = *ts;
            }
            _ => {}
        }
    }

    if best_out == 0 {
        anyhow::bail!(
            "No quote available for {} {} → {}. Check that a CL pool exists and has sufficient liquidity.",
            args.amount_in, sym_in, sym_out
        );
    }

    let amount_out_human = format_amount(best_out, dec_out);
    println!("{}", serde_json::to_string_pretty(&serde_json::json!({
        "token_in": sym_in,
        "token_out": sym_out,
        "amount_in": args.amount_in,
        "amount_out": amount_out_human,
        "amount_out_raw": best_out.to_string(),
        "tick_spacing": best_ts,
        "chain": "Base (8453)"
    }))?);
    Ok(())
}

use clap::Args;
use tokio::time::{sleep, Duration};
use crate::config::{nfpm, rpc_url, token_symbol, CHAIN_ID, pad_address};
use crate::onchainos::{extract_tx_hash, resolve_wallet, wallet_contract_call};
use crate::rpc::{format_amount, get_decimals, nfpm_positions};

#[derive(Args)]
pub struct RemoveLiquidityArgs {
    /// NFT token ID of the position to remove liquidity from
    #[arg(long)]
    pub token_id: u128,
    /// Percentage of liquidity to remove (1-100, default: 100 = full close)
    #[arg(long, default_value = "100")]
    pub percent: u8,
    /// Slippage tolerance % (default: 0.5%)
    #[arg(long, default_value = "0.5")]
    pub slippage: f64,
    /// Deadline in minutes (default: 20)
    #[arg(long, default_value = "20")]
    pub deadline_minutes: u64,
    /// Broadcast the transaction. Without this flag, prints a preview only.
    #[arg(long)]
    pub confirm: bool,
    /// Build calldata without calling onchainos
    #[arg(long)]
    pub dry_run: bool,
}

/// NFPM.decreaseLiquidity(DecreaseLiquidityParams) — selector 0x0c49ccbe
/// Params: tokenId(uint256), liquidity(uint128), amount0Min(uint256), amount1Min(uint256), deadline(uint256)
fn build_decrease_liquidity(token_id: u128, liquidity: u128, amount0_min: u128, amount1_min: u128, deadline: u64) -> String {
    format!(
        "0x0c49ccbe{}{}{}{}{}",
        format!("{:0>64x}", token_id),
        format!("{:0>64x}", liquidity),
        format!("{:0>64x}", amount0_min),
        format!("{:0>64x}", amount1_min),
        format!("{:0>64x}", deadline),
    )
}

/// NFPM.collect(CollectParams) — selector 0xfc6f7865
/// Params: tokenId(uint256), recipient(address), amount0Max(uint128), amount1Max(uint128)
fn build_collect(token_id: u128, recipient: &str, amount0_max: u128, amount1_max: u128) -> String {
    format!(
        "0xfc6f7865{}{}{}{}",
        format!("{:0>64x}", token_id),
        pad_address(recipient),
        format!("{:0>64x}", amount0_max),
        format!("{:0>64x}", amount1_max),
    )
}

pub async fn run(args: RemoveLiquidityArgs) -> anyhow::Result<()> {
    let rpc = rpc_url();
    let nfpm_addr = nfpm();

    if args.percent == 0 || args.percent > 100 {
        anyhow::bail!("--percent must be between 1 and 100");
    }

    let pos = nfpm_positions(nfpm_addr, args.token_id, rpc).await?;
    if pos.liquidity == 0 {
        anyhow::bail!("Position {} has no liquidity (already closed or never minted)", args.token_id);
    }

    let liquidity_to_remove = (pos.liquidity as u128 * args.percent as u128) / 100;
    // The exact output amounts depend on the current price tick and pool math.
    // Setting mins to 0 means we accept any output; the --slippage flag is informational
    // for the user. For large positions, prefer calling with a tighter deadline.
    let amount0_min: u128 = 0;
    let amount1_min: u128 = 0;

    let dec0 = get_decimals(&pos.token0, rpc).await.unwrap_or(18);
    let dec1 = get_decimals(&pos.token1, rpc).await.unwrap_or(18);
    let sym0 = token_symbol(&pos.token0).to_string();
    let sym1 = token_symbol(&pos.token1).to_string();

    let recipient = if args.dry_run {
        "0x0000000000000000000000000000000000000000".to_string()
    } else {
        resolve_wallet(CHAIN_ID)?
    };

    let deadline = crate::config::unix_now() + args.deadline_minutes * 60;
    let decrease_calldata = build_decrease_liquidity(
        args.token_id, liquidity_to_remove, amount0_min, amount1_min, deadline,
    );
    let collect_calldata = build_collect(args.token_id, &recipient, u128::MAX, u128::MAX);

    let preview = serde_json::json!({
        "preview": true,
        "action": "remove-liquidity",
        "token_id": args.token_id,
        "token0": sym0,
        "token1": sym1,
        "tick_lower": pos.tick_lower,
        "tick_upper": pos.tick_upper,
        "liquidity_to_remove": liquidity_to_remove.to_string(),
        "total_liquidity": pos.liquidity.to_string(),
        "percent": args.percent,
        "uncollected_fees_token0": format_amount(pos.tokens_owed0, dec0),
        "uncollected_fees_token1": format_amount(pos.tokens_owed1, dec1),
        "recipient": recipient,
        "chain": "Base (8453)",
        "note": "Two transactions will be sent: decreaseLiquidity then collect"
    });

    if !args.confirm && !args.dry_run {
        println!("{}", serde_json::to_string_pretty(&preview)?);
        eprintln!("\nAdd --confirm to remove liquidity from position {}.", args.token_id);
        return Ok(());
    }

    // Tx 1: decreaseLiquidity
    eprintln!("[aerodrome-slipstream-plugin] Step 1/2: decreaseLiquidity...");
    let r1 = wallet_contract_call(CHAIN_ID, nfpm_addr, &decrease_calldata, true, args.dry_run, Some(&recipient)).await?;
    let h1 = extract_tx_hash(&r1);
    eprintln!("[aerodrome-slipstream-plugin] decreaseLiquidity tx: {}", h1);

    if !args.dry_run {
        sleep(Duration::from_secs(5)).await;
    }

    // Tx 2: collect (withdraw tokens)
    eprintln!("[aerodrome-slipstream-plugin] Step 2/2: collect...");
    let r2 = wallet_contract_call(CHAIN_ID, nfpm_addr, &collect_calldata, true, args.dry_run, Some(&recipient)).await?;
    let h2 = extract_tx_hash(&r2);
    eprintln!("[aerodrome-slipstream-plugin] collect tx: {}", h2);

    let mut out = serde_json::json!({
        "ok": true,
        "action": "remove-liquidity",
        "token_id": args.token_id,
        "percent_removed": args.percent,
        "decrease_tx": h1,
        "collect_tx": h2,
        "explorer_decrease": format!("https://basescan.org/tx/{}", h1),
        "explorer_collect": format!("https://basescan.org/tx/{}", h2),
    });
    if args.dry_run {
        out["dry_run"] = serde_json::json!(true);
    }
    println!("{}", serde_json::to_string_pretty(&out)?);
    Ok(())
}

use clap::Args;
use tokio::time::{sleep, Duration};
use crate::config::{
    build_approve_calldata, cl_factory, common_tick_spacings,
    resolve_token, rpc_url, swap_router, token_symbol, unix_now, CHAIN_ID, pad_address,
};
use crate::onchainos::{extract_tx_hash, resolve_wallet, wallet_contract_call};
use crate::rpc::{cl_get_pool, format_amount, get_allowance, get_decimals, parse_human_amount};
use super::quote::get_quote;

#[derive(Args)]
pub struct SwapArgs {
    /// Input token (symbol or address, e.g. WETH, USDC)
    #[arg(long)]
    pub token_in: String,
    /// Output token (symbol or address)
    #[arg(long)]
    pub token_out: String,
    /// Amount of token_in to swap (human-readable, e.g. "0.01" for 0.01 WETH)
    #[arg(long)]
    pub amount_in: String,
    /// Slippage tolerance in percent (default: 0.5%)
    #[arg(long, default_value = "0.5")]
    pub slippage: f64,
    /// Specific tick spacing to use (default: auto-select best)
    #[arg(long)]
    pub tick_spacing: Option<i32>,
    /// Deadline in minutes from now (default: 20)
    #[arg(long, default_value = "20")]
    pub deadline_minutes: u64,
    /// Broadcast the swap. Without this flag, prints a preview only.
    #[arg(long)]
    pub confirm: bool,
    /// Build calldata but do not call onchainos (testing only)
    #[arg(long)]
    pub dry_run: bool,
}

/// SwapRouter.exactInputSingle(ExactInputSingleParams) → uint256 amountOut
/// Selector: keccak("exactInputSingle((address,address,int24,address,uint256,uint256,uint256,uint160))") = 0xa026383e
///
/// ExactInputSingleParams struct (ABI order):
///   address tokenIn       (32 bytes)
///   address tokenOut      (32 bytes)
///   int24   tickSpacing   (32 bytes)
///   address recipient     (32 bytes)
///   uint256 deadline      (32 bytes)
///   uint256 amountIn      (32 bytes)
///   uint256 amountOutMin  (32 bytes)
///   uint160 sqrtPriceLimitX96 (32 bytes)
fn build_exact_input_single(
    token_in: &str,
    token_out: &str,
    tick_spacing: i32,
    recipient: &str,
    deadline: u64,
    amount_in: u128,
    amount_out_min: u128,
) -> String {
    let ta  = pad_address(token_in);
    let tb  = pad_address(token_out);
    let ts  = format!("{:0>64x}", tick_spacing as u64);
    let rec = pad_address(recipient);
    let dl  = format!("{:0>64x}", deadline);
    let ain = format!("{:0>64x}", amount_in);
    let aom = format!("{:0>64x}", amount_out_min);
    let lim = format!("{:0>64x}", 0u64); // no sqrt price limit
    format!("0xa026383e{}{}{}{}{}{}{}{}", ta, tb, ts, rec, dl, ain, aom, lim)
}

pub async fn run(args: SwapArgs) -> anyhow::Result<()> {
    let rpc = rpc_url();
    let factory = cl_factory();
    let router = swap_router();
    let token_in = resolve_token(&args.token_in);
    let token_out = resolve_token(&args.token_out);

    let sym_in  = if token_symbol(&token_in) != "UNKNOWN"  { token_symbol(&token_in).to_string()  } else { args.token_in.clone() };
    let sym_out = if token_symbol(&token_out) != "UNKNOWN" { token_symbol(&token_out).to_string() } else { args.token_out.clone() };

    let dec_in  = get_decimals(&token_in, rpc).await.unwrap_or(18);
    let dec_out = get_decimals(&token_out, rpc).await.unwrap_or(6);
    let amount_in_raw = parse_human_amount(&args.amount_in, dec_in)?;

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

    // ── 1. Find best pool / quote ─────────────────────────────────────────────
    let zero = "0x0000000000000000000000000000000000000000";
    let tick_spacings: Vec<i32> = match args.tick_spacing {
        Some(ts) => vec![ts],
        None => common_tick_spacings().to_vec(),
    };

    let mut best_out: u128 = 0;
    let mut best_ts = 0i32;

    for ts in &tick_spacings {
        let pool = cl_get_pool(factory, &token_in, &token_out, *ts, rpc).await?;
        if pool == zero { continue; }
        match get_quote(&token_in, &token_out, amount_in_raw, *ts, rpc).await {
            Ok(out) if out > best_out => { best_out = out; best_ts = *ts; }
            _ => {}
        }
    }

    if best_out == 0 {
        anyhow::bail!(
            "No quote available for {} {} → {}. No Slipstream CL pool found with sufficient liquidity.",
            args.amount_in, sym_in, sym_out
        );
    }

    let slippage_factor = 1.0 - (args.slippage / 100.0);
    let amount_out_min = (best_out as f64 * slippage_factor) as u128;

    // ── 2. Resolve recipient ──────────────────────────────────────────────────
    let recipient = if args.dry_run {
        zero.to_string()
    } else {
        resolve_wallet(CHAIN_ID)?
    };

    let deadline = unix_now() + args.deadline_minutes * 60;
    let calldata = build_exact_input_single(
        &token_in, &token_out, best_ts, &recipient, deadline, amount_in_raw, amount_out_min,
    );

    // ── 3. Preview ────────────────────────────────────────────────────────────
    let preview = serde_json::json!({
        "preview": true,
        "action": "swap",
        "token_in": sym_in,
        "token_out": sym_out,
        "amount_in": args.amount_in,
        "expected_out": format_amount(best_out, dec_out),
        "minimum_out": format_amount(amount_out_min, dec_out),
        "slippage": format!("{}%", args.slippage),
        "tick_spacing": best_ts,
        "recipient": recipient,
        "router": router,
        "chain": "Base (8453)"
    });

    if !args.confirm && !args.dry_run {
        println!("{}", serde_json::to_string_pretty(&preview)?);
        eprintln!("\nAdd --confirm to broadcast this swap.");
        return Ok(());
    }

    // ── 4. Approve if needed ──────────────────────────────────────────────────
    if !args.dry_run {
        let allowance = get_allowance(&token_in, &recipient, router, rpc).await?;
        if allowance < amount_in_raw {
            eprintln!("[aerodrome-slipstream-plugin] Approving {} {} for SwapRouter...", sym_in, args.amount_in);
            let approve_data = build_approve_calldata(router, amount_in_raw);
            let approve_result = wallet_contract_call(CHAIN_ID, &token_in, &approve_data, true, false, Some(&recipient)).await?;
            let approve_hash = extract_tx_hash(&approve_result);
            eprintln!("[aerodrome-slipstream-plugin] Approve tx: {}", approve_hash);
            sleep(Duration::from_secs(5)).await;
        }
    }

    // ── 5. Execute swap ───────────────────────────────────────────────────────
    let result = wallet_contract_call(CHAIN_ID, router, &calldata, true, args.dry_run, Some(&recipient)).await?;
    let tx_hash = extract_tx_hash(&result);

    let mut out = serde_json::json!({
        "ok": true,
        "action": "swap",
        "token_in": sym_in,
        "token_out": sym_out,
        "amount_in": args.amount_in,
        "minimum_out": format_amount(amount_out_min, dec_out),
        "tick_spacing": best_ts,
        "tx_hash": tx_hash,
        "explorer": format!("https://basescan.org/tx/{}", tx_hash),
    });
    if args.dry_run {
        out["dry_run"] = serde_json::json!(true);
    }
    println!("{}", serde_json::to_string_pretty(&out)?);
    Ok(())
}