Gmx V2 Plugin

{
  "name": "gmx-v2-plugin",
  "description": "Trade perpetuals and spot on GMX V2 — open/close leveraged positions, place limit/stop orders, add/remove GM pool liquidity, query markets and positions",
  "version": "0.2.7",
  "author": {"name": "GeoGu360", "github": "GeoGu360"},
  "homepage": "https://github.com/GeoGu360/plugin-store/tree/main/skills/gmx-v2",
  "repository": "https://github.com/GeoGu360/plugin-store",
  "license": "MIT",
  "keywords": ["perpetuals", "spot", "trading", "arbitrum", "avalanche", "leverage"]
}

target/

[package]
name = "gmx-v2-plugin"
version = "0.2.7"
edition = "2021"

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

[dependencies]
clap = { version = "4", features = ["derive"] }
reqwest = { version = "0.11", features = ["json", "blocking"] }
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) 2025 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: gmx-v2-plugin
version: "0.2.7"
description: "Trade perpetuals and spot on GMX V2 — open/close leveraged positions, place limit/stop orders, add/remove GM pool liquidity on Arbitrum and Avalanche"
author:
  name: GeoGu360
  github: GeoGu360
category: dapp
tags:
  - perpetuals
  - trading
  - leverage
  - arbitrum
  - avalanche
license: MIT
components:
  skill:
    dir: .
build:
  lang: rust
  binary_name: gmx-v2-plugin
api_calls:
  - "https://arbitrum-api.gmxinfra.io"
  - "https://arbitrum-api.gmxinfra2.io"
  - "https://avalanche-api.gmxinfra.io"
  - "https://avalanche-api.gmxinfra2.io"
  - "https://arbitrum.publicnode.com"
  - "https://avalanche-c-chain-rpc.publicnode.com"

/// ABI encoding utilities for GMX V2 multicall construction

/// Encode a single bytes32 value (already 32 bytes as hex string)
pub fn encode_bytes32(val: &str) -> String {
    let v = val.trim_start_matches("0x");
    format!("{:0>64}", v)
}

/// Encode an address (20 bytes) into 32-byte ABI slot (left-zero-padded)
pub fn encode_address(addr: &str) -> String {
    let a = addr.trim_start_matches("0x");
    format!("{:0>64}", a)
}

/// Encode a uint256 value into 32-byte ABI slot
pub fn encode_u256(val: u128) -> String {
    format!("{:064x}", val)
}

/// Encode a bool into 32-byte ABI slot
pub fn encode_bool(val: bool) -> String {
    if val {
        "0000000000000000000000000000000000000000000000000000000000000001".to_string()
    } else {
        "0000000000000000000000000000000000000000000000000000000000000000".to_string()
    }
}

/// Zero address (32 bytes)
pub fn zero_address() -> String {
    "0000000000000000000000000000000000000000000000000000000000000000".to_string()
}

/// Max uint256
pub fn max_uint256() -> u128 {
    u128::MAX
}

/// Encode `sendWnt(address receiver, uint256 amount)` calldata
/// Selector: 0x7d39aaf1
pub fn encode_send_wnt(receiver: &str, amount: u128) -> String {
    let receiver_padded = encode_address(receiver);
    let amount_padded = encode_u256(amount);
    format!("7d39aaf1{}{}", receiver_padded, amount_padded)
}

/// Encode `sendTokens(address token, address receiver, uint256 amount)` calldata
/// Selector: 0xe6d66ac8
pub fn encode_send_tokens(token: &str, receiver: &str, amount: u128) -> String {
    let token_padded = encode_address(token);
    let receiver_padded = encode_address(receiver);
    let amount_padded = encode_u256(amount);
    format!("e6d66ac8{}{}{}", token_padded, receiver_padded, amount_padded)
}

/// Encode `cancelOrder(bytes32 key)` calldata
/// Selector: 0x7489ec23
pub fn encode_cancel_order(key: &str) -> String {
    let key_clean = key.trim_start_matches("0x");
    let key_padded = format!("{:0>64}", key_clean);
    format!("7489ec23{}", key_padded)
}

/// Encode `claimFundingFees(address[] markets, address[] tokens, address receiver)` calldata
/// Selector: 0xc41b1ab3
pub fn encode_claim_funding_fees(markets: &[&str], tokens: &[&str], receiver: &str) -> String {
    // ABI encoding for dynamic arrays:
    // selector (4 bytes) + offset(markets) + offset(tokens) + offset(receiver_param -> but receiver is address, not dynamic)
    // Actually: claimFundingFees(address[],address[],address)
    // Head: offset to markets array, offset to tokens array, receiver address (padded)
    // Then arrays inline

    let head_size = 3 * 32; // 3 slots in head
    let markets_array_size = (1 + markets.len()) * 32; // length + elements

    let offset_markets = head_size; // 0x60
    let offset_tokens = head_size + markets_array_size;

    let mut out = String::from("c41b1ab3");
    // Head
    out.push_str(&encode_u256(offset_markets as u128));
    out.push_str(&encode_u256(offset_tokens as u128));
    out.push_str(&encode_address(receiver));
    // markets array
    out.push_str(&encode_u256(markets.len() as u128));
    for m in markets {
        out.push_str(&encode_address(m));
    }
    // tokens array
    out.push_str(&encode_u256(tokens.len() as u128));
    for t in tokens {
        out.push_str(&encode_address(t));
    }
    out
}

/// Encode `createOrder(CreateOrderParams)` calldata for GMX V2
/// Selector: 0xf59c48eb
///
/// CreateOrderParams (actual deployed struct):
///   addresses: (receiver, cancellationReceiver, callbackContract, uiFeeReceiver, market, initialCollateralToken, swapPath[])
///   numbers:   (sizeDeltaUsd, initialCollateralDeltaAmount, triggerPrice, acceptablePrice, executionFee, callbackGasLimit, minOutputAmount, validFromTime)
///   orderType:                  uint8
///   decreasePositionSwapType:   uint8
///   isLong:                     bool
///   shouldUnwrapNativeToken:    bool
///   autoCancel:                 bool
///   referralCode:               bytes32
///   dataList:                   bytes32[]  (empty)
///
/// ABI sig: createOrder(((address,address,address,address,address,address,address[]),(uint256,uint256,uint256,uint256,uint256,uint256,uint256,uint256),uint8,uint8,bool,bool,bool,bytes32,bytes32[]))
#[allow(clippy::too_many_arguments)]
pub fn encode_create_order(
    account: &str,
    receiver: &str,
    market: &str,
    collateral_token: &str,
    order_type: u8,
    size_delta_usd: u128,
    collateral_delta_amount: u128,
    trigger_price: u128,
    acceptable_price: u128,
    execution_fee: u128,
    is_long: bool,
    _src_chain_id: u64,
) -> String {
    // ── Addresses tuple ──────────────────────────────────────────────────────
    // (receiver, cancellationReceiver, callbackContract, uiFeeReceiver, market, initialCollateralToken, swapPath[])
    // 6 static addresses + 1 offset for swapPath (dynamic array, length=0)
    // Head: 7 words (6 addrs + swapPath offset), Tail: swapPath length word (=0)
    // swapPath offset = 7*32 = 224 (relative to start of addresses tuple head[0])
    let swap_path_offset: usize = 7 * 32;
    let mut addr_enc = String::new();
    addr_enc.push_str(&encode_address(receiver));         // receiver
    addr_enc.push_str(&encode_address(account));          // cancellationReceiver = account
    addr_enc.push_str(&zero_address());                   // callbackContract = 0x0
    addr_enc.push_str(&zero_address());                   // uiFeeReceiver = 0x0
    addr_enc.push_str(&encode_address(market));           // market
    addr_enc.push_str(&encode_address(collateral_token)); // initialCollateralToken
    addr_enc.push_str(&encode_u256(swap_path_offset as u128)); // offset to swapPath[]
    addr_enc.push_str(&encode_u256(0));                   // swapPath length = 0
    // addr_enc = 8 words = 256 bytes

    // ── Numbers tuple (8 static uint256 fields, encoded inline) ─────────────
    let mut num_enc = String::new();
    num_enc.push_str(&encode_u256(size_delta_usd));           // sizeDeltaUsd
    num_enc.push_str(&encode_u256(collateral_delta_amount));  // initialCollateralDeltaAmount
    num_enc.push_str(&encode_u256(trigger_price));            // triggerPrice
    num_enc.push_str(&encode_u256(acceptable_price));         // acceptablePrice
    num_enc.push_str(&encode_u256(execution_fee));            // executionFee
    num_enc.push_str(&encode_u256(0));                        // callbackGasLimit = 0
    num_enc.push_str(&encode_u256(0));                        // minOutputAmount = 0
    num_enc.push_str(&encode_u256(0));                        // validFromTime = 0
    // num_enc = 8 words = 256 bytes (static tuple, encoded inline in parent head)

    // ── Top-level struct encoding ─────────────────────────────────────────────
    // The outer struct (CreateOrderParams) has 9 top-level components:
    //   0. addresses   — DYNAMIC  → offset in head
    //   1. numbers     — STATIC   → encoded inline (8 words)
    //   2. orderType   — STATIC   → 1 word
    //   3. decreasePositionSwapType — STATIC → 1 word
    //   4. isLong      — STATIC   → 1 word
    //   5. shouldUnwrapNativeToken — STATIC → 1 word
    //   6. autoCancel  — STATIC   → 1 word
    //   7. referralCode — STATIC  → 1 word
    //   8. dataList    — DYNAMIC  → offset in head
    //
    // Head layout (words): addresses_offset(1) + numbers(8) + orderType(1) +
    //                      decreaseType(1) + isLong(1) + shouldUnwrap(1) +
    //                      autoCancel(1) + referralCode(1) + dataList_offset(1) = 16 words
    // Head size = 16 * 32 = 512 bytes
    //
    // Offsets are relative to start of struct encoding (start of head[0]).
    // addresses tail starts at offset 512 (= head end)
    // dataList tail starts at offset 512 + 256 = 768 (= after addresses 8 words)
    let head_size: usize = 16 * 32; // 512 bytes
    let addr_offset = head_size;                      // 512
    let datalist_offset = head_size + addr_enc.len() / 2; // 512 + 256 = 768

    let mut struct_enc = String::new();
    struct_enc.push_str(&encode_u256(addr_offset as u128));     // [0] addresses offset
    struct_enc.push_str(&num_enc);                               // [1-8] numbers inline (8 words)
    struct_enc.push_str(&encode_u256(order_type as u128));       // [9] orderType
    struct_enc.push_str(&encode_u256(0));                        // [10] decreasePositionSwapType = 0
    struct_enc.push_str(&encode_bool(is_long));                  // [11] isLong
    struct_enc.push_str(&encode_bool(false));                    // [12] shouldUnwrapNativeToken = false
    struct_enc.push_str(&encode_bool(false));                    // [13] autoCancel = false
    struct_enc.push_str(&encode_u256(0));                        // [14] referralCode = bytes32(0)
    struct_enc.push_str(&encode_u256(datalist_offset as u128));  // [15] dataList offset
    // Tail:
    struct_enc.push_str(&addr_enc);                              // addresses tail (256 bytes)
    struct_enc.push_str(&encode_u256(0));                        // dataList length = 0

    // Function: createOrder takes 1 dynamic struct arg → wrap in offset 0x20
    format!("f59c48eb{}{}", encode_u256(0x20), struct_enc)
}

/// Encode `createDeposit(CreateDepositParams)` calldata
///
/// Selector: 0xc82aa41b
/// keccak256("createDeposit(((address,address,address,address,address,address,address[],address[]),uint256,bool,uint256,uint256,bytes32[]))")
/// Verified from deployed ExchangeRouter bytecode (PUSH4 scan on Arbitrum mainnet).
///
/// Flat struct layout (T = outer tuple):
///   T HEAD (6 words = 192 bytes):
///     W0: offset_to_addresses = 192
///     W1: minMarketTokens
///     W2: shouldUnwrapNativeToken = false
///     W3: executionFee
///     W4: callbackGasLimit = 0
///     W5: offset_to_dataList = 192 + 320 = 512
///   addresses tuple (10 words = 320 bytes):
///     receiver, callbackContract=0, uiFeeReceiver=0, market,
///     initialLongToken, initialShortToken,
///     offset_longSwapPath=256, offset_shortSwapPath=288,
///     longSwapPath length=0, shortSwapPath length=0
///   dataList (1 word): length = 0
#[allow(clippy::too_many_arguments)]
pub fn encode_create_deposit(
    receiver: &str,
    _callback_contract: &str,
    _ui_fee_receiver: &str,
    market: &str,
    initial_long_token: &str,
    initial_short_token: &str,
    min_market_tokens: u128,
    execution_fee: u128,
    _src_chain_id: u64,
) -> String {
    // --- addresses tuple (10 words = 320 bytes) ---
    let mut addresses = String::new();
    addresses.push_str(&encode_address(receiver));            // receiver
    addresses.push_str(&zero_address());                      // callbackContract = 0
    addresses.push_str(&zero_address());                      // uiFeeReceiver = 0
    addresses.push_str(&encode_address(market));              // market
    addresses.push_str(&encode_address(initial_long_token));  // initialLongToken
    addresses.push_str(&encode_address(initial_short_token)); // initialShortToken
    addresses.push_str(&encode_u256(256));                    // offset to longSwapPath = A_HEAD_SIZE
    addresses.push_str(&encode_u256(288));                    // offset to shortSwapPath = 256 + 32
    addresses.push_str(&encode_u256(0));                      // longSwapPath length = 0
    addresses.push_str(&encode_u256(0));                      // shortSwapPath length = 0

    // --- T HEAD (6 words = 192 bytes) ---
    const T_HEAD_SIZE: usize = 192;
    const A_SIZE: usize = 320;
    const DATALIST_OFFSET: usize = T_HEAD_SIZE + A_SIZE; // = 512

    let mut t = String::new();
    t.push_str(&encode_u256(T_HEAD_SIZE as u128));     // W0: offset to addresses
    t.push_str(&encode_u256(min_market_tokens));        // W1: minMarketTokens
    t.push_str(&encode_bool(false));                    // W2: shouldUnwrapNativeToken
    t.push_str(&encode_u256(execution_fee));            // W3: executionFee
    t.push_str(&encode_u256(0));                        // W4: callbackGasLimit = 0
    t.push_str(&encode_u256(DATALIST_OFFSET as u128)); // W5: offset to dataList
    t.push_str(&addresses);                             // addresses (320 bytes)
    t.push_str(&encode_u256(0));                        // dataList length = 0

    format!("c82aa41b{}{}", encode_u256(0x20), t)
}

/// Encode `createWithdrawal(CreateWithdrawalParams)` calldata
///
/// Selector: 0xe78dc235
/// keccak256("createWithdrawal(((address,address,address,address,address[],address[]),uint256,uint256,bool,uint256,uint256,bytes32[]))")
/// Verified from deployed ExchangeRouter bytecode (PUSH4 scan on Arbitrum mainnet).
///
/// Flat struct layout (T = outer tuple):
///   T HEAD (7 words = 224 bytes):
///     W0: offset_to_addresses = 224
///     W1: minLongTokenAmount
///     W2: minShortTokenAmount
///     W3: shouldUnwrapNativeToken = false
///     W4: executionFee
///     W5: callbackGasLimit = 0
///     W6: offset_to_dataList = 224 + 256 = 480
///   addresses tuple (8 words = 256 bytes):
///     receiver, callbackContract=0, uiFeeReceiver=0, market,
///     offset_longSwapPath=192, offset_shortSwapPath=224,
///     longSwapPath length=0, shortSwapPath length=0
///   dataList (1 word): length = 0
pub fn encode_create_withdrawal(
    receiver: &str,
    market: &str,
    min_long_token_amount: u128,
    min_short_token_amount: u128,
    execution_fee: u128,
) -> String {
    // --- addresses tuple (8 words = 256 bytes) ---
    let mut addresses = String::new();
    addresses.push_str(&encode_address(receiver)); // receiver
    addresses.push_str(&zero_address());            // callbackContract = 0
    addresses.push_str(&zero_address());            // uiFeeReceiver = 0
    addresses.push_str(&encode_address(market));    // market
    addresses.push_str(&encode_u256(192));          // offset to longSwapPath = A_HEAD_SIZE
    addresses.push_str(&encode_u256(224));          // offset to shortSwapPath = 192 + 32
    addresses.push_str(&encode_u256(0));            // longSwapPath length = 0
    addresses.push_str(&encode_u256(0));            // shortSwapPath length = 0

    // --- T HEAD (7 words = 224 bytes) ---
    const T_HEAD_SIZE: usize = 224;
    const A_SIZE: usize = 256;
    const DATALIST_OFFSET: usize = T_HEAD_SIZE + A_SIZE; // = 480

    let mut t = String::new();
    t.push_str(&encode_u256(T_HEAD_SIZE as u128));      // W0: offset to addresses
    t.push_str(&encode_u256(min_long_token_amount));     // W1
    t.push_str(&encode_u256(min_short_token_amount));    // W2
    t.push_str(&encode_bool(false));                     // W3: shouldUnwrapNativeToken
    t.push_str(&encode_u256(execution_fee));             // W4
    t.push_str(&encode_u256(0));                         // W5: callbackGasLimit = 0
    t.push_str(&encode_u256(DATALIST_OFFSET as u128));   // W6: offset to dataList
    t.push_str(&addresses);                              // addresses (256 bytes)
    t.push_str(&encode_u256(0));                         // dataList length = 0

    format!("e78dc235{}{}", encode_u256(0x20), t)
}

/// Encode the outer `multicall(bytes[])` calldata
/// Selector: 0xac9650d8
pub fn encode_multicall(inner_calls: &[String]) -> String {
    // multicall(bytes[]) — single dynamic array argument
    // Encoding:
    // [selector][offset_to_array=0x20][array_length][offsets_to_each_element][element_data]

    let n = inner_calls.len();

    // Calculate offsets for each bytes element.
    // Per ABI spec: offsets in bytes[] are relative to the start of the FIRST offset word
    // (immediately after the length word), NOT relative to the length word itself.
    // So the first element's offset = n * 32 (just the n offset words).
    // Each bytes element is: 32 (length word) + ceil(data_len/32)*32 (padded data)
    let array_head_size = n * 32; // n offset words only (length word excluded from offset base)

    let mut element_offsets: Vec<usize> = Vec::with_capacity(n);
    let mut element_data: Vec<String> = Vec::with_capacity(n);
    let mut current_offset = array_head_size;

    for call_hex in inner_calls {
        element_offsets.push(current_offset);
        let data_bytes = call_hex.len() / 2; // hex string → byte length
        // Encode: length (32 bytes) + data (padded to 32-byte boundary)
        let padded_len = (data_bytes + 31) / 32 * 32;
        let padded_hex_len = padded_len * 2;
        let padding_chars = padded_hex_len - call_hex.len();
        let data_padded = format!("{}{}", call_hex, "0".repeat(padding_chars));
        let encoded_element = format!("{}{}", encode_u256(data_bytes as u128), data_padded);
        current_offset += encoded_element.len() / 2;
        element_data.push(encoded_element);
    }

    let mut result = String::from("ac9650d8");
    // Outer offset: points to start of bytes[] data = 0x20
    result.push_str(&encode_u256(0x20));
    // Array length
    result.push_str(&encode_u256(n as u128));
    // Offsets to each element (relative to start of array = after length word)
    for &off in &element_offsets {
        // Offset is relative to the start of the array data area (after length word)
        // The array data area starts at offset 0x20 + 0x20 = 0x40 from calldata start (after selector+outer_offset+length)
        // But ABI spec: offsets within the array are relative to the start of the array encoding
        // (which includes the length word itself)
        result.push_str(&encode_u256(off as u128));
    }
    // Element data
    for ed in &element_data {
        result.push_str(ed);
    }

    result
}

/// Convert a U256 price in 30-decimal GMX precision to a human-readable USD string
pub fn price_from_gmx(price_str: &str) -> f64 {
    let price_u128 = if let Ok(v) = price_str.parse::<u128>() {
        v
    } else {
        return 0.0;
    };
    // Price is in 10^30 units; divide by 10^30
    price_u128 as f64 / 1e30
}

/// Compute acceptable price with slippage
/// long: minPrice * (1 - slippage_bps/10000)
/// short: maxPrice * (1 + slippage_bps/10000)
pub fn compute_acceptable_price(price: u128, is_long: bool, slippage_bps: u32) -> u128 {
    let bps = slippage_bps as u128;
    if is_long {
        price.saturating_sub(price * bps / 10_000)
    } else {
        price + price * bps / 10_000
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_encode_address() {
        let addr = "0x1C3fa76e6E1088bCE750f23a5BFcffa1efEF6A41";
        let encoded = encode_address(addr);
        assert_eq!(encoded.len(), 64);
        assert!(encoded.ends_with("1c3fa76e6e1088bce750f23a5bfcffa1efef6a41") || encoded.to_lowercase().ends_with("1c3fa76e6e1088bce750f23a5bfcffa1efef6a41"));
    }

    #[test]
    fn test_encode_u256() {
        let encoded = encode_u256(1000);
        assert_eq!(encoded.len(), 64);
    }

    #[test]
    fn test_price_from_gmx() {
        let price = "1800000000000000000000000000000000"; // 1800 * 10^30
        let usd = price_from_gmx(price);
        assert!((usd - 1800.0).abs() < 1.0);
    }
}

use anyhow::Context;
use serde::{Deserialize, Serialize};
use serde_json::Value;

/// GMX REST API base URL based on chain
pub fn api_base(cfg: &crate::config::ChainConfig) -> &'static str {
    cfg.api_base
}

pub fn api_fallback(cfg: &crate::config::ChainConfig) -> &'static str {
    cfg.api_fallback
}

// ---- Market types ----

#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct Market {
    pub name: Option<String>,
    #[serde(rename = "marketToken")]
    pub market_token: Option<String>,
    #[serde(rename = "indexToken")]
    pub index_token: Option<String>,
    #[serde(rename = "longToken")]
    pub long_token: Option<String>,
    #[serde(rename = "shortToken")]
    pub short_token: Option<String>,
    #[serde(rename = "isListed")]
    pub is_listed: Option<bool>,
    #[serde(rename = "availableLiquidityLong", default, deserialize_with = "deser_number_or_string::deserialize")]
    pub available_liquidity_long: Option<String>,
    #[serde(rename = "availableLiquidityShort", default, deserialize_with = "deser_number_or_string::deserialize")]
    pub available_liquidity_short: Option<String>,
    #[serde(rename = "openInterestLong", default, deserialize_with = "deser_number_or_string::deserialize")]
    pub open_interest_long: Option<String>,
    #[serde(rename = "openInterestShort", default, deserialize_with = "deser_number_or_string::deserialize")]
    pub open_interest_short: Option<String>,
    #[serde(rename = "netRate1h", default, deserialize_with = "deser_number_or_string::deserialize")]
    pub net_rate_1h: Option<String>,
    #[serde(rename = "fundingRateLong", default, deserialize_with = "deser_number_or_string::deserialize")]
    pub funding_rate_long: Option<String>,
    #[serde(rename = "fundingRateShort", default, deserialize_with = "deser_number_or_string::deserialize")]
    pub funding_rate_short: Option<String>,
    #[serde(rename = "borrowingRateLong", default, deserialize_with = "deser_number_or_string::deserialize")]
    pub borrowing_rate_long: Option<String>,
    #[serde(rename = "borrowingRateShort", default, deserialize_with = "deser_number_or_string::deserialize")]
    pub borrowing_rate_short: Option<String>,
}

#[derive(Debug, Deserialize)]
pub struct MarketsResponse {
    pub markets: Option<Vec<Market>>,
}

// ---- Price types ----

#[derive(Debug, Deserialize, Serialize, Clone)]
#[serde(rename_all = "camelCase")]
pub struct PriceTicker {
    #[serde(rename = "tokenAddress")]
    pub token_address: Option<String>,
    #[serde(rename = "tokenSymbol")]
    pub token_symbol: Option<String>,
    #[serde(rename = "minPrice", default, deserialize_with = "deser_number_or_string::deserialize")]
    pub min_price: Option<String>,
    #[serde(rename = "maxPrice", default, deserialize_with = "deser_number_or_string::deserialize")]
    pub max_price: Option<String>,
    #[serde(rename = "updatedAt", default, deserialize_with = "deser_number_or_string::deserialize")]
    pub updated_at: Option<String>,
}

// ---- Token types ----

#[derive(Debug, Deserialize, Serialize, Clone)]
pub struct TokenInfo {
    pub symbol: Option<String>,
    pub address: Option<String>,
    pub decimals: Option<u8>,
}

// ---- API fetch helpers ----

/// GET /markets/info — returns full market info with rates
pub async fn fetch_markets(cfg: &crate::config::ChainConfig) -> anyhow::Result<Vec<Market>> {
    let url = format!("{}/markets/info", cfg.api_base);
    let resp = fetch_with_fallback(&url, &format!("{}/markets/info", cfg.api_fallback)).await?;
    // Try outer "markets" key, or treat as array directly
    if let Some(markets) = resp.get("markets").and_then(|v| v.as_array()) {
        let filtered: Vec<Market> = markets
            .iter()
            .filter_map(|v| serde_json::from_value(v.clone()).ok())
            .filter(|m: &Market| m.is_listed.unwrap_or(true))
            .collect();
        return Ok(filtered);
    }
    if let Some(arr) = resp.as_array() {
        let filtered: Vec<Market> = arr
            .iter()
            .filter_map(|v| serde_json::from_value(v.clone()).ok())
            .filter(|m: &Market| m.is_listed.unwrap_or(true))
            .collect();
        return Ok(filtered);
    }
    Ok(vec![])
}

/// GET /prices/tickers — returns oracle prices
pub async fn fetch_prices(cfg: &crate::config::ChainConfig) -> anyhow::Result<Vec<PriceTicker>> {
    let url = format!("{}/prices/tickers", cfg.api_base);
    let fallback = format!("{}/prices/tickers", cfg.api_fallback);
    let resp = fetch_with_fallback(&url, &fallback).await?;
    if let Some(arr) = resp.as_array() {
        let tickers: Vec<PriceTicker> = arr
            .iter()
            .filter_map(|v| serde_json::from_value(v.clone()).ok())
            .collect();
        return Ok(tickers);
    }
    // Some responses wrap in a field
    if let Some(arr) = resp.get("data").and_then(|v| v.as_array()) {
        let tickers: Vec<PriceTicker> = arr
            .iter()
            .filter_map(|v| serde_json::from_value(v.clone()).ok())
            .collect();
        return Ok(tickers);
    }
    Ok(vec![])
}

/// Lookup a market by index token symbol or address.
///
/// Match priority (most specific first):
/// 1. Exact full name match, e.g. "ETH/USD [WETH-USDC]"
/// 2. Exact base-symbol match — name prefix before " [", e.g. "ETH/USD" matches "ETH/USD [WETH-USDC]"
///    If multiple markets share the same base symbol the first one in the list is returned and a
///    warning is printed so the caller can see ambiguity.
/// 3. Exact index-token address match (checksummed or lowercase)
///
/// `contains()` is intentionally NOT used — it caused non-deterministic market selection when
/// multiple markets share a common substring (e.g. "SOL/USD [SOL-USDC]" vs "SOL/USD [SOL-SOL]").
pub fn find_market_by_symbol<'a>(markets: &'a [Market], query: &str) -> Option<&'a Market> {
    let query_lower = query.to_lowercase();

    // 1. Exact full name match
    if let Some(m) = markets.iter().find(|m| {
        m.name.as_deref().map(|n| n.to_lowercase() == query_lower).unwrap_or(false)
    }) {
        return Some(m);
    }

    // 2. Exact base-symbol match (part before " [")
    let base_matches: Vec<&Market> = markets.iter().filter(|m| {
        if let Some(name) = &m.name {
            let base = name.split(" [").next().unwrap_or(name);
            base.to_lowercase() == query_lower
        } else {
            false
        }
    }).collect();
    if base_matches.len() > 1 {
        eprintln!(
            "WARNING: ambiguous market '{}' — {} matches found. Using '{}'. \
             Pass the full name (e.g. \"{}\") to select a specific market.",
            query,
            base_matches.len(),
            base_matches[0].name.as_deref().unwrap_or("?"),
            base_matches[0].name.as_deref().unwrap_or("?"),
        );
    }
    if let Some(m) = base_matches.into_iter().next() {
        return Some(m);
    }

    // 3. Exact market-token (GM token) address match
    if let Some(m) = markets.iter().find(|m| {
        m.market_token.as_deref()
            .map(|addr| addr.to_lowercase() == query_lower)
            .unwrap_or(false)
    }) {
        return Some(m);
    }

    // 4. Exact index-token address match
    markets.iter().find(|m| {
        m.index_token.as_deref()
            .map(|addr| addr.to_lowercase() == query_lower)
            .unwrap_or(false)
    })
}

/// GET /tokens — returns token list with decimals
pub async fn fetch_tokens(cfg: &crate::config::ChainConfig) -> anyhow::Result<Vec<TokenInfo>> {
    let url = format!("{}/tokens", cfg.api_base);
    let fallback = format!("{}/tokens", cfg.api_fallback);
    let resp = fetch_with_fallback(&url, &fallback).await?;
    if let Some(arr) = resp.as_array() {
        let tokens: Vec<TokenInfo> = arr
            .iter()
            .filter_map(|v| serde_json::from_value(v.clone()).ok())
            .collect();
        return Ok(tokens);
    }
    if let Some(arr) = resp.get("tokens").and_then(|v| v.as_array()) {
        let tokens: Vec<TokenInfo> = arr
            .iter()
            .filter_map(|v| serde_json::from_value(v.clone()).ok())
            .collect();
        return Ok(tokens);
    }
    Ok(vec![])
}

/// Format a raw token amount into human-readable form (up to 6 decimal places).
pub fn format_token_amount(amount: u128, decimals: u8) -> String {
    if decimals == 0 {
        return amount.to_string();
    }
    let display_decimals = (decimals as u32).min(6);
    let divisor = 10u128.pow(decimals as u32);
    let whole = amount / divisor;
    let frac_full = amount % divisor;
    let scale = (decimals as u32).saturating_sub(display_decimals);
    let frac_display = frac_full / 10u128.pow(scale);
    format!("{}.{:0>width$}", whole, frac_display, width = display_decimals as usize)
}

/// Convert raw GMX price to USD given token decimals.
/// GMX stores prices as: price_usd * 10^(30 - token_decimals)
/// So: price_usd = raw / 10^(30 - token_decimals)
pub fn raw_price_to_usd(raw: u128, token_decimals: u8) -> f64 {
    let precision_exp = 30u32.saturating_sub(token_decimals as u32);
    let divisor = 10f64.powi(precision_exp as i32);
    raw as f64 / divisor
}

/// Lookup price by token address (case-insensitive)
pub fn find_price<'a>(tickers: &'a [PriceTicker], token_addr: &str) -> Option<&'a PriceTicker> {
    let addr_lower = token_addr.to_lowercase();
    tickers.iter().find(|t| {
        t.token_address
            .as_deref()
            .map(|a| a.to_lowercase() == addr_lower)
            .unwrap_or(false)
    })
}

async fn fetch_with_fallback(url: &str, fallback: &str) -> anyhow::Result<Value> {
    let client = reqwest::Client::new();
    match client.get(url).send().await {
        Ok(resp) if resp.status().is_success() => {
            Ok(resp.json().await.context("Failed to parse API response")?)
        }
        _ => {
            // Try fallback
            let resp = client
                .get(fallback)
                .send()
                .await
                .context("Both primary and fallback API requests failed")?;
            Ok(resp.json().await.context("Failed to parse fallback API response")?)
        }
    }
}

// ---- Defensive deserialization helper ----
// Some GMX API fields return numbers as JSON numbers OR strings

mod deser_number_or_string {
    use serde::{self, 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,
        })
    }
}

use clap::Args;
use serde_json::json;

#[derive(Args)]
pub struct CancelOrderArgs {
    /// Order key (bytes32 hex, from get-orders)
    #[arg(long)]
    pub key: String,

    /// Wallet address (defaults to logged-in wallet)
    #[arg(long)]
    pub from: Option<String>,
}

pub async fn run(chain: &str, dry_run: bool, confirm: bool, args: CancelOrderArgs) -> anyhow::Result<()> {
    let cfg = crate::config::get_chain_config(chain)?;

    let wallet = args.from.clone().unwrap_or_else(|| {
        crate::onchainos::resolve_wallet(cfg.chain_id).unwrap_or_default()
    });
    if wallet.is_empty() {
        anyhow::bail!("Cannot determine wallet address. Pass --from or ensure onchainos is logged in.");
    }

    // Validate the key looks like a bytes32
    let key_clean = args.key.trim_start_matches("0x");
    if key_clean.len() != 64 {
        anyhow::bail!("Order key must be a 32-byte hex string (64 hex chars). Got: '{}'", args.key);
    }

    let calldata_hex = crate::abi::encode_cancel_order(&args.key);
    let calldata = format!("0x{}", calldata_hex);

    eprintln!("=== Cancel Order Preview ===");
    eprintln!("Order key: {}", args.key);
    eprintln!("Exchange router: {}", cfg.exchange_router);
    if !confirm { eprintln!("Add --confirm to broadcast."); }

    if !confirm && !dry_run {
        println!(
            "{}",
            serde_json::to_string_pretty(&json!({
                "ok": true,
                "status": "preview",
                "message": "Add --confirm to broadcast this transaction",
                "chain": chain,
                "orderKey": args.key,
                "calldata": calldata
            }))?
        );
        return Ok(());
    }

    let result = crate::onchainos::wallet_contract_call_with_gas(
        cfg.chain_id,
        cfg.exchange_router,
        &calldata,
        Some(&wallet),
        None,
        dry_run,
        confirm,
        Some(300_000),
    ).await?;

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

    // G17: verify the cancel tx actually landed on-chain before reporting ok:true
    if !dry_run {
        if tx_hash == "pending" || tx_hash.is_empty() {
            println!(
                "{}",
                serde_json::to_string_pretty(&json!({
                    "ok": false,
                    "error": "TX_NOT_SUBMITTED",
                    "reason": "onchainos did not return a tx hash — transaction may not have been submitted",
                    "chain": chain,
                    "orderKey": args.key
                }))?
            );
            return Ok(());
        }
        crate::onchainos::wait_for_tx(cfg.chain_id, &tx_hash, &wallet, 60)?;
    }

    println!(
        "{}",
        serde_json::to_string_pretty(&json!({
            "ok": true,
            "dry_run": dry_run,
            "chain": chain,
            "txHash": tx_hash,
            "orderKey": args.key,
            "calldata": if dry_run { Some(calldata.as_str()) } else { None }
        }))?
    );
    Ok(())
}

use clap::Args;
use serde_json::json;

#[derive(Args)]
pub struct ClaimFundingFeesArgs {
    /// Comma-separated market token addresses to claim from
    #[arg(long)]
    pub markets: String,

    /// Comma-separated token addresses corresponding to each market
    #[arg(long)]
    pub tokens: String,

    /// Receiver address (defaults to logged-in wallet)
    #[arg(long)]
    pub receiver: Option<String>,

    /// Wallet address (defaults to logged-in wallet)
    #[arg(long)]
    pub from: Option<String>,
}

pub async fn run(chain: &str, dry_run: bool, confirm: bool, args: ClaimFundingFeesArgs) -> anyhow::Result<()> {
    let cfg = crate::config::get_chain_config(chain)?;

    let wallet = args.from.clone().unwrap_or_else(|| {
        crate::onchainos::resolve_wallet(cfg.chain_id).unwrap_or_default()
    });
    if wallet.is_empty() {
        anyhow::bail!("Cannot determine wallet address. Pass --from or ensure onchainos is logged in.");
    }

    let receiver = args.receiver.as_deref().unwrap_or(&wallet).to_string();

    // Parse comma-separated addresses
    let market_addrs: Vec<&str> = args.markets.split(',').map(|s| s.trim()).collect();
    let token_addrs: Vec<&str> = args.tokens.split(',').map(|s| s.trim()).collect();

    if market_addrs.len() != token_addrs.len() {
        anyhow::bail!(
            "markets and tokens arrays must have the same length ({} vs {})",
            market_addrs.len(),
            token_addrs.len()
        );
    }
    if market_addrs.is_empty() {
        anyhow::bail!("Must provide at least one market address.");
    }

    let calldata_hex = crate::abi::encode_claim_funding_fees(&market_addrs, &token_addrs, &receiver);
    let calldata = format!("0x{}", calldata_hex);

    eprintln!("=== Claim Funding Fees Preview ===");
    eprintln!("Markets: {:?}", market_addrs);
    eprintln!("Tokens: {:?}", token_addrs);
    eprintln!("Receiver: {}", receiver);
    eprintln!("Note: No execution fee needed for claims.");
    if !confirm { eprintln!("Add --confirm to broadcast."); }

    if !confirm && !dry_run {
        println!(
            "{}",
            serde_json::to_string_pretty(&json!({
                "ok": true,
                "status": "preview",
                "message": "Add --confirm to broadcast this transaction",
                "chain": chain,
                "markets": market_addrs,
                "tokens": token_addrs,
                "receiver": receiver,
                "calldata": calldata
            }))?
        );
        return Ok(());
    }

    // G20: snapshot balances before tx so we can report claimed amounts
    let pre_balances: Vec<u128> = if confirm && !dry_run {
        let mut bals = Vec::new();
        for token in &token_addrs {
            let bal = crate::rpc::check_erc20_balance(cfg.rpc_url, token, &receiver).await.unwrap_or(0);
            bals.push(bal);
        }
        bals
    } else {
        vec![0u128; token_addrs.len()]
    };

    let result = crate::onchainos::wallet_contract_call_with_gas(
        cfg.chain_id,
        cfg.exchange_router,
        &calldata,
        Some(&wallet),
        None, // no ETH value needed for claim
        dry_run,
        confirm,
        Some(300_000),
    ).await?;

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

    // G20: post-tx balance delta = claimed amounts
    let claimed: Vec<serde_json::Value> = if confirm && !dry_run {
        crate::onchainos::wait_for_tx(cfg.chain_id, &tx_hash, &wallet, 60)?;
        let mut out = Vec::new();
        for (i, token) in token_addrs.iter().enumerate() {
            let post = crate::rpc::check_erc20_balance(cfg.rpc_url, token, &receiver).await.unwrap_or(0);
            let delta = post.saturating_sub(pre_balances[i]);
            out.push(json!({ "token": token, "claimedRaw": delta.to_string() }));
        }
        out
    } else {
        vec![]
    };

    println!(
        "{}",
        serde_json::to_string_pretty(&json!({
            "ok": true,
            "dry_run": dry_run,
            "chain": chain,
            "txHash": tx_hash,
            "markets": market_addrs,
            "tokens": token_addrs,
            "receiver": receiver,
            "claimed": claimed,
            "calldata": if dry_run { Some(calldata.as_str()) } else { None }
        }))?
    );
    Ok(())
}

use clap::Args;
use serde_json::json;

#[derive(Args)]
pub struct ClosePositionArgs {
    /// Market token address of the position to close
    #[arg(long)]
    pub market_token: String,

    /// Collateral token address of the position
    #[arg(long)]
    pub collateral_token: String,

    /// Size to close in USD (use full position size for full close)
    #[arg(long)]
    pub size_usd: f64,

    /// Collateral amount to withdraw (use full collateral for full close)
    #[arg(long)]
    pub collateral_amount: u128,

    /// Is the position long?
    #[arg(long)]
    pub long: bool,

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

    /// Wallet address (defaults to logged-in wallet)
    #[arg(long)]
    pub from: Option<String>,
}

pub async fn run(chain: &str, dry_run: bool, confirm: bool, args: ClosePositionArgs) -> anyhow::Result<()> {
    let cfg = crate::config::get_chain_config(chain)?;

    let wallet = args.from.clone().unwrap_or_else(|| {
        crate::onchainos::resolve_wallet(cfg.chain_id).unwrap_or_default()
    });
    if wallet.is_empty() {
        anyhow::bail!("Cannot determine wallet address. Pass --from or ensure onchainos is logged in.");
    }

    // Fetch current prices for acceptable price calculation
    let markets = crate::api::fetch_markets(cfg).await?;
    let tickers = crate::api::fetch_prices(cfg).await?;
    let token_infos = crate::api::fetch_tokens(cfg).await.unwrap_or_default();

    // Find market to get index token
    let market_info = markets.iter().find(|m| {
        m.market_token.as_deref()
            .map(|t| t.to_lowercase() == args.market_token.to_lowercase())
            .unwrap_or(false)
    });

    let price_tick = market_info
        .and_then(|m| m.index_token.as_deref())
        .and_then(|addr| crate::api::find_price(&tickers, addr));

    let (min_price_raw, max_price_raw) = price_tick
        .map(|t| (
            t.min_price.as_deref().unwrap_or("0").parse::<u128>().unwrap_or(0),
            t.max_price.as_deref().unwrap_or("0").parse::<u128>().unwrap_or(0),
        ))
        .unwrap_or((0, 0));

    // Use integer math to avoid f64 precision loss (same as open_position parse_usd_to_u128)
    let size_delta_usd = {
        let int_part = args.size_usd.floor() as u128;
        let frac_part = args.size_usd - args.size_usd.floor();
        let precision: u128 = 1_000_000_000_000_000_000_000_000_000_000; // 10^30
        int_part * precision + (frac_part * 1e30) as u128
    };

    // For decrease orders, GMX executes at:
    //   LONG close: min_price (selling at bid)   → need floor:   acceptable = min_price × (1 - slip)
    //   SHORT close: max_price (buying at ask)   → need ceiling: acceptable = max_price × (1 + slip)
    let (base_price, is_floor) = if args.long {
        (min_price_raw, true)
    } else {
        (max_price_raw, false)
    };
    let acceptable_price = crate::abi::compute_acceptable_price(base_price, is_floor, args.slippage_bps);

    let execution_fee = cfg.execution_fee_wei;

    // Build multicall: [sendWnt, createOrder] (no sendTokens for decrease — collateral stays in vault)
    let send_wnt = crate::abi::encode_send_wnt(cfg.order_vault, execution_fee);
    let create_order = crate::abi::encode_create_order(
        &wallet,
        &wallet,
        &args.market_token,
        &args.collateral_token,
        4, // MarketDecrease
        size_delta_usd,
        args.collateral_amount,
        0, // triggerPrice = 0 for market orders
        acceptable_price,
        execution_fee,
        args.long,
        cfg.chain_id,
    );

    let multicall_hex = crate::abi::encode_multicall(&[send_wnt, create_order]);
    let calldata = format!("0x{}", multicall_hex);

    let index_decimals = market_info
        .and_then(|m| m.index_token.as_deref())
        .and_then(|addr| token_infos.iter().find(|t| t.address.as_deref().map(|a| a.to_lowercase()) == Some(addr.to_lowercase())))
        .and_then(|t| t.decimals)
        .unwrap_or(18u8);
    let collateral_decimals = token_infos.iter()
        .find(|t| t.address.as_deref().map(|a| a.to_lowercase()) == Some(args.collateral_token.to_lowercase()))
        .and_then(|t| t.decimals)
        .unwrap_or(6u8);
    let mid_price_usd = if min_price_raw == 0 && max_price_raw == 0 {
        0.0
    } else {
        (crate::api::raw_price_to_usd(min_price_raw, index_decimals) + crate::api::raw_price_to_usd(max_price_raw, index_decimals)) / 2.0
    };

    let acceptable_price_usd = crate::api::raw_price_to_usd(acceptable_price, index_decimals);
    let execution_fee_eth = execution_fee as f64 / 1e18;
    let collateral_fmt = crate::api::format_token_amount(args.collateral_amount, collateral_decimals);

    // Pre-flight: ETH balance for execution fee + gas
    let eth_balance = crate::rpc::get_eth_balance(&wallet, cfg.rpc_url).await;
    let gas_margin: u128 = 200_000_000_000_000; // 0.0002 ETH
    let eth_required = execution_fee.saturating_add(gas_margin);
    if eth_balance < eth_required {
        println!("{}", serde_json::to_string_pretty(&json!({
            "ok": false,
            "error": "INSUFFICIENT_ETH_FOR_EXECUTION",
            "reason": "Wallet does not have enough ETH to cover execution fee + gas.",
            "eth_balance": format!("{:.8}", eth_balance as f64 / 1e18),
            "execution_fee_eth": format!("{:.8}", execution_fee as f64 / 1e18),
            "gas_buffer_eth": format!("{:.8}", gas_margin as f64 / 1e18),
            "eth_required": format!("{:.8}", eth_required as f64 / 1e18),
            "suggestion": format!("Top up wallet {} with at least {:.6} ETH.", wallet, (eth_required.saturating_sub(eth_balance)) as f64 / 1e18)
        }))?);
        return Ok(());
    }

    eprintln!("=== Close Position Preview ===");
    eprintln!("Market token: {}", args.market_token);
    eprintln!("Direction: {}", if args.long { "LONG (closing)" } else { "SHORT (closing)" });
    eprintln!("Size to close: ${:.2} USD", args.size_usd);
    eprintln!("Collateral to withdraw: {}", collateral_fmt);
    eprintln!("Current price: ${:.4}", mid_price_usd);
    eprintln!("Acceptable price: ${:.4}", acceptable_price_usd);
    eprintln!("⚠ GMX V2 keeper model: position closes 1-30s after tx lands.");
    if !confirm { eprintln!("Add --confirm to broadcast."); }

    if !confirm && !dry_run {
        println!(
            "{}",
            serde_json::to_string_pretty(&json!({
                "ok": true,
                "status": "preview",
                "message": "Add --confirm to broadcast this transaction",
                "chain": chain,
                "marketToken": args.market_token,
                "collateralToken": args.collateral_token,
                "direction": if args.long { "long" } else { "short" },
                "sizeToClose_usd": args.size_usd,
                "collateralToWithdraw": collateral_fmt,
                "currentPrice_usd": format!("{:.4}", mid_price_usd),
                "acceptablePrice_usd": format!("{:.4}", acceptable_price_usd),
                "executionFee_eth": format!("{:.6}", execution_fee_eth),
                "calldata": calldata
            }))?
        );
        return Ok(());
    }

    let result = crate::onchainos::wallet_contract_call(
        cfg.chain_id,
        cfg.exchange_router,
        &calldata,
        Some(&wallet),
        Some(execution_fee),
        dry_run,
        confirm,
    ).await?;

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

    println!(
        "{}",
        serde_json::to_string_pretty(&json!({
            "ok": true,
            "dry_run": dry_run,
            "chain": chain,
            "txHash": tx_hash,
            "marketToken": args.market_token,
            "collateralToken": args.collateral_token,
            "direction": if args.long { "long" } else { "short" },
            "sizeToClose_usd": args.size_usd,
            "collateralToWithdraw": collateral_fmt,
            "currentPrice_usd": format!("{:.4}", mid_price_usd),
            "acceptablePrice_usd": format!("{:.4}", acceptable_price_usd),
            "executionFee_eth": format!("{:.6}", execution_fee_eth),
            "note": "GMX V2 keeper model: position closes within 1-30s after tx confirmation",
            "calldata": if dry_run { Some(calldata.as_str()) } else { None }
        }))?
    );
    Ok(())
}

use clap::Args;
use serde_json::json;

#[derive(Args)]
pub struct DepositLiquidityArgs {
    /// Market symbol or market token address (e.g. "ETH/USD" or 0x...)
    #[arg(long)]
    pub market: String,

    /// Long token amount in smallest units (e.g. ETH in wei). Use 0 to deposit short-side only.
    #[arg(long, default_value_t = 0)]
    pub long_amount: u128,

    /// Short token amount in smallest units (e.g. USDC units). Use 0 to deposit long-side only.
    #[arg(long, default_value_t = 0)]
    pub short_amount: u128,

    /// Minimum GM tokens to receive (slippage protection). Use 0 to accept any amount.
    #[arg(long, default_value_t = 0)]
    pub min_market_tokens: u128,

    /// Wallet address (defaults to logged-in wallet)
    #[arg(long)]
    pub from: Option<String>,
}

pub async fn run(chain: &str, dry_run: bool, confirm: bool, args: DepositLiquidityArgs) -> anyhow::Result<()> {
    let cfg = crate::config::get_chain_config(chain)?;

    if args.long_amount == 0 && args.short_amount == 0 {
        anyhow::bail!("Must provide either --long-amount or --short-amount (or both).");
    }

    let wallet = args.from.clone().unwrap_or_else(|| {
        crate::onchainos::resolve_wallet(cfg.chain_id).unwrap_or_default()
    });
    if wallet.is_empty() {
        anyhow::bail!("Cannot determine wallet address. Pass --from or ensure onchainos is logged in.");
    }

    // Fetch market info
    let markets = crate::api::fetch_markets(cfg).await?;
    let market = crate::api::find_market_by_symbol(&markets, &args.market)
        .ok_or_else(|| anyhow::anyhow!("Market '{}' not found on {}", args.market, chain))?;

    let market_token = market.market_token.as_deref()
        .ok_or_else(|| anyhow::anyhow!("Market has no marketToken address"))?;
    let long_token = market.long_token.as_deref()
        .ok_or_else(|| anyhow::anyhow!("Market has no longToken"))?;
    let short_token = market.short_token.as_deref()
        .ok_or_else(|| anyhow::anyhow!("Market has no shortToken"))?;

    let token_infos = crate::api::fetch_tokens(cfg).await.unwrap_or_default();
    let long_decimals = token_infos.iter()
        .find(|t| t.address.as_deref().map(|a| a.to_lowercase()) == Some(long_token.to_lowercase()))
        .and_then(|t| t.decimals).unwrap_or(18u8);
    let short_decimals = token_infos.iter()
        .find(|t| t.address.as_deref().map(|a| a.to_lowercase()) == Some(short_token.to_lowercase()))
        .and_then(|t| t.decimals).unwrap_or(6u8);
    let long_fmt = crate::api::format_token_amount(args.long_amount, long_decimals);
    let short_fmt = crate::api::format_token_amount(args.short_amount, short_decimals);
    let min_gm_fmt = crate::api::format_token_amount(args.min_market_tokens, 18);

    let execution_fee = cfg.execution_fee_wei;
    let execution_fee_eth = execution_fee as f64 / 1e18;

    // Pre-flight: ETH balance for execution fee + gas
    let eth_balance = crate::rpc::get_eth_balance(&wallet, cfg.rpc_url).await;
    let gas_margin: u128 = 200_000_000_000_000; // 0.0002 ETH
    let eth_required = execution_fee.saturating_add(gas_margin);
    if eth_balance < eth_required {
        println!("{}", serde_json::to_string_pretty(&json!({
            "ok": false,
            "error": "INSUFFICIENT_ETH_FOR_EXECUTION",
            "reason": "Wallet does not have enough ETH to cover execution fee + gas.",
            "eth_balance": format!("{:.8}", eth_balance as f64 / 1e18),
            "execution_fee_eth": format!("{:.8}", execution_fee as f64 / 1e18),
            "gas_buffer_eth": format!("{:.8}", gas_margin as f64 / 1e18),
            "eth_required": format!("{:.8}", eth_required as f64 / 1e18),
            "suggestion": format!("Top up wallet {} with at least {:.6} ETH.", wallet, (eth_required.saturating_sub(eth_balance)) as f64 / 1e18)
        }))?);
        return Ok(());
    }

    // Pre-flight: token balance checks
    if args.long_amount > 0 {
        let bal = crate::rpc::check_erc20_balance(cfg.rpc_url, long_token, &wallet).await.unwrap_or(u128::MAX);
        if bal < args.long_amount {
            println!("{}", serde_json::to_string_pretty(&json!({
                "ok": false,
                "error": "INSUFFICIENT_LONG_TOKEN_BALANCE",
                "reason": "Wallet long token balance is less than --long-amount.",
                "token": long_token,
                "wallet_balance": bal.to_string(),
                "wallet_balance_formatted": crate::api::format_token_amount(bal, long_decimals),
                "required_amount": args.long_amount.to_string(),
                "required_formatted": long_fmt,
                "suggestion": format!("Reduce --long-amount to at most {} or top up the token.", bal)
            }))?);
            return Ok(());
        }
    }
    if args.short_amount > 0 {
        let bal = crate::rpc::check_erc20_balance(cfg.rpc_url, short_token, &wallet).await.unwrap_or(u128::MAX);
        if bal < args.short_amount {
            println!("{}", serde_json::to_string_pretty(&json!({
                "ok": false,
                "error": "INSUFFICIENT_SHORT_TOKEN_BALANCE",
                "reason": "Wallet short token balance is less than --short-amount.",
                "token": short_token,
                "wallet_balance": bal.to_string(),
                "wallet_balance_formatted": crate::api::format_token_amount(bal, short_decimals),
                "required_amount": args.short_amount.to_string(),
                "required_formatted": short_fmt,
                "suggestion": format!("Reduce --short-amount to at most {} or top up the token.", bal)
            }))?);
            return Ok(());
        }
    }

    // Approve long token if needed (only when about to execute)
    if confirm && !dry_run && args.long_amount > 0 {
        let allowance = crate::onchainos::check_allowance(
            cfg.rpc_url, long_token, &wallet, cfg.router,
        ).await.unwrap_or(0);
        if allowance < args.long_amount {
            eprintln!("WARNING: Approving {} long token to {} -- approving exact amount only. Use --dry-run to preview.", args.long_amount, cfg.router);
            let r = crate::onchainos::erc20_approve(
                cfg.chain_id, long_token, cfg.router, args.long_amount, Some(&wallet), false, confirm,
            ).await?;
            let approve_hash = crate::onchainos::extract_tx_hash(&r);
            eprintln!("Approval tx: {}", approve_hash);
            crate::onchainos::wait_for_tx(cfg.chain_id, approve_hash, &wallet, 60)?;
        }
    }

    // Approve short token if needed (only when about to execute)
    if confirm && !dry_run && args.short_amount > 0 {
        let allowance = crate::onchainos::check_allowance(
            cfg.rpc_url, short_token, &wallet, cfg.router,
        ).await.unwrap_or(0);
        if allowance < args.short_amount {
            eprintln!("WARNING: Approving {} short token to {} -- approving exact amount only. Use --dry-run to preview.", args.short_amount, cfg.router);
            let r = crate::onchainos::erc20_approve(
                cfg.chain_id, short_token, cfg.router, args.short_amount, Some(&wallet), false, confirm,
            ).await?;
            let approve_hash2 = crate::onchainos::extract_tx_hash(&r);
            eprintln!("Approval tx: {}", approve_hash2);
            crate::onchainos::wait_for_tx(cfg.chain_id, approve_hash2, &wallet, 60)?;
        }
    }

    // Build multicall: [sendWnt, (sendTokens long if > 0), (sendTokens short if > 0), createDeposit]
    let send_wnt = crate::abi::encode_send_wnt(cfg.deposit_vault, execution_fee);
    let create_deposit = crate::abi::encode_create_deposit(
        &wallet,
        "0x0000000000000000000000000000000000000000",
        "0x0000000000000000000000000000000000000000",
        market_token,
        long_token,
        short_token,
        args.min_market_tokens,
        execution_fee,
        cfg.chain_id,
    );

    let mut inner_calls = vec![send_wnt];
    if args.long_amount > 0 {
        inner_calls.push(crate::abi::encode_send_tokens(long_token, cfg.deposit_vault, args.long_amount));
    }
    if args.short_amount > 0 {
        inner_calls.push(crate::abi::encode_send_tokens(short_token, cfg.deposit_vault, args.short_amount));
    }
    inner_calls.push(create_deposit);

    let multicall_hex = crate::abi::encode_multicall(&inner_calls);
    let calldata = format!("0x{}", multicall_hex);

    eprintln!("=== Deposit Liquidity Preview ===");
    eprintln!("Market: {}", market.name.as_deref().unwrap_or("?"));
    eprintln!("Market token: {}", market_token);
    eprintln!("Long token amount: {}", long_fmt);
    eprintln!("Short token amount: {}", short_fmt);
    eprintln!("Min GM tokens to receive: {}", min_gm_fmt);
    if args.min_market_tokens == 0 {
        eprintln!("⚠ min-market-tokens is 0 — no slippage protection on GM tokens received.");
    }
    eprintln!("Execution fee: {:.6} ETH", execution_fee_eth);
    eprintln!("⚠ GMX V2 keeper model: GM tokens minted 1-30s after tx lands.");
    if !confirm { eprintln!("Add --confirm to broadcast."); }

    if !confirm && !dry_run {
        println!(
            "{}",
            serde_json::to_string_pretty(&json!({
                "ok": true,
                "status": "preview",
                "message": "Add --confirm to broadcast this transaction",
                "chain": chain,
                "market": market.name,
                "marketToken": market_token,
                "longTokenAmount": long_fmt,
                "shortTokenAmount": short_fmt,
                "minGmTokens": min_gm_fmt,
                "executionFee_eth": format!("{:.6}", execution_fee_eth),
                "calldata": calldata
            }))?
        );
        return Ok(());
    }

    let result = crate::onchainos::wallet_contract_call_with_gas(
        cfg.chain_id,
        cfg.exchange_router,
        &calldata,
        Some(&wallet),
        Some(execution_fee),
        dry_run,
        confirm,
        Some(800_000),
    ).await?;

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

    println!(
        "{}",
        serde_json::to_string_pretty(&json!({
            "ok": true,
            "dry_run": dry_run,
            "chain": chain,
            "txHash": tx_hash,
            "market": market.name,
            "marketToken": market_token,
            "longTokenAmount": long_fmt,
            "shortTokenAmount": short_fmt,
            "minGmTokens": min_gm_fmt,
            "executionFee_eth": format!("{:.6}", execution_fee_eth),
            "note": "GM tokens will be minted within 1-30s after tx confirmation by keeper",
            "calldata": if dry_run { Some(calldata.as_str()) } else { None }
        }))?
    );
    Ok(())
}