Pump Fun Plugin

{
  "name": "pump-fun-plugin",
  "description": "Buy and sell tokens on pump.fun bonding curves on Solana mainnet",
  "version": "0.1.9",
  "author": {
    "name": "skylavis-sky",
    "github": "skylavis-sky"
  },
  "homepage": "https://github.com/skylavis-sky/onchainos-plugins/tree/main/pump-fun",
  "repository": "https://github.com/skylavis-sky/onchainos-plugins",
  "license": "MIT",
  "keywords": [
    "solana",
    "memecoins",
    "bonding-curve",
    "launchpad",
    "pump-fun"
  ]
}

target/

[package]
name = "pump-fun-plugin"
version = "0.1.9"
edition = "2021"

[[bin]]
name = "pump-fun-plugin"
path = "src/main.rs"

[dependencies]
anyhow = "1"
clap = { version = "4", features = ["derive"] }
reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "1", features = ["full"] }
pumpfun = "4.6.0"
solana-sdk = "2.1"
openssl = { version = "0.10", features = ["vendored"] }

MIT License

Copyright (c) 2024 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: pump-fun-plugin
version: "0.1.9"
description: "Buy and sell tokens on pump.fun bonding curves on Solana mainnet"
author:
  name: skylavis-sky
  github: skylavis-sky
category: dapp
tags:
  - solana
  - memecoins
  - bonding-curve
  - launchpad
  - pump-fun
license: MIT

components:
  skill:
    dir: .

build:
  lang: rust
  binary_name: pump-fun-plugin

api_calls:
  - "https://api.mainnet-beta.solana.com"
  - "https://frontend-api.pump.fun"

use anyhow::Result;
use clap::Args;
use serde::Serialize;

use crate::config::DEFAULT_SLIPPAGE_BPS;
use crate::onchainos::{self, SOL_MINT};
use crate::onchainos::resolve_wallet_solana;

#[derive(Args, Debug)]
pub struct BuyArgs {
    /// Token mint address (base58)
    #[arg(long)]
    pub mint: String,

    /// SOL amount to spend, in readable units (e.g. "0.01" = 0.01 SOL)
    #[arg(long)]
    pub sol_amount: String,

    /// Slippage tolerance in basis points (default: 100 = 1%)
    #[arg(long, default_value_t = DEFAULT_SLIPPAGE_BPS)]
    pub slippage_bps: u64,

    /// Confirm execution — required to execute on-chain. Without this flag, shows a preview.
    #[arg(long)]
    pub confirm: bool,
}

#[derive(Serialize, Debug)]
struct BuyOutput {
    ok: bool,
    mint: String,
    sol_amount: String,
    slippage_bps: u64,
    #[serde(skip_serializing_if = "Option::is_none")]
    wallet: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    tx_hash: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    explorer_url: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    dry_run: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    preview: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    note: Option<String>,
}

pub async fn execute(args: &BuyArgs, dry_run: bool) -> Result<()> {
    if dry_run || !args.confirm {
        let wallet = resolve_wallet_solana().ok();
        let (is_dry_run, is_preview, note) = if dry_run {
            (Some(true), None, format!(
                "dry_run=true — no transaction submitted. Pass --confirm to execute. \
                 Run `pump-fun-plugin get-price --mint {} --direction buy --amount <lamports>` to see estimated tokens out.",
                args.mint
            ))
        } else {
            (None, Some(true), format!(
                "Preview: re-run with --confirm to execute on-chain. \
                 Run `pump-fun-plugin get-price --mint {} --direction buy --amount <lamports>` to see estimated tokens out.",
                args.mint
            ))
        };
        println!(
            "{}",
            serde_json::to_string_pretty(&BuyOutput {
                ok: true,
                mint: args.mint.clone(),
                sol_amount: args.sol_amount.clone(),
                slippage_bps: args.slippage_bps,
                wallet,
                tx_hash: None,
                explorer_url: None,
                dry_run: is_dry_run,
                preview: is_preview,
                note: Some(note),
            })?
        );
        return Ok(());
    }

    let result =
        onchainos::swap_execute_solana(SOL_MINT, &args.mint, &args.sol_amount, args.slippage_bps)
            .await?;

    let tx_hash = onchainos::extract_tx_hash(&result)?;
    let wallet = resolve_wallet_solana().ok();
    let explorer_url = Some(format!("https://solscan.io/tx/{}", tx_hash));

    println!(
        "{}",
        serde_json::to_string_pretty(&BuyOutput {
            ok: true,
            mint: args.mint.clone(),
            sol_amount: args.sol_amount.clone(),
            slippage_bps: args.slippage_bps,
            wallet,
            tx_hash: Some(tx_hash),
            explorer_url,
            dry_run: None,
            preview: None,
            note: None,
        })?
    );
    Ok(())
}

use anyhow::Result;
use clap::Args;
use serde::Serialize;
use std::sync::Arc;

/// Serialize an f64 as a decimal string (never scientific notation).
/// Formats to 9 decimal places and strips trailing zeros.
fn serialize_f64_decimal<S>(value: &f64, serializer: S) -> Result<S::Ok, S::Error>
where
    S: serde::Serializer,
{
    serializer.serialize_str(
        &format!("{:.9}", value)
            .trim_end_matches('0')
            .trim_end_matches('.')
            .to_string(),
    )
}

use pumpfun::{
    common::types::{Cluster, PriorityFee},
    PumpFun,
};
use solana_sdk::{commitment_config::CommitmentConfig, pubkey::Pubkey, signature::Keypair};

use crate::config::{DEFAULT_RPC_URL, FEE_BASIS_POINTS};

#[derive(Args, Debug)]
pub struct GetPriceArgs {
    /// Token mint address (base58)
    #[arg(long)]
    pub mint: String,

    /// Trade direction: "buy" or "sell"
    #[arg(long)]
    pub direction: String,

    /// Amount: SOL lamports for buy direction, token units for sell direction
    #[arg(long)]
    pub amount: u64,

    /// Fee in basis points for sell price calculation (default: 100 = 1%)
    #[arg(long, default_value_t = FEE_BASIS_POINTS)]
    pub fee_bps: u64,

    /// Solana RPC URL (overrides HELIUS_RPC_URL env var and default)
    #[arg(long)]
    pub rpc_url: Option<String>,
}

#[derive(Serialize, Debug)]
struct GetPriceOutput {
    ok: bool,
    mint: String,
    direction: String,
    amount_in: u64,
    amount_out: u64,
    #[serde(serialize_with = "serialize_f64_decimal")]
    amount_out_ui: f64,
    #[serde(serialize_with = "serialize_f64_decimal")]
    price_sol_per_token: f64,
    /// SOL (not lamports). Divide the raw on-chain lamport value by 1e9.
    #[serde(serialize_with = "serialize_f64_decimal")]
    market_cap_sol: f64,
    bonding_complete: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    graduated_warning: Option<String>,
}

pub async fn execute(args: &GetPriceArgs) -> Result<()> {
    let direction = args.direction.to_lowercase();
    if direction != "buy" && direction != "sell" {
        anyhow::bail!("direction must be 'buy' or 'sell', got '{}'", args.direction);
    }

    let rpc_url = args
        .rpc_url
        .clone()
        .or_else(|| std::env::var("HELIUS_RPC_URL").ok())
        .unwrap_or_else(|| DEFAULT_RPC_URL.to_string());

    let mint: Pubkey = args
        .mint
        .parse()
        .map_err(|e| anyhow::anyhow!("Invalid mint address '{}': {}", args.mint, e))?;

    let placeholder_keypair = Arc::new(Keypair::new());
    let commitment = CommitmentConfig::confirmed();
    let priority_fee = PriorityFee::default();
    let ws_url = derive_ws_url(&rpc_url);
    let cluster = Cluster::new(rpc_url, ws_url, commitment, priority_fee);

    let pumpfun = PumpFun::new(placeholder_keypair, cluster);

    let curve = pumpfun
        .get_bonding_curve_account(&mint)
        .await
        .map_err(|e| {
            let msg = e.to_string();
            if msg.contains("Borsh") || msg.contains("serialization") || msg.contains("length") {
                anyhow::anyhow!(
                    "Failed to fetch bonding curve: {}. \
                     This token may use an updated pump.fun contract layout not yet supported by the SDK. \
                     Try `onchainos token search --mint {}` for token info instead.",
                    msg, mint
                )
            } else {
                anyhow::anyhow!("Failed to fetch bonding curve: {}", msg)
            }
        })?;

    let price_sol_per_token = if curve.virtual_token_reserves > 0 {
        curve.virtual_sol_reserves as f64 / curve.virtual_token_reserves as f64
    } else {
        0.0
    };

    let (amount_out, amount_out_ui) = if direction == "buy" && curve.complete {
        // Graduated token — bonding curve is closed, get_buy_price would error.
        // Return ok:true with amount_out=0 and a graduated_warning instead.
        (0u64, 0.0f64)
    } else if direction == "buy" {
        let tokens = curve
            .get_buy_price(args.amount)
            .map_err(|e| anyhow::anyhow!("get_buy_price failed: {e}"))?;
        // pump.fun tokens have 6 decimals
        let ui = tokens as f64 / 1_000_000.0;
        (tokens, ui)
    } else if curve.complete {
        // Graduated token — bonding curve is closed, get_sell_price returns "Curve is complete".
        // Return ok:true with amount_out=0 and a graduated_warning instead of erroring out.
        (0u64, 0.0f64)
    } else {
        let lamports = curve
            .get_sell_price(args.amount, args.fee_bps)
            .map_err(|e| anyhow::anyhow!("get_sell_price failed: {e}"))?;
        // SOL lamports → UI SOL
        let ui = lamports as f64 / 1_000_000_000.0;
        (lamports, ui)
    };

    let graduated_warning = if curve.complete {
        Some("Token has graduated from bonding curve. Use onchainos dex swap execute --chain 501 to trade on PumpSwap/Raydium.".to_string())
    } else {
        None
    };

    let output = GetPriceOutput {
        ok: true,
        mint: args.mint.clone(),
        direction,
        amount_in: args.amount,
        amount_out,
        amount_out_ui,
        price_sol_per_token,
        market_cap_sol: curve.get_market_cap_sol() as f64 / 1_000_000_000.0,
        bonding_complete: curve.complete,
        graduated_warning,
    };

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

/// Derive a WebSocket URL from an HTTP RPC URL.
fn derive_ws_url(http_url: &str) -> String {
    http_url
        .replace("https://", "wss://")
        .replace("http://", "ws://")
}

use anyhow::Result;
use clap::Args;
use serde::Serialize;
use std::sync::Arc;

/// Serialize an f64 as a decimal string (never scientific notation).
/// Formats to 9 decimal places and strips trailing zeros.
fn serialize_f64_decimal<S>(value: &f64, serializer: S) -> Result<S::Ok, S::Error>
where
    S: serde::Serializer,
{
    serializer.serialize_str(
        &format!("{:.9}", value)
            .trim_end_matches('0')
            .trim_end_matches('.')
            .to_string(),
    )
}

use pumpfun::{
    common::types::{Cluster, PriorityFee},
    PumpFun,
};
use solana_sdk::{commitment_config::CommitmentConfig, pubkey::Pubkey, signature::Keypair};

use crate::config::{DEFAULT_RPC_URL, FEE_BASIS_POINTS, GRADUATION_SOL_THRESHOLD};

#[derive(Args, Debug)]
pub struct GetTokenInfoArgs {
    /// Token mint address (base58)
    #[arg(long)]
    pub mint: String,

    /// Solana RPC URL (overrides HELIUS_RPC_URL env var and default)
    #[arg(long)]
    pub rpc_url: Option<String>,
}

#[derive(Serialize, Debug)]
struct TokenInfoOutput {
    ok: bool,
    mint: String,
    virtual_token_reserves: u64,
    virtual_sol_reserves: u64,
    real_token_reserves: u64,
    /// SOL (not lamports). Divide the raw on-chain lamport value by 1e9.
    #[serde(serialize_with = "serialize_f64_decimal")]
    real_sol_reserves: f64,
    token_total_supply: u64,
    complete: bool,
    creator: String,
    #[serde(serialize_with = "serialize_f64_decimal")]
    price_sol_per_token: f64,
    /// SOL (not lamports). Divide the raw on-chain lamport value by 1e9.
    #[serde(serialize_with = "serialize_f64_decimal")]
    market_cap_sol: f64,
    /// SOL (not lamports). Divide the raw on-chain lamport value by 1e9.
    #[serde(serialize_with = "serialize_f64_decimal")]
    final_market_cap_sol: f64,
    #[serde(serialize_with = "serialize_f64_decimal")]
    graduation_progress_pct: f64,
    status: String,
}

pub async fn execute(args: &GetTokenInfoArgs) -> Result<()> {
    let rpc_url = args
        .rpc_url
        .clone()
        .or_else(|| std::env::var("HELIUS_RPC_URL").ok())
        .unwrap_or_else(|| DEFAULT_RPC_URL.to_string());

    let mint: Pubkey = args
        .mint
        .parse()
        .map_err(|e| anyhow::anyhow!("Invalid mint address '{}': {}", args.mint, e))?;

    // Use a placeholder keypair — reads don't require signing
    let placeholder_keypair = Arc::new(Keypair::new());

    let commitment = CommitmentConfig::confirmed();
    let priority_fee = PriorityFee::default();

    // Build cluster with custom RPC URL
    let ws_url = derive_ws_url(&rpc_url);
    let cluster = Cluster::new(rpc_url, ws_url, commitment, priority_fee);

    let pumpfun = PumpFun::new(placeholder_keypair, cluster);

    let curve = pumpfun
        .get_bonding_curve_account(&mint)
        .await
        .map_err(|e| {
            let msg = e.to_string();
            if msg.contains("Borsh") || msg.contains("serialization") || msg.contains("length") {
                anyhow::anyhow!(
                    "Failed to fetch bonding curve: {}. \
                     This token may use an updated pump.fun contract layout not yet supported by the SDK. \
                     Try `onchainos token search --mint {}` for token info instead.",
                    msg, mint
                )
            } else {
                anyhow::anyhow!("Failed to fetch bonding curve: {}", msg)
            }
        })?;

    let price_sol_per_token = if curve.virtual_token_reserves > 0 {
        curve.virtual_sol_reserves as f64 / curve.virtual_token_reserves as f64
    } else {
        0.0
    };

    let graduation_progress_pct = if GRADUATION_SOL_THRESHOLD > 0 {
        (curve.real_sol_reserves as f64 / GRADUATION_SOL_THRESHOLD as f64) * 100.0
    } else {
        0.0
    };

    let status = if curve.complete {
        "Graduated (trading on PumpSwap/Raydium)".to_string()
    } else {
        "Active (bonding curve)".to_string()
    };

    // get_final_market_cap_sol internally calls get_buy_out_price which can panic with
    // divide-by-zero when virtual_token_reserves <= real_token_reserves (nearly exhausted
    // bonding curve). Guard against this by catching the panic.
    let final_market_cap_sol = {
        let vtr = curve.virtual_token_reserves;
        let rtr = curve.real_token_reserves;
        // Replicate the sol_tokens selection from get_buy_out_price:
        // sol_tokens = max(amount, real_sol_reserves) where amount = real_token_reserves
        // Then denominator = virtual_token_reserves - sol_tokens, which panics when 0.
        // Use saturating arithmetic to return 0 in the degenerate case.
        let sol_tokens = if rtr < curve.real_sol_reserves {
            curve.real_sol_reserves as u128
        } else {
            rtr as u128
        };
        let vtr_u128 = vtr as u128;
        if vtr_u128 <= sol_tokens || vtr == 0 {
            // Degenerate case — bonding curve nearly or fully exhausted; return 0
            0u64
        } else {
            curve.get_final_market_cap_sol(FEE_BASIS_POINTS)
        }
    };

    let output = TokenInfoOutput {
        ok: true,
        mint: args.mint.clone(),
        virtual_token_reserves: curve.virtual_token_reserves,
        virtual_sol_reserves: curve.virtual_sol_reserves,
        real_token_reserves: curve.real_token_reserves,
        real_sol_reserves: curve.real_sol_reserves as f64 / 1_000_000_000.0,
        token_total_supply: curve.token_total_supply,
        complete: curve.complete,
        creator: curve.creator.to_string(),
        price_sol_per_token,
        market_cap_sol: curve.get_market_cap_sol() as f64 / 1_000_000_000.0,
        final_market_cap_sol: final_market_cap_sol as f64 / 1_000_000_000.0,
        graduation_progress_pct: graduation_progress_pct.min(100.0),
        status,
    };

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

/// Derive a WebSocket URL from an HTTP RPC URL.
fn derive_ws_url(http_url: &str) -> String {
    http_url
        .replace("https://", "wss://")
        .replace("http://", "ws://")
}

pub mod get_token_info;
pub mod get_price;
pub mod buy;
pub mod sell;
pub mod quickstart;

use anyhow::Result;

/// Fetch SOL balance in lamports for the given wallet via Solana JSON-RPC.
async fn sol_balance_lamports(wallet: &str) -> u64 {
    let client = match reqwest::Client::builder()
        .timeout(std::time::Duration::from_secs(10))
        .build()
    {
        Ok(c) => c,
        Err(_) => return 0,
    };

    let body = serde_json::json!({
        "jsonrpc": "2.0",
        "id": 1,
        "method": "getBalance",
        "params": [wallet]
    });

    let resp = match client
        .post("https://api.mainnet-beta.solana.com")
        .json(&body)
        .send()
        .await
    {
        Ok(r) => r,
        Err(_) => return 0,
    };

    let json: serde_json::Value = match resp.json().await {
        Ok(v) => v,
        Err(_) => return 0,
    };

    json["result"]["value"].as_u64().unwrap_or(0)
}

pub async fn run() -> Result<()> {
    let wallet = crate::onchainos::resolve_wallet_solana()?;

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

    let lamports = sol_balance_lamports(&wallet).await;
    // 1 SOL = 1_000_000_000 lamports
    let sol_balance = lamports as f64 / 1_000_000_000.0;
    let sol_balance_str = format!("{:.6}", sol_balance);

    let threshold = 0.05_f64;
    let (status, suggestion, next_command, onboarding_steps) = if sol_balance >= threshold {
        (
            "ready",
            "Your wallet has SOL. Find a token mint and start trading on pump.fun.",
            "pump-fun-plugin get-token-info --mint <TOKEN_MINT>",
            serde_json::json!([
                "1. Get token info (replace with your token mint):",
                "   pump-fun-plugin get-token-info --mint <TOKEN_MINT>",
                "2. Check buy price (--amount is in lamports; 10000000 = 0.01 SOL):",
                "   pump-fun-plugin get-price --mint <TOKEN_MINT> --direction buy --amount 10000000",
                "3. Preview a buy (no transaction):",
                "   pump-fun-plugin buy --mint <TOKEN_MINT> --sol-amount 0.01",
                "4. Execute when ready:",
                "   pump-fun-plugin buy --mint <TOKEN_MINT> --sol-amount 0.01 --confirm",
                "5. Preview a sell (no transaction):",
                "   pump-fun-plugin sell --mint <TOKEN_MINT> --token-amount <AMOUNT>",
                "6. Execute sell when ready:",
                "   pump-fun-plugin sell --mint <TOKEN_MINT> --token-amount <AMOUNT> --confirm",
                "Note: Find token mints at pump.fun or via search"
            ]),
        )
    } else {
        (
            "no_funds",
            "Your wallet has insufficient SOL. Send SOL to your wallet to start trading.",
            "pump-fun-plugin quickstart",
            serde_json::json!([
                "1. Send SOL to your wallet on Solana mainnet:",
                format!("   {}", wallet),
                "   Minimum recommended: 0.05 SOL (covers fees + minimum buy of 0.01 SOL)",
                "2. Run quickstart again:",
                "   pump-fun-plugin quickstart"
            ]),
        )
    };

    let output = serde_json::json!({
        "ok": true,
        "about": "pump.fun plugin — buy and sell tokens on Solana bonding curves before and after DEX graduation.",
        "wallet": wallet,
        "chain": "Solana",
        "assets": {
            "sol_balance": sol_balance_str
        },
        "status": status,
        "suggestion": suggestion,
        "next_command": next_command,
        "onboarding_steps": onboarding_steps
    });

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

use anyhow::Result;
use clap::Args;
use serde::Serialize;

use crate::config::DEFAULT_SLIPPAGE_BPS;
use crate::onchainos::{self, SOL_MINT};
use crate::onchainos::resolve_wallet_solana;

#[derive(Args, Debug)]
pub struct SellArgs {
    /// Token mint address (base58)
    #[arg(long)]
    pub mint: String,

    /// Readable token amount to sell (e.g. "1000000"). Omit to sell entire balance.
    #[arg(long)]
    pub token_amount: Option<String>,

    /// Slippage tolerance in basis points (default: 100 = 1%)
    #[arg(long, default_value_t = DEFAULT_SLIPPAGE_BPS)]
    pub slippage_bps: u64,

    /// Confirm execution — required to execute on-chain. Without this flag, shows a preview.
    #[arg(long)]
    pub confirm: bool,
}

#[derive(Serialize, Debug)]
struct SellOutput {
    ok: bool,
    mint: String,
    token_amount: String,
    slippage_bps: u64,
    #[serde(skip_serializing_if = "Option::is_none")]
    wallet: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    tx_hash: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    explorer_url: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    dry_run: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    preview: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    note: Option<String>,
}

pub async fn execute(args: &SellArgs, dry_run: bool) -> Result<()> {
    // Resolve amount: explicit or placeholder/balance
    let amount = match &args.token_amount {
        Some(a) => a.clone(),
        None => {
            if dry_run || !args.confirm {
                "<full balance>".to_string()
            } else {
                onchainos::get_token_balance(&args.mint)?
                    .ok_or_else(|| anyhow::anyhow!(
                        "No balance found for mint {} in your Solana wallet. \
                         Ensure the token is held in the active wallet, or specify \
                         the amount explicitly with --token-amount <amount>.",
                        args.mint
                    ))?
            }
        }
    };

    if dry_run || !args.confirm {
        let wallet = resolve_wallet_solana().ok();
        let (is_dry_run, is_preview, note) = if dry_run {
            (Some(true), None, format!(
                "dry_run=true — no transaction submitted. Pass --confirm to execute. \
                 Run `pump-fun-plugin get-price --mint {} --direction sell --amount <token_atoms>` to see estimated SOL out.",
                args.mint
            ))
        } else {
            (None, Some(true), format!(
                "Preview: re-run with --confirm to execute on-chain. \
                 Run `pump-fun-plugin get-price --mint {} --direction sell --amount <token_atoms>` to see estimated SOL out.",
                args.mint
            ))
        };
        println!(
            "{}",
            serde_json::to_string_pretty(&SellOutput {
                ok: true,
                mint: args.mint.clone(),
                token_amount: amount,
                slippage_bps: args.slippage_bps,
                wallet,
                tx_hash: None,
                explorer_url: None,
                dry_run: is_dry_run,
                preview: is_preview,
                note: Some(note),
            })?
        );
        return Ok(());
    }

    let result =
        onchainos::swap_execute_solana(&args.mint, SOL_MINT, &amount, args.slippage_bps).await?;

    let tx_hash = onchainos::extract_tx_hash(&result)?;
    let wallet = resolve_wallet_solana().ok();
    let explorer_url = Some(format!("https://solscan.io/tx/{}", tx_hash));

    println!(
        "{}",
        serde_json::to_string_pretty(&SellOutput {
            ok: true,
            mint: args.mint.clone(),
            token_amount: amount,
            slippage_bps: args.slippage_bps,
            wallet,
            tx_hash: Some(tx_hash),
            explorer_url,
            dry_run: None,
            preview: None,
            note: None,
        })?
    );
    Ok(())
}

/// Default Solana RPC endpoint (public mainnet-beta)
pub const DEFAULT_RPC_URL: &str = "https://api.mainnet-beta.solana.com";

/// Default slippage in basis points (100 = 1%)
pub const DEFAULT_SLIPPAGE_BPS: u64 = 100;

/// Fee basis points used in sell price calculation (pump.fun standard 1%)
pub const FEE_BASIS_POINTS: u64 = 100;

/// Approximate SOL threshold for bonding curve graduation (~85 SOL in lamports)
pub const GRADUATION_SOL_THRESHOLD: u64 = 85_000_000_000;

mod commands;
mod config;
mod onchainos;

use clap::{Parser, Subcommand};

use commands::{
    buy::BuyArgs, get_price::GetPriceArgs, get_token_info::GetTokenInfoArgs, sell::SellArgs,
};

#[derive(Parser, Debug)]
#[command(
    name = "pump-fun",
    about = "Plugin for pump.fun — buy and sell tokens on Solana bonding curves via onchainos swap",
    version
)]
struct Cli {
    /// Simulate without broadcasting (no on-chain transaction sent)
    #[arg(long, global = true)]
    dry_run: bool,

    #[command(subcommand)]
    command: Commands,
}

#[derive(Subcommand, Debug)]
enum Commands {
    /// Get on-chain bonding curve info for a token
    GetTokenInfo(GetTokenInfoArgs),

    /// Get current buy or sell price for a token
    GetPrice(GetPriceArgs),

    /// Buy tokens on a pump.fun bonding curve via onchainos swap
    Buy(BuyArgs),

    /// Sell tokens back to a pump.fun bonding curve via onchainos swap
    Sell(SellArgs),

    /// Check wallet state and get guided next steps
    Quickstart,
}

#[tokio::main]
async fn main() {
    let cli = Cli::parse();

    let result = match &cli.command {
        Commands::GetTokenInfo(args) => commands::get_token_info::execute(args).await,
        Commands::GetPrice(args) => commands::get_price::execute(args).await,
        Commands::Buy(args) => commands::buy::execute(args, cli.dry_run).await,
        Commands::Sell(args) => commands::sell::execute(args, cli.dry_run).await,
        Commands::Quickstart => commands::quickstart::run().await,
    };

    if let Err(e) = result {
        eprintln!("{}", serde_json::json!({"ok": false, "error": e.to_string()}));
        std::process::exit(1);
    }
}

use std::process::Command;
use serde_json::Value;

/// Solana native SOL mint address used by onchainos swap
pub const SOL_MINT: &str = "11111111111111111111111111111111";

/// Resolve the current Solana wallet address (base58) via onchainos.
pub fn resolve_wallet_solana() -> anyhow::Result<String> {
    let output = Command::new("onchainos")
        .args(["wallet", "addresses", "--chain", "501"])
        .output()?;
    let json: Value = serde_json::from_str(&String::from_utf8_lossy(&output.stdout))
        .map_err(|e| anyhow::anyhow!("wallet addresses parse error: {}", e))?;
    let addr = json["data"]["solana"][0]["address"]
        .as_str()
        .unwrap_or("")
        .to_string();
    if addr.is_empty() {
        anyhow::bail!("Could not resolve Solana wallet address. Make sure onchainos is logged in.");
    }
    Ok(addr)
}

/// Execute a swap via `onchainos swap execute`.
/// Works for both bonding curve tokens and graduated (DEX) tokens.
pub async fn swap_execute_solana(
    from_mint: &str,
    to_mint: &str,
    readable_amount: &str,
    slippage_bps: u64,
) -> anyhow::Result<Value> {
    // Convert bps to percent string (e.g. 100 bps → "1", 50 bps → "0.5")
    let slippage_pct = format!("{}", slippage_bps as f64 / 100.0);
    let wallet = resolve_wallet_solana()?;

    let output = tokio::process::Command::new("onchainos")
        .args([
            "swap",
            "execute",
            "--chain",
            "solana",
            "--from",
            from_mint,
            "--to",
            to_mint,
            "--readable-amount",
            readable_amount,
            "--slippage",
            &slippage_pct,
            "--wallet",
            &wallet,
        ])
        .output()
        .await?;

    let stdout = String::from_utf8_lossy(&output.stdout);
    let stderr = String::from_utf8_lossy(&output.stderr);

    if stdout.trim().is_empty() {
        anyhow::bail!("onchainos swap execute returned empty output. stderr: {}", stderr);
    }

    let result: Value = serde_json::from_str(&stdout)
        .map_err(|e| anyhow::anyhow!("onchainos swap execute non-JSON: {stdout}\n{e}"))?;

    if result["ok"].as_bool() != Some(true) {
        let err = result["error"].as_str().unwrap_or("unknown error");
        anyhow::bail!("onchainos swap execute failed: {}", err);
    }

    Ok(result)
}

/// Get token balance for a specific mint from the onchainos wallet.
/// Returns readable amount as a string, or None if not held.
pub fn get_token_balance(mint: &str) -> anyhow::Result<Option<String>> {
    let output = Command::new("onchainos")
        .args(["wallet", "balance", "--chain", "501"])
        .output()?;
    let json: Value = serde_json::from_str(&String::from_utf8_lossy(&output.stdout))?;

    let details = match json["data"]["details"].as_array() {
        Some(d) => d,
        None => return Ok(None),
    };

    for detail in details {
        if let Some(assets) = detail["tokenAssets"].as_array() {
            for asset in assets {
                // onchainos wallet balance --chain 501 structure:
                //   asset["address"]      = wallet address (always present — do NOT use for mint matching)
                //   asset["tokenAddress"] = token mint address (correct field to match against)
                //   asset["mint"]         = fallback for alternative response shapes
                let addr = asset["tokenAddress"].as_str()
                    .or_else(|| asset["mint"].as_str())
                    .unwrap_or("");
                if addr.eq_ignore_ascii_case(mint) {
                    if let Some(bal) = asset["balance"].as_str()
                        .or_else(|| asset["readableBalance"].as_str())
                        .or_else(|| asset["uiAmount"].as_str())
                    {
                        return Ok(Some(bal.to_string()));
                    }
                    if let Some(n) = asset["balance"].as_f64()
                        .or_else(|| asset["uiAmount"].as_f64())
                    {
                        return Ok(Some(n.to_string()));
                    }
                }
            }
        }
    }
    Ok(None)
}

/// Extract the txHash from an onchainos swap response.
/// Returns an error if txHash is absent, so broadcast failures are not silently masked.
pub fn extract_tx_hash(result: &Value) -> anyhow::Result<String> {
    result["data"]["txHash"]
        .as_str()
        .or_else(|| result["data"]["swapTxHash"].as_str())
        .or_else(|| result["txHash"].as_str())
        .map(|s| s.to_string())
        .ok_or_else(|| anyhow::anyhow!("onchainos response missing txHash: {}", result))
}