Pendle Plugin

{
  "name": "pendle-plugin",
  "description": "Pendle Finance yield tokenization plugin \u2014 buy/sell PT & YT, add/remove liquidity, mint/redeem PT+YT pairs across Ethereum, Arbitrum, BSC, and Base",
  "version": "0.2.9"
}

/target/
Cargo.lock

[package]
name = "pendle-plugin"
version = "0.2.9"
edition = "2021"

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

[dependencies]
clap = { version = "4", features = ["derive"] }
reqwest = { version = "0.12", features = ["json", "blocking"] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tokio = { version = "1", features = ["full"] }
anyhow = "1"
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: pendle-plugin
version: "0.2.9"
description: "Pendle Finance yield tokenization plugin — buy/sell PT & YT, add/remove liquidity, mint/redeem PT+YT pairs across Ethereum, Arbitrum, BSC, and Base"
author:
  name: skylavis-sky
  github: skylavis-sky
category: dapp
tags:
  - yield-trading
  - fixed-yield
  - pt
  - yt
  - liquidity
license: MIT

components:
  skill:
    dir: .

build:
  lang: rust
  binary_name: pendle-plugin

api_calls:
  - "https://api-v2.pendle.finance/core"
  - "https://ethereum.publicnode.com"
  - "https://arbitrum-one-rpc.publicnode.com"
  - "https://bsc.publicnode.com"
  - "https://base-rpc.publicnode.com"

use anyhow::Context;
use serde::Deserialize;
use serde_json::Value;

use crate::config::PENDLE_API_BASE;

// ─── Custom deserializer: accept JSON number or string ────────────────────────
mod deser_number_or_string {
    use serde::{Deserialize, Deserializer};
    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<Option<String>, D::Error> {
        use serde_json::Value;
        Ok(match Option::<Value>::deserialize(d)? {
            Some(Value::String(s)) => Some(s),
            Some(Value::Number(n)) => Some(n.to_string()),
            _ => None,
        })
    }
}

// ─── Market structures ────────────────────────────────────────────────────────

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct MarketLiquidity {
    #[serde(default, deserialize_with = "deser_number_or_string::deserialize")]
    pub usd: Option<String>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TradingVolume {
    #[serde(default, deserialize_with = "deser_number_or_string::deserialize")]
    pub usd: Option<String>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Market {
    pub address: Option<String>,
    pub name: Option<String>,
    #[serde(rename = "chainId")]
    pub chain_id: Option<u64>,
    pub expiry: Option<String>,
    pub pt: Option<Value>,
    pub yt: Option<Value>,
    pub sy: Option<Value>,
    #[serde(default, deserialize_with = "deser_number_or_string::deserialize")]
    pub implied_apy: Option<String>,
    pub liquidity: Option<MarketLiquidity>,
    pub trading_volume: Option<TradingVolume>,
}

#[derive(Debug, Deserialize)]
pub struct MarketsResponse {
    pub results: Option<Vec<Value>>,
    pub total: Option<u64>,
}

// ─── Position structures ──────────────────────────────────────────────────────

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Position {
    pub chain_id: Option<u64>,
    pub market_address: Option<String>,
    #[serde(default, deserialize_with = "deser_number_or_string::deserialize")]
    pub pt_balance: Option<String>,
    #[serde(default, deserialize_with = "deser_number_or_string::deserialize")]
    pub yt_balance: Option<String>,
    #[serde(default, deserialize_with = "deser_number_or_string::deserialize")]
    pub lp_balance: Option<String>,
    #[serde(default, deserialize_with = "deser_number_or_string::deserialize")]
    pub value_usd: Option<String>,
    #[serde(default, deserialize_with = "deser_number_or_string::deserialize")]
    pub implied_apy: Option<String>,
}

// ─── HTTP client ──────────────────────────────────────────────────────────────

fn build_client(api_key: Option<&str>) -> anyhow::Result<reqwest::Client> {
    let mut builder = reqwest::Client::builder();
    if let Some(key) = api_key {
        let mut headers = reqwest::header::HeaderMap::new();
        let auth_val = format!("Bearer {}", key);
        headers.insert(
            reqwest::header::AUTHORIZATION,
            reqwest::header::HeaderValue::from_str(&auth_val)?,
        );
        builder = builder.default_headers(headers);
    }
    Ok(builder.build()?)
}

// ─── API functions ────────────────────────────────────────────────────────────

/// GET /v2/markets/all — list Pendle markets
pub async fn list_markets(
    chain_id: Option<u64>,
    is_active: Option<bool>,
    skip: u64,
    limit: u64,
    api_key: Option<&str>,
) -> anyhow::Result<Value> {
    let client = build_client(api_key)?;
    let mut url = format!("{}/v2/markets/all?skip={}&limit={}", PENDLE_API_BASE, skip, limit);
    if let Some(cid) = chain_id {
        url.push_str(&format!("&chainId={}", cid));
    }
    if let Some(active) = is_active {
        url.push_str(&format!("&isActive={}", active));
    }
    let resp = client
        .get(&url)
        .send()
        .await
        .context("Failed to call Pendle markets API")?;
    let body: Value = resp.json().await.context("Failed to parse markets response")?;
    Ok(body)
}

/// GET /v3/{chainId}/markets/{marketAddress}/historical-data
pub async fn get_market(
    chain_id: u64,
    market_address: &str,
    time_frame: Option<&str>,
    api_key: Option<&str>,
) -> anyhow::Result<Value> {
    let client = build_client(api_key)?;
    let mut url = format!(
        "{}/v3/{}/markets/{}/historical-data",
        PENDLE_API_BASE, chain_id, market_address
    );
    if let Some(tf) = time_frame {
        url.push_str(&format!("?time_frame={}", tf));
    }
    let resp = client
        .get(&url)
        .send()
        .await
        .context("Failed to call Pendle market detail API")?;
    let body: Value = resp.json().await.context("Failed to parse market detail response")?;
    Ok(body)
}

/// GET /v1/dashboard/positions/database/{user}
pub async fn get_positions(
    user: &str,
    filter_usd: Option<f64>,
    api_key: Option<&str>,
) -> anyhow::Result<Value> {
    let client = build_client(api_key)?;
    let mut url = format!(
        "{}/v1/dashboard/positions/database/{}",
        PENDLE_API_BASE, user
    );
    if let Some(min_usd) = filter_usd {
        url.push_str(&format!("?filterUsd={}", min_usd));
    }
    let resp = client
        .get(&url)
        .send()
        .await
        .context("Failed to call Pendle positions API")?;
    let body: Value = resp.json().await.context("Failed to parse positions response")?;
    Ok(body)
}

/// GET /v1/prices/assets — batch asset price query
pub async fn get_asset_prices(
    chain_id: Option<u64>,
    ids: Option<&str>,
    asset_type: Option<&str>,
    api_key: Option<&str>,
) -> anyhow::Result<Value> {
    let client = build_client(api_key)?;
    let mut params = Vec::new();
    if let Some(cid) = chain_id {
        params.push(format!("chainId={}", cid));
    }
    if let Some(i) = ids {
        params.push(format!("ids={}", i));
    }
    if let Some(t) = asset_type {
        params.push(format!("type={}", t));
    }
    let url = if params.is_empty() {
        format!("{}/v1/prices/assets", PENDLE_API_BASE)
    } else {
        format!("{}/v1/prices/assets?{}", PENDLE_API_BASE, params.join("&"))
    };
    let resp = client
        .get(&url)
        .send()
        .await
        .context("Failed to call Pendle prices API")?;
    let body: Value = resp.json().await.context("Failed to parse prices response")?;
    Ok(body)
}

/// GET /v2/sdk/{chainId}/convert — Pendle Hosted SDK v2 endpoint.
///
/// Used for multi-token operations where the v3 POST endpoint cannot classify the action:
///   - mintPyFromToken:  tokensIn = underlying, tokensOut = "pt_addr,yt_addr"
///   - redeemPyToToken:  tokensIn = "pt_addr,yt_addr", amountsIn = "pt_amt,yt_amt", tokensOut = underlying
///
/// Per the official Pendle hosted-SDK examples (pendle-finance/pendle-examples-public),
/// the v2 GET endpoint is the correct path for mint/redeem PY. The response schema is
/// identical to v3 POST (routes[].tx.data / routes[].tx.to) so all existing extractors work.
pub async fn sdk_convert_v2_get(
    chain_id: u64,
    receiver: &str,
    tokens_in: &str,   // comma-separated for multi-input (e.g. "pt_addr,yt_addr")
    amounts_in: &str,  // comma-separated for multi-input (e.g. "pt_wei,yt_wei")
    tokens_out: &str,  // comma-separated for multi-output (e.g. "pt_addr,yt_addr")
    slippage: f64,
    api_key: Option<&str>,
) -> anyhow::Result<Value> {
    let client = build_client(api_key)?;
    let url = format!(
        "{}/v2/sdk/{}/convert?tokensIn={}&amountsIn={}&tokensOut={}&receiver={}&slippage={}&enableAggregator=true",
        PENDLE_API_BASE, chain_id,
        tokens_in, amounts_in, tokens_out, receiver, slippage
    );

    let resp = client
        .get(&url)
        .send()
        .await
        .context("Failed to call Pendle SDK v2 convert API")?;

    let status = resp.status();
    let body_text = resp.text().await.context("Failed to read SDK v2 convert response body")?;

    if !status.is_success() {
        anyhow::bail!(
            "Pendle SDK v2 convert returned HTTP {}: {}",
            status.as_u16(),
            body_text.trim()
        );
    }

    let response: Value = serde_json::from_str(&body_text)
        .context("Failed to parse SDK v2 convert response")?;
    Ok(response)
}

/// POST /v3/sdk/{chainId}/convert — generate transaction calldata via Pendle Hosted SDK
pub async fn sdk_convert(
    chain_id: u64,
    receiver: &str,
    inputs: Vec<SdkTokenAmount>,
    outputs: Vec<SdkTokenAmount>,
    slippage: f64,
    api_key: Option<&str>,
) -> anyhow::Result<Value> {
    let client = build_client(api_key)?;
    let url = format!("{}/v3/sdk/{}/convert", PENDLE_API_BASE, chain_id);

    // Pendle SDK /convert API:
    //   inputs: [{ "token": address, "amount": bigint_string }]
    //   outputs: [address_string, ...]  (plain addresses, no objects)
    //   enableAggregator: true  — allows arbitrary tokenIn/tokenOut (e.g. USDC for sell-pt)
    let body = serde_json::json!({
        "inputs": inputs.iter().map(|i| serde_json::json!({
            "token": i.token,
            "amount": i.amount
        })).collect::<Vec<_>>(),
        "outputs": outputs.iter().map(|o| o.token.as_str()).collect::<Vec<_>>(),
        "receiver": receiver,
        "slippage": slippage,
        "enableAggregator": true
    });

    let resp = client
        .post(&url)
        .json(&body)
        .send()
        .await
        .context("Failed to call Pendle SDK convert API")?;

    let status = resp.status();
    let body_text = resp.text().await.context("Failed to read SDK convert response body")?;

    if !status.is_success() {
        anyhow::bail!(
            "Pendle SDK convert returned HTTP {}: {}",
            status.as_u16(),
            body_text.trim()
        );
    }

    let response: Value = serde_json::from_str(&body_text)
        .context("Failed to parse SDK convert response")?;
    Ok(response)
}

pub struct SdkTokenAmount {
    pub token: String,
    pub amount: String,
}

/// Validate calldata and router address returned by the Pendle Hosted SDK.
///
/// Guards against a supply-chain attack where a compromised SDK response returns
/// calldata that drains the wallet via a standard ERC-20/ERC-721 operation, or
/// routes funds through an unknown contract.
///
/// Checks (in order):
///  1. Calldata is well-formed hex with at least a 4-byte selector.
///  2. router_to is Pendle Router v3 or a known DEX aggregator.
///  3. Selector is not a standard token drain operation (transfer, transferFrom,
///     approve, setApprovalForAll, safeTransferFrom).
pub fn validate_sdk_calldata(calldata: &str, router_to: &str) -> anyhow::Result<()> {
    // 1. Well-formed hex, at least 4 bytes (8 hex chars after 0x prefix)
    let hex = calldata.strip_prefix("0x").unwrap_or(calldata);
    if hex.len() < 8 {
        anyhow::bail!(
            "SDK returned malformed calldata (too short — expected at least 4 bytes): '{}'",
            calldata
        );
    }
    if !hex.chars().all(|c| c.is_ascii_hexdigit()) {
        anyhow::bail!(
            "SDK returned non-hex calldata: '{}'",
            &calldata[..calldata.len().min(20)]
        );
    }

    // 2. router_to must be in the Pendle / known aggregator whitelist
    let router_lower = router_to.to_lowercase();
    let known_routers: &[&str] = &[
        "0x888888888889758f76e7103c6cbf23abbf58f946", // Pendle Router v3
        "0x1111111254eeb25477b68fb85ed929f73a960582", // 1inch v5
        "0x111111125421ca6dc452d289314280a0f8842a65", // 1inch v6
        "0xdef1c0ded9bec7f1a1670819833240f027b25eff", // 0x Exchange Proxy
        "0xe592427a0aece92de3edee1f18e0157c05861564", // Uniswap v3 SwapRouter
    ];
    if !known_routers.contains(&router_lower.as_str()) {
        anyhow::bail!(
            "SDK returned unrecognised router address '{}'. Expected Pendle Router v3 \
             (0x8888...8946) or a known DEX aggregator. Aborting to prevent funds being \
             routed to an unexpected contract.",
            router_to
        );
    }

    // 3. Selector must not be a standard ERC-20/ERC-721 token operation
    let selector = hex[..8].to_lowercase();
    let dangerous: &[(&str, &str)] = &[
        ("a9059cbb", "transfer(address,uint256)"),
        ("23b872dd", "transferFrom(address,address,uint256)"),
        ("095ea7b3", "approve(address,uint256)"),
        ("a22cb465", "setApprovalForAll(address,bool)"),
        ("42842e0e", "safeTransferFrom(address,address,uint256)"),
        ("b88d4fde", "safeTransferFrom(address,address,uint256,bytes)"),
    ];
    for (sel, sig) in dangerous {
        if selector == *sel {
            anyhow::bail!(
                "SDK returned calldata with selector 0x{} ({}). This is a token operation, \
                 not a Pendle Router call. Aborting to prevent unintended token transfer or approval.",
                sel, sig
            );
        }
    }

    Ok(())
}

/// Extract calldata and router address from SDK convert response.
/// Validates the calldata with `validate_sdk_calldata` before returning.
pub fn extract_sdk_calldata(response: &Value) -> anyhow::Result<(String, String)> {
    let routes = response["routes"]
        .as_array()
        .context("No routes in SDK response")?;
    let route = routes.first().context("Empty routes array")?;
    let calldata = route["tx"]["data"]
        .as_str()
        .context("No tx.data in route")?
        .to_string();
    let to = route["tx"]["to"]
        .as_str()
        .unwrap_or(crate::config::PENDLE_ROUTER)
        .to_string();
    validate_sdk_calldata(&calldata, &to)?;
    Ok((calldata, to))
}

/// Extract the expected output amount from SDK convert response.
///
/// Pendle SDK v3 response layout:
///   routes[0].outputs[0].amount  ← primary (confirmed via live API)
///   routes[0].data.*             ← fallback for older SDK shapes
pub fn extract_amount_out(response: &Value) -> Option<String> {
    let route = response["routes"].as_array()?.first()?;

    // Primary: Pendle SDK v3 places output amount at routes[0].outputs[0].amount
    if let Some(outputs) = route["outputs"].as_array() {
        if let Some(first) = outputs.first() {
            if let Some(s) = first["amount"].as_str() {
                return Some(s.to_string());
            }
            if let Some(n) = first["amount"].as_u64() {
                return Some(n.to_string());
            }
        }
    }

    // Fallback: older SDK field names under routes[0].data
    let data = &route["data"];
    for field in &["netPtOut", "netYtOut", "netLpOut", "netTokenOut", "amountOut", "outputAmount"] {
        if let Some(s) = data[field].as_str() {
            return Some(s.to_string());
        }
        if let Some(n) = data[field].as_u64() {
            return Some(n.to_string());
        }
    }
    None
}

/// Extract price impact from SDK convert response.
/// The SDK reports priceImpact as a negative decimal (e.g. -0.015 = 1.5% loss).
/// Returns Some(pct) as a positive percentage value, or None if the field is absent.
pub fn extract_price_impact(response: &Value) -> Option<f64> {
    let route = response["routes"].as_array()?.first()?;
    let impact = route["data"]["priceImpact"]
        .as_f64()
        .or_else(|| route["data"]["price_impact"].as_f64())?;
    Some(impact.abs() * 100.0)
}

/// Client-side minimum-output guard.
///
/// After getting a quote from the SDK, compare the expected output against the
/// user-supplied minimum.  Values of "0" or "" are treated as "no minimum" and
/// always pass.  If the quote is below the minimum the command aborts before any
/// approval or on-chain call, saving gas and preventing a worse-than-expected fill.
///
/// `label` is the human-readable token name used in the error message ("pt", "yt",
/// "lp", "token").
pub fn check_min_out(expected: &Option<String>, min_out: &str, label: &str) -> anyhow::Result<()> {
    let min: u128 = min_out.parse().unwrap_or(0);
    if min == 0 {
        return Ok(());
    }
    if let Some(expected_str) = expected {
        let got: u128 = expected_str.parse().unwrap_or(0);
        if got < min {
            anyhow::bail!(
                "SDK quote {} wei {} is below your --min-{}-out {} wei. \
                 Slippage may be too tight or the market moved. \
                 Lower --min-{}-out or increase --slippage before retrying.",
                got, label, label, min, label
            );
        }
    }
    Ok(())
}

/// Extract required approvals from SDK convert response
pub fn extract_required_approvals(response: &Value) -> Vec<(String, String)> {
    // Returns list of (token_address, spender_address) pairs
    let mut approvals = Vec::new();
    if let Some(arr) = response["requiredApprovals"].as_array() {
        for item in arr {
            let token = item["token"].as_str().unwrap_or("").to_string();
            let spender = item["spender"]
                .as_str()
                .unwrap_or(crate::config::PENDLE_ROUTER)
                .to_string();
            if !token.is_empty() {
                approvals.push((token, spender));
            }
        }
    }
    approvals
}

use anyhow::Result;
use serde_json::Value;

use crate::api::{self, SdkTokenAmount};
use crate::onchainos;

pub async fn run(
    chain_id: u64,
    token_in: &str,
    amount_in: &str,
    lp_address: &str,
    min_lp_out: &str,
    from: Option<&str>,
    slippage: f64,
    dry_run: bool,
    confirm: bool,
    api_key: Option<&str>,
) -> Result<Value> {
    // Validate inputs
    onchainos::validate_evm_address(token_in)?;
    onchainos::validate_evm_address(lp_address)?;
    onchainos::validate_amount(amount_in, "--amount-in")?;

    let wallet = from
        .map(|s| s.to_string())
        .unwrap_or_else(|| onchainos::resolve_wallet(chain_id).unwrap_or_default());
    if wallet.is_empty() {
        anyhow::bail!("Cannot resolve wallet address. Pass --from or ensure onchainos is logged in.");
    }

    // Pre-flight balance check: verify wallet holds enough token_in before calling the SDK
    if !dry_run {
        let balance = onchainos::erc20_balance_of(chain_id, token_in, &wallet).await.unwrap_or(0);
        let required: u128 = amount_in.parse().unwrap_or(0);
        if balance < required {
            anyhow::bail!(
                "Insufficient balance: wallet {} holds {} wei of token {} but {} wei is required. \
                 Acquire more before retrying.",
                wallet, balance, token_in, required
            );
        }
    }

    // Hosted SDK routes automatically to addLiquiditySingleToken
    let sdk_resp = api::sdk_convert(
        chain_id,
        &wallet,
        vec![SdkTokenAmount {
            token: token_in.to_string(),
            amount: amount_in.to_string(),
        }],
        vec![SdkTokenAmount {
            token: lp_address.to_string(),
            amount: min_lp_out.to_string(),
        }],
        slippage,
        api_key,
    )
    .await?;

    let (calldata, router_to) = api::extract_sdk_calldata(&sdk_resp)?;
    let approvals = api::extract_required_approvals(&sdk_resp);
    let expected_lp_out = api::extract_amount_out(&sdk_resp);
    api::check_min_out(&expected_lp_out, min_lp_out, "lp")?;

    // Preview gate: show SDK quote without executing
    if !confirm && !dry_run {
        return Ok(serde_json::json!({
            "ok": true,
            "preview": true,
            "note": "Preview — add --confirm to execute on-chain.",
            "operation": "add-liquidity",
            "chain_id": chain_id,
            "token_in": token_in,
            "amount_in": amount_in,
            "lp_address": lp_address,
            "expected_lp_out": expected_lp_out,
            "router": router_to,
            "calldata": calldata,
            "wallet": wallet,
            "required_approvals": approvals.len(),
        }));
    }

    let amount_in_wei: u128 = amount_in.parse().map_err(|_| anyhow::anyhow!("Failed to parse amount-in: '{}'", amount_in))?;

    let mut approve_hashes: Vec<String> = Vec::new();
    for (token_addr, spender) in &approvals {
        let approve_result = onchainos::erc20_approve(
            chain_id,
            token_addr,
            spender,
            amount_in_wei,
            Some(&wallet),
            dry_run,
        )
        .await?;
        let approve_hash = onchainos::extract_tx_hash(&approve_result)?;
        if !dry_run { onchainos::wait_for_tx(&approve_hash, onchainos::default_rpc_url(chain_id)).await; }
        approve_hashes.push(approve_hash);
    }

    let result = onchainos::wallet_contract_call(
        chain_id,
        &router_to,
        &calldata,
        Some(&wallet),
        None,
        dry_run,
    )
    .await?;

    let tx_hash = onchainos::extract_tx_hash(&result)?;

    Ok(serde_json::json!({
        "ok": true,
        "operation": "add-liquidity",
        "chain_id": chain_id,
        "token_in": token_in,
        "amount_in": amount_in,
        "lp_address": lp_address,
        "min_lp_out": min_lp_out,
        "expected_lp_out": expected_lp_out,
        "router": router_to,
        "calldata": calldata,
        "wallet": wallet,
        "approve_txs": approve_hashes,
        "tx_hash": tx_hash,
        "dry_run": dry_run
    }))
}

use anyhow::Result;
use serde_json::Value;

use crate::api::{self, SdkTokenAmount};
use crate::onchainos;

pub async fn run(
    chain_id: u64,
    token_in: &str,
    amount_in: &str,
    pt_address: &str,
    min_pt_out: &str,
    from: Option<&str>,
    slippage: f64,
    dry_run: bool,
    confirm: bool,
    api_key: Option<&str>,
) -> Result<Value> {
    // Validate inputs
    onchainos::validate_evm_address(token_in)?;
    onchainos::validate_evm_address(pt_address)?;
    onchainos::validate_amount(amount_in, "--amount-in")?;

    // Resolve receiver/sender wallet
    let wallet = from
        .map(|s| s.to_string())
        .unwrap_or_else(|| onchainos::resolve_wallet(chain_id).unwrap_or_default());
    if wallet.is_empty() {
        anyhow::bail!("Cannot resolve wallet address. Pass --from or ensure onchainos is logged in.");
    }

    // Pre-flight balance check: verify wallet holds enough token_in before calling the SDK
    if !dry_run {
        let balance = onchainos::erc20_balance_of(chain_id, token_in, &wallet).await.unwrap_or(0);
        let required: u128 = amount_in.parse().unwrap_or(0);
        if balance < required {
            anyhow::bail!(
                "Insufficient balance: wallet {} holds {} wei of token {} but {} wei is required. \
                 Acquire more before retrying.",
                wallet, balance, token_in, required
            );
        }
    }

    // Call Pendle Hosted SDK to generate calldata
    let sdk_resp = api::sdk_convert(
        chain_id,
        &wallet,
        vec![SdkTokenAmount {
            token: token_in.to_string(),
            amount: amount_in.to_string(),
        }],
        vec![SdkTokenAmount {
            token: pt_address.to_string(),
            amount: min_pt_out.to_string(),
        }],
        slippage,
        api_key,
    )
    .await?;

    let (calldata, router_to) = api::extract_sdk_calldata(&sdk_resp)?;
    let approvals = api::extract_required_approvals(&sdk_resp);
    let expected_pt_out = api::extract_amount_out(&sdk_resp);
    api::check_min_out(&expected_pt_out, min_pt_out, "pt")?;

    // Preview gate: show SDK quote without executing
    if !confirm && !dry_run {
        return Ok(serde_json::json!({
            "ok": true,
            "preview": true,
            "note": "Preview — add --confirm to execute on-chain.",
            "operation": "buy-pt",
            "chain_id": chain_id,
            "token_in": token_in,
            "amount_in": amount_in,
            "pt_address": pt_address,
            "expected_pt_out": expected_pt_out,
            "router": router_to,
            "calldata": calldata,
            "wallet": wallet,
            "required_approvals": approvals.len(),
        }));
    }

    let amount_in_wei: u128 = amount_in.parse().map_err(|_| anyhow::anyhow!("Failed to parse amount-in: '{}'", amount_in))?;

    let mut approve_hashes: Vec<String> = Vec::new();

    // Submit ERC-20 approvals if needed
    for (token_addr, spender) in &approvals {
        let approve_result = onchainos::erc20_approve(
            chain_id,
            token_addr,
            spender,
            amount_in_wei,
            Some(&wallet),
            dry_run,
        )
        .await?;
        let approve_hash = onchainos::extract_tx_hash(&approve_result)?;
        if !dry_run { onchainos::wait_for_tx(&approve_hash, onchainos::default_rpc_url(chain_id)).await; }
        approve_hashes.push(approve_hash);
    }

    // Submit main buy-PT transaction
    let result = onchainos::wallet_contract_call(
        chain_id,
        &router_to,
        &calldata,
        Some(&wallet),
        None,
        dry_run,
    )
    .await?;

    let tx_hash = onchainos::extract_tx_hash(&result)?;

    Ok(serde_json::json!({
        "ok": true,
        "operation": "buy-pt",
        "chain_id": chain_id,
        "token_in": token_in,
        "amount_in": amount_in,
        "pt_address": pt_address,
        "min_pt_out": min_pt_out,
        "expected_pt_out": expected_pt_out,
        "router": router_to,
        "calldata": calldata,
        "wallet": wallet,
        "approve_txs": approve_hashes,
        "tx_hash": tx_hash,
        "dry_run": dry_run
    }))
}

use anyhow::Result;
use serde_json::Value;

use crate::api::{self, SdkTokenAmount};
use crate::onchainos;

pub async fn run(
    chain_id: u64,
    token_in: &str,
    amount_in: &str,
    yt_address: &str,
    min_yt_out: &str,
    from: Option<&str>,
    slippage: f64,
    dry_run: bool,
    confirm: bool,
    api_key: Option<&str>,
) -> Result<Value> {
    // Validate inputs
    onchainos::validate_evm_address(token_in)?;
    onchainos::validate_evm_address(yt_address)?;
    onchainos::validate_amount(amount_in, "--amount-in")?;

    let wallet = from
        .map(|s| s.to_string())
        .unwrap_or_else(|| onchainos::resolve_wallet(chain_id).unwrap_or_default());
    if wallet.is_empty() {
        anyhow::bail!("Cannot resolve wallet address. Pass --from or ensure onchainos is logged in.");
    }

    // Pre-flight balance check: verify wallet holds enough token_in before calling the SDK
    if !dry_run {
        let balance = onchainos::erc20_balance_of(chain_id, token_in, &wallet).await.unwrap_or(0);
        let required: u128 = amount_in.parse().unwrap_or(0);
        if balance < required {
            anyhow::bail!(
                "Insufficient balance: wallet {} holds {} wei of token {} but {} wei is required. \
                 Acquire more before retrying.",
                wallet, balance, token_in, required
            );
        }
    }

    let sdk_resp = api::sdk_convert(
        chain_id,
        &wallet,
        vec![SdkTokenAmount {
            token: token_in.to_string(),
            amount: amount_in.to_string(),
        }],
        vec![SdkTokenAmount {
            token: yt_address.to_string(),
            amount: min_yt_out.to_string(),
        }],
        slippage,
        api_key,
    )
    .await?;

    let (calldata, router_to) = api::extract_sdk_calldata(&sdk_resp)?;
    let approvals = api::extract_required_approvals(&sdk_resp);
    let expected_yt_out = api::extract_amount_out(&sdk_resp);
    api::check_min_out(&expected_yt_out, min_yt_out, "yt")?;

    // Preview gate: show SDK quote without executing
    if !confirm && !dry_run {
        return Ok(serde_json::json!({
            "ok": true,
            "preview": true,
            "note": "Preview — add --confirm to execute on-chain.",
            "operation": "buy-yt",
            "chain_id": chain_id,
            "token_in": token_in,
            "amount_in": amount_in,
            "yt_address": yt_address,
            "expected_yt_out": expected_yt_out,
            "router": router_to,
            "calldata": calldata,
            "wallet": wallet,
            "required_approvals": approvals.len(),
        }));
    }

    let amount_in_wei: u128 = amount_in.parse().map_err(|_| anyhow::anyhow!("Failed to parse amount-in: '{}'", amount_in))?;

    let mut approve_hashes: Vec<String> = Vec::new();
    for (token_addr, spender) in &approvals {
        let approve_result = onchainos::erc20_approve(
            chain_id,
            token_addr,
            spender,
            amount_in_wei,
            Some(&wallet),
            dry_run,
        )
        .await?;
        let approve_hash = onchainos::extract_tx_hash(&approve_result)?;
        if !dry_run { onchainos::wait_for_tx(&approve_hash, onchainos::default_rpc_url(chain_id)).await; }
        approve_hashes.push(approve_hash);
    }

    let result = onchainos::wallet_contract_call(
        chain_id,
        &router_to,
        &calldata,
        Some(&wallet),
        None,
        dry_run,
    )
    .await?;

    let tx_hash = onchainos::extract_tx_hash(&result)?;

    Ok(serde_json::json!({
        "ok": true,
        "operation": "buy-yt",
        "chain_id": chain_id,
        "token_in": token_in,
        "amount_in": amount_in,
        "yt_address": yt_address,
        "min_yt_out": min_yt_out,
        "expected_yt_out": expected_yt_out,
        "router": router_to,
        "calldata": calldata,
        "wallet": wallet,
        "approve_txs": approve_hashes,
        "tx_hash": tx_hash,
        "dry_run": dry_run
    }))
}

use anyhow::Result;
use serde_json::Value;

use crate::api;

pub async fn run(
    chain_id: Option<u64>,
    ids: Option<&str>,
    asset_type: Option<&str>,
    api_key: Option<&str>,
) -> Result<Value> {
    let data = api::get_asset_prices(chain_id, ids, asset_type, api_key).await?;
    Ok(data)
}

use anyhow::Result;
use serde_json::Value;

use crate::api;

/// Strip the optional "chainId-" prefix from a Pendle address string.
/// Pendle API returns addresses as "42161-0xabc..." — callers expect just "0xabc...".
fn strip_chain_prefix(addr: &str) -> &str {
    if let Some(pos) = addr.find("-0x") {
        &addr[pos + 1..]
    } else {
        addr
    }
}

fn extract_addr(v: &Value) -> String {
    // Pendle API encodes addresses as plain strings "chainId-0x..." at the market level
    v.as_str().map(strip_chain_prefix).unwrap_or("").to_string()
}

/// Returns a clean summary of token addresses for a Pendle market.
/// Fetches market data from the Pendle API and extracts the PT, YT, SY, LP,
/// and underlying asset addresses needed for trading commands.
pub async fn run(chain_id: u64, market: &str, api_key: Option<&str>) -> Result<Value> {
    let market_lower = market.to_lowercase();

    // Paginate in 100-result pages (Pendle API cap) to find the target market
    let mut found_market: Option<serde_json::Value> = None;
    let mut skip = 0u64;
    loop {
        let data = api::list_markets(Some(chain_id), None, skip, 100, api_key).await?;

        let results = data["results"]
            .as_array()
            .ok_or_else(|| anyhow::anyhow!("Unexpected response from Pendle markets API"))?;

        if let Some(m) = results.iter().find(|m| {
            m["address"]
                .as_str()
                .map(|a| strip_chain_prefix(a).to_lowercase() == market_lower)
                .unwrap_or(false)
        }) {
            found_market = Some(m.clone());
            break;
        }

        let total = data["total"].as_u64().unwrap_or(0);
        skip += results.len() as u64;
        if skip >= total || results.is_empty() {
            break;
        }
    }

    let m = found_market.ok_or_else(|| {
        anyhow::anyhow!(
            "Market {} not found on chain {}. Use list-markets to discover available markets.",
            market, chain_id
        )
    })?;

    let pt_address = extract_addr(&m["pt"]);
    let yt_address = extract_addr(&m["yt"]);
    let sy_address = extract_addr(&m["sy"]);
    let underlying_address = extract_addr(&m["underlyingAsset"]);
    let expiry = m["expiry"].as_str().unwrap_or("");
    let name = m["name"].as_str().unwrap_or("");
    let implied_apy = m["impliedApy"].as_f64().map(|v| format!("{:.4}", v));

    Ok(serde_json::json!({
        "ok": true,
        "chain_id": chain_id,
        "market": market,
        "name": name,
        "expiry": expiry,
        "implied_apy": implied_apy,
        "addresses": {
            "market_lp": market,
            "pt": pt_address,
            "yt": yt_address,
            "sy": sy_address,
            "underlying": underlying_address,
        },
        "usage": {
            "buy-pt":           format!("pendle --chain {} buy-pt --pt-address {} --token-in {} --amount-in <WEI>", chain_id, pt_address, underlying_address),
            "sell-pt":          format!("pendle --chain {} sell-pt --pt-address {} --token-out {} --amount-in <WEI>", chain_id, pt_address, underlying_address),
            "buy-yt":           format!("pendle --chain {} buy-yt --yt-address {} --token-in {} --amount-in <WEI>", chain_id, yt_address, underlying_address),
            "sell-yt":          format!("pendle --chain {} sell-yt --yt-address {} --token-out {} --amount-in <WEI>", chain_id, yt_address, underlying_address),
            "add-liquidity":    format!("pendle --chain {} add-liquidity --lp-address {} --token-in {} --amount-in <WEI>", chain_id, market, underlying_address),
            "remove-liquidity": format!("pendle --chain {} remove-liquidity --lp-address {} --token-out {} --lp-amount-in <WEI>", chain_id, market, underlying_address),
            "mint-py":          format!("pendle --chain {} mint-py --pt-address {} --yt-address {} --token-in {} --amount-in <WEI>", chain_id, pt_address, yt_address, underlying_address),
        }
    }))
}

use anyhow::Result;
use serde_json::Value;

use crate::api;

pub async fn run(
    chain_id: u64,
    market_address: &str,
    time_frame: Option<&str>,
    api_key: Option<&str>,
) -> Result<Value> {
    // Map user-facing time-frame values to Pendle API interval parameter values.
    // The API accepts "hour", "day", "week" — not the display aliases "1D", "1W", "1M".
    let mapped_time_frame = time_frame.map(|tf| match tf {
        "1D" => "hour",
        "1W" => "day",
        "1M" => "week",
        other => other,
    });
    let data = api::get_market(chain_id, market_address, mapped_time_frame, api_key).await?;
    Ok(data)
}

use anyhow::Result;
use serde_json::Value;

use crate::api;
use crate::onchainos;

pub async fn run(
    user: Option<&str>,
    chain_id: u64,
    filter_usd: Option<f64>,
    api_key: Option<&str>,
) -> Result<Value> {
    let address = match user {
        Some(addr) => addr.to_string(),
        None => {
            let resolved = onchainos::resolve_wallet(chain_id)?;
            if resolved.is_empty() {
                anyhow::bail!("Cannot resolve wallet address. Pass --user or ensure onchainos is logged in.");
            }
            resolved
        }
    };

    let data = api::get_positions(&address, filter_usd, api_key).await?;
    Ok(data)
}

use anyhow::Result;
use serde_json::Value;

use crate::api;

pub async fn run(
    chain_id: Option<u64>,
    is_active: Option<bool>,
    skip: u64,
    limit: u64,
    search: Option<&str>,
    api_key: Option<&str>,
) -> Result<Value> {
    // When searching, fetch a larger batch for client-side filtering
    let fetch_limit = if search.is_some() { 100 } else { limit };
    let mut data = api::list_markets(chain_id, is_active, skip, fetch_limit, api_key).await?;

    // Pendle API moved impliedApy and liquidity into a nested `details` sub-object.
    // Lift them back to the top level for backwards-compatible output.
    if let Some(arr) = data.get_mut("results").and_then(|v| v.as_array_mut()) {
        for item in arr.iter_mut() {
            if item["impliedApy"].is_null() {
                let v = item["details"]["impliedApy"].clone();
                if !v.is_null() {
                    item["impliedApy"] = v;
                }
            }
            if item["liquidity"].is_null() {
                let v = item["details"]["liquidity"].clone();
                if !v.is_null() {
                    item["liquidity"] = v;
                }
            }
        }
    }

    let Some(term) = search else {
        return Ok(data);
    };

    let term_lower = term.to_lowercase();

    let results = match data["results"].as_array() {
        Some(r) => r,
        None => return Ok(data), // no results array — passthrough
    };

    let filtered: Vec<&Value> = results
        .iter()
        .filter(|m| {
            let name = m["name"].as_str().unwrap_or("").to_lowercase();
            let pt_sym = m["pt"]["symbol"].as_str().unwrap_or("").to_lowercase();
            let yt_sym = m["yt"]["symbol"].as_str().unwrap_or("").to_lowercase();
            let sy_sym = m["sy"]["symbol"].as_str().unwrap_or("").to_lowercase();
            name.contains(&term_lower)
                || pt_sym.contains(&term_lower)
                || yt_sym.contains(&term_lower)
                || sy_sym.contains(&term_lower)
        })
        .take(limit as usize)
        .collect();

    let is_eth_search = matches!(term_lower.as_str(), "eth" | "weth");

    let hint: Option<String> = if is_eth_search && !filtered.is_empty() {
        // Results found but user searched for raw ETH/WETH — clarify these are derivatives
        Some(
            "These are ETH liquid staking/restaking derivative pools — Pendle does not have \
             raw ETH or WETH pools. All ETH yield on Pendle uses derivatives such as weETH, \
             wstETH, rETH, rsETH, ezETH, sfrxETH, or cbETH as the underlying."
                .to_string(),
        )
    } else if filtered.is_empty() && is_eth_search {
        Some(
            "No markets found for 'ETH'/'WETH' directly. Pendle ETH pools use liquid \
             staking/restaking derivatives — try searching for: weETH, wstETH, rETH, \
             rsETH, ezETH, sfrxETH, cbETH."
                .to_string(),
        )
    } else if filtered.is_empty() {
        Some(format!(
            "No markets matched '{}'. Try a broader search term or omit --search to see all markets.",
            term
        ))
    } else {
        None
    };

    let mut resp = serde_json::json!({
        "results": filtered,
        "total": filtered.len(),
        "search": term,
    });

    if let Some(h) = hint {
        resp["hint"] = serde_json::json!(h);
    }

    Ok(resp)
}

use anyhow::Result;
use serde_json::Value;

use crate::api;
use crate::onchainos;

pub async fn run(
    chain_id: u64,
    token_in: &str,
    amount_in: &str,
    pt_address: &str,
    yt_address: &str,
    from: Option<&str>,
    slippage: f64,
    dry_run: bool,
    confirm: bool,
    api_key: Option<&str>,
) -> Result<Value> {
    // Validate inputs
    onchainos::validate_evm_address(token_in)?;
    onchainos::validate_evm_address(pt_address)?;
    onchainos::validate_evm_address(yt_address)?;
    onchainos::validate_amount(amount_in, "--amount-in")?;

    let wallet = from
        .map(|s| s.to_string())
        .unwrap_or_else(|| onchainos::resolve_wallet(chain_id).unwrap_or_default());
    if wallet.is_empty() {
        anyhow::bail!("Cannot resolve wallet address. Pass --from or ensure onchainos is logged in.");
    }

    // Pre-flight balance check: verify wallet holds enough token_in before calling the SDK
    if !dry_run {
        let balance = onchainos::erc20_balance_of(chain_id, token_in, &wallet).await.unwrap_or(0);
        let required: u128 = amount_in.parse().unwrap_or(0);
        if balance < required {
            anyhow::bail!(
                "Insufficient balance: wallet {} holds {} wei of token {} but {} wei is required. \
                 Acquire more before retrying.",
                wallet, balance, token_in, required
            );
        }
    }

    // Use the v2 GET endpoint with comma-separated tokensOut — the v3 POST endpoint cannot
    // classify mintPyFromToken when outputs contains both PT and YT addresses.
    // Ref: pendle-finance/pendle-examples-public hosted-sdk-demo/src/mint-py.ts
    let sdk_resp = api::sdk_convert_v2_get(
        chain_id,
        &wallet,
        token_in,
        amount_in,
        &format!("{},{}", pt_address, yt_address),
        slippage,
        api_key,
    )
    .await?;

    let (calldata, router_to) = api::extract_sdk_calldata(&sdk_resp)?;
    let approvals = api::extract_required_approvals(&sdk_resp);
    let expected_py_out = api::extract_amount_out(&sdk_resp);

    // Preview gate: show SDK quote without executing
    if !confirm && !dry_run {
        return Ok(serde_json::json!({
            "ok": true,
            "preview": true,
            "note": "Preview — add --confirm to execute on-chain.",
            "operation": "mint-py",
            "chain_id": chain_id,
            "token_in": token_in,
            "amount_in": amount_in,
            "pt_address": pt_address,
            "yt_address": yt_address,
            "expected_py_out": expected_py_out,
            "router": router_to,
            "calldata": calldata,
            "wallet": wallet,
            "required_approvals": approvals.len(),
        }));
    }

    let amount_in_wei: u128 = amount_in.parse().map_err(|_| anyhow::anyhow!("Failed to parse amount-in: '{}'", amount_in))?;

    let mut approve_hashes: Vec<String> = Vec::new();
    for (token_addr, spender) in &approvals {
        let approve_result = onchainos::erc20_approve(
            chain_id,
            token_addr,
            spender,
            amount_in_wei,
            Some(&wallet),
            dry_run,
        )
        .await?;
        let approve_hash = onchainos::extract_tx_hash(&approve_result)?;
        if !dry_run { onchainos::wait_for_tx(&approve_hash, onchainos::default_rpc_url(chain_id)).await; }
        approve_hashes.push(approve_hash);
    }

    let result = onchainos::wallet_contract_call(
        chain_id,
        &router_to,
        &calldata,
        Some(&wallet),
        None,
        dry_run,
    )
    .await?;

    let tx_hash = onchainos::extract_tx_hash(&result)?;

    Ok(serde_json::json!({
        "ok": true,
        "operation": "mint-py",
        "chain_id": chain_id,
        "token_in": token_in,
        "amount_in": amount_in,
        "pt_address": pt_address,
        "yt_address": yt_address,
        "expected_py_out": expected_py_out,
        "router": router_to,
        "calldata": calldata,
        "wallet": wallet,
        "approve_txs": approve_hashes,
        "tx_hash": tx_hash,
        "dry_run": dry_run
    }))
}