Clanker Plugin

{
  "name": "clanker-plugin",
  "description": "Deploy and manage Clanker ERC-20 tokens on Base and Arbitrum — launch tokens, search by creator, and claim LP fee rewards",
  "version": "0.2.6",
  "author": {"name": "GeoGu360", "github": "GeoGu360"},
  "homepage": "https://github.com/okx/plugin-store",
  "repository": "https://github.com/okx/plugin-store",
  "license": "MIT",
  "keywords": ["token-launch", "meme", "erc20", "uniswap-v4", "base"]
}

target/

[package]
name = "clanker-plugin"
version = "0.2.6"
edition = "2021"

[[bin]]
name = "clanker-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"
alloy-sol-types = "0.8"
alloy-primitives = "0.8"
hex = "0.4"
uuid = { version = "1", features = ["v4"] }

MIT License

Copyright (c) 2026 skylavis-sky

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

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

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

schema_version: 1
name: clanker-plugin
version: "0.2.6"
description: "Deploy and manage Clanker ERC-20 tokens on Base and Arbitrum — launch tokens, search by creator, and claim LP fee rewards"
author:
  name: GeoGu360
  github: GeoGu360
category: dapp
tags:
  - token-launch
  - meme
  - erc20
  - uniswap-v4
  - base
license: MIT

components:
  skill:
    dir: .

build:
  lang: rust
  binary_name: clanker-plugin

api_calls:
  - "https://clanker.world/api"
  - "https://base-rpc.publicnode.com"
  - "https://arb1.arbitrum.io/rpc"
  - "https://basescan.org"

// src/api.rs — Clanker REST API client
use anyhow::Context;
use serde_json::Value;

const CLANKER_API_BASE: &str = "https://clanker.world/api";

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

/// GET /api/tokens — list recently deployed tokens
pub async fn list_tokens(
    page: u32,
    limit: u32,
    sort: &str,
    chain_id: Option<u64>,
) -> anyhow::Result<Value> {
    let client = reqwest::Client::new();
    let mut params = vec![
        ("page", page.to_string()),
        ("limit", limit.to_string()),
        ("sort", sort.to_string()),
    ];
    if let Some(cid) = chain_id {
        params.push(("chain_id", cid.to_string()));
    }
    let resp = client
        .get(format!("{}/tokens", CLANKER_API_BASE))
        .query(&params)
        .send()
        .await
        .context("list_tokens HTTP request failed")?
        .json::<Value>()
        .await
        .context("list_tokens JSON parse failed")?;
    Ok(resp)
}

/// GET /api/search-creator — search tokens by creator address or Farcaster username
pub async fn search_creator(
    q: &str,
    limit: u32,
    offset: u32,
    sort: &str,
    trusted_only: bool,
) -> anyhow::Result<Value> {
    let client = reqwest::Client::new();
    let trusted_str = trusted_only.to_string();
    let params = vec![
        ("q", q.to_string()),
        ("limit", limit.to_string()),
        ("offset", offset.to_string()),
        ("sort", sort.to_string()),
        ("trustedOnly", trusted_str),
    ];
    let resp = client
        .get(format!("{}/search-creator", CLANKER_API_BASE))
        .query(&params)
        .send()
        .await
        .context("search_creator HTTP request failed")?
        .json::<Value>()
        .await
        .context("search_creator JSON parse failed")?;
    Ok(resp)
}

// src/commands/claim_rewards.rs — claim LP fee rewards from ClankerFeeLocker
use crate::config;
use crate::onchainos;
use crate::rpc;
use anyhow::{bail, Result};
use alloy_sol_types::{sol, SolCall};

sol! {
    function collectRewards(address token) external;
}

pub async fn run(
    chain_id: u64,
    token_address: &str,
    from: Option<&str>,
    dry_run: bool,
    confirm: bool,
) -> Result<()> {
    // Require explicit --confirm for live claims
    if !dry_run && !confirm {
        bail!(
            "Claiming rewards requires explicit confirmation. Run with --dry-run first to preview, \
             then re-run with --confirm to execute."
        );
    }

    // ── 1. Resolve wallet address ─────────────────────────────────────────
    let wallet = from
        .map(|s| s.to_string())
        .unwrap_or_else(|| onchainos::resolve_wallet(chain_id).unwrap_or_default());
    if wallet.is_empty() {
        bail!("Cannot determine wallet address — pass --from or ensure onchainos is logged in");
    }

    // ── 2. Security scan ─────────────────────────────────────────────────
    let scan = onchainos::security_token_scan(chain_id, token_address)?;
    let scan_ok = scan["ok"].as_bool().unwrap_or(false)
        || scan["data"].is_object();
    if !scan_ok {
        bail!(
            "Security scan failed for token {} on chain {}. Aborting to protect funds.",
            token_address,
            chain_id
        );
    }
    // Check for block-level risk indicators
    let risk_level = scan["data"]["riskLevel"]
        .as_str()
        .or_else(|| scan["data"]["risk_level"].as_str())
        .unwrap_or("");
    if risk_level.to_lowercase() == "block" {
        bail!(
            "Token {} flagged as HIGH RISK (block). Refusing to proceed.",
            token_address
        );
    }

    // ── 3. Resolve fee locker address ────────────────────────────────────
    // Clanker V4 lockers are resolved via the factory's feeLockerForToken().
    // If factory lookup fails (token not registered in this factory or call reverts),
    // fall back to the well-known V4 locker address from config.
    let rpc_url = config::rpc_url(chain_id);
    let fee_locker_addr = if let Some(factory) = config::factory_address(chain_id) {
        match rpc::resolve_fee_locker(rpc_url, factory, token_address).await {
            Ok(resolved) if resolved.len() == 42
                && resolved.starts_with("0x")
                && resolved != "0x0000000000000000000000000000000000000000" =>
            {
                resolved
            }
            _ => {
                // Factory lookup failed or returned zero address — use fallback
                config::fallback_fee_locker(chain_id)
                    .ok_or_else(|| anyhow::anyhow!("No fallback fee locker for chain {}", chain_id))?
                    .to_string()
            }
        }
    } else {
        config::fallback_fee_locker(chain_id)
            .ok_or_else(|| anyhow::anyhow!("No fee locker configured for chain {}", chain_id))?
            .to_string()
    };

    // ── 4. Check pending rewards via tokenRewards(address token) ─────────
    // The ClankerFeeLocker exposes tokenRewards(address) for querying and
    // collectRewards(address) for claiming.
    let has_rewards = rpc::has_pending_rewards(rpc_url, &fee_locker_addr, token_address).await;
    if let Ok(false) = has_rewards {
        let output = serde_json::json!({
            "ok": true,
            "data": {
                "status": "no_rewards",
                "message": "No claimable rewards at this time for this token.",
                "token_address": token_address,
                "wallet": wallet,
                "fee_locker": fee_locker_addr,
            }
        });
        println!("{}", serde_json::to_string_pretty(&output)?);
        return Ok(());
    }

    // ── 5. Encode collectRewards(address token) calldata ─────────────────
    let token_addr_parsed: alloy_primitives::Address = token_address
        .parse()
        .map_err(|_| anyhow::anyhow!("Invalid token address: {}", token_address))?;

    let call = collectRewardsCall {
        token: token_addr_parsed,
    };
    let calldata = format!("0x{}", hex::encode(call.abi_encode()));

    // ── 6. Dry-run preview ────────────────────────────────────────────────
    if dry_run {
        let preview = serde_json::json!({
            "ok": true,
            "dry_run": true,
            "data": {
                "action": "claim_rewards",
                "chain_id": chain_id,
                "fee_locker": fee_locker_addr,
                "input_data": calldata,
                "from": wallet,
                "token_address": token_address,
                "onchainos_command": format!(
                    "onchainos wallet contract-call --chain {} --to {} --input-data {} --from {} --force",
                    chain_id, fee_locker_addr, calldata, wallet
                ),
                "note": "Run without --dry-run after user confirmation to execute on-chain"
            }
        });
        println!("{}", serde_json::to_string_pretty(&preview)?);
        return Ok(());
    }

    // ── 7. Execute on-chain (after user confirmation by agent) ────────────
    // The agent MUST ask user to confirm before reaching this point.
    // --force is only passed when confirm=true (i.e. not a dry-run preview).
    let result = onchainos::wallet_contract_call(
        chain_id,
        &fee_locker_addr,
        &calldata,
        Some(&wallet),
        None,
        confirm, // --force only when user has confirmed
        false,
    )
    .await?;

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

    let output = serde_json::json!({
        "ok": true,
        "data": {
            "action": "claim_rewards",
            "token_address": token_address,
            "fee_locker": fee_locker_addr,
            "from": wallet,
            "chain_id": chain_id,
            "tx_hash": tx_hash,
            "explorer_url": format!(
                "https://{}/tx/{}",
                if chain_id == 42161 { "arbiscan.io" } else { "basescan.org" },
                tx_hash
            )
        }
    });
    println!("{}", serde_json::to_string_pretty(&output)?);
    Ok(())
}

// src/commands/deploy_token.rs — deploy via direct factory deployToken() call (no API key required)
//
// Calls Clanker V4 factory `deployToken(DeploymentConfig)` directly from the user's wallet.
// Factory: 0xE85A59c628F7d27878ACeB4bf3b35733630083a9 (Base)
// ABI source: github.com/clanker-devco/clanker-sdk — src/abi/v4/Clanker.ts

#![allow(non_snake_case)]

use alloy_primitives::{Address, Bytes, FixedBytes, U256};
use alloy_sol_types::{sol, SolCall, SolValue};
use anyhow::{bail, Result};
use uuid::Uuid;

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

// ── Addresses (Base, chain 8453) ───────────────────────────────────────────

const WETH_BASE: &str            = "0x4200000000000000000000000000000000000006";
const HOOK_STATIC_V2_BASE: &str  = "0xb429d62f8f3bFFb98CdB9569533eA23bF0Ba28CC";
const LOCKER_BASE: &str          = "0x63D2DfEA64b3433F4071A98665bcD7Ca14d93496";
const MEV_MODULE_V2_BASE: &str   = "0xebB25BB797D82CB78E1bc70406b13233c0854413";

// ── Pool parameters ────────────────────────────────────────────────────────

const TICK_IF_TOKEN0_IS_CLANKER: i32 = -230400;
const TICK_SPACING: i32              = 200;
const TICK_LOWER: i32                = -230400;
const TICK_UPPER: i32                = -120000;
const FEE_UNI_BPS: u32              = 10_000;
const MEV_STARTING_FEE: u32         = 666_777;
const MEV_ENDING_FEE: u32           = 41_673;
const MEV_DECAY_SECS: u64           = 15;

// ── ABI types ──────────────────────────────────────────────────────────────

sol! {
    struct PoolInitializationData {
        address extension;
        bytes   extensionData;
        bytes   feeData;
    }

    struct FeeConfig {
        uint24 clankerFee;
        uint24 pairedFee;
    }

    struct LockerInstantiationData {
        uint8[] feePreference;
    }

    struct MevSniperAuctionInitData {
        uint24  startingFee;
        uint24  endingFee;
        uint256 secondsToDecay;
    }

    struct TokenConfig {
        address tokenAdmin;
        string  name;
        string  symbol;
        bytes32 salt;
        string  image;
        string  metadata;
        string  context;
        uint256 originatingChainId;
    }

    struct PoolConfig {
        address hook;
        address pairedToken;
        int24   tickIfToken0IsClanker;
        int24   tickSpacing;
        bytes   poolData;
    }

    struct LockerConfig {
        address   locker;
        address[] rewardAdmins;
        address[] rewardRecipients;
        uint16[]  rewardBps;
        int24[]   tickLower;
        int24[]   tickUpper;
        uint16[]  positionBps;
        bytes     lockerData;
    }

    struct MevModuleConfig {
        address mevModule;
        bytes   mevModuleData;
    }

    struct ExtensionConfig {
        address extension;
        uint256 msgValue;
        uint16  extensionBps;
        bytes   extensionData;
    }

    struct DeploymentConfig {
        TokenConfig       tokenConfig;
        PoolConfig        poolConfig;
        LockerConfig      lockerConfig;
        MevModuleConfig   mevModuleConfig;
        ExtensionConfig[] extensionConfigs;
    }

    function deployToken(DeploymentConfig deploymentConfig)
        external payable returns (address tokenAddress);
}

type I24 = alloy_primitives::aliases::I24;
type U24 = alloy_primitives::aliases::U24;

fn i24(v: i32) -> Result<I24> {
    I24::try_from(v as i64).map_err(|_| anyhow::anyhow!("int24 overflow: {}", v))
}

fn u24(v: u32) -> Result<U24> {
    U24::try_from(v as u64).map_err(|_| anyhow::anyhow!("uint24 overflow: {}", v))
}

#[allow(clippy::too_many_arguments)]
pub async fn run(
    chain_id: u64,
    name: &str,
    symbol: &str,
    from: Option<&str>,
    image_url: Option<&str>,
    dry_run: bool,
    confirm: bool,
) -> Result<()> {
    if name.trim().is_empty() {
        bail!("--name cannot be empty");
    }
    if symbol.trim().is_empty() {
        bail!("--symbol cannot be empty");
    }

    if chain_id != 8453 {
        bail!(
            "Direct on-chain deployment is only supported on Base (chain 8453). \
             Arbitrum support is planned for a future release."
        );
    }

    // Preview gate: show intent without broadcasting when neither --dry-run nor --confirm
    if !dry_run && !confirm {
        let wallet_preview = from
            .map(|s| s.to_string())
            .unwrap_or_else(|| onchainos::resolve_wallet(chain_id).unwrap_or_default());
        if wallet_preview.is_empty() {
            bail!("Cannot determine wallet address — pass --from or ensure onchainos is logged in");
        }
        let hex_valid = wallet_preview.len() > 2
            && wallet_preview[2..].chars().all(|c| c.is_ascii_hexdigit());
        if !wallet_preview.starts_with("0x") || wallet_preview.len() != 42 || !hex_valid {
            bail!("Invalid wallet address: {}. Must be a 42-character hex address (0x...).", wallet_preview);
        }
        let preview = serde_json::json!({
            "ok": true,
            "preview": true,
            "message": "Add --dry-run to see full calldata, or --confirm to deploy on-chain",
            "data": {
                "chain": chain_id,
                "name": name,
                "symbol": symbol,
                "deployer": wallet_preview,
                "note": "Token admin and LP reward recipient will be set to deployer address"
            }
        });
        println!("{}", serde_json::to_string_pretty(&preview)?);
        return Ok(());
    }

    // ── 1. Resolve wallet ─────────────────────────────────────────────────
    let wallet_str = from
        .map(|s| s.to_string())
        .unwrap_or_else(|| onchainos::resolve_wallet(chain_id).unwrap_or_default());
    if wallet_str.is_empty() {
        bail!("Cannot determine wallet address — pass --from or ensure onchainos is logged in");
    }

    let factory = config::factory_address(chain_id)
        .ok_or_else(|| anyhow::anyhow!("No factory address configured for chain {}", chain_id))?;

    let wallet_addr: Address = wallet_str
        .parse()
        .map_err(|_| anyhow::anyhow!("Invalid wallet address: {}", wallet_str))?;

    let hook_addr: Address   = HOOK_STATIC_V2_BASE.parse().unwrap();
    let weth_addr: Address   = WETH_BASE.parse().unwrap();
    let locker_addr: Address = LOCKER_BASE.parse().unwrap();
    let mev_addr: Address    = MEV_MODULE_V2_BASE.parse().unwrap();

    // ── 2. Unique salt per deployment ─────────────────────────────────────
    let uuid = Uuid::new_v4();
    let mut salt_bytes = [0u8; 32];
    salt_bytes[..16].copy_from_slice(uuid.as_bytes());
    let salt = FixedBytes::<32>::from(salt_bytes);

    // ── 3. Encode inner bytes fields ──────────────────────────────────────

    let fee_data = FeeConfig {
        clankerFee: u24(FEE_UNI_BPS)?,
        pairedFee:  u24(FEE_UNI_BPS)?,
    }
    .abi_encode();

    let pool_data = PoolInitializationData {
        extension:     Address::ZERO,
        extensionData: Bytes::new(),
        feeData:       Bytes::from(fee_data),
    }
    .abi_encode();

    let locker_data = LockerInstantiationData {
        feePreference: vec![0u8],
    }
    .abi_encode();

    let mev_data = MevSniperAuctionInitData {
        startingFee:    u24(MEV_STARTING_FEE)?,
        endingFee:      u24(MEV_ENDING_FEE)?,
        secondsToDecay: U256::from(MEV_DECAY_SECS),
    }
    .abi_encode();

    // ── 4. Assemble DeploymentConfig ──────────────────────────────────────

    let deployment_config = DeploymentConfig {
        tokenConfig: TokenConfig {
            tokenAdmin:         wallet_addr,
            name:               name.to_string(),
            symbol:             symbol.to_string(),
            salt,
            image:              image_url.unwrap_or("").to_string(),
            metadata:           String::new(),
            context:            String::new(),
            originatingChainId: U256::from(chain_id),
        },
        poolConfig: PoolConfig {
            hook:                  hook_addr,
            pairedToken:           weth_addr,
            tickIfToken0IsClanker: i24(TICK_IF_TOKEN0_IS_CLANKER)?,
            tickSpacing:           i24(TICK_SPACING)?,
            poolData:              Bytes::from(pool_data),
        },
        lockerConfig: LockerConfig {
            locker:           locker_addr,
            rewardAdmins:     vec![wallet_addr],
            rewardRecipients: vec![wallet_addr],
            rewardBps:        vec![10_000u16],
            tickLower:        vec![i24(TICK_LOWER)?],
            tickUpper:        vec![i24(TICK_UPPER)?],
            positionBps:      vec![10_000u16],
            lockerData:       Bytes::from(locker_data),
        },
        mevModuleConfig: MevModuleConfig {
            mevModule:     mev_addr,
            mevModuleData: Bytes::from(mev_data),
        },
        extensionConfigs: vec![],
    };

    // ── 5. Encode calldata ────────────────────────────────────────────────

    let calldata = format!(
        "0x{}",
        hex::encode(deployTokenCall { deploymentConfig: deployment_config }.abi_encode())
    );

    // ── 6. Dry-run preview ────────────────────────────────────────────────
    if dry_run {
        let preview = serde_json::json!({
            "ok": true,
            "dry_run": true,
            "data": {
                "action": "deploy_token",
                "chain_id": chain_id,
                "name": name,
                "symbol": symbol,
                "token_admin": wallet_str,
                "reward_recipient": wallet_str,
                "paired_token": "WETH",
                "hook": "feeStaticHookV2",
                "mev_protection": "mevModuleV2 (gradual fee decay)",
                "initial_price_tick": TICK_IF_TOKEN0_IS_CLANKER,
                "lp_range": { "tick_lower": TICK_LOWER, "tick_upper": TICK_UPPER },
                "factory": factory,
                "calldata_selector": &calldata[..10],
                "note": "Re-run with --confirm to execute on-chain"
            }
        });
        println!("{}", serde_json::to_string_pretty(&preview)?);
        return Ok(());
    }

    // ── 7. Execute on-chain ───────────────────────────────────────────────
    let result = onchainos::wallet_contract_call(
        chain_id,
        factory,
        &calldata,
        Some(&wallet_str),
        None,
        confirm, // --force only when user has confirmed
        false,
    )
    .await?;

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

    let output = serde_json::json!({
        "ok": true,
        "data": {
            "name": name,
            "symbol": symbol,
            "chain_id": chain_id,
            "token_admin": wallet_str,
            "reward_recipient": wallet_str,
            "tx_hash": tx_hash,
            "explorer_url": format!("https://basescan.org/tx/{}", tx_hash),
            "note": "Token deployment submitted. Check the transaction on Basescan to find the deployed contract address (look for the contract creation event or Transfer from address(0))."
        }
    });
    println!("{}", serde_json::to_string_pretty(&output)?);
    Ok(())
}

// src/commands/list_tokens.rs — list recently deployed Clanker tokens
use crate::api;
use anyhow::Result;
use serde_json::Value;

pub async fn run(
    page: u32,
    limit: u32,
    sort: &str,
    chain_id: Option<u64>,
) -> Result<()> {
    let result: Value = api::list_tokens(page, limit, sort, chain_id).await?;

    // API returns { data: [...], total: ..., cursor: ... }
    // (Note: top-level "data" array, NOT "tokens")
    let tokens = {
        let raw = result["data"].as_array().cloned().unwrap_or_default();
        if let Some(cid) = chain_id {
            raw.into_iter()
                .filter(|t| t["chain_id"].as_u64().map(|c| c == cid).unwrap_or(true))
                .collect::<Vec<_>>()
        } else {
            raw
        }
    };
    let total = result["total"].as_u64().unwrap_or(0);
    // API uses cursor-based pagination; derive has_more from whether cursor is present
    let has_more = result["cursor"].is_string() && !result["cursor"].as_str().unwrap_or("").is_empty();

    let output = serde_json::json!({
        "ok": true,
        "data": {
            "tokens": tokens.iter().map(|t| {
                serde_json::json!({
                    "contract_address": t["contract_address"],
                    "name": t["name"],
                    "symbol": t["symbol"],
                    "chain_id": t["chain_id"],
                    "deployed_at": t["deployed_at"],
                    "img_url": t["img_url"],
                    "pool_address": t["pool_address"],
                    "description": t["description"],
                })
            }).collect::<Vec<_>>(),
            "total": total,
            "has_more": has_more,
            "page": page,
        }
    });

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

pub mod claim_rewards;
pub mod deploy_token;
pub mod list_tokens;
pub mod quickstart;
pub mod search_tokens;
pub mod token_info;

// commands/quickstart.rs — Clanker wallet-state onboarding
use crate::config;
use crate::onchainos;
use serde_json::{json, Value};

const ABOUT: &str = "Clanker is a permissionless token launcher on Base — deploy your own \
    ERC-20 token with a liquidity pool in seconds, then claim trading fees earned by your \
    token's pool.";

// Minimum ETH needed to deploy (covers factory gas on Base)
const MIN_DEPLOY_GAS_WEI: u128 = 1_000_000_000_000_000; // 0.001 ETH

async fn eth_balance_wei(wallet: &str, rpc_url: &str) -> u128 {
    let client = reqwest::Client::new();
    let body = serde_json::json!({
        "jsonrpc": "2.0",
        "method": "eth_getBalance",
        "params": [wallet, "latest"],
        "id": 1
    });
    match client.post(rpc_url).json(&body).send().await {
        Ok(resp) => {
            match resp.json::<serde_json::Value>().await {
                Ok(val) => val["result"].as_str()
                    .and_then(|s| u128::from_str_radix(s.trim_start_matches("0x"), 16).ok())
                    .unwrap_or(0),
                Err(_) => 0,
            }
        }
        Err(_) => 0,
    }
}

pub async fn run(chain_id: u64) -> anyhow::Result<Value> {
    let rpc_url = config::rpc_url(chain_id);

    let chain_display = match chain_id {
        8453  => "Base",
        42161 => "Arbitrum",
        _     => "Base",
    };

    let wallet = onchainos::resolve_wallet(chain_id)
        .map_err(|e| anyhow::anyhow!("Cannot resolve wallet: {e}"))?;

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

    let eth_wei = eth_balance_wei(&wallet, rpc_url).await;
    let eth_balance = eth_wei as f64 / 1e18;

    let has_eth = eth_wei > 0;
    let can_deploy = eth_wei >= MIN_DEPLOY_GAS_WEI;

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

    let (status, suggestion, next_command, onboarding_steps): (&str, &str, String, Vec<String>) =
        if can_deploy {
            (
                "ready",
                "Your wallet has ETH to deploy a token on Base. Try listing recent launches or deploying your own token.",
                format!("clanker {}list-tokens --limit 5", chain_flag),
                vec![
                    "1. Browse recently deployed tokens for inspiration:".to_string(),
                    format!("   clanker {}list-tokens --limit 5", chain_flag),
                    "2. Preview your token deployment (safe — no tx sent):".to_string(),
                    format!("   clanker {}deploy-token --name \"MyToken\" --symbol \"MTK\" --from {}", chain_flag, wallet),
                    "3. Deploy your token (add --confirm):".to_string(),
                    format!("   clanker {}deploy-token --name \"MyToken\" --symbol \"MTK\" --from {} --confirm", chain_flag, wallet),
                    "4. After deployment, claim LP fees:".to_string(),
                    format!("   clanker {}claim-rewards --token-address <your-token> --from {} --confirm", chain_flag, wallet),
                ],
            )
        } else if has_eth && !can_deploy {
            (
                "needs_funds",
                "You have some ETH but may not have enough for deployment gas. Consider adding more ETH.",
                format!("clanker {}list-tokens --limit 5", chain_flag),
                vec![
                    format!("1. Send at least {:.4} ETH to your wallet for deployment gas:", MIN_DEPLOY_GAS_WEI as f64 / 1e18),
                    format!("   {}", wallet),
                    "2. Browse recent Clanker launches while you wait:".to_string(),
                    format!("   clanker {}list-tokens --limit 5", chain_flag),
                    "3. Run quickstart again after topping up:".to_string(),
                    format!("   clanker {}quickstart", chain_flag),
                ],
            )
        } else {
            (
                "no_funds",
                "No ETH found. Bridge ETH to Base to deploy a token.",
                format!("clanker {}list-tokens --limit 5", chain_flag),
                vec![
                    format!("1. Bridge or send ETH to your wallet on {}:", chain_display),
                    format!("   {}", wallet),
                    format!("   Minimum recommended: {:.4} ETH", MIN_DEPLOY_GAS_WEI as f64 / 1e18),
                    "2. Run quickstart again after funding:".to_string(),
                    format!("   clanker {}quickstart", chain_flag),
                    "3. While you wait, explore recent launches:".to_string(),
                    format!("   clanker {}list-tokens --limit 5", chain_flag),
                ],
            )
        };

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

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

    Ok(out)
}

// src/commands/search_tokens.rs — search Clanker tokens by creator address or Farcaster username
use crate::api;
use anyhow::Result;
use serde_json::Value;

pub async fn run(
    query: &str,
    limit: u32,
    offset: u32,
    sort: &str,
    trusted_only: bool,
) -> Result<()> {
    let result: Value = api::search_creator(query, limit, offset, sort, trusted_only).await?;

    let tokens = result["tokens"].as_array().cloned().unwrap_or_default();
    let total = result["total"].as_u64().unwrap_or(0);

    let output = serde_json::json!({
        "ok": true,
        "data": {
            "query": query,
            "tokens": tokens.iter().map(|t| {
                serde_json::json!({
                    "contract_address": t["contract_address"],
                    "name": t["name"],
                    "symbol": t["symbol"],
                    "chain_id": t["chain_id"],
                    "deployed_at": t["deployed_at"],
                    "trust_status": t["trustStatus"],
                })
            }).collect::<Vec<_>>(),
            "total": total,
            "user": result["user"],
            "searched_address": result["searchedAddress"],
        }
    });

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

// src/commands/token_info.rs — query on-chain token info + price for a Clanker token
use crate::onchainos;
use anyhow::Result;

pub fn run(chain_id: u64, token_address: &str) -> Result<()> {
    // Validate address format before querying
    let is_valid_addr = token_address.starts_with("0x")
        && token_address.len() == 42
        && token_address[2..].chars().all(|c| c.is_ascii_hexdigit());
    if !is_valid_addr {
        anyhow::bail!(
            "Invalid token address: '{}'. Must be a 42-character hex address (0x...).",
            token_address
        );
    }

    let info = onchainos::token_info(chain_id, token_address)?;
    let price = onchainos::token_price_info(chain_id, token_address)?;

    // price["data"] is [] when no price oracle covers this token (common for new/illiquid tokens).
    // Surface a clear status rather than a bare empty array.
    let price_data = &price["data"];
    let price_available = !price_data.is_null()
        && !(price_data.is_array() && price_data.as_array().map_or(true, |a| a.is_empty()));

    let price_field = if price_available {
        price_data.clone()
    } else {
        serde_json::json!(null)
    };

    let info_value = {
        let d = &info["data"];
        if let Some(arr) = d.as_array() {
            arr.first().cloned().unwrap_or(serde_json::Value::Null)
        } else {
            d.clone()
        }
    };

    let output = serde_json::json!({
        "ok": true,
        "data": {
            "token_address": token_address,
            "chain_id": chain_id,
            "info": info_value,
            "price": price_field,
            "price_available": price_available,
            "price_note": if price_available {
                serde_json::json!(null)
            } else {
                serde_json::json!("No price data available — token is not yet tracked by any price oracle. This is common for newly deployed or low-liquidity Clanker tokens.")
            }
        }
    });

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

// src/config.rs — Chain config and contract addresses

/// Return the RPC URL for a given chain ID.
pub fn rpc_url(chain_id: u64) -> &'static str {
    match chain_id {
        8453 => "https://base-rpc.publicnode.com",
        42161 => "https://arb1.arbitrum.io/rpc",
        _ => "https://base-rpc.publicnode.com",
    }
}

/// Clanker Factory address keyed by chain ID (v4.0.0).
/// Used to dynamically resolve the fee locker via `feeLockerForToken(address)`.
pub fn factory_address(chain_id: u64) -> Option<&'static str> {
    match chain_id {
        8453 => Some("0xE85A59c628F7d27878ACeB4bf3b35733630083a9"),
        // Arbitrum factory — resolve at runtime via gitbook docs; omit hardcode
        _ => None,
    }
}

/// Fallback ClankerFeeLocker address for Base v4.0 (used if factory lookup fails).
/// 0x63D2DfEA64b3433F4071A98665bcD7Ca14d93496 is the verified V4 locker used by recent Clanker tokens.
/// It exposes tokenRewards(address) and collectRewards(address) (not collectFees).
pub fn fallback_fee_locker(chain_id: u64) -> Option<&'static str> {
    match chain_id {
        8453 => Some("0x63D2DfEA64b3433F4071A98665bcD7Ca14d93496"),
        _ => None,
    }
}

// src/main.rs — Clanker plugin CLI entry point
mod api;
mod commands;
mod config;
mod onchainos;
mod rpc;

use clap::{Parser, Subcommand};

#[derive(Parser)]
#[command(name = "clanker", about = "Clanker token launch plugin for OnchainOS", version)]
struct Cli {
    /// Chain ID (default: 8453 Base; also supports 42161 Arbitrum One)
    #[arg(long, default_value = "8453")]
    chain: u64,

    /// Simulate without broadcasting (skips on-chain calls)
    #[arg(long)]
    dry_run: bool,

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

#[derive(Subcommand)]
enum Commands {
    /// List recently deployed Clanker tokens
    ListTokens {
        /// Page number (1-based)
        #[arg(long, default_value = "1")]
        page: u32,

        /// Number of tokens per page (max 50)
        #[arg(long, default_value = "20")]
        limit: u32,

        /// Sort direction: asc or desc
        #[arg(long, default_value = "desc")]
        sort: String,
    },

    /// Search tokens by creator wallet address or Farcaster username
    SearchTokens {
        /// Wallet address (0x...) or Farcaster username
        #[arg(long)]
        query: String,

        /// Max number of results (max 50)
        #[arg(long, default_value = "20")]
        limit: u32,

        /// Pagination offset
        #[arg(long, default_value = "0")]
        offset: u32,

        /// Sort direction: asc or desc
        #[arg(long, default_value = "desc")]
        sort: String,

        /// Only return tokens from trusted deployers
        #[arg(long)]
        trusted_only: bool,
    },

    /// Query on-chain info and price for a Clanker token
    TokenInfo {
        /// Token contract address
        #[arg(long)]
        address: String,
    },

    /// Deploy a new ERC-20 token directly on-chain via the Clanker V4 factory (no API key required)
    DeployToken {
        /// Token name (e.g. "SkyDog")
        #[arg(long)]
        name: String,

        /// Token symbol (e.g. "SKYDOG")
        #[arg(long)]
        symbol: String,

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

        /// Token image URL (IPFS or HTTPS)
        #[arg(long)]
        image_url: Option<String>,

        /// Confirm and execute the deployment (required after reviewing --dry-run output)
        #[arg(long)]
        confirm: bool,
    },

    /// Claim LP fee rewards for a Clanker token you created
    ClaimRewards {
        /// Token contract address to claim rewards for
        #[arg(long)]
        token_address: String,

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

        /// Confirm and execute the claim (required after reviewing --dry-run output)
        #[arg(long)]
        confirm: bool,
    },

    /// Check wallet state and get personalised onboarding steps
    Quickstart,
}

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

    let result = match cli.command {
        Commands::ListTokens { page, limit, sort } => {
            commands::list_tokens::run(page, limit, &sort, Some(cli.chain)).await
        }

        Commands::SearchTokens {
            query,
            limit,
            offset,
            sort,
            trusted_only,
        } => commands::search_tokens::run(&query, limit, offset, &sort, trusted_only).await,

        Commands::TokenInfo { address } => {
            commands::token_info::run(cli.chain, &address)
                .map_err(|e| anyhow::anyhow!(e))
        }

        Commands::DeployToken {
            name,
            symbol,
            from,
            image_url,
            confirm,
        } => {
            commands::deploy_token::run(
                cli.chain,
                &name,
                &symbol,
                from.as_deref(),
                image_url.as_deref(),
                cli.dry_run,
                confirm,
            )
            .await
        }

        Commands::ClaimRewards {
            token_address,
            from,
            confirm,
        } => {
            commands::claim_rewards::run(
                cli.chain,
                &token_address,
                from.as_deref(),
                cli.dry_run,
                confirm,
            )
            .await
        }

        Commands::Quickstart => {
            match commands::quickstart::run(cli.chain).await {
                Ok(val) => {
                    println!("{}", serde_json::to_string_pretty(&val).unwrap_or_default());
                    Ok(())
                }
                Err(e) => Err(e),
            }
        }
    };

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

// src/onchainos.rs — onchainos CLI wrapper (verified against v2.2.6)
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");

/// Run an onchainos sub-command, check exit code, parse stdout as JSON.
fn run_onchainos(args: &[&str]) -> anyhow::Result<Value> {
    let output = Command::new("onchainos").args(args).output()?;
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        let stdout = String::from_utf8_lossy(&output.stdout);
        return Err(anyhow::anyhow!(
            "onchainos {} failed (exit {}): {}",
            args.first().unwrap_or(&""),
            output.status.code().unwrap_or(-1),
            if stderr.trim().is_empty() { stdout } else { stderr }
        ));
    }
    Ok(serde_json::from_str(&String::from_utf8_lossy(&output.stdout))?)
}

/// Resolve the current logged-in wallet EVM address via `wallet addresses`.
pub fn resolve_wallet(_chain_id: u64) -> anyhow::Result<String> {
    let json = run_onchainos(&["wallet", "addresses"])?;
    Ok(json["data"]["evmAddress"].as_str().unwrap_or("").to_string())
}

/// Call `onchainos wallet contract-call`.
///
/// ⚠️ dry_run=true returns a simulated response immediately — contract-call does NOT
///    accept --dry-run and would fail if we passed it.
/// ⚠️ Add --force for DEX/reward operations to prevent "pending" txHash.
pub async fn wallet_contract_call(
    chain_id: u64,
    to: &str,
    input_data: &str,
    from: Option<&str>,
    amt: Option<u64>,
    force: bool,
    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,
            "to": to
        }));
    }

    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_owned;
    if let Some(f) = from {
        from_owned = f.to_string();
        args.extend_from_slice(&["--from", &from_owned]);
    }

    if force {
        args.push("--force");
    }

    let output = Command::new("onchainos").args(&args).output()?;
    if !output.status.success() {
        let stderr = String::from_utf8_lossy(&output.stderr);
        let stdout = String::from_utf8_lossy(&output.stdout);
        return Err(anyhow::anyhow!(
            "onchainos wallet contract-call failed (exit {}): {}",
            output.status.code().unwrap_or(-1),
            if stderr.trim().is_empty() { stdout } else { stderr }
        ));
    }
    let stdout = String::from_utf8_lossy(&output.stdout);
    Ok(serde_json::from_str(&stdout)?)
}

/// Extract txHash from `wallet contract-call` response, or return an error if the call failed.
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"))
}

/// Run `onchainos security token-scan` and return the parsed JSON result.
/// Uses `--tokens <chainId>:<address>` format as required by the onchainos CLI.
pub fn security_token_scan(chain_id: u64, token_addr: &str) -> anyhow::Result<Value> {
    let tokens_arg = format!("{}:{}", chain_id, token_addr);
    run_onchainos(&["security", "token-scan", "--tokens", &tokens_arg])
}

/// Run `onchainos token info` for a contract address.
pub fn token_info(chain_id: u64, token_addr: &str) -> anyhow::Result<Value> {
    let chain_str = chain_id.to_string();
    run_onchainos(&["token", "info", "--address", token_addr, "--chain", &chain_str])
}

/// Run `onchainos token price-info` for a contract address.
pub fn token_price_info(chain_id: u64, token_addr: &str) -> anyhow::Result<Value> {
    let chain_str = chain_id.to_string();
    run_onchainos(&["token", "price-info", "--address", token_addr, "--chain", &chain_str])
}

/// Run `onchainos wallet status` and return JSON.
pub fn wallet_status() -> anyhow::Result<Value> {
    run_onchainos(&["wallet", "status"])
}

/// Run `onchainos wallet addresses` and return the first EVM address.
pub fn wallet_addresses() -> anyhow::Result<String> {
    let json = run_onchainos(&["wallet", "addresses"])?;
    Ok(json["data"]["evm"]
        .get(0)
        .and_then(|v| v["address"].as_str())
        .unwrap_or("")
        .to_string())
}

// src/rpc.rs — Direct eth_call via JSON-RPC (no onchainos needed for reads)
use anyhow::Context;
use serde_json::{json, Value};

/// Perform a raw `eth_call` against an RPC endpoint.
pub async fn eth_call(rpc_url: &str, to: &str, data: &str) -> anyhow::Result<String> {
    let client = reqwest::Client::builder()
        .timeout(std::time::Duration::from_secs(10))
        .build()
        .context("failed to build HTTP client")?;
    let body = json!({
        "jsonrpc": "2.0",
        "method": "eth_call",
        "params": [
            { "to": to, "data": data },
            "latest"
        ],
        "id": 1
    });
    let resp: Value = client
        .post(rpc_url)
        .json(&body)
        .send()
        .await
        .context("eth_call HTTP request failed")?
        .json()
        .await
        .context("eth_call JSON parse failed")?;

    if let Some(err) = resp.get("error") {
        anyhow::bail!("eth_call RPC error: {}", err);
    }
    Ok(resp["result"].as_str().unwrap_or("0x").to_string())
}

/// Decode a 32-byte ABI-encoded address from an eth_call result (strips 0x + left-pad).
pub fn decode_address_result(hex_result: &str) -> String {
    let s = hex_result.trim_start_matches("0x");
    if s.len() >= 64 {
        format!("0x{}", &s[s.len() - 40..])
    } else {
        String::new()
    }
}

/// Call `feeLockerForToken(address token)` on the Clanker factory to resolve
/// the fee locker address for a given token.
///
/// Selector: keccak256("feeLockerForToken(address)")[0..4] = 0xb14177cb
/// Note: This may revert for tokens where the locker is stored differently;
/// callers should fall back to the config fallback address on error.
pub async fn resolve_fee_locker(
    rpc_url: &str,
    factory_addr: &str,
    token_addr: &str,
) -> anyhow::Result<String> {
    // selector: keccak256("feeLockerForToken(address)") = 0xb14177cb
    let token_padded = format!(
        "{:0>64}",
        token_addr.trim_start_matches("0x").to_lowercase()
    );
    let calldata = format!("0xb14177cb{}", token_padded);

    let result = eth_call(rpc_url, factory_addr, &calldata).await?;
    let addr = decode_address_result(&result);
    Ok(addr)
}

/// Query `tokenRewards(address token)` on a ClankerFeeLocker V4.
///
/// Selector: keccak256("tokenRewards(address)") = 0x30bd3eeb
///
/// Returns `Ok(true)` if the call succeeds and returns non-zero data (rewards exist),
/// `Ok(false)` if the call succeeds and returns empty or zero rewards,
/// or an error if the call fails.
pub async fn has_pending_rewards(
    rpc_url: &str,
    fee_locker_addr: &str,
    token_addr: &str,
) -> anyhow::Result<bool> {
    // selector: keccak256("tokenRewards(address)") = 0x30bd3eeb
    let token_padded = format!(
        "{:0>64}",
        token_addr.trim_start_matches("0x").to_lowercase()
    );
    let calldata = format!("0x30bd3eeb{}", token_padded);

    let result = eth_call(rpc_url, fee_locker_addr, &calldata).await?;
    let hex = result.trim_start_matches("0x");
    // tokenRewards returns a struct (ABI-encoded). If it returns non-empty non-zero
    // data, there is a reward config (though not necessarily claimable balance).
    // We treat any non-empty, non-all-zeros response as "rewards may exist".
    if hex.is_empty() {
        return Ok(false);
    }
    let all_zero = hex.chars().all(|c| c == '0');
    Ok(!all_zero)
}