Sparklend Plugin

{
  "name": "sparklend-plugin",
  "description": "SparkLend lending and borrowing on Ethereum Mainnet — supply, withdraw, borrow, repay, positions, health factor, reserves.",
  "version": "0.1.1"
}

[package]
name = "sparklend-plugin"
version = "0.1.1"
edition = "2021"

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

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

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: sparklend-plugin
version: "0.1.1"
description: "SparkLend lending and borrowing on Ethereum Mainnet — supply, withdraw, borrow, repay, positions, health factor, reserves."
author:
  name: skylavis-sky
  github: skylavis-sky
category: dapp
license: MIT
homepage: https://spark.fi
repository: https://github.com/skylavis-sky/plugin-store
tags:
  - defi
  - lending
  - ethereum
  - sparklend
  - aave
chains:
  - ethereum

components:
  skill:
    dir: .

build:
  lang: rust
  binary_name: sparklend-plugin

api_calls:
  - "https://ethereum.publicnode.com"

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

sol! {
    function supply(
        address asset,
        uint256 amount,
        address onBehalfOf,
        uint16 referralCode
    ) external;

    function withdraw(
        address asset,
        uint256 amount,
        address to
    ) external returns (uint256);

    function borrow(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        uint16 referralCode,
        address onBehalfOf
    ) external;

    function repay(
        address asset,
        uint256 amount,
        uint256 interestRateMode,
        address onBehalfOf
    ) external returns (uint256);

    function setUserUseReserveAsCollateral(
        address asset,
        bool useAsCollateral
    ) external;

    function approve(
        address spender,
        uint256 amount
    ) external returns (bool);
}

fn parse_address(addr: &str) -> anyhow::Result<Address> {
    addr.parse::<Address>()
        .with_context(|| format!("Invalid address: {}", addr))
}

/// Encode Pool.supply() calldata.
/// referralCode is always 0.
pub fn encode_supply(asset: &str, amount: u128, on_behalf_of: &str) -> anyhow::Result<String> {
    let call = supplyCall {
        asset: parse_address(asset)?,
        amount: U256::from(amount),
        onBehalfOf: parse_address(on_behalf_of)?,
        referralCode: crate::config::REFERRAL_CODE,
    };
    let encoded = call.abi_encode();
    Ok(format!("0x{}", hex::encode(encoded)))
}

/// Encode Pool.withdraw() calldata.
/// Pass u128::MAX for full withdrawal (maps to type(uint256).max).
pub fn encode_withdraw(asset: &str, amount: u128, to: &str) -> anyhow::Result<String> {
    let amount_u256 = if amount == u128::MAX {
        U256::MAX
    } else {
        U256::from(amount)
    };
    let call = withdrawCall {
        asset: parse_address(asset)?,
        amount: amount_u256,
        to: parse_address(to)?,
    };
    let encoded = call.abi_encode();
    Ok(format!("0x{}", hex::encode(encoded)))
}

/// Encode Pool.borrow() calldata.
/// interestRateMode is always 2 (variable) — stable (1) is deprecated in V3.1+
pub fn encode_borrow(
    asset: &str,
    amount: u128,
    on_behalf_of: &str,
) -> anyhow::Result<String> {
    let call = borrowCall {
        asset: parse_address(asset)?,
        amount: U256::from(amount),
        interestRateMode: U256::from(crate::config::INTEREST_RATE_MODE_VARIABLE),
        referralCode: crate::config::REFERRAL_CODE,
        onBehalfOf: parse_address(on_behalf_of)?,
    };
    let encoded = call.abi_encode();
    Ok(format!("0x{}", hex::encode(encoded)))
}

/// Encode Pool.repay() calldata.
/// Pass u128::MAX for full repay (maps to type(uint256).max in Solidity).
pub fn encode_repay(
    asset: &str,
    amount: u128,
    on_behalf_of: &str,
) -> anyhow::Result<String> {
    let amount_u256 = if amount == u128::MAX {
        U256::MAX
    } else {
        U256::from(amount)
    };
    let call = repayCall {
        asset: parse_address(asset)?,
        amount: amount_u256,
        interestRateMode: U256::from(crate::config::INTEREST_RATE_MODE_VARIABLE),
        onBehalfOf: parse_address(on_behalf_of)?,
    };
    let encoded = call.abi_encode();
    Ok(format!("0x{}", hex::encode(encoded)))
}

/// Encode ERC-20 approve() calldata.
/// Pass u128::MAX for unlimited approval (type(uint256).max).
pub fn encode_erc20_approve(spender: &str, amount: u128) -> anyhow::Result<String> {
    let amount_u256 = if amount == u128::MAX {
        U256::MAX
    } else {
        U256::from(amount)
    };
    let call = approveCall {
        spender: parse_address(spender)?,
        amount: amount_u256,
    };
    let encoded = call.abi_encode();
    Ok(format!("0x{}", hex::encode(encoded)))
}

use anyhow::Context;
use serde_json::{json, Value};

use crate::calldata;
use crate::config::{self, HF_WARN_THRESHOLD};
use crate::onchainos;
use crate::rpc;

/// Borrow assets from SparkLend via Pool.borrow() — variable rate only.
///
/// Flow:
/// 1. Resolve from address (active wallet if not specified)
/// 2. Resolve Pool address at runtime via PoolAddressesProvider.getPool()
/// 3. Check availableBorrowsBase and warn if post-borrow HF < 1.1
/// 4. Encode borrow calldata and submit via onchainos wallet contract-call
pub async fn run(
    chain_id: u64,
    asset: &str,
    amount: f64,
    from: Option<&str>,
    dry_run: bool,
) -> anyhow::Result<Value> {
    let from_addr = resolve_from(from, chain_id)?;

    // Resolve Pool address at runtime
    let pool_addr = rpc::get_pool(config::POOL_ADDRESSES_PROVIDER, config::RPC_URL)
        .await
        .context("Failed to resolve SparkLend Pool address")?;

    // Pre-flight: check account health
    let account_data = rpc::get_user_account_data(&pool_addr, &from_addr, config::RPC_URL)
        .await
        .context("Failed to fetch user account data")?;

    let hf_display = if account_data.health_factor >= u128::MAX / 2 {
        "no_debt".to_string()
    } else {
        format!("{:.4}", account_data.health_factor_f64())
    };
    let hf_status = if account_data.health_factor >= u128::MAX / 2 {
        "no_debt"
    } else {
        account_data.health_factor_status()
    };
    let hf = account_data.health_factor_f64();

    let mut warnings: Vec<String> = vec![];
    if hf < HF_WARN_THRESHOLD && account_data.total_debt_base > 0 {
        warnings.push(format!(
            "Current health factor is {:.2} — below the warning threshold of {}. Borrowing more will increase liquidation risk.",
            hf, HF_WARN_THRESHOLD
        ));
    }

    let available_usd = account_data.available_borrows_usd();
    if available_usd <= 0.0 && !dry_run {
        anyhow::bail!(
            "No borrow capacity available. Total collateral: ${:.2}, Total debt: ${:.2}",
            account_data.total_collateral_usd(),
            account_data.total_debt_usd()
        );
    }
    if available_usd <= 0.0 {
        warnings.push(format!(
            "No borrow capacity available (no collateral posted). Total collateral: ${:.2}. \
             This borrow would revert on-chain.",
            account_data.total_collateral_usd()
        ));
    }

    if amount <= 0.0 {
        anyhow::bail!("--amount must be greater than 0");
    }

    // Resolve asset address and decimals
    let (asset_addr, decimals) = onchainos::resolve_token(asset, chain_id)
        .with_context(|| format!("Could not resolve token address for '{}'", asset))?;
    let amount_minimal = (amount * 10u128.pow(decimals as u32) as f64) as u128;

    let calldata = calldata::encode_borrow(&asset_addr, amount_minimal, &from_addr)
        .context("Failed to encode borrow calldata")?;

    // Dry-run: return preview without broadcasting
    if dry_run {
        return Ok(json!({
            "ok": true,
            "dryRun": true,
            "asset": asset,
            "tokenAddress": asset_addr,
            "borrowAmount": amount,
            "borrowAmountMinimal": amount_minimal.to_string(),
            "poolAddress": pool_addr,
            "chain": config::CHAIN_NAME,
            "currentHealthFactor": hf_display,
            "healthFactorStatus": hf_status,
            "availableBorrowsUSD": format!("{:.2}", available_usd),
            "warnings": warnings,
            "calldata": calldata,
        }));
    }

    let result = onchainos::wallet_contract_call(
        chain_id,
        &pool_addr,
        &calldata,
        Some(&from_addr),
        false,
    )
    .context("onchainos wallet contract-call failed")?;

    let tx_hash = result["data"]["txHash"]
        .as_str()
        .or_else(|| result["txHash"].as_str())
        .or_else(|| result["hash"].as_str())
        .unwrap_or("pending");

    Ok(json!({
        "ok": true,
        "txHash": tx_hash,
        "explorer": format!("https://etherscan.io/tx/{}", tx_hash),
        "asset": asset,
        "tokenAddress": asset_addr,
        "borrowAmount": amount,
        "borrowAmountMinimal": amount_minimal.to_string(),
        "poolAddress": pool_addr,
        "chain": config::CHAIN_NAME,
        "currentHealthFactor": hf_display,
        "healthFactorStatus": hf_status,
        "availableBorrowsUSD": format!("{:.2}", available_usd),
        "warnings": warnings,
        "dryRun": false,
    }))
}

fn resolve_from(from: Option<&str>, chain_id: u64) -> anyhow::Result<String> {
    if let Some(addr) = from {
        return Ok(addr.to_string());
    }
    onchainos::wallet_address(chain_id).context(
        "No --from address specified and could not resolve active wallet. \
         Run `onchainos wallet status` to check login status.",
    )
}

use anyhow::Context;
use serde_json::{json, Value};

use crate::config;
use crate::onchainos;
use crate::rpc;

/// Fetch and display the health factor and account summary for a SparkLend position.
pub async fn run(chain_id: u64, from: Option<&str>) -> anyhow::Result<Value> {
    let user_addr = if let Some(addr) = from {
        addr.to_string()
    } else {
        onchainos::wallet_address(chain_id).context(
            "No --from address specified and could not resolve active wallet.",
        )?
    };

    // Resolve Pool address at runtime
    let pool_addr = rpc::get_pool(config::POOL_ADDRESSES_PROVIDER, config::RPC_URL)
        .await
        .context("Failed to resolve SparkLend Pool address")?;

    let data = rpc::get_user_account_data(&pool_addr, &user_addr, config::RPC_URL)
        .await
        .context("Failed to fetch user account data")?;

    let hf_display = if data.health_factor >= u128::MAX / 2 {
        "no_debt".to_string()
    } else {
        format!("{:.2}", data.health_factor_f64())
    };
    let status = if data.health_factor >= u128::MAX / 2 {
        "no_debt"
    } else {
        data.health_factor_status()
    };

    let liq_threshold_pct = data.current_liquidation_threshold as f64 / 100.0;
    let ltv_pct = data.ltv as f64 / 100.0;

    Ok(json!({
        "ok": true,
        "chain": config::CHAIN_NAME,
        "chainId": chain_id,
        "userAddress": user_addr,
        "poolAddress": pool_addr,
        "healthFactor": hf_display,
        "healthFactorStatus": status,
        "totalCollateralUSD": format!("{:.2}", data.total_collateral_usd()),
        "totalDebtUSD": format!("{:.2}", data.total_debt_usd()),
        "availableBorrowsUSD": format!("{:.2}", data.available_borrows_usd()),
        "currentLiquidationThreshold": format!("{:.2}%", liq_threshold_pct),
        "loanToValue": format!("{:.2}%", ltv_pct),
        "raw": {
            "healthFactorRaw": data.health_factor.to_string(),
            "totalCollateralBase": data.total_collateral_base.to_string(),
            "totalDebtBase": data.total_debt_base.to_string(),
            "availableBorrowsBase": data.available_borrows_base.to_string()
        }
    }))
}

pub mod borrow;
pub mod health_factor;
pub mod positions;
pub mod repay;
pub mod reserves;
pub mod supply;
pub mod withdraw;

use anyhow::Context;
use serde_json::{json, Value};

use crate::config;
use crate::onchainos;
use crate::rpc;

/// View current SparkLend positions.
///
/// Data source: on-chain Pool.getUserAccountData — aggregate health factor, LTV,
/// liquidation threshold, total collateral/debt/borrow capacity.
pub async fn run(chain_id: u64, from: Option<&str>) -> anyhow::Result<Value> {
    let user_addr = if let Some(addr) = from {
        addr.to_string()
    } else {
        onchainos::wallet_address(chain_id).context(
            "No --from address specified and could not resolve active wallet.",
        )?
    };

    // Resolve Pool address at runtime (never hardcoded)
    let pool_addr = rpc::get_pool(config::POOL_ADDRESSES_PROVIDER, config::RPC_URL)
        .await
        .context("Failed to resolve SparkLend Pool address")?;

    // Fetch aggregate account data on-chain via Pool.getUserAccountData
    let account_data = rpc::get_user_account_data(&pool_addr, &user_addr, config::RPC_URL)
        .await
        .context("Failed to fetch user account data from SparkLend Pool")?;

    // When a wallet has no position, the contract returns uint256.max as the health factor.
    let hf_display = if account_data.health_factor >= u128::MAX / 2 {
        "no_debt".to_string()
    } else {
        format!("{:.4}", account_data.health_factor_f64())
    };
    let hf_status = if account_data.health_factor >= u128::MAX / 2 {
        "no_debt"
    } else {
        account_data.health_factor_status()
    };

    let (liq_threshold_display, ltv_display) = if account_data.total_collateral_base == 0 {
        ("0.00%".to_string(), "0.00%".to_string())
    } else {
        (
            format!("{:.2}%", account_data.current_liquidation_threshold as f64 / 100.0),
            format!("{:.2}%", account_data.ltv as f64 / 100.0),
        )
    };

    let no_position = account_data.total_collateral_base == 0 && account_data.total_debt_base == 0;

    Ok(json!({
        "ok": true,
        "chain": config::CHAIN_NAME,
        "chainId": chain_id,
        "userAddress": user_addr,
        "poolAddress": pool_addr,
        "healthFactor": hf_display,
        "healthFactorStatus": hf_status,
        "totalCollateralUSD": format!("{:.2}", account_data.total_collateral_usd()),
        "totalDebtUSD": format!("{:.2}", account_data.total_debt_usd()),
        "availableBorrowsUSD": format!("{:.2}", account_data.available_borrows_usd()),
        "currentLiquidationThreshold": liq_threshold_display,
        "loanToValue": ltv_display,
        "message": if no_position {
            Some("No active SparkLend position. Supply assets to get started.")
        } else {
            None
        }
    }))
}

use anyhow::Context;
use serde_json::{json, Value};

use crate::calldata;
use crate::config;
use crate::onchainos;
use crate::rpc;

/// Repay borrowed assets on SparkLend via Pool.repay().
///
/// Flow:
/// 1. Resolve from address
/// 2. Resolve Pool address at runtime
/// 3. Check user has outstanding debt
/// 4. Check ERC-20 allowance; approve if insufficient
/// 5. Wait for approve tx confirmation, then submit repay
pub async fn run(
    chain_id: u64,
    asset: &str,
    amount: Option<f64>,
    all: bool,
    from: Option<&str>,
    dry_run: bool,
) -> anyhow::Result<Value> {
    if amount.is_none() && !all {
        anyhow::bail!("Specify either --amount <value> or --all for full repayment");
    }
    if let Some(amt) = amount {
        if amt <= 0.0 {
            anyhow::bail!("--amount must be greater than 0");
        }
    }

    let from_addr = resolve_from(from, chain_id)?;

    // Resolve Pool address at runtime
    let pool_addr = rpc::get_pool(config::POOL_ADDRESSES_PROVIDER, config::RPC_URL)
        .await
        .context("Failed to resolve SparkLend Pool address")?;

    // Resolve token contract address and decimals
    let (token_addr, decimals) = onchainos::resolve_token(asset, chain_id)
        .with_context(|| format!("Could not resolve token address for '{}'", asset))?;

    // Pre-flight: check debt
    let account_data = rpc::get_user_account_data(&pool_addr, &from_addr, config::RPC_URL)
        .await
        .context("Failed to fetch user account data")?;

    if account_data.total_debt_base == 0 && !dry_run {
        return Ok(json!({
            "ok": true,
            "message": "No outstanding debt to repay.",
            "totalDebtUSD": "0.00"
        }));
    }
    let zero_debt_warning = if account_data.total_debt_base == 0 {
        Some("No outstanding debt detected. Repay calldata shown for simulation only — tx would revert on-chain.")
    } else {
        None
    };

    let (amount_minimal, amount_display) = if all {
        (u128::MAX, "all".to_string())
    } else {
        let v = amount.unwrap();
        let minimal = (v * 10u128.pow(decimals as u32) as f64) as u128;
        (minimal, v.to_string())
    };

    // Check ERC-20 allowance; approve if insufficient.
    // For --all: always approve with u128::MAX so Aave can pull full debt + last-second interest.
    let needs_approval = if all {
        true
    } else {
        let allowance = rpc::get_allowance(&token_addr, &from_addr, &pool_addr, config::RPC_URL)
            .await
            .context("Failed to fetch token allowance")?;
        allowance < amount_minimal
    };

    let mut approval_result: Option<Value> = None;
    if needs_approval {
        let approve_amount = if all { u128::MAX } else { amount_minimal };
        let approve_calldata = calldata::encode_erc20_approve(&pool_addr, approve_amount)
            .context("Failed to encode approve calldata")?;
        let approve_res = onchainos::wallet_contract_call(
            chain_id,
            &token_addr,
            &approve_calldata,
            Some(&from_addr),
            dry_run,
        )
        .context("ERC-20 approve failed")?;
        if !dry_run {
            let approve_tx = approve_res["data"]["txHash"]
                .as_str()
                .or_else(|| approve_res["txHash"].as_str())
                .unwrap_or("");
            if approve_tx.is_empty() || !approve_tx.starts_with("0x") {
                anyhow::bail!(
                    "Approve tx was not broadcast (tx hash: '{}'). Check wallet connection and retry.",
                    approve_tx
                );
            }
            rpc::wait_for_tx(config::RPC_URL, approve_tx)
                .await
                .context("Approve tx did not confirm in time")?;
        }
        approval_result = Some(approve_res);
    }

    // Encode repay calldata
    let calldata = calldata::encode_repay(&token_addr, amount_minimal, &from_addr)
        .context("Failed to encode repay calldata")?;

    // Dry-run: return preview without broadcasting
    if dry_run {
        let amount_display_fmt = if all { "all".to_string() } else { format!("{:.6}", amount.unwrap_or(0.0)) };
        return Ok(json!({
            "ok": true,
            "dryRun": true,
            "asset": asset,
            "tokenAddress": token_addr,
            "repayAmount": amount_display,
            "repayAmountDisplay": amount_display_fmt,
            "poolAddress": pool_addr,
            "chain": config::CHAIN_NAME,
            "totalDebtBefore": format!("{:.2}", account_data.total_debt_usd()),
            "healthFactorBefore": if account_data.health_factor >= u128::MAX / 2 {
                "no_debt".to_string()
            } else {
                format!("{:.4}", account_data.health_factor_f64())
            },
            "approvalCalldata": approval_result.as_ref().and_then(|r| r["simulatedCommand"].as_str()),
            "repayCalldata": calldata,
            "warning": zero_debt_warning,
        }));
    }

    let result = onchainos::wallet_contract_call(
        chain_id,
        &pool_addr,
        &calldata,
        Some(&from_addr),
        false,
    )
    .context("Pool.repay() failed")?;

    let tx_hash = result["data"]["txHash"]
        .as_str()
        .or_else(|| result["txHash"].as_str())
        .or_else(|| result["hash"].as_str())
        .unwrap_or("pending");

    let amount_display_fmt = if all {
        "all".to_string()
    } else {
        format!("{:.6}", amount.unwrap_or(0.0))
    };

    Ok(json!({
        "ok": true,
        "txHash": tx_hash,
        "explorer": format!("https://etherscan.io/tx/{}", tx_hash),
        "asset": asset,
        "tokenAddress": token_addr,
        "repayAmount": amount_display,
        "repayAmountDisplay": amount_display_fmt,
        "poolAddress": pool_addr,
        "chain": config::CHAIN_NAME,
        "totalDebtBefore": format!("{:.2}", account_data.total_debt_usd()),
        "healthFactorBefore": if account_data.health_factor >= u128::MAX / 2 {
            "no_debt".to_string()
        } else {
            format!("{:.4}", account_data.health_factor_f64())
        },
        "approvalExecuted": approval_result.is_some(),
        "dryRun": false,
        "warning": zero_debt_warning,
    }))
}

fn resolve_from(from: Option<&str>, chain_id: u64) -> anyhow::Result<String> {
    if let Some(addr) = from {
        return Ok(addr.to_string());
    }
    onchainos::wallet_address(chain_id).context(
        "No --from address specified and could not resolve active wallet.",
    )
}

use anyhow::Context;
use serde_json::{json, Value};

use crate::config;
use crate::rpc;

/// List SparkLend reserve data — supply APYs, variable borrow APYs, asset addresses.
///
/// Calls Pool.getReservesList() to obtain asset addresses, then queries each asset
/// via Pool.getReserveData(address) (selector 0x35ea6a75) which returns the packed
/// DataTypes.ReserveData struct:
///
///   Slot 0: configuration (uint256, packed bitmask)
///   Slot 1: liquidityIndex (ray = 1e27)
///   Slot 2: currentLiquidityRate  ← supply APY (ray = 1e27)
///   Slot 3: variableBorrowIndex (ray)
///   Slot 4: currentVariableBorrowRate  ← variable borrow APY (ray = 1e27)
pub async fn run(
    chain_id: u64,
    asset_filter: Option<&str>,
) -> anyhow::Result<Value> {
    // Resolve Pool address at runtime
    let pool_addr = rpc::get_pool(config::POOL_ADDRESSES_PROVIDER, config::RPC_URL)
        .await
        .context("Failed to resolve SparkLend Pool address")?;

    // Get list of reserves from Pool.getReservesList()
    let reserves_list_hex = rpc::eth_call(config::RPC_URL, &pool_addr, "0xd1946dbc")
        .await
        .context("Failed to call Pool.getReservesList()")?;

    let reserve_addresses = decode_address_array(&reserves_list_hex)?;

    if reserve_addresses.is_empty() {
        return Ok(json!({
            "ok": true,
            "chain": config::CHAIN_NAME,
            "chainId": chain_id,
            "reserves": [],
            "message": "No reserves found"
        }));
    }

    let mut reserves: Vec<Value> = Vec::new();

    for addr in &reserve_addresses {
        let symbol = rpc::get_erc20_symbol(addr, config::RPC_URL).await.unwrap_or_default();

        // Apply filter: match by address (0x...) or symbol (case-insensitive)
        if let Some(filter) = asset_filter {
            if filter.starts_with("0x") {
                if !addr.eq_ignore_ascii_case(filter) {
                    continue;
                }
            } else if !symbol.eq_ignore_ascii_case(filter) {
                continue;
            }
        }

        match get_reserve_data_from_pool(&pool_addr, addr, &symbol, config::RPC_URL).await {
            Ok(reserve_data) => {
                reserves.push(reserve_data);
            }
            Err(e) => {
                eprintln!("Warning: failed to fetch data for reserve {}: {}", addr, e);
            }
        }
    }

    Ok(json!({
        "ok": true,
        "chain": config::CHAIN_NAME,
        "chainId": chain_id,
        "reserveCount": reserves.len(),
        "reserves": reserves
    }))
}

/// Fetch reserve data from Pool.getReserveData(address) — selector 0x35ea6a75.
async fn get_reserve_data_from_pool(
    pool_addr: &str,
    asset_addr: &str,
    symbol: &str,
    rpc_url: &str,
) -> anyhow::Result<Value> {
    let addr_bytes = hex::decode(asset_addr.trim_start_matches("0x"))?;
    let mut data = hex::decode("35ea6a75")?;
    data.extend_from_slice(&[0u8; 12]);
    data.extend_from_slice(&addr_bytes);
    let data_hex = format!("0x{}", hex::encode(&data));

    let result = rpc::eth_call(rpc_url, pool_addr, &data_hex).await?;
    let raw = result.trim_start_matches("0x");

    if raw.len() < 64 * 5 {
        anyhow::bail!("Pool.getReserveData: short response ({} chars)", raw.len());
    }

    // Slot 2: currentLiquidityRate (supply APY, ray = 1e27)
    let liquidity_rate = decode_ray_to_apy_pct(raw, 2)?;
    // Slot 4: currentVariableBorrowRate (variable borrow APY, ray = 1e27)
    let variable_borrow_rate = decode_ray_to_apy_pct(raw, 4)?;

    Ok(json!({
        "symbol": symbol,
        "underlyingAsset": asset_addr,
        "supplyApy": format!("{:.4}%", liquidity_rate),
        "variableBorrowApy": format!("{:.4}%", variable_borrow_rate)
    }))
}

fn decode_ray_to_apy_pct(raw: &str, slot: usize) -> anyhow::Result<f64> {
    let start = slot * 64;
    let end = start + 64;
    if raw.len() < end {
        return Ok(0.0);
    }
    let slot_hex = &raw[start..end];
    let low = &slot_hex[32..64];
    let val = u128::from_str_radix(low, 16).unwrap_or(0);
    let pct = val as f64 / 1e27 * 100.0;
    Ok(pct)
}

/// Decode an ABI-encoded dynamic array of addresses.
/// ABI encoding: offset (32), length (32), then N x address (32 each)
fn decode_address_array(hex_result: &str) -> anyhow::Result<Vec<String>> {
    let raw = hex_result.trim_start_matches("0x");
    if raw.len() < 128 {
        return Ok(vec![]);
    }
    let len_hex = &raw[64..128];
    let len = usize::from_str_radix(len_hex.trim_start_matches('0'), 16).unwrap_or(0);
    if len == 0 {
        return Ok(vec![]);
    }

    let mut addresses = Vec::with_capacity(len);
    let data_start = 128;
    for i in 0..len {
        let slot_start = data_start + i * 64;
        let slot_end = slot_start + 64;
        if raw.len() < slot_end {
            break;
        }
        let addr_hex = &raw[slot_end - 40..slot_end];
        addresses.push(format!("0x{}", addr_hex));
    }
    Ok(addresses)
}

use anyhow::Context;
use serde_json::{json, Value};

use crate::calldata;
use crate::config;
use crate::onchainos;
use crate::rpc;

/// Supply assets to SparkLend Pool via direct contract-call.
///
/// Flow:
/// 1. Resolve token contract address (symbol → address via onchainos token search)
/// 2. Resolve Pool address via PoolAddressesProvider
/// 3. If supplying WETH and wallet has insufficient WETH, auto-wrap ETH
/// 4. Approve token to Pool (ERC-20 approve)
/// 5. Call Pool.supply(asset, amount, onBehalfOf, 0)
pub async fn run(
    chain_id: u64,
    asset: &str,
    amount: f64,
    from: Option<&str>,
    dry_run: bool,
) -> anyhow::Result<Value> {
    if amount <= 0.0 {
        anyhow::bail!("--amount must be greater than 0");
    }

    let from_addr = resolve_from(from, chain_id)?;

    // Resolve token address and decimals
    let (token_addr, decimals) = onchainos::resolve_token(asset, chain_id)
        .with_context(|| format!("Could not resolve token address for '{}'", asset))?;

    let amount_minimal = human_to_minimal(amount, decimals as u64);
    let amount_display = format!("{:.6}", amount);

    // Resolve Pool address at runtime
    let pool_addr = rpc::get_pool(config::POOL_ADDRESSES_PROVIDER, config::RPC_URL)
        .await
        .context("Failed to resolve SparkLend Pool address")?;

    // Pre-flight: if supplying WETH and wallet has insufficient WETH, auto-wrap ETH.
    // WETH.deposit{value: needed}() selector: 0xd0e30db0
    let is_weth = config::WETH_ADDRESS.to_lowercase() == token_addr.to_lowercase();
    let mut wrap_tx: Option<String> = None;

    if is_weth {
        let weth_balance = rpc::get_erc20_balance(&token_addr, &from_addr, config::RPC_URL)
            .await
            .context("Failed to fetch WETH balance")?;
        if weth_balance < amount_minimal {
            let needed = amount_minimal - weth_balance;
            let eth_balance = rpc::get_eth_balance(&from_addr, config::RPC_URL)
                .await
                .context("Failed to fetch ETH balance")?;
            if eth_balance < needed {
                anyhow::bail!(
                    "Insufficient balance: need {:.6} WETH to supply, have {:.6} WETH and {:.6} ETH. \
                     Add more ETH or WETH to your wallet.",
                    amount_minimal as f64 / 1e18,
                    weth_balance as f64 / 1e18,
                    eth_balance as f64 / 1e18,
                );
            }
            if dry_run {
                let wrap_cmd = format!(
                    "onchainos wallet contract-call --chain {} --to {} --input-data 0xd0e30db0 --amt {} --from {}",
                    chain_id, token_addr, needed, from_addr
                );
                eprintln!("[dry-run] step 0 wrap ETH→WETH: {}", wrap_cmd);
            } else {
                let wrap_result = onchainos::wallet_contract_call_with_value(
                    chain_id,
                    &token_addr,
                    "0xd0e30db0",
                    Some(&from_addr),
                    needed,
                    false,
                )
                .context("WETH.deposit() (ETH→WETH wrap) failed")?;
                let tx = wrap_result["data"]["txHash"]
                    .as_str()
                    .or_else(|| wrap_result["txHash"].as_str())
                    .or_else(|| wrap_result["hash"].as_str())
                    .unwrap_or("pending")
                    .to_string();
                if tx == "pending" || !tx.starts_with("0x") {
                    anyhow::bail!(
                        "WETH wrap tx was not broadcast (tx hash: '{}'). Check wallet connection and retry.",
                        tx
                    );
                }
                rpc::wait_for_tx(config::RPC_URL, &tx)
                    .await
                    .context("WETH wrap tx did not confirm in time")?;
                wrap_tx = Some(tx);
            }
        }
    } else {
        // Non-WETH: check ERC-20 balance before attempting supply
        let token_balance = rpc::get_erc20_balance(&token_addr, &from_addr, config::RPC_URL)
            .await
            .context("Failed to fetch token balance")?;
        if token_balance < amount_minimal && !dry_run {
            anyhow::bail!(
                "Insufficient {} balance: need {:.6}, have {:.6}. Add funds to your wallet before supplying.",
                asset,
                amount_minimal as f64 / 10f64.powi(decimals as i32),
                token_balance as f64 / 10f64.powi(decimals as i32),
            );
        }
    }

    if dry_run {
        let approve_calldata = calldata::encode_erc20_approve(&pool_addr, amount_minimal)
            .context("Failed to encode approve calldata")?;
        let supply_calldata = calldata::encode_supply(&token_addr, amount_minimal, &from_addr)
            .context("Failed to encode supply calldata")?;
        let approve_cmd = format!(
            "onchainos wallet contract-call --chain {} --to {} --input-data {} --from {}",
            chain_id, token_addr, approve_calldata, from_addr
        );
        let supply_cmd = format!(
            "onchainos wallet contract-call --chain {} --to {} --input-data {} --from {}",
            chain_id, pool_addr, supply_calldata, from_addr
        );
        eprintln!("[dry-run] step 1 approve: {}", approve_cmd);
        eprintln!("[dry-run] step 2 supply: {}", supply_cmd);
        return Ok(json!({
            "ok": true,
            "dryRun": true,
            "asset": asset,
            "tokenAddress": token_addr,
            "amount": amount,
            "amountDisplay": amount_display,
            "amountMinimal": amount_minimal.to_string(),
            "poolAddress": pool_addr,
            "chain": config::CHAIN_NAME,
            "steps": [
                {"step": 1, "action": "approve", "simulatedCommand": approve_cmd},
                {"step": 2, "action": "supply",  "simulatedCommand": supply_cmd}
            ]
        }));
    }

    // Step 1: approve
    let approve_calldata = calldata::encode_erc20_approve(&pool_addr, amount_minimal)
        .context("Failed to encode approve calldata")?;
    let approve_result = onchainos::wallet_contract_call(
        chain_id,
        &token_addr,
        &approve_calldata,
        Some(&from_addr),
        false,
    )
    .context("ERC-20 approve failed")?;
    let approve_tx = approve_result["data"]["txHash"]
        .as_str()
        .or_else(|| approve_result["txHash"].as_str())
        .or_else(|| approve_result["hash"].as_str())
        .unwrap_or("pending")
        .to_string();

    if approve_tx == "pending" || !approve_tx.starts_with("0x") {
        anyhow::bail!(
            "Approve tx was not broadcast (tx hash: '{}'). Check wallet connection and retry.",
            approve_tx
        );
    }
    rpc::wait_for_tx(config::RPC_URL, &approve_tx)
        .await
        .context("Approve tx did not confirm in time")?;

    // Step 2: supply
    let supply_calldata = calldata::encode_supply(&token_addr, amount_minimal, &from_addr)
        .context("Failed to encode supply calldata")?;
    let supply_result = onchainos::wallet_contract_call(
        chain_id,
        &pool_addr,
        &supply_calldata,
        Some(&from_addr),
        false,
    )
    .context("Pool.supply() failed")?;
    let supply_tx = supply_result["data"]["txHash"]
        .as_str()
        .or_else(|| supply_result["txHash"].as_str())
        .or_else(|| supply_result["hash"].as_str())
        .unwrap_or("pending");

    Ok(json!({
        "ok": true,
        "asset": asset,
        "tokenAddress": token_addr,
        "amount": amount,
        "amountDisplay": amount_display,
        "amountMinimal": amount_minimal.to_string(),
        "poolAddress": pool_addr,
        "chain": config::CHAIN_NAME,
        "wrapTxHash": wrap_tx,
        "approveTxHash": approve_tx,
        "supplyTxHash": supply_tx.to_string(),
        "explorer": format!("https://etherscan.io/tx/{}", supply_tx),
        "dryRun": false
    }))
}

fn resolve_from(from: Option<&str>, chain_id: u64) -> anyhow::Result<String> {
    if let Some(addr) = from {
        return Ok(addr.to_string());
    }
    onchainos::wallet_address(chain_id).context("No --from address and could not resolve active wallet.")
}

pub fn human_to_minimal(amount: f64, decimals: u64) -> u128 {
    let factor = 10u128.pow(decimals as u32);
    (amount * factor as f64) as u128
}

use anyhow::Context;
use serde_json::{json, Value};

use crate::calldata;
use crate::config;
use crate::onchainos;
use crate::rpc;

/// Withdraw assets from SparkLend Pool via Pool.withdraw().
///
/// Flow:
/// 1. Resolve token contract address
/// 2. Resolve Pool address via PoolAddressesProvider
/// 3. Check outstanding debt and warn if health factor may be affected
/// 4. Call Pool.withdraw(asset, amount, to)
///    - For --all: amount = type(uint256).max
///    - For --amount X: amount = X in minimal units (auto-capped to aToken balance)
pub async fn run(
    chain_id: u64,
    asset: &str,
    amount: Option<f64>,
    all: bool,
    from: Option<&str>,
    dry_run: bool,
) -> anyhow::Result<Value> {
    if amount.is_none() && !all {
        anyhow::bail!("Specify either --amount <value> or --all for full withdrawal");
    }
    if let Some(amt) = amount {
        if amt <= 0.0 {
            anyhow::bail!("--amount must be greater than 0");
        }
    }

    let from_addr = resolve_from(from, chain_id)?;

    // Resolve token address and decimals
    let (token_addr, decimals) = onchainos::resolve_token(asset, chain_id)
        .with_context(|| format!("Could not resolve token address for '{}'", asset))?;

    // Resolve Pool address at runtime
    let pool_addr = rpc::get_pool(config::POOL_ADDRESSES_PROVIDER, config::RPC_URL)
        .await
        .context("Failed to resolve SparkLend Pool address")?;

    // Pre-flight: check outstanding debt
    let account_data = rpc::get_user_account_data(&pool_addr, &from_addr, config::RPC_URL)
        .await
        .context("Failed to fetch user account data")?;

    if account_data.total_debt_usd() >= 0.005 {
        eprintln!(
            "[sparklend] WARNING: You have outstanding debt (${:.4}). Withdrawing collateral reduces \
             your health factor (currently {:.2}). If HF drops below 1.0, the transaction will revert. \
             Repay debt first, or withdraw a smaller amount to keep HF above 1.0.",
            account_data.total_debt_usd(),
            account_data.health_factor_f64(),
        );
    }

    let (amount_minimal, amount_display) = if all {
        (u128::MAX, "all".to_string())
    } else {
        let amt = amount.unwrap();
        let mut minimal = super::supply::human_to_minimal(amt, decimals as u64);

        // Pre-flight: cap --amount to actual aToken (spToken) balance to prevent precision-mismatch revert.
        let actual_atoken_balance: Option<u128> = async {
            let pdp = rpc::get_pool_data_provider(config::POOL_ADDRESSES_PROVIDER, config::RPC_URL)
                .await
                .ok()?;
            let atoken_addr = rpc::get_atoken_address(&pdp, &token_addr, config::RPC_URL)
                .await
                .ok()?;
            rpc::get_erc20_balance(&atoken_addr, &from_addr, config::RPC_URL)
                .await
                .ok()
        }
        .await;

        if let Some(bal) = actual_atoken_balance {
            if bal == 0 && !dry_run {
                anyhow::bail!(
                    "No {} supplied to SparkLend. Nothing to withdraw.",
                    asset
                );
            } else if bal > 0 && minimal > bal {
                eprintln!(
                    "[sparklend] NOTE: Requested {:.6} {} but spToken balance is {:.6}. \
                     Adjusting withdrawal amount down to actual balance.",
                    minimal as f64 / 10f64.powi(decimals as i32),
                    asset,
                    bal as f64 / 10f64.powi(decimals as i32),
                );
                minimal = bal;
            }
        }

        let display_amt = minimal as f64 / 10f64.powi(decimals as i32);
        (minimal, format!("{:.6}", display_amt))
    };

    // Encode calldata
    let calldata = calldata::encode_withdraw(&token_addr, amount_minimal, &from_addr)
        .context("Failed to encode withdraw calldata")?;

    if dry_run {
        let cmd = format!(
            "onchainos wallet contract-call --chain {} --to {} --input-data {} --from {}",
            chain_id, pool_addr, calldata, from_addr
        );
        eprintln!("[dry-run] would execute: {}", cmd);
        return Ok(json!({
            "ok": true,
            "dryRun": true,
            "asset": asset,
            "tokenAddress": token_addr,
            "amount": amount_display,
            "amountDisplay": amount_display,
            "poolAddress": pool_addr,
            "chain": config::CHAIN_NAME,
            "simulatedCommand": cmd
        }));
    }

    let result = onchainos::wallet_contract_call(
        chain_id,
        &pool_addr,
        &calldata,
        Some(&from_addr),
        false,
    )
    .context("Pool.withdraw() failed")?;

    let tx_hash = result["data"]["txHash"]
        .as_str()
        .or_else(|| result["txHash"].as_str())
        .unwrap_or("pending");

    Ok(json!({
        "ok": true,
        "txHash": tx_hash,
        "explorer": format!("https://etherscan.io/tx/{}", tx_hash),
        "asset": asset,
        "tokenAddress": token_addr,
        "amount": amount_display,
        "amountDisplay": amount_display,
        "poolAddress": pool_addr,
        "chain": config::CHAIN_NAME,
        "dryRun": false,
        "raw": result
    }))
}

fn resolve_from(from: Option<&str>, chain_id: u64) -> anyhow::Result<String> {
    if let Some(addr) = from {
        return Ok(addr.to_string());
    }
    onchainos::wallet_address(chain_id).context("No --from address and could not resolve active wallet.")
}

/// SparkLend (Sky Protocol) — Aave V3 fork on Ethereum Mainnet.
///
/// PoolAddressesProvider address verified against SparkLend docs:
///   https://docs.spark.fi/dev/deployments/mainnet-addresses
///
/// SparkLend is ABI-compatible with Aave V3 (same Pool interface).
/// Only Ethereum Mainnet (chain 1) is supported.
pub const CHAIN_ID: u64 = 1;
pub const CHAIN_NAME: &str = "Ethereum Mainnet";
pub const RPC_URL: &str = "https://ethereum.publicnode.com";

/// SparkLend PoolAddressesProvider on Ethereum Mainnet.
/// This is the immutable registry entry point — the Pool proxy address
/// must always be resolved at runtime via PoolAddressesProvider.getPool().
pub const POOL_ADDRESSES_PROVIDER: &str = "0x02C3eA4e34C0cBd694D2adFa2c690EECbC1793eE";

/// WETH address on Ethereum Mainnet.
/// Used for ETH→WETH auto-wrap in supply command.
pub const WETH_ADDRESS: &str = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";

/// Interest rate mode: variable (2). Stable rate (1) deprecated in V3.1+.
pub const INTEREST_RATE_MODE_VARIABLE: u128 = 2;

/// Aave referral code (0 = no referral)
pub const REFERRAL_CODE: u16 = 0;

/// Health factor warning threshold (human-readable)
pub const HF_WARN_THRESHOLD: f64 = 1.1;

mod calldata;
mod commands;
mod config;
mod onchainos;
mod rpc;

use clap::{Parser, Subcommand};
use serde_json::Value;

#[derive(Parser)]
#[command(
    name = "sparklend-plugin",
    about = "SparkLend lending and borrowing on Ethereum Mainnet via OnchaionOS",
    version = env!("CARGO_PKG_VERSION")
)]
struct Cli {
    #[command(subcommand)]
    command: Commands,
    /// Wallet address (defaults to active onchainos wallet)
    #[arg(long, global = true)]
    from: Option<String>,
    /// Execute the transaction on-chain. Without this flag the operation is simulated only.
    #[arg(long, global = true, default_value = "false")]
    confirm: bool,
}

#[derive(Subcommand)]
enum Commands {
    /// Supply/deposit an asset to earn interest (spTokens)
    Supply {
        /// Asset ERC-20 address or symbol (e.g. DAI, USDC, WETH, wstETH)
        #[arg(long)]
        asset: String,
        /// Human-readable amount (e.g. 1000.0)
        #[arg(long)]
        amount: f64,
    },
    /// Withdraw a previously supplied asset
    Withdraw {
        /// Asset ERC-20 address or symbol
        #[arg(long)]
        asset: String,
        /// Human-readable amount to withdraw (omit if using --all)
        #[arg(long)]
        amount: Option<f64>,
        /// Withdraw the full balance
        #[arg(long, default_value = "false")]
        all: bool,
    },
    /// Borrow an asset against posted collateral
    Borrow {
        /// Asset ERC-20 address or symbol (e.g. DAI, USDC, WETH)
        #[arg(long)]
        asset: String,
        /// Human-readable amount (e.g. 0.5 for 0.5 WETH)
        #[arg(long)]
        amount: f64,
    },
    /// Repay borrowed debt (partial or full)
    Repay {
        /// Asset ERC-20 address or symbol (e.g. DAI, USDC, WETH)
        #[arg(long)]
        asset: String,
        /// Human-readable amount to repay (omit if using --all)
        #[arg(long)]
        amount: Option<f64>,
        /// Repay the full outstanding balance
        #[arg(long, default_value = "false")]
        all: bool,
    },
    /// View current supply and borrow positions
    Positions {},
    /// Check health factor and liquidation risk
    HealthFactor {},
    /// List market rates and APYs for all supported assets
    Reserves {
        /// Filter by asset address or symbol (optional)
        #[arg(long)]
        asset: Option<String>,
    },
}

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

    let result: anyhow::Result<Value> = match cli.command {
        Commands::Supply { asset, amount } => {
            commands::supply::run(chain_id, &asset, amount, cli.from.as_deref(), !cli.confirm)
                .await
        }
        Commands::Withdraw { asset, amount, all } => {
            commands::withdraw::run(
                chain_id,
                &asset,
                amount,
                all,
                cli.from.as_deref(),
                !cli.confirm,
            )
            .await
        }
        Commands::Borrow { asset, amount } => {
            commands::borrow::run(chain_id, &asset, amount, cli.from.as_deref(), !cli.confirm)
                .await
        }
        Commands::Repay { asset, amount, all } => {
            commands::repay::run(
                chain_id,
                &asset,
                amount,
                all,
                cli.from.as_deref(),
                !cli.confirm,
            )
            .await
        }
        Commands::Positions {} => {
            commands::positions::run(chain_id, cli.from.as_deref()).await
        }
        Commands::HealthFactor {} => {
            commands::health_factor::run(chain_id, cli.from.as_deref()).await
        }
        Commands::Reserves { asset } => {
            commands::reserves::run(chain_id, asset.as_deref()).await
        }
    };

    match result {
        Ok(val) => {
            println!("{}", serde_json::to_string_pretty(&val).unwrap_or_default());
        }
        Err(err) => {
            let error_json = serde_json::json!({
                "ok": false,
                "error": err.to_string()
            });
            eprintln!(
                "{}",
                serde_json::to_string_pretty(&error_json).unwrap_or_default()
            );
            std::process::exit(1);
        }
    }
}

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

/// Build a base Command for onchainos, explicitly adding ~/.local/bin to PATH.
fn base_cmd() -> Command {
    let mut cmd = Command::new("onchainos");
    let home = std::env::var("HOME").unwrap_or_default();
    let existing_path = std::env::var("PATH").unwrap_or_default();
    let path = format!("{}/.local/bin:{}", home, existing_path);
    cmd.env("PATH", path);
    cmd
}

/// Run a Command and return its stdout as a parsed JSON Value.
fn run_cmd(mut cmd: Command) -> anyhow::Result<Value> {
    let output = cmd.output().context("Failed to spawn onchainos process")?;
    let stdout = String::from_utf8_lossy(&output.stdout);

    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        anyhow::bail!(
            "onchainos exited with status {}: stderr={} stdout={}",
            output.status.code().unwrap_or(-1),
            stderr.trim(),
            stdout.trim()
        );
    }
    serde_json::from_str(stdout.trim())
        .with_context(|| format!("Failed to parse onchainos JSON output: {}", stdout.trim()))
}

/// Resolve a token symbol or address to (contract_address, decimals).
/// Queries onchainos token search to get actual decimals.
pub fn resolve_token(asset: &str, _chain_id: u64) -> anyhow::Result<(String, u8)> {
    let is_address = asset.starts_with("0x") && asset.len() == 42;
    let mut cmd = base_cmd();
    cmd.args(["token", "search", "--query", asset, "--chain", "ethereum"]);
    let result = run_cmd(cmd)?;

    let tokens = result
        .as_array()
        .or_else(|| result.get("data").and_then(|d| d.as_array()))
        .ok_or_else(|| anyhow::anyhow!("No tokens found for '{}' on Ethereum", asset))?;

    let first = tokens.first().ok_or_else(|| {
        anyhow::anyhow!("No token match for '{}' on Ethereum", asset)
    })?;

    let addr = if is_address {
        asset.to_lowercase()
    } else {
        first["tokenContractAddress"]
            .as_str()
            .ok_or_else(|| anyhow::anyhow!("Missing tokenContractAddress in token search result"))?
            .to_lowercase()
    };

    let decimals = first["decimal"]
        .as_str()
        .and_then(|s| s.parse::<u8>().ok())
        .unwrap_or(18);

    Ok((addr, decimals))
}

/// Submit a contract call via onchainos wallet contract-call.
///
/// If dry_run is true, prints the command that would be run and returns a mock
/// success JSON without actually executing it.
pub fn wallet_contract_call(
    chain_id: u64,
    to: &str,
    input_data: &str,
    from: Option<&str>,
    dry_run: bool,
) -> anyhow::Result<Value> {
    let mut args: Vec<String> = vec![
        "wallet".to_string(),
        "contract-call".to_string(),
        "--chain".to_string(),
        chain_id.to_string(),
        "--to".to_string(),
        to.to_string(),
        "--input-data".to_string(),
        input_data.to_string(),
    ];
    if let Some(addr) = from {
        args.push("--from".to_string());
        args.push(addr.to_string());
    }
    args.push("--biz-type".to_string());
    args.push("dapp".to_string());
    args.push("--strategy".to_string());
    args.push("sparklend-plugin".to_string());
    if dry_run {
        args.push("--dry-run".to_string());
        let cmd_str = format!("onchainos {}", args.join(" "));
        eprintln!("[dry-run] would execute: {}", cmd_str);
        return Ok(serde_json::json!({
            "ok": true,
            "dryRun": true,
            "simulatedCommand": cmd_str
        }));
    }
    args.push("--force".to_string());
    let mut cmd = base_cmd();
    cmd.args(&args);
    run_cmd(cmd)
}

/// Same as wallet_contract_call but attaches a native ETH value (--amt).
/// Used for WETH.deposit() and similar payable calls.
pub fn wallet_contract_call_with_value(
    chain_id: u64,
    to: &str,
    input_data: &str,
    from: Option<&str>,
    value_wei: u128,
    dry_run: bool,
) -> anyhow::Result<Value> {
    let mut args: Vec<String> = vec![
        "wallet".to_string(),
        "contract-call".to_string(),
        "--chain".to_string(),
        chain_id.to_string(),
        "--to".to_string(),
        to.to_string(),
        "--input-data".to_string(),
        input_data.to_string(),
        "--amt".to_string(),
        value_wei.to_string(),
    ];
    if let Some(addr) = from {
        args.push("--from".to_string());
        args.push(addr.to_string());
    }
    args.push("--biz-type".to_string());
    args.push("dapp".to_string());
    args.push("--strategy".to_string());
    args.push("sparklend-plugin".to_string());
    if dry_run {
        args.push("--dry-run".to_string());
        let cmd_str = format!("onchainos {}", args.join(" "));
        eprintln!("[dry-run] would execute: {}", cmd_str);
        return Ok(serde_json::json!({
            "ok": true,
            "dryRun": true,
            "simulatedCommand": cmd_str
        }));
    }
    args.push("--force".to_string());
    let mut cmd = base_cmd();
    cmd.args(&args);
    run_cmd(cmd)
}

/// Get the currently active EVM wallet address for the given chain.
pub fn wallet_address(chain_id: u64) -> anyhow::Result<String> {
    let mut cmd = base_cmd();
    cmd.args(["wallet", "addresses", "--chain", &chain_id.to_string()]);
    let result = run_cmd(cmd)?;
    result["data"]["evm"][0]["address"]
        .as_str()
        .map(|s| s.to_string())
        .ok_or_else(|| anyhow::anyhow!("Could not resolve wallet address from onchainos wallet addresses"))
}