Aave V3 Plugin

{
  "name": "aave-v3-plugin",
  "description": "Lend and borrow crypto assets on Aave V3 — the leading decentralized liquidity protocol. Trigger phrases: supply to aave, deposit to aave, borrow from aave, repay aave loan, aave health factor, my aave positions, aave interest rates, enable emode, disable collateral, claim aave rewards.",
  "version": "0.2.8"
}

target/

[package]
name = "aave-v3-plugin"
version = "0.2.8"
edition = "2021"

[[bin]]
name = "aave-v3-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) 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: aave-v3-plugin
version: "0.2.8"
description: "Lend and borrow crypto assets on Aave V3 — the leading decentralized liquidity protocol. Trigger phrases: supply to aave, deposit to aave, borrow from aave, repay aave loan, aave health factor, my aave positions, aave interest rates, enable emode, disable collateral, claim aave rewards."
author:
  name: skylavis-sky
  github: skylavis-sky
category: dapp
tags:
  - lending
  - borrowing
  - defi
  - earn
  - aave
  - collateral
  - health-factor
license: MIT

components:
  skill:
    dir: .

build:
  lang: rust
  binary_name: aave-v3-plugin

api_calls:
  - "https://ethereum.publicnode.com"
  - "https://polygon-bor-rpc.publicnode.com"
  - "https://arbitrum-one-rpc.publicnode.com"
  - "https://base-rpc.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 setUserEMode(uint8 categoryId) 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.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> {
    // For full repay, use U256::MAX
    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 Pool.setUserUseReserveAsCollateral() calldata.
pub fn encode_set_collateral(asset: &str, use_as_collateral: bool) -> anyhow::Result<String> {
    let call = setUserUseReserveAsCollateralCall {
        asset: parse_address(asset)?,
        useAsCollateral: use_as_collateral,
    };
    let encoded = call.abi_encode();
    Ok(format!("0x{}", hex::encode(encoded)))
}

/// Encode Pool.setUserEMode() calldata.
pub fn encode_set_emode(category_id: u8) -> anyhow::Result<String> {
    let call = setUserEModeCall {
        categoryId: category_id,
    };
    let encoded = call.abi_encode();
    Ok(format!("0x{}", hex::encode(encoded)))
}

/// 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 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::{get_chain_config, HF_WARN_THRESHOLD};
use crate::onchainos;
use crate::rpc;

/// Borrow assets from Aave V3 via Pool.borrow() ABI calldata.
///
/// 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 cfg = get_chain_config(chain_id)?;

    // Resolve caller address
    let from_addr = resolve_from(from, chain_id)?;

    // Resolve Pool address at runtime
    let pool_addr = rpc::get_pool(cfg.pool_addresses_provider, cfg.rpc_url)
        .await
        .context("Failed to resolve Pool address from PoolAddressesProvider")?;

    // Pre-flight: check account health
    let account_data = rpc::get_user_account_data(&pool_addr, &from_addr, cfg.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();

    // Warn if health factor is already below warning threshold
    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
        ));
    }

    // Check available borrow capacity
    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()
        ));
    }

    // Note: amount validation is best-effort here since we don't have the USD price
    // of the specific asset. The on-chain tx will revert if over capacity.

    // Resolve asset address and decimals via onchainos token search (handles USDC=6, WBTC=8, etc.)
    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")?;

    let result = onchainos::wallet_contract_call(
        chain_id,
        &pool_addr,
        &calldata,
        Some(&from_addr),
        dry_run,
    )
    .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,
        "asset": asset,
        "borrowAmount": amount,
        "borrowAmountMinimal": amount_minimal.to_string(),
        "poolAddress": pool_addr,
        "currentHealthFactor": hf_display,
        "healthFactorStatus": hf_status,
        "availableBorrowsUSD": format!("{:.2}", available_usd),
        "warnings": warnings,
        "dryRun": dry_run,
        "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 specified and could not resolve active wallet. \
         Run `onchainos wallet status` to check login status.",
    )
}

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

/// Claim accrued Aave V3 rewards via onchainos defi collect.
///
/// Flow:
/// 1. Fetch defi positions to get analysisPlatformId for Aave V3
/// 2. If no Aave V3 positions exist, return early with "no positions" message
/// 3. Call defi collect --platform-id <id> --chain <chain> --reward-type REWARD_PLATFORM
pub async fn run(
    chain_id: u64,
    from: Option<&str>,
    dry_run: bool,
) -> anyhow::Result<Value> {
    let wallet_addr = if let Some(addr) = from {
        addr.to_string()
    } else {
        crate::onchainos::wallet_address(chain_id).context(
            "No --from address specified and could not resolve active wallet.",
        )?
    };

    // Step 1: get positions to find analysisPlatformId
    let positions = crate::onchainos::defi_positions(chain_id, &wallet_addr)
        .context("Failed to fetch defi positions")?;

    let platform_id = find_aave_platform_id(&positions);
    let platform_id = match platform_id {
        Some(id) => id,
        None => {
            return Ok(json!({
                "ok": true,
                "message": "No active Aave V3 positions found on this chain. Supply assets first to earn rewards.",
                "chainId": chain_id
            }));
        }
    };

    if dry_run {
        let cmd = format!(
            "onchainos defi collect --platform-id {} --address {} --chain {} --reward-type REWARD_PLATFORM",
            platform_id,
            wallet_addr,
            crate::onchainos::chain_id_to_name_pub(chain_id)
        );
        eprintln!("[dry-run] would execute: {}", cmd);
        return Ok(json!({
            "ok": true,
            "dryRun": true,
            "platformId": platform_id,
            "simulatedCommand": cmd
        }));
    }

    let result = match crate::onchainos::defi_collect(platform_id, chain_id, &wallet_addr, "REWARD_PLATFORM") {
        Ok(res) => res,
        Err(e) => {
            let msg = e.to_string();
            if msg.contains("No reward tokens found") || msg.contains("no reward") {
                return Ok(json!({
                    "ok": true,
                    "message": "No claimable rewards found for this Aave V3 position.",
                    "platformId": platform_id,
                    "chainId": chain_id
                }));
            }
            return Err(e.context("onchainos defi collect 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,
        "platformId": platform_id,
        "chainId": chain_id,
        "raw": result
    }))
}

/// Extract the analysisPlatformId for Aave V3 from defi positions response.
fn find_aave_platform_id(positions: &Value) -> Option<u64> {
    let wallet_list = positions
        .get("data")
        .and_then(|d| d.get("walletIdPlatformList"))
        .and_then(|l| l.as_array())?;

    for wallet_entry in wallet_list {
        let platforms = wallet_entry
            .get("platformList")
            .and_then(|l| l.as_array())?;
        for platform in platforms {
            let name = platform
                .get("platformName")
                .and_then(|n| n.as_str())
                .unwrap_or("");
            if name.to_lowercase().contains("aave") {
                if let Some(id) = platform.get("analysisPlatformId").and_then(|v| v.as_u64()) {
                    return Some(id);
                }
            }
        }
    }
    None
}

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

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

/// Fetch and display the health factor and account summary for a user.
pub async fn run(chain_id: u64, from: Option<&str>) -> anyhow::Result<Value> {
    let cfg = get_chain_config(chain_id)?;

    // Resolve user address
    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(cfg.pool_addresses_provider, cfg.rpc_url)
        .await
        .context("Failed to resolve Pool address from PoolAddressesProvider")?;

    // Fetch account data
    let data = rpc::get_user_account_data(&pool_addr, &user_addr, cfg.rpc_url)
        .await
        .context("Failed to fetch user account data")?;

    // When a wallet has no Aave position, the contract returns uint256.max as the health factor.
    // Detect this sentinel and replace with a human-readable label instead of a huge number.
    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()
    };

    // Liquidation threshold as percentage
    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": cfg.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 claim_rewards;
pub mod health_factor;
pub mod positions;
pub mod quickstart;
pub mod repay;
pub mod reserves;
pub mod set_collateral;
pub mod set_emode;
pub mod supply;
pub mod withdraw;

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

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

/// View current Aave V3 positions.
///
/// Data sources:
/// - on-chain Pool.getUserAccountData: aggregate health factor, LTV, liquidation threshold
/// - onchainos defi position-detail (platform 10): per-asset SUPPLY / BORROW breakdown
pub async fn run(chain_id: u64, from: Option<&str>) -> anyhow::Result<Value> {
    let cfg = get_chain_config(chain_id)?;

    // Resolve user address
    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(cfg.pool_addresses_provider, cfg.rpc_url)
        .await
        .context("Failed to resolve Pool address")?;

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

    // Fetch per-asset SUPPLY / BORROW breakdown via onchainos
    let per_asset = fetch_per_asset_positions(chain_id, &user_addr);

    // When a wallet has no Aave position, the contract returns uint256.max as the health factor.
    // Detect this sentinel and replace with a human-readable label instead of a huge number.
    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()
    };

    // When there is no collateral, LTV and liquidation threshold are category defaults
    // returned by Aave even for empty positions — zero them out to avoid confusion.
    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),
        )
    };

    Ok(json!({
        "ok": true,
        "chain": cfg.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,
        "positions": per_asset
    }))
}

/// Parse onchainos defi position-detail response into clean SUPPLY/BORROW lists.
/// Returns null if no Aave positions found or onchainos call fails.
fn fetch_per_asset_positions(chain_id: u64, user_addr: &str) -> Value {
    let raw = match onchainos::defi_position_detail(chain_id, user_addr) {
        Ok(v) => v,
        Err(e) => {
            eprintln!("[positions] onchainos position-detail failed: {}", e);
            return json!(null);
        }
    };

    let chain_idx = chain_id.to_string();
    let empty = vec![];

    // Navigate: data[0].walletIdPlatformDetailList[0].networkHoldVoList
    let networks = raw["data"]
        .as_array()
        .and_then(|a| a.first())
        .and_then(|p| p["walletIdPlatformDetailList"].as_array())
        .and_then(|a| a.first())
        .and_then(|w| w["networkHoldVoList"].as_array())
        .unwrap_or(&empty);

    // Find the network entry matching this chain
    let network = networks.iter().find(|n| {
        n["chainIndex"].as_str() == Some(&chain_idx)
    });

    let Some(network) = network else {
        return json!({"supply": [], "borrow": []});
    };

    let markets = network["investMarketTokenBalanceVoList"]
        .as_array()
        .unwrap_or(&empty);

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

    for market in markets {
        let asset_map = &market["assetMap"];

        if let Some(supply_list) = asset_map["SUPPLY"].as_array() {
            for item in supply_list {
                let token = item["assetsTokenList"].as_array()
                    .and_then(|a| a.first())
                    .cloned()
                    .unwrap_or(json!({}));
                supply.push(json!({
                    "asset": item["investmentName"].as_str().unwrap_or("?"),
                    "tokenAddress": token["tokenAddress"].as_str().unwrap_or("?"),
                    "amount": token["coinAmount"].as_str().unwrap_or("0"),
                    "valueUSD": item["totalValue"].as_str().unwrap_or("0"),
                    "marketId": item["marketId"].as_str().unwrap_or("?")
                }));
            }
        }

        if let Some(borrow_list) = asset_map["BORROW"].as_array() {
            for item in borrow_list {
                let token = item["assetsTokenList"].as_array()
                    .and_then(|a| a.first())
                    .cloned()
                    .unwrap_or(json!({}));
                // totalValue is negative for borrows; strip the sign for amount display
                let value_str = item["totalValue"].as_str().unwrap_or("0");
                let value_abs = value_str.trim_start_matches('-');
                borrow.push(json!({
                    "asset": item["investmentName"].as_str().unwrap_or("?"),
                    "tokenAddress": token["tokenAddress"].as_str().unwrap_or("?"),
                    "amount": token["coinAmount"].as_str().unwrap_or("0"),
                    "valueUSD": value_abs,
                    "marketId": item["marketId"].as_str().unwrap_or("?")
                }));
            }
        }
    }

    json!({"supply": supply, "borrow": borrow})
}

use serde_json::{json, Value};

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

const ABOUT: &str = "Aave V3 is a leading decentralized liquidity protocol — supply assets to \
    earn yield, borrow against collateral with variable rates, and manage positions \
    across Ethereum, Base, Arbitrum, and Polygon. $20B+ TVL.";

// Canonical USDC addresses per chain
const USDC_ETHEREUM: &str = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
const USDC_BASE: &str = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const USDC_ARBITRUM: &str = "0xaf88d065e77c8cC2239327C5EDb3A432268e5831";
const USDC_POLYGON: &str = "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359";

// Minimum native token needed for approve + supply tx
const MIN_GAS_ETHEREUM_WEI: u128 = 3_000_000_000_000_000; // 0.003 ETH
const MIN_GAS_L2_WEI: u128 = 100_000_000_000_000;          // 0.0001 ETH (L2 cheap)

// Minimum meaningful token balances to be considered "funded"
const MIN_USDC_RAW: u128 = 1_000_000;           // 1 USDC (6 decimals)
const MIN_WETH_RAW: u128 = 500_000_000_000_000;  // 0.0005 WETH (18 decimals)

pub async fn run(chain_id: u64, from: Option<&str>) -> anyhow::Result<Value> {
    let cfg = get_chain_config(chain_id)?;

    let wallet = if let Some(addr) = from {
        addr.to_string()
    } else {
        onchainos::wallet_address(chain_id)
            .map_err(|e| anyhow::anyhow!("Cannot resolve wallet: {e}"))?
    };

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

    let usdc_addr = match chain_id {
        1     => USDC_ETHEREUM,
        8453  => USDC_BASE,
        42161 => USDC_ARBITRUM,
        137   => USDC_POLYGON,
        _     => USDC_ETHEREUM,
    };
    let weth_addr = cfg.weth_address;
    let min_gas_wei = if chain_id == 1 { MIN_GAS_ETHEREUM_WEI } else { MIN_GAS_L2_WEI };

    // Resolve Pool address (needed for on-chain account data query)
    let pool_addr = rpc::get_pool(cfg.pool_addresses_provider, cfg.rpc_url)
        .await
        .unwrap_or_default();

    // Fetch wallet balances and Aave position data in parallel
    let (eth_res, usdc_res, weth_res, account_res) = tokio::join!(
        rpc::get_eth_balance(&wallet, cfg.rpc_url),
        rpc::get_erc20_balance(usdc_addr, &wallet, cfg.rpc_url),
        rpc::get_erc20_balance(weth_addr, &wallet, cfg.rpc_url),
        async {
            if pool_addr.is_empty() {
                return Err(anyhow::anyhow!("pool address unavailable"));
            }
            rpc::get_user_account_data(&pool_addr, &wallet, cfg.rpc_url).await
        },
    );

    let eth_wei   = eth_res.unwrap_or(0);
    let usdc_raw  = usdc_res.unwrap_or(0);
    let weth_raw  = weth_res.unwrap_or(0);

    let eth_balance  = eth_wei  as f64 / 1e18;
    let usdc_balance = usdc_raw as f64 / 1_000_000.0;
    let weth_balance = weth_raw as f64 / 1e18;

    // Has active Aave positions if collateral or debt is non-zero
    let has_positions = account_res.as_ref()
        .map(|a| a.total_collateral_base > 0 || a.total_debt_base > 0)
        .unwrap_or(false);

    let has_tokens = usdc_raw >= MIN_USDC_RAW || weth_raw >= MIN_WETH_RAW;
    let has_gas    = eth_wei  >= min_gas_wei;

    let chain_flag = if chain_id != 8453 {
        format!("--chain {} ", chain_id)
    } else {
        String::new()
    };
    let from_flag = format!("--from {}", &wallet);

    let (status, suggestion, onboarding_steps, next_command): (&str, &str, Vec<String>, String) =
        if has_positions {
            (
                "active",
                "You have open Aave V3 positions. Review your health factor and manage them.",
                vec![],
                format!("aave-v3-plugin {}positions {}", chain_flag, from_flag),
            )
        } else if has_gas && has_tokens {
            let (asset, example_amount) = if usdc_balance >= 1.0 {
                ("USDC", format!("{:.2}", (usdc_balance * 0.9).max(1.0).min(usdc_balance)))
            } else {
                ("WETH", format!("{:.4}", (weth_balance * 0.9).max(0.0005).min(weth_balance)))
            };
            (
                "ready",
                "Your wallet is funded. Supply assets to Aave V3 to start earning yield.",
                vec![
                    "1. Check current reserve rates:".to_string(),
                    format!("   aave-v3-plugin {}reserves", chain_flag),
                    "2. Supply assets to earn interest:".to_string(),
                    format!(
                        "   aave-v3-plugin {}--confirm supply --asset {} --amount {} {}",
                        chain_flag, asset, example_amount, from_flag
                    ),
                    "3. View your positions after supplying:".to_string(),
                    format!("   aave-v3-plugin {}positions {}", chain_flag, from_flag),
                ],
                format!("aave-v3-plugin {}reserves", chain_flag),
            )
        } else if has_tokens && !has_gas {
            (
                "needs_gas",
                "You have tokens but need ETH for gas fees. Send ETH to your wallet.",
                vec![
                    format!("1. Send at least {:.4} ETH (gas) to:", min_gas_wei as f64 / 1e18),
                    format!("   {}", wallet),
                    "2. Run quickstart again to confirm:".to_string(),
                    format!("   aave-v3-plugin {}quickstart {}", chain_flag, from_flag),
                ],
                format!("aave-v3-plugin {}quickstart {}", chain_flag, from_flag),
            )
        } else if has_gas && !has_tokens {
            (
                "needs_funds",
                "You have ETH for gas but no USDC or WETH to supply. Transfer tokens to your wallet.",
                vec![
                    "1. Send USDC or WETH to your wallet:".to_string(),
                    format!("   {}", wallet),
                    "2. Run quickstart again after funding:".to_string(),
                    format!("   aave-v3-plugin {}quickstart {}", chain_flag, from_flag),
                    "3. Browse available reserves:".to_string(),
                    format!("   aave-v3-plugin {}reserves", chain_flag),
                ],
                format!("aave-v3-plugin {}reserves", chain_flag),
            )
        } else {
            (
                "no_funds",
                "No ETH or tokens found. Send ETH (for gas) and USDC/WETH to get started.",
                vec![
                    "1. Send ETH (for gas) and USDC or WETH to your wallet:".to_string(),
                    format!("   {}", wallet),
                    format!("   Minimum gas: {:.4} ETH", min_gas_wei as f64 / 1e18),
                    "2. Run quickstart again:".to_string(),
                    format!("   aave-v3-plugin {}quickstart {}", chain_flag, from_flag),
                    "3. Browse available reserves and rates:".to_string(),
                    format!("   aave-v3-plugin {}reserves", chain_flag),
                ],
                format!("aave-v3-plugin {}quickstart {}", chain_flag, from_flag),
            )
        };

    let mut out = json!({
        "ok": true,
        "about": ABOUT,
        "wallet": wallet,
        "chain": cfg.name,
        "chainId": chain_id,
        "assets": {
            "eth_balance": format!("{:.6}", eth_balance),
            "usdc_balance": format!("{:.2}", usdc_balance),
            "weth_balance": format!("{:.6}", weth_balance),
        },
        "status": status,
        "suggestion": suggestion,
        "next_command": next_command,
    });

    if !onboarding_steps.is_empty() {
        out["onboarding_steps"] = json!(onboarding_steps);
    }

    // Include Aave position summary if user has active positions
    if let Ok(account_data) = &account_res {
        if account_data.total_collateral_base > 0 || account_data.total_debt_base > 0 {
            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()
            };
            out["positions"] = json!({
                "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()),
            });
        }
    }

    Ok(out)
}

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

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

/// Repay borrowed assets on Aave V3 via Pool.repay() ABI calldata.
///
/// 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. Encode repay calldata and submit
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");
    }

    let cfg = get_chain_config(chain_id)?;

    // Resolve caller address
    let from_addr = resolve_from(from, chain_id)?;

    // Resolve Pool address at runtime
    let pool_addr = rpc::get_pool(cfg.pool_addresses_provider, cfg.rpc_url)
        .await
        .context("Failed to resolve Pool address")?;

    // Resolve token contract address and decimals (handles both symbol and 0x address)
    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, cfg.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
    };

    // Compute repay amount in minimal units.
    // For --all: use u128::MAX, which encode_repay maps to type(uint256).max.
    // Aave interprets uint256.max as "repay full debt including all accrued interest",
    // pulling the exact outstanding amount from the wallet — no dust risk.
    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())
    };

    // Pre-flight: check wallet ERC-20 balance can cover the repay amount.
    // Skip in dry-run (no real submission), and for --all (Aave only pulls the actual
    // outstanding debt, which we cannot precisely price-check off-chain — let the on-chain
    // call surface insufficient-balance reverts in that edge case).
    if !dry_run && !all {
        let token_balance = rpc::get_erc20_balance(&token_addr, &from_addr, cfg.rpc_url)
            .await
            .context("Failed to fetch token balance")?;
        if token_balance < amount_minimal {
            anyhow::bail!(
                "Insufficient {} balance: need {:.6}, have {:.6}. Add funds to your wallet before repaying.",
                asset,
                amount_minimal as f64 / 10f64.powi(decimals as i32),
                token_balance as f64 / 10f64.powi(decimals as i32),
            );
        }
    }

    // Step 4: Check ERC-20 allowance for token → pool.
    // For --all (amount_minimal == u128::MAX), always approve with u128::MAX (unlimited)
    // so Aave can pull the full debt amount including last-second interest.
    let needs_approval = if all {
        true
    } else {
        let allowance = rpc::get_allowance(&token_addr, &from_addr, &pool_addr, cfg.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")?;
        // Wait for approve tx to be mined before submitting repay.
        // Bail early if approve was not broadcast — proceeding with a "pending" hash
        // would submit repay before allowance is on-chain, causing STF revert.
        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(cfg.rpc_url, approve_tx)
                .await
                .context("Approve tx did not confirm in time")?;
        }
        approval_result = Some(approve_res);
    }

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

    let result = onchainos::wallet_contract_call(
        chain_id,
        &pool_addr,
        &calldata,
        Some(&from_addr),
        dry_run,
    )
    .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");

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

    Ok(json!({
        "ok": true,
        "txHash": tx_hash,
        "asset": asset,
        "repayAmount": amount_display,
        "repayAmountDisplay": amount_display_fmt,
        "poolAddress": pool_addr,
        "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(),
        "approvalResult": approval_result,
        "dryRun": dry_run,
        "warning": zero_debt_warning,
        "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 specified and could not resolve active wallet.",
    )
}

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

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

/// List Aave V3 reserve data.
///
/// 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)  ← USE THIS
///   Slot 3: variableBorrowIndex (ray)
///   Slot 4: currentVariableBorrowRate  ← variable borrow APY (ray = 1e27)  ← USE THIS
///   Slot 5: currentStableBorrowRate (deprecated)
///   Slot 6: lastUpdateTimestamp + id (packed)
///   Slot 7: id (uint16)
///   Slot 8: liquidationGracePeriodUntil + aTokenAddress (packed)
///   ...
///
/// Note: This calls Pool.getReserveData (not AaveProtocolDataProvider.getReserveData),
/// which uses the same 0x35ea6a75 selector but returns different slot indices for rates.
/// Pool.getReserveData is used directly since the DataProvider address resolution was
/// unreliable across chain deployments.
pub async fn run(
    chain_id: u64,
    asset_filter: Option<&str>,
) -> anyhow::Result<Value> {
    let cfg = get_chain_config(chain_id)?;

    // Resolve Pool address at runtime
    let pool_addr = rpc::get_pool(cfg.pool_addresses_provider, cfg.rpc_url)
        .await
        .context("Failed to resolve Pool address")?;

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

    // Decode the dynamic address array returned by getReservesList()
    let reserve_addresses = decode_address_array(&reserves_list_hex)?;

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

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

    for addr in &reserve_addresses {
        // Fetch symbol first so we can filter by it
        let raw_symbol = rpc::get_erc20_symbol(addr, cfg.rpc_url).await.unwrap_or_default();
        // Arbitrum has two USDC tokens: native USDC and bridged USDC.e (0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8).
        // Both return "USDC" from the contract, so we disambiguate by address.
        let symbol = if chain_id == 42161
            && addr.eq_ignore_ascii_case("0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8")
        {
            "USDC.e".to_string()
        } else {
            raw_symbol
        };

        // 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;
            }
        }

        // Call Pool.getReserveData(address asset) — selector 0x35ea6a75
        match get_reserve_data_from_pool(&pool_addr, addr, &symbol, cfg.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": cfg.name,
        "chainId": chain_id,
        "reserveCount": reserves.len(),
        "reserves": reserves
    }))
}

/// Fetch reserve data from Pool.getReserveData(address) — selector 0x35ea6a75.
/// Returns DataTypes.ReserveData packed struct where:
///   Slot 2: currentLiquidityRate  (supply APY, ray = 1e27)
///   Slot 4: currentVariableBorrowRate  (variable borrow APY, ray = 1e27)
async fn get_reserve_data_from_pool(
    pool_addr: &str,
    asset_addr: &str,
    symbol: &str,
    rpc_url: &str,
) -> anyhow::Result<Value> {
    // getReserveData(address asset) → selector 0x35ea6a75
    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");

    // Pool.getReserveData returns DataTypes.ReserveData (at least 15 x 32-byte slots)
    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)
    }))
}

/// Decode a ray value (1e27) at slot index into an APY percentage.
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];
    // Ray has 27 decimals. We take lower 32 hex (16 bytes) to avoid overflow.
    // For rates, the value fits in u128.
    let low = &slot_hex[32..64];
    let val = u128::from_str_radix(low, 16).unwrap_or(0);
    // Rate / 1e27 * 100 for percentage
    let pct = val as f64 / 1e27 * 100.0;
    Ok(pct)
}

#[allow(dead_code)]
fn decode_u128_at(raw: &str, slot: usize) -> anyhow::Result<u128> {
    let start = slot * 64;
    let end = start + 64;
    if raw.len() < end {
        return Ok(0);
    }
    let low = &raw[start + 32..end];
    Ok(u128::from_str_radix(low, 16).unwrap_or(0))
}

/// 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![]);
    }
    // Slot 0: offset to array data (should be 0x20)
    // Slot 1: array length
    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; // after offset + length words
    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::{get_chain_config, HF_WARN_THRESHOLD};
use crate::onchainos;
use crate::rpc;

/// Enable or disable an asset as collateral via Pool.setUserUseReserveAsCollateral().
///
/// Flow:
/// 1. Resolve Pool address at runtime
/// 2. Check current health factor — warn if disabling collateral would risk liquidation
/// 3. Encode calldata and submit
pub async fn run(
    chain_id: u64,
    asset: &str,
    enable: bool,
    from: Option<&str>,
    dry_run: bool,
) -> anyhow::Result<Value> {
    let cfg = get_chain_config(chain_id)?;

    let from_addr = resolve_from(from, chain_id)?;

    // Resolve Pool address at runtime
    let pool_addr = rpc::get_pool(cfg.pool_addresses_provider, cfg.rpc_url)
        .await
        .context("Failed to resolve Pool address")?;

    // Pre-flight: check health factor
    let account_data = rpc::get_user_account_data(&pool_addr, &from_addr, cfg.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 = account_data.health_factor_f64();
    let mut warnings: Vec<String> = vec![];

    if !enable && hf < HF_WARN_THRESHOLD && account_data.total_debt_base > 0 {
        warnings.push(format!(
            "WARNING: Disabling collateral when health factor is {:.2} (below {}) may trigger liquidation. Proceed with caution.",
            hf, HF_WARN_THRESHOLD
        ));
    }

    // Resolve asset address (handles both symbol and address inputs)
    let (asset_addr, _decimals) = onchainos::resolve_token(asset, chain_id)
        .with_context(|| format!("Could not resolve token address for '{}'", asset))?;

    // Encode calldata
    let calldata = calldata::encode_set_collateral(&asset_addr, enable)
        .context("Failed to encode setUserUseReserveAsCollateral calldata")?;

    let result = onchainos::wallet_contract_call(
        chain_id,
        &pool_addr,
        &calldata,
        Some(&from_addr),
        dry_run,
    )
    .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,
        "asset": asset,
        "useAsCollateral": enable,
        "poolAddress": pool_addr,
        "healthFactorBefore": hf_display,
        "warnings": warnings,
        "dryRun": dry_run,
        "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.")
}

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

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

/// Set E-Mode category via Pool.setUserEMode().
///
/// E-Mode categories:
///   0 = No E-Mode (default)
///   1 = Stablecoins (higher LTV for correlated stablecoin assets)
///   2 = ETH-correlated assets (chain-specific)
///
/// Flow:
/// 1. Resolve Pool address at runtime
/// 2. Encode setUserEMode calldata
/// 3. Submit via onchainos wallet contract-call
pub async fn run(
    chain_id: u64,
    category: u8,
    from: Option<&str>,
    dry_run: bool,
) -> anyhow::Result<Value> {
    let cfg = get_chain_config(chain_id)?;

    let from_addr = resolve_from(from, chain_id)?;

    // Resolve Pool address at runtime
    let pool_addr = rpc::get_pool(cfg.pool_addresses_provider, cfg.rpc_url)
        .await
        .context("Failed to resolve Pool address")?;

    // Encode calldata
    let calldata = calldata::encode_set_emode(category)
        .context("Failed to encode setUserEMode calldata")?;

    let result = onchainos::wallet_contract_call(
        chain_id,
        &pool_addr,
        &calldata,
        Some(&from_addr),
        dry_run,
    )
    .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");

    let category_name = match category {
        0 => "No E-Mode",
        1 => "Stablecoins",
        2 => "ETH-correlated",
        _ => "Unknown",
    };

    Ok(json!({
        "ok": true,
        "txHash": tx_hash,
        "categoryId": category,
        "categoryName": category_name,
        "poolAddress": pool_addr,
        "dryRun": dry_run,
        "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.")
}