Compound V3 Plugin

{
  "name": "compound-v3-plugin",
  "description": "Compound V3 (Comet) lending plugin: supply collateral, borrow/repay the base asset, and claim COMP rewards",
  "version": "0.2.8",
  "author": {
    "name": "skylavis-sky",
    "github": "skylavis-sky"
  },
  "homepage": "https://github.com/skylavis-sky/onchainos-plugins/tree/main/compound-v3",
  "repository": "https://github.com/skylavis-sky/onchainos-plugins",
  "license": "MIT",
  "keywords": [
    "lending",
    "borrowing",
    "defi",
    "compound",
    "comet"
  ]
}

/target/

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

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

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

MIT License

Copyright (c) 2024 skylavis-sky

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

schema_version: 1
name: compound-v3-plugin
version: "0.2.8"
description: "Compound V3 (Comet) lending plugin: supply collateral, borrow/repay the base asset, and claim COMP rewards"
author:
  name: skylavis-sky
  github: skylavis-sky
category: dapp
tags:
  - lending
  - borrowing
  - defi
  - compound
  - comet
license: MIT

components:
  skill:
    dir: .

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

api_calls:
  - "https://ethereum.publicnode.com"
  - "https://base-rpc.publicnode.com"
  - "https://arbitrum-one-rpc.publicnode.com"
  - "https://polygon-bor-rpc.publicnode.com"
  - "https://plugin-store-dun.vercel.app/install"
  - "https://www.okx.com/priapi/v1/wallet/plugins/download/report"

use crate::config::get_market_config;
use crate::onchainos;
use crate::rpc;
use anyhow::Result;

pub async fn run(
    chain_id: u64,
    market: &str,
    amount_str: &str,  // human-readable amount (e.g. "0.1" for 0.1 USDC)
    from: Option<String>,
    dry_run: bool,
    confirm: bool,
) -> Result<()> {
    let cfg = get_market_config(chain_id, market)?;
    let amount = rpc::parse_human_amount(amount_str, cfg.base_asset_decimals)?;

    // Resolve wallet address — must not default to zero address
    let wallet = from
        .clone()
        .unwrap_or_else(|| onchainos::resolve_wallet(chain_id).unwrap_or_default());
    if wallet.is_empty() {
        anyhow::bail!("Cannot resolve wallet address. Pass --from or log in via onchainos.");
    }

    // Pre-flight: simulate borrow to catch NotCollateralized() and other reverts
    // before spending gas. isBorrowCollateralized() is a false positive for new
    // accounts (principal=0 → returns true even with zero collateral), so we
    // simulate the actual calldata instead.
    rpc::simulate_borrow(
        cfg.comet_proxy,
        cfg.base_asset,
        amount,
        &wallet,
        cfg.rpc_url,
        cfg.base_asset_decimals,
        cfg.base_asset_symbol,
    ).await?;

    // Fetch baseBorrowMin for preview — gives agents/users the minimum position size upfront
    let min_borrow_raw = rpc::get_base_borrow_min(cfg.comet_proxy, cfg.rpc_url).await.unwrap_or(0);

    // Build withdraw(address,uint256) calldata (borrow = withdraw base asset)
    // selector: 0xf3fef3a3
    let base_padded = rpc::pad_address(cfg.base_asset);
    let amount_hex = rpc::pad_u128(amount);
    let borrow_calldata = format!("0xf3fef3a3{}{}", base_padded, amount_hex);

    let decimals_factor = 10u128.pow(cfg.base_asset_decimals as u32) as f64;

    // Confirm gate: show preview and exit if --confirm not given (and not dry-run)
    if !dry_run && !confirm {
        let result = serde_json::json!({
            "ok": true,
            "preview": true,
            "operation": "borrow",
            "chain_id": chain_id,
            "market": market,
            "base_asset": cfg.base_asset_symbol,
            "amount": amount_str,
            "amount_raw": amount.to_string(),
            "amount_human": format!("{:.6}", amount as f64 / decimals_factor),
            "min_borrow_amount": format!("{:.6}", min_borrow_raw as f64 / decimals_factor),
            "min_borrow_amount_raw": min_borrow_raw.to_string(),
            "comet": cfg.comet_proxy,
            "pending_transactions": 1,
            "transactions": [
                {"step": 1, "action": "Comet.withdraw (borrow base asset)", "comet": cfg.comet_proxy, "base_asset": cfg.base_asset, "amount_raw": amount.to_string(), "calldata": borrow_calldata}
            ],
            "note": "Re-run with --confirm to execute this transaction on-chain."
        });
        println!("{}", serde_json::to_string_pretty(&result)?);
        return Ok(());
    }

    if dry_run {
        let result = serde_json::json!({
            "ok": true,
            "dry_run": true,
            "note": "Borrow uses Comet.withdraw(base_asset, amount). No ERC-20 approve needed.",
            "min_borrow_amount": format!("{:.6}", min_borrow_raw as f64 / decimals_factor),
            "min_borrow_amount_raw": min_borrow_raw.to_string(),
            "steps": [
                {
                    "step": 1,
                    "action": "Comet.withdraw (borrow base asset)",
                    "comet": cfg.comet_proxy,
                    "base_asset": cfg.base_asset,
                    "amount": format!("{:.6}", amount as f64 / decimals_factor),
                    "amount_raw": amount.to_string(),
                    "calldata": borrow_calldata
                }
            ]
        });
        println!("{}", serde_json::to_string_pretty(&result)?);
        return Ok(());
    }

    // Execute Comet.withdraw (which initiates borrow when supply < amount)
    let borrow_result = onchainos::wallet_contract_call(
        chain_id,
        cfg.comet_proxy,
        &borrow_calldata,
        Some(&wallet),
        None,
        false,
    )
    .await?;
    let borrow_tx = onchainos::extract_tx_hash_or_err(&borrow_result)?;

    // Wait for borrow tx to confirm before reading post-tx balance
    onchainos::wait_for_tx(&borrow_tx, cfg.rpc_url).await;

    let new_borrow = rpc::get_borrow_balance_of(cfg.comet_proxy, &wallet, cfg.rpc_url)
        .await
        .unwrap_or(0);

    let result = serde_json::json!({
        "ok": true,
        "data": {
            "chain_id": chain_id,
            "market": market,
            "base_asset": cfg.base_asset_symbol,
            "amount_raw": amount.to_string(),
            "amount": format!("{:.6}", amount as f64 / decimals_factor),
            "wallet": wallet,
            "borrow_tx_hash": borrow_tx,
            "new_borrow_balance": format!("{:.6}", new_borrow as f64 / decimals_factor),
            "new_borrow_balance_raw": new_borrow.to_string()
        }
    });

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

use crate::config::get_market_config;
use crate::onchainos;
use crate::rpc;
use anyhow::Result;

pub async fn run(
    chain_id: u64,
    market: &str,
    from: Option<String>,
    dry_run: bool,
    confirm: bool,
) -> Result<()> {
    let cfg = get_market_config(chain_id, market)?;

    // Resolve wallet address — must not default to zero address
    let wallet = from
        .clone()
        .unwrap_or_else(|| onchainos::resolve_wallet(chain_id).unwrap_or_default());
    if wallet.is_empty() {
        anyhow::bail!("Cannot resolve wallet address. Pass --from or log in via onchainos.");
    }

    // Pre-flight: check rewards owed
    let reward_owed = rpc::get_reward_owed(
        cfg.rewards_contract,
        cfg.comet_proxy,
        &wallet,
        cfg.rpc_url,
    )
    .await?;

    if reward_owed == 0 {
        let result = serde_json::json!({
            "ok": true,
            "data": {
                "message": "No claimable COMP rewards at this time.",
                "reward_owed_raw": "0"
            }
        });
        println!("{}", serde_json::to_string_pretty(&result)?);
        return Ok(());
    }

    // Build CometRewards.claimTo(address comet, address src, address to, bool shouldAccrue)
    // selector: 0x4ff85d94
    let comet_padded = rpc::pad_address(cfg.comet_proxy);
    let wallet_padded = rpc::pad_address(&wallet);
    let bool_true = "0000000000000000000000000000000000000000000000000000000000000001";
    let claim_calldata = format!(
        "0x4ff85d94{}{}{}{}",
        comet_padded, wallet_padded, wallet_padded, bool_true
    );

    // Confirm gate: show preview and exit if --confirm not given (and not dry-run)
    if !dry_run && !confirm {
        let result = serde_json::json!({
            "ok": true,
            "preview": true,
            "operation": "claim-rewards",
            "chain_id": chain_id,
            "market": market,
            "wallet": wallet,
            "reward_owed_raw": reward_owed.to_string(),
            "rewards_contract": cfg.rewards_contract,
            "comet": cfg.comet_proxy,
            "pending_transactions": 1,
            "transactions": [
                {"step": 1, "action": "CometRewards.claimTo", "rewards_contract": cfg.rewards_contract, "comet": cfg.comet_proxy, "src": wallet.clone(), "to": wallet.clone(), "calldata": claim_calldata}
            ],
            "note": "Re-run with --confirm to execute this transaction on-chain."
        });
        println!("{}", serde_json::to_string_pretty(&result)?);
        return Ok(());
    }

    if dry_run {
        let result = serde_json::json!({
            "ok": true,
            "dry_run": true,
            "reward_owed_raw": reward_owed.to_string(),
            "steps": [
                {
                    "step": 1,
                    "action": "CometRewards.claimTo",
                    "rewards_contract": cfg.rewards_contract,
                    "comet": cfg.comet_proxy,
                    "src": wallet,
                    "to": wallet,
                    "should_accrue": true,
                    "calldata": claim_calldata
                }
            ]
        });
        println!("{}", serde_json::to_string_pretty(&result)?);
        return Ok(());
    }

    // Execute CometRewards.claimTo
    let claim_result = onchainos::wallet_contract_call(
        chain_id,
        cfg.rewards_contract,
        &claim_calldata,
        Some(&wallet),
        None,
        false,
    )
    .await?;
    let claim_tx = onchainos::extract_tx_hash_or_err(&claim_result)?;

    let result = serde_json::json!({
        "ok": true,
        "data": {
            "chain_id": chain_id,
            "market": market,
            "wallet": wallet,
            "reward_owed_raw": reward_owed.to_string(),
            "claim_tx_hash": claim_tx,
            "message": "COMP rewards claimed successfully."
        }
    });

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

use crate::config::get_market_config;
use crate::rpc;
use anyhow::Result;

pub async fn run(chain_id: u64, market: &str) -> Result<()> {
    let cfg = get_market_config(chain_id, market)?;

    let utilization = rpc::get_utilization(cfg.comet_proxy, cfg.rpc_url).await?;
    let supply_rate = rpc::get_supply_rate(cfg.comet_proxy, utilization, cfg.rpc_url).await?;
    let borrow_rate = rpc::get_borrow_rate(cfg.comet_proxy, utilization, cfg.rpc_url).await?;
    let total_supply = rpc::get_total_supply(cfg.comet_proxy, cfg.rpc_url).await?;
    let total_borrow = rpc::get_total_borrow(cfg.comet_proxy, cfg.rpc_url).await?;

    let supply_apr = rpc::rate_to_apr_pct(supply_rate);
    let borrow_apr = rpc::rate_to_apr_pct(borrow_rate);
    let util_pct = (utilization as f64 / 1e18) * 100.0;
    let decimals_factor = 10u128.pow(cfg.base_asset_decimals as u32) as f64;

    let result = serde_json::json!({
        "ok": true,
        "data": {
            "chain_id": chain_id,
            "market": market,
            "base_asset": cfg.base_asset_symbol,
            "comet_proxy": cfg.comet_proxy,
            "utilization_pct": format!("{:.2}", util_pct),
            "supply_apr_pct": format!("{:.4}", supply_apr),
            "borrow_apr_pct": format!("{:.4}", borrow_apr),
            "total_supply": format!("{:.2}", total_supply as f64 / decimals_factor),
            "total_borrow": format!("{:.2}", total_borrow as f64 / decimals_factor),
            "total_supply_raw": total_supply.to_string(),
            "total_borrow_raw": total_borrow.to_string()
        }
    });

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

use crate::config::get_market_config;
use crate::onchainos;
use crate::rpc;
use anyhow::Result;

pub async fn run(chain_id: u64, market: &str, wallet: Option<String>, collateral_asset: Option<String>) -> Result<()> {
    let cfg = get_market_config(chain_id, market)?;

    let wallet_addr = match wallet {
        Some(w) => w,
        None => {
            let w = onchainos::resolve_wallet(chain_id)?;
            if w.is_empty() {
                anyhow::bail!("Cannot resolve wallet address. Pass --wallet or log in via onchainos.");
            }
            w
        }
    };

    let supply_balance = rpc::get_balance_of(cfg.comet_proxy, &wallet_addr, cfg.rpc_url).await?;
    let borrow_balance = rpc::get_borrow_balance_of(cfg.comet_proxy, &wallet_addr, cfg.rpc_url).await?;
    let is_collateralized = rpc::is_borrow_collateralized(cfg.comet_proxy, &wallet_addr, cfg.rpc_url).await?;

    let decimals_factor = 10u128.pow(cfg.base_asset_decimals as u32) as f64;

    let mut collateral_info = serde_json::json!(null);
    if let Some(asset) = &collateral_asset {
        let col_bal = rpc::get_collateral_balance_of(cfg.comet_proxy, &wallet_addr, asset, cfg.rpc_url).await?;
        let col_decimals = rpc::get_erc20_decimals(asset, cfg.rpc_url).await.unwrap_or(18);
        let col_factor = 10u128.pow(col_decimals as u32) as f64;
        collateral_info = serde_json::json!({
            "asset": asset,
            "balance": format!("{:.decimals$}", col_bal as f64 / col_factor, decimals = col_decimals as usize),
            "balance_raw": col_bal.to_string(),
        });
    }

    let result = serde_json::json!({
        "ok": true,
        "data": {
            "chain_id": chain_id,
            "market": market,
            "base_asset": cfg.base_asset_symbol,
            "wallet": wallet_addr,
            "supply_balance": format!("{:.6}", supply_balance as f64 / decimals_factor),
            "supply_balance_raw": supply_balance.to_string(),
            "borrow_balance": format!("{:.6}", borrow_balance as f64 / decimals_factor),
            "borrow_balance_raw": borrow_balance.to_string(),
            "is_borrow_collateralized": is_collateralized,
            "collateral": collateral_info
        }
    });

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

pub mod get_markets;
pub mod get_position;
pub mod supply;
pub mod borrow;
pub mod repay;
pub mod withdraw;
pub mod claim_rewards;
pub mod quickstart;

use crate::config::get_market_config;
use crate::onchainos;
use crate::rpc;
use anyhow::Result;

const ABOUT: &str = "Compound V3 (Comet) is an on-chain lending protocol. Each market has one base asset you can supply to earn interest or borrow against collateral. Supported chains: Ethereum (1), Base (8453), Arbitrum (42161), Polygon (137).";

pub async fn run(chain_id: u64, market: &str, wallet: Option<String>) -> Result<()> {
    let cfg = get_market_config(chain_id, market)?;

    let wallet_addr = match wallet {
        Some(w) => w,
        None => {
            let w = onchainos::resolve_wallet(chain_id)?;
            if w.is_empty() {
                anyhow::bail!("Cannot resolve wallet address. Pass --wallet or log in via onchainos.");
            }
            w
        }
    };

    // Parallel fetch: Comet supply + borrow balance. Tolerate RPC errors silently —
    // this command is a status probe, not a trading command.
    let (supply_res, borrow_res) = tokio::join!(
        rpc::get_balance_of(cfg.comet_proxy, &wallet_addr, cfg.rpc_url),
        rpc::get_borrow_balance_of(cfg.comet_proxy, &wallet_addr, cfg.rpc_url),
    );

    let supply_raw = supply_res.unwrap_or(0);
    let borrow_raw = borrow_res.unwrap_or(0);

    let factor = 10u128.pow(cfg.base_asset_decimals as u32) as f64;
    let supply_balance = supply_raw as f64 / factor;
    let borrow_balance = borrow_raw as f64 / factor;

    let (status, suggestion, next_command) =
        build_suggestion(chain_id, market, cfg.base_asset_symbol, supply_balance, borrow_balance);

    let out = serde_json::json!({
        "ok": true,
        "about": ABOUT,
        "wallet": wallet_addr,
        "chain_id": chain_id,
        "market": market,
        "base_asset": cfg.base_asset_symbol,
        "assets": {
            "comet_supply_balance":     format!("{:.6}", supply_balance),
            "comet_supply_balance_raw": supply_raw.to_string(),
            "comet_borrow_balance":     format!("{:.6}", borrow_balance),
            "comet_borrow_balance_raw": borrow_raw.to_string(),
        },
        "status":       status,
        "suggestion":   suggestion,
        "next_command": next_command,
    });

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

/// Returns (status, human-readable suggestion, ready-to-run command).
fn build_suggestion(
    chain_id: u64,
    market: &str,
    base_asset_symbol: &str,
    supply_balance: f64,
    borrow_balance: f64,
) -> (&'static str, String, String) {
    // 1. borrowed — active borrow position; review health and plan repay
    if borrow_balance > 0.0 {
        return (
            "borrowed",
            format!(
                "You have an active borrow of {:.6} {}. Review your position and health factor; repay when ready.",
                borrow_balance, base_asset_symbol
            ),
            format!(
                "compound-v3-plugin --chain {} --market {} get-position",
                chain_id, market
            ),
        );
    }

    // 2. earning — supply base asset, no borrow
    if supply_balance > 0.0 {
        return (
            "earning",
            format!(
                "You are supplying {:.6} {} and earning interest. No active borrow.",
                supply_balance, base_asset_symbol
            ),
            format!(
                "compound-v3-plugin --chain {} --market {} get-position",
                chain_id, market
            ),
        );
    }

    // 3. new_user — no Comet position on this market
    (
        "new_user",
        format!(
            "No Compound V3 position on {} (chain {}). Browse current APRs and supply or collateralize to start.",
            market, chain_id
        ),
        format!(
            "compound-v3-plugin --chain {} --market {} get-markets",
            chain_id, market
        ),
    )
}

use crate::config::get_market_config;
use crate::onchainos;
use crate::rpc;
use anyhow::Result;

pub async fn run(
    chain_id: u64,
    market: &str,
    amount_str: Option<&str>, // None = repay all; human-readable (e.g. "5.0")
    from: Option<String>,
    dry_run: bool,
    confirm: bool,
) -> Result<()> {
    let cfg = get_market_config(chain_id, market)?;

    // Resolve wallet address — must not default to zero address
    let wallet = from
        .clone()
        .unwrap_or_else(|| onchainos::resolve_wallet(chain_id).unwrap_or_default());
    if wallet.is_empty() {
        anyhow::bail!("Cannot resolve wallet address. Pass --from or log in via onchainos.");
    }

    let borrow_balance = rpc::get_borrow_balance_of(cfg.comet_proxy, &wallet, cfg.rpc_url).await?;
    if borrow_balance == 0 {
        let result = serde_json::json!({
            "ok": true,
            "data": {
                "message": "No outstanding borrow balance to repay.",
                "borrow_balance": "0"
            }
        });
        println!("{}", serde_json::to_string_pretty(&result)?);
        return Ok(());
    }

    let wallet_balance = rpc::get_erc20_balance(cfg.base_asset, &wallet, cfg.rpc_url).await?;
    let decimals_factor = 10u128.pow(cfg.base_asset_decimals as u32) as f64;

    // Determine repay amount:
    // - If specified: use that amount (capped by borrow balance)
    // - If "repay all": use min(borrow_balance, wallet_balance) to avoid overflow revert
    let amount: Option<u128> = match amount_str {
        Some(s) => Some(rpc::parse_human_amount(s, cfg.base_asset_decimals)?),
        None => None,
    };
    let repay_amount = match amount {
        Some(a) => a.min(borrow_balance),
        None => {
            if wallet_balance < borrow_balance {
                anyhow::bail!(
                    "Wallet {} balance {:.6} {} is less than borrow balance {:.6} {}. \
                     Acquire {:.6} more {} to repay fully.",
                    wallet,
                    wallet_balance as f64 / decimals_factor,
                    cfg.base_asset_symbol,
                    borrow_balance as f64 / decimals_factor,
                    cfg.base_asset_symbol,
                    (borrow_balance - wallet_balance) as f64 / decimals_factor,
                    cfg.base_asset_symbol
                );
            }
            borrow_balance.min(wallet_balance)
        }
    };

    // For explicit --amount: check wallet has enough before spending gas on approve
    if amount.is_some() && wallet_balance < repay_amount {
        anyhow::bail!(
            "Insufficient wallet balance to repay: wallet has {:.6} {} but repay amount is {:.6} {}. \
             Acquire {:.6} more {}, or omit --amount to repay as much as your wallet holds.",
            wallet_balance as f64 / decimals_factor,
            cfg.base_asset_symbol,
            repay_amount as f64 / decimals_factor,
            cfg.base_asset_symbol,
            (repay_amount - wallet_balance) as f64 / decimals_factor,
            cfg.base_asset_symbol
        );
    }

    // Repay uses Comet.supply(base_asset, repay_amount) — same method as supply
    // selector: 0xf2b9fdb8
    let base_padded = rpc::pad_address(cfg.base_asset);
    let amount_hex = rpc::pad_u128(repay_amount);
    let repay_calldata = format!("0xf2b9fdb8{}{}", base_padded, amount_hex);

    // Confirm gate: show preview and exit if --confirm not given (and not dry-run)
    if !dry_run && !confirm {
        let result = serde_json::json!({
            "ok": true,
            "preview": true,
            "operation": "repay",
            "chain_id": chain_id,
            "market": market,
            "base_asset": cfg.base_asset_symbol,
            "repay_amount": format!("{:.6}", repay_amount as f64 / decimals_factor),
            "repay_amount_raw": repay_amount.to_string(),
            "borrow_balance": format!("{:.6}", borrow_balance as f64 / decimals_factor),
            "wallet_balance": format!("{:.6}", wallet_balance as f64 / decimals_factor),
            "comet": cfg.comet_proxy,
            "pending_transactions": 2,
            "transactions": [
                {"step": 1, "action": "ERC-20 approve", "token": cfg.base_asset, "spender": cfg.comet_proxy, "amount_raw": repay_amount.to_string()},
                {"step": 2, "action": "Comet.supply (repay)", "comet": cfg.comet_proxy, "base_asset": cfg.base_asset, "amount_raw": repay_amount.to_string(), "calldata": repay_calldata}
            ],
            "note": "Re-run with --confirm to execute these transactions on-chain."
        });
        println!("{}", serde_json::to_string_pretty(&result)?);
        return Ok(());
    }

    if dry_run {
        let result = serde_json::json!({
            "ok": true,
            "dry_run": true,
            "note": "Repay uses Comet.supply(base_asset, amount). supply with base asset = repay debt.",
            "borrow_balance": format!("{:.6}", borrow_balance as f64 / decimals_factor),
            "wallet_balance": format!("{:.6}", wallet_balance as f64 / decimals_factor),
            "steps": [
                {
                    "step": 1,
                    "action": "ERC-20 approve",
                    "token": cfg.base_asset,
                    "spender": cfg.comet_proxy,
                    "amount_raw": repay_amount.to_string()
                },
                {
                    "step": 2,
                    "action": "wait 3s"
                },
                {
                    "step": 3,
                    "action": "Comet.supply (repay)",
                    "comet": cfg.comet_proxy,
                    "base_asset": cfg.base_asset,
                    "amount": format!("{:.6}", repay_amount as f64 / decimals_factor),
                    "amount_raw": repay_amount.to_string(),
                    "calldata": repay_calldata
                }
            ]
        });
        println!("{}", serde_json::to_string_pretty(&result)?);
        return Ok(());
    }

    // Step 1: ERC-20 approve
    let approve_result = onchainos::erc20_approve(
        chain_id,
        cfg.base_asset,
        cfg.comet_proxy,
        repay_amount,
        Some(&wallet),
        false,
    )
    .await?;
    let approve_tx = onchainos::extract_tx_hash_or_err(&approve_result)?;

    // Step 2: 3-second delay to avoid nonce collision
    tokio::time::sleep(std::time::Duration::from_secs(3)).await;

    // Step 3: Comet.supply (= repay)
    let repay_result = onchainos::wallet_contract_call(
        chain_id,
        cfg.comet_proxy,
        &repay_calldata,
        Some(&wallet),
        None,
        false,
    )
    .await?;
    let repay_tx = onchainos::extract_tx_hash_or_err(&repay_result)?;

    // Wait for repay tx to confirm before reading remaining balance
    onchainos::wait_for_tx(&repay_tx, cfg.rpc_url).await;

    let remaining = rpc::get_borrow_balance_of(cfg.comet_proxy, &wallet, cfg.rpc_url)
        .await
        .unwrap_or(0);

    let result = serde_json::json!({
        "ok": true,
        "data": {
            "chain_id": chain_id,
            "market": market,
            "base_asset": cfg.base_asset_symbol,
            "repaid_amount": format!("{:.6}", repay_amount as f64 / decimals_factor),
            "repaid_amount_raw": repay_amount.to_string(),
            "wallet": wallet,
            "approve_tx_hash": approve_tx,
            "repay_tx_hash": repay_tx,
            "remaining_borrow_balance": format!("{:.6}", remaining as f64 / decimals_factor),
            "remaining_borrow_balance_raw": remaining.to_string()
        }
    });

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

use crate::config::get_market_config;
use crate::onchainos;
use crate::rpc;
use anyhow::Result;

pub async fn run(
    chain_id: u64,
    market: &str,
    asset: &str,        // token contract address to supply
    amount_str: &str,   // human-readable amount (e.g. "1.5" for 1.5 USDC, "0.001" for 0.001 WETH)
    from: Option<String>,
    dry_run: bool,
    confirm: bool,
) -> Result<()> {
    let cfg = get_market_config(chain_id, market)?;
    let asset_decimals = rpc::get_erc20_decimals(asset, cfg.rpc_url).await.unwrap_or(18);
    let amount = rpc::parse_human_amount(amount_str, asset_decimals)?;

    // Resolve wallet address — must not default to zero address
    let wallet = from
        .clone()
        .unwrap_or_else(|| onchainos::resolve_wallet(chain_id).unwrap_or_default());
    if wallet.is_empty() {
        anyhow::bail!("Cannot resolve wallet address. Pass --from or log in via onchainos.");
    }

    // Pre-check: verify wallet has sufficient token balance before spending gas on approve
    let wallet_token_balance = rpc::get_erc20_balance(asset, &wallet, cfg.rpc_url).await.unwrap_or(u128::MAX);
    if wallet_token_balance < amount {
        let decimals_factor = 10u128.pow(asset_decimals as u32) as f64;
        anyhow::bail!(
            "Insufficient wallet balance: wallet {} has {:.decimals$} of token {} but needs {:.decimals$}. \
             Acquire more of this token before supplying.",
            wallet,
            wallet_token_balance as f64 / decimals_factor,
            asset,
            amount as f64 / decimals_factor,
            decimals = asset_decimals as usize
        );
    }

    // Build supply(address,uint256) calldata
    // selector: 0xf2b9fdb8
    let asset_padded = rpc::pad_address(asset);
    let amount_hex = rpc::pad_u128(amount);
    let supply_calldata = format!("0xf2b9fdb8{}{}", asset_padded, amount_hex);

    // Confirm gate: show preview and exit if --confirm not given (and not dry-run)
    if !dry_run && !confirm {
        let decimals_factor = 10u128.pow(asset_decimals as u32) as f64;
        let result = serde_json::json!({
            "ok": true,
            "preview": true,
            "operation": "supply",
            "chain_id": chain_id,
            "market": market,
            "asset": asset,
            "amount": amount_str,
            "amount_raw": amount.to_string(),
            "amount_human": format!("{:.decimals$}", amount as f64 / decimals_factor, decimals = asset_decimals as usize),
            "comet": cfg.comet_proxy,
            "pending_transactions": 2,
            "transactions": [
                {"step": 1, "action": "ERC-20 approve", "token": asset, "spender": cfg.comet_proxy, "amount_raw": amount.to_string()},
                {"step": 2, "action": "Comet.supply", "comet": cfg.comet_proxy, "asset": asset, "amount_raw": amount.to_string(), "calldata": supply_calldata}
            ],
            "note": "Re-run with --confirm to execute these transactions on-chain."
        });
        println!("{}", serde_json::to_string_pretty(&result)?);
        return Ok(());
    }

    if dry_run {
        let result = serde_json::json!({
            "ok": true,
            "dry_run": true,
            "steps": [
                {
                    "step": 1,
                    "action": "ERC-20 approve",
                    "token": asset,
                    "spender": cfg.comet_proxy,
                    "amount_raw": amount.to_string()
                },
                {
                    "step": 2,
                    "action": "wait 3s"
                },
                {
                    "step": 3,
                    "action": "Comet.supply",
                    "comet": cfg.comet_proxy,
                    "asset": asset,
                    "amount_raw": amount.to_string(),
                    "calldata": supply_calldata
                }
            ]
        });
        println!("{}", serde_json::to_string_pretty(&result)?);
        return Ok(());
    }

    // Step 1: ERC-20 approve
    let approve_result = onchainos::erc20_approve(
        chain_id,
        asset,
        cfg.comet_proxy,
        amount,
        Some(&wallet),
        false,
    )
    .await?;
    let approve_tx = onchainos::extract_tx_hash_or_err(&approve_result)?;

    // Step 2: 3-second delay to avoid nonce collision
    tokio::time::sleep(std::time::Duration::from_secs(3)).await;

    // Step 3: Comet.supply
    let supply_result = onchainos::wallet_contract_call(
        chain_id,
        cfg.comet_proxy,
        &supply_calldata,
        Some(&wallet),
        None,
        false,
    )
    .await?;
    let supply_tx = onchainos::extract_tx_hash_or_err(&supply_result)?;

    // Wait for supply tx to confirm before reading post-tx balances
    onchainos::wait_for_tx(&supply_tx, cfg.rpc_url).await;

    // Read the correct post-tx balance:
    // - base asset supplied → read balanceOf (supply position)
    // - collateral asset supplied → read collateralBalanceOf (collateral slot)
    let is_base = asset.eq_ignore_ascii_case(cfg.base_asset);
    let (balance_key, balance_raw_key, new_balance_human, new_balance_raw) = if is_base {
        let bal = rpc::get_balance_of(cfg.comet_proxy, &wallet, cfg.rpc_url).await.unwrap_or(0);
        let factor = 10u128.pow(cfg.base_asset_decimals as u32) as f64;
        ("new_supply_balance", "new_supply_balance_raw", format!("{:.6}", bal as f64 / factor), bal.to_string())
    } else {
        let bal = rpc::get_collateral_balance_of(cfg.comet_proxy, &wallet, asset, cfg.rpc_url).await.unwrap_or(0);
        let factor = 10u128.pow(asset_decimals as u32) as f64;
        ("new_collateral_balance", "new_collateral_balance_raw", format!("{:.decimals$}", bal as f64 / factor, decimals = asset_decimals as usize), bal.to_string())
    };

    let result = serde_json::json!({
        "ok": true,
        "data": {
            "chain_id": chain_id,
            "market": market,
            "asset": asset,
            "amount_raw": amount.to_string(),
            "wallet": wallet,
            "approve_tx_hash": approve_tx,
            "supply_tx_hash": supply_tx,
            balance_key: new_balance_human,
            balance_raw_key: new_balance_raw
        }
    });

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

use crate::config::get_market_config;
use crate::onchainos;
use crate::rpc;
use anyhow::Result;

pub async fn run(
    chain_id: u64,
    market: &str,
    asset: &str,        // collateral token address (or base asset address)
    amount_str: &str,   // human-readable amount (e.g. "0.5" for 0.5 WETH)
    from: Option<String>,
    dry_run: bool,
    confirm: bool,
) -> Result<()> {
    let cfg = get_market_config(chain_id, market)?;
    let asset_decimals = rpc::get_erc20_decimals(asset, cfg.rpc_url).await.unwrap_or(18);
    let amount = rpc::parse_human_amount(amount_str, asset_decimals)?;

    // Resolve wallet address — must not default to zero address
    let wallet = from
        .clone()
        .unwrap_or_else(|| onchainos::resolve_wallet(chain_id).unwrap_or_default());
    if wallet.is_empty() {
        anyhow::bail!("Cannot resolve wallet address. Pass --from or log in via onchainos.");
    }

    // Safety check: must clear all debt before withdrawing collateral
    let borrow_balance = rpc::get_borrow_balance_of(cfg.comet_proxy, &wallet, cfg.rpc_url).await?;
    if borrow_balance > 0 {
        let decimals_factor = 10u128.pow(cfg.base_asset_decimals as u32) as f64;
        anyhow::bail!(
            "Account has outstanding debt of {:.6} {} on this market. \
             Repay all debt before withdrawing collateral to avoid liquidation.",
            borrow_balance as f64 / decimals_factor,
            cfg.base_asset_symbol
        );
    }

    // Pre-flight: check on-chain balance so dust/rounding mismatches surface before any gas is spent
    let is_base = asset.eq_ignore_ascii_case(cfg.base_asset);
    let on_chain_balance: u128 = if is_base {
        rpc::get_balance_of(cfg.comet_proxy, &wallet, cfg.rpc_url).await.unwrap_or(0)
    } else {
        rpc::get_collateral_balance_of(cfg.comet_proxy, &wallet, asset, cfg.rpc_url).await.unwrap_or(0)
    };
    let balance_type = if is_base { "supply balance" } else { "collateral balance" };
    let asset_factor = 10f64.powi(asset_decimals as i32);
    if on_chain_balance == 0 {
        anyhow::bail!(
            "No {} of asset {} in this market. Supply the asset first before attempting to withdraw.",
            balance_type,
            asset
        );
    }
    if amount > on_chain_balance {
        anyhow::bail!(
            "Withdrawal amount {:.decimals$} exceeds your current {}: {:.decimals$} (raw: {}). \
             Use --amount {:.decimals$} or less.",
            amount as f64 / asset_factor,
            balance_type,
            on_chain_balance as f64 / asset_factor,
            on_chain_balance,
            on_chain_balance as f64 / asset_factor,
            decimals = asset_decimals as usize
        );
    }

    // Build withdraw(address,uint256) calldata
    // selector: 0xf3fef3a3
    let asset_padded = rpc::pad_address(asset);
    let amount_hex = rpc::pad_u128(amount);
    let withdraw_calldata = format!("0xf3fef3a3{}{}", asset_padded, amount_hex);

    let amount_human = format!("{:.decimals$}", amount as f64 / 10f64.powi(asset_decimals as i32), decimals = asset_decimals as usize);

    // Confirm gate: show preview and exit if --confirm not given (and not dry-run)
    if !dry_run && !confirm {
        let result = serde_json::json!({
            "ok": true,
            "preview": true,
            "operation": "withdraw",
            "chain_id": chain_id,
            "market": market,
            "asset": asset,
            "amount": amount_human,
            "amount_raw": amount.to_string(),
            "current_balance": format!("{:.decimals$}", on_chain_balance as f64 / asset_factor, decimals = asset_decimals as usize),
            "current_balance_raw": on_chain_balance.to_string(),
            "balance_type": balance_type,
            "comet": cfg.comet_proxy,
            "pending_transactions": 1,
            "transactions": [
                {"step": 1, "action": "Comet.withdraw", "comet": cfg.comet_proxy, "asset": asset, "amount": amount_human.clone(), "amount_raw": amount.to_string(), "calldata": withdraw_calldata}
            ],
            "note": "Re-run with --confirm to execute this transaction on-chain."
        });
        println!("{}", serde_json::to_string_pretty(&result)?);
        return Ok(());
    }

    if dry_run {
        let result = serde_json::json!({
            "ok": true,
            "dry_run": true,
            "note": "Withdraw uses Comet.withdraw(asset, amount). No ERC-20 approve needed.",
            "steps": [
                {
                    "step": 1,
                    "action": "Comet.withdraw",
                    "comet": cfg.comet_proxy,
                    "asset": asset,
                    "amount": amount_human,
                    "amount_raw": amount.to_string(),
                    "calldata": withdraw_calldata
                }
            ]
        });
        println!("{}", serde_json::to_string_pretty(&result)?);
        return Ok(());
    }

    // Execute Comet.withdraw
    let withdraw_result = onchainos::wallet_contract_call(
        chain_id,
        cfg.comet_proxy,
        &withdraw_calldata,
        Some(&wallet),
        None,
        false,
    )
    .await?;
    let withdraw_tx = onchainos::extract_tx_hash_or_err(&withdraw_result)?;

    let result = serde_json::json!({
        "ok": true,
        "data": {
            "chain_id": chain_id,
            "market": market,
            "asset": asset,
            "amount": amount_human,
            "amount_raw": amount.to_string(),
            "wallet": wallet,
            "withdraw_tx_hash": withdraw_tx
        }
    });

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

/// Chain and market configuration for Compound V3

#[derive(Debug, Clone)]
pub struct MarketConfig {
    pub chain_id: u64,
    pub comet_proxy: &'static str,
    pub rewards_contract: &'static str,
    pub base_asset: &'static str,
    pub base_asset_decimals: u8,
    pub base_asset_symbol: &'static str,
    pub rpc_url: &'static str,
}

/// All known Compound V3 markets, indexed by (chain_id, market_symbol_lowercase)
pub fn get_market_config(chain_id: u64, market: &str) -> anyhow::Result<MarketConfig> {
    let m = market.to_lowercase();
    match (chain_id, m.as_str()) {
        (1, "usdc") => Ok(MarketConfig {
            chain_id: 1,
            comet_proxy: "0xc3d688B66703497DAA19211EEdff47f25384cdc3",
            rewards_contract: "0x1B0e765F6224C21223AeA2af16c1C46E38885a40",
            base_asset: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
            base_asset_decimals: 6,
            base_asset_symbol: "USDC",
            rpc_url: "https://ethereum.publicnode.com",
        }),
        (8453, "usdc") => Ok(MarketConfig {
            chain_id: 8453,
            comet_proxy: "0xb125E6687d4313864e53df431d5425969c15Eb2F",
            rewards_contract: "0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1",
            base_asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
            base_asset_decimals: 6,
            base_asset_symbol: "USDC",
            rpc_url: "https://base-rpc.publicnode.com",
        }),
        (8453, "weth") => Ok(MarketConfig {
            chain_id: 8453,
            comet_proxy: "0x46e6b214b524310239732D51387075E0e70970bf",
            rewards_contract: "0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1",
            base_asset: "0x4200000000000000000000000000000000000006",
            base_asset_decimals: 18,
            base_asset_symbol: "WETH",
            rpc_url: "https://base-rpc.publicnode.com",
        }),
        (42161, "usdc") => Ok(MarketConfig {
            chain_id: 42161,
            comet_proxy: "0x9c4ec768c28520B50860ea7a15bd7213a9fF58bf",
            rewards_contract: "0x88730d254A2f7e6AC8388c3198aFd694bA9f7fae",
            base_asset: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
            base_asset_decimals: 6,
            base_asset_symbol: "USDC",
            rpc_url: "https://arbitrum-one-rpc.publicnode.com",
        }),
        (42161, "weth") => Ok(MarketConfig {
            chain_id: 42161,
            comet_proxy: "0x6f7D514bbD4aFf3BcD1140B7344b32f063dEe486",
            rewards_contract: "0x88730d254A2f7e6AC8388c3198aFd694bA9f7fae",
            base_asset: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
            base_asset_decimals: 18,
            base_asset_symbol: "WETH",
            rpc_url: "https://arbitrum-one-rpc.publicnode.com",
        }),
        (42161, "usdc.e") => Ok(MarketConfig {
            chain_id: 42161,
            comet_proxy: "0xA5EDBDD9646f8dFF606d7448e414884C7d905dCA",
            rewards_contract: "0x88730d254A2f7e6AC8388c3198aFd694bA9f7fae",
            base_asset: "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
            base_asset_decimals: 6,
            base_asset_symbol: "USDC.e",
            rpc_url: "https://arbitrum-one-rpc.publicnode.com",
        }),
        (137, "usdc") => Ok(MarketConfig {
            chain_id: 137,
            comet_proxy: "0xF25212E676D1F7F89Cd72fFEe66158f541246445",
            rewards_contract: "0x45939657d1CA34A8FA39A924B71D28Fe8431e581",
            base_asset: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
            base_asset_decimals: 6,
            base_asset_symbol: "USDC",
            rpc_url: "https://polygon-bor-rpc.publicnode.com",
        }),
        _ => anyhow::bail!(
            "Unsupported chain_id={} market={}. Supported markets: \
             usdc (chains 1/8453/42161/137), \
             weth (chains 8453/42161), \
             usdc.e (chain 42161 only)",
            chain_id,
            market
        ),
    }
}

/// Default RPC URL for a chain (used outside market context)
pub fn default_rpc_url(chain_id: u64) -> &'static str {
    match chain_id {
        1 => "https://ethereum.publicnode.com",
        8453 => "https://base-rpc.publicnode.com",
        42161 => "https://arbitrum-one-rpc.publicnode.com",
        137 => "https://polygon-bor-rpc.publicnode.com",
        _ => "https://base-rpc.publicnode.com",
    }
}

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

use clap::{Parser, Subcommand};

#[derive(Parser)]
#[command(name = "compound-v3", version, about = "Compound V3 (Comet) lending plugin")]
struct Cli {
    /// Chain ID (1=Ethereum, 8453=Base, 42161=Arbitrum, 137=Polygon)
    #[arg(long, default_value = "8453", global = true)]
    chain: u64,

    /// Market name — usdc (all chains), weth (Base/Arbitrum), usdc.e (Arbitrum only)
    #[arg(long, default_value = "usdc", global = true)]
    market: String,

    /// Simulate without broadcasting on-chain transactions
    #[arg(long, global = true)]
    dry_run: bool,

    /// Execute the transaction on-chain. Without this flag write operations show a preview and exit.
    #[arg(long, global = true)]
    confirm: bool,

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

#[derive(Subcommand)]
enum Commands {
    /// Check wallet state and get a recommended next step (supply/borrow/earning overview)
    Quickstart {
        /// Wallet address (defaults to logged-in onchainos wallet)
        #[arg(long)]
        wallet: Option<String>,
    },

    /// List market info: supply APR, borrow APR, utilization, TVL
    GetMarkets,

    /// View account position: supply balance, borrow balance, collateral
    GetPosition {
        /// Wallet address (defaults to logged-in onchainos wallet)
        #[arg(long)]
        wallet: Option<String>,

        /// Collateral asset address to check collateral balance for
        #[arg(long)]
        collateral_asset: Option<String>,
    },

    /// Supply collateral or base asset (also used for repaying debt)
    Supply {
        /// Token contract address to supply
        #[arg(long)]
        asset: String,

        /// Amount in human-readable units (e.g. 1.5 for 1.5 USDC, 0.001 for 0.001 WETH)
        #[arg(long)]
        amount: String,

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

    /// Borrow base asset (implemented via Comet.withdraw)
    Borrow {
        /// Amount of base asset to borrow in human-readable units (e.g. 0.1 for 0.1 USDC)
        #[arg(long)]
        amount: String,

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

    /// Repay borrowed base asset
    Repay {
        /// Amount to repay in human-readable units. Omit to repay all debt.
        #[arg(long)]
        amount: Option<String>,

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

    /// Withdraw supplied collateral (requires zero borrow balance)
    Withdraw {
        /// Token contract address to withdraw
        #[arg(long)]
        asset: String,

        /// Amount in human-readable units (e.g. 0.001 for 0.001 WETH)
        #[arg(long)]
        amount: String,

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

    /// Claim COMP rewards from the CometRewards contract
    ClaimRewards {
        /// Sender wallet address (defaults to logged-in wallet)
        #[arg(long)]
        from: Option<String>,
    },
}

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

    let result = match cli.command {
        Commands::Quickstart { wallet } => {
            commands::quickstart::run(cli.chain, &cli.market, wallet).await
        }
        Commands::GetMarkets => {
            commands::get_markets::run(cli.chain, &cli.market).await
        }
        Commands::GetPosition { wallet, collateral_asset } => {
            commands::get_position::run(cli.chain, &cli.market, wallet, collateral_asset).await
        }
        Commands::Supply { asset, amount, from } => {
            commands::supply::run(cli.chain, &cli.market, &asset, &amount, from, cli.dry_run, cli.confirm).await
        }
        Commands::Borrow { amount, from } => {
            commands::borrow::run(cli.chain, &cli.market, &amount, from, cli.dry_run, cli.confirm).await
        }
        Commands::Repay { amount, from } => {
            commands::repay::run(cli.chain, &cli.market, amount.as_deref(), from, cli.dry_run, cli.confirm).await
        }
        Commands::Withdraw { asset, amount, from } => {
            commands::withdraw::run(cli.chain, &cli.market, &asset, &amount, from, cli.dry_run, cli.confirm).await
        }
        Commands::ClaimRewards { from } => {
            commands::claim_rewards::run(cli.chain, &cli.market, from, cli.dry_run, cli.confirm).await
        }
    };

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

// src/onchainos.rs
use std::process::Command;
use serde_json::Value;

/// `--biz-type` / `--strategy`: attribution to the onchainos backend.
/// Source-of-truth for the plugin name is Cargo.toml's `[package]` `name`.
const BIZ_TYPE: &str = "dapp";
const STRATEGY: &str = env!("CARGO_PKG_NAME");

/// Query the currently logged-in wallet address for the given EVM chain.
pub fn resolve_wallet(chain_id: u64) -> anyhow::Result<String> {
    let chain_str = chain_id.to_string();
    let output = Command::new("onchainos")
        .args(["wallet", "addresses", "--chain", &chain_str])
        .output()?;
    let json: Value = serde_json::from_str(&String::from_utf8_lossy(&output.stdout))
        .map_err(|e| anyhow::anyhow!("wallet addresses parse error: {}", e))?;
    let addr = json["data"]["evm"][0]["address"].as_str().unwrap_or("").to_string();
    Ok(addr)
}

/// Submit a contract call via onchainos wallet contract-call.
/// ⚠️  dry_run=true returns a simulated response immediately — contract-call does NOT support --dry-run.
pub async fn wallet_contract_call(
    chain_id: u64,
    to: &str,
    input_data: &str,
    from: Option<&str>,
    amt: Option<u64>,
    dry_run: bool,
) -> anyhow::Result<Value> {
    if dry_run {
        return Ok(serde_json::json!({
            "ok": true,
            "dry_run": true,
            "data": { "txHash": "0x0000000000000000000000000000000000000000000000000000000000000000" },
            "calldata": input_data
        }));
    }

    let chain_str = chain_id.to_string();
    let mut args = vec![
        "wallet",
        "contract-call",
        "--biz-type",
        BIZ_TYPE,
        "--strategy",
        STRATEGY,
        "--chain",
        &chain_str,
        "--to",
        to,
        "--input-data",
        input_data,
    ];
    let amt_str;
    if let Some(v) = amt {
        amt_str = v.to_string();
        args.extend_from_slice(&["--amt", &amt_str]);
    }
    let from_str;
    if let Some(f) = from {
        from_str = f.to_string();
        args.extend_from_slice(&["--from", &from_str]);
    }

    let output = tokio::process::Command::new("onchainos").args(&args).output().await?;
    let stdout = String::from_utf8_lossy(&output.stdout);
    Ok(serde_json::from_str(&stdout)?)
}

/// Extract txHash from wallet contract-call response: {"ok":true,"data":{"txHash":"0x..."}}
/// Returns an error if the response indicates failure or if no txHash is present.
pub fn extract_tx_hash_or_err(result: &Value) -> anyhow::Result<String> {
    if result["ok"].as_bool() != Some(true) {
        let err_msg = result["error"].as_str()
            .or_else(|| result["message"].as_str())
            .unwrap_or("unknown error");
        return Err(anyhow::anyhow!("contract-call failed: {}", err_msg));
    }
    result["data"]["txHash"]
        .as_str()
        .or_else(|| result["txHash"].as_str())
        .map(|s| s.to_string())
        .ok_or_else(|| anyhow::anyhow!("no txHash in contract-call response"))
}

/// ERC-20 approve via wallet contract-call (approve(address,uint256) selector = 0x095ea7b3)
pub async fn erc20_approve(
    chain_id: u64,
    token_addr: &str,
    spender: &str,
    amount: u128,
    from: Option<&str>,
    dry_run: bool,
) -> anyhow::Result<Value> {
    let spender_padded = format!("{:0>64}", &spender[2..]);
    let amount_hex = format!("{:064x}", amount);
    let calldata = format!("0x095ea7b3{}{}", spender_padded, amount_hex);
    wallet_contract_call(chain_id, token_addr, &calldata, from, None, dry_run).await
}

/// Poll eth_getTransactionReceipt until the tx is confirmed or timeout.
/// Uses 20 attempts × 2s = 40s — sufficient for Base (~2s blocks) and Arbitrum (~0.25s blocks).
pub async fn wait_for_tx(tx_hash: &str, rpc_url: &str) {
    let client = reqwest::Client::new();
    for _ in 0..20u32 {
        tokio::time::sleep(std::time::Duration::from_secs(2)).await;
        let body = serde_json::json!({
            "jsonrpc": "2.0",
            "method": "eth_getTransactionReceipt",
            "params": [tx_hash],
            "id": 1
        });
        if let Ok(resp) = client.post(rpc_url).json(&body).send().await {
            if let Ok(json) = resp.json::<serde_json::Value>().await {
                if json.get("result").map(|r| !r.is_null()).unwrap_or(false) {
                    return;
                }
            }
        }
    }
    // Timeout — continue anyway; balance read may be slightly stale
}

/// wallet balance — returns native JSON output from onchainos.
pub fn wallet_balance(chain_id: u64) -> anyhow::Result<Value> {
    let chain_str = chain_id.to_string();
    let output = Command::new("onchainos")
        .args(["wallet", "balance", "--chain", &chain_str])
        .output()?;
    Ok(serde_json::from_str(&String::from_utf8_lossy(&output.stdout))?)
}