Debank

"""
DeBank Extension - Blockchain Data Tools

Provides comprehensive blockchain data including:
- User portfolios and balances
- Token data and prices
- Transaction history
- DeFi protocol positions
- NFT holdings
- Transaction simulation

Environment Variables Required:
- DEBANK_API_KEY: DeBank Cloud API key

Usage:
    This extension is auto-loaded by the ExtensionLoader.
    Tools are available to agents configured with these tools in agents.yaml.
"""
import os
import sys
import logging
from typing import List

try:
    from core.tool import ToolRegistry
except Exception:
    ToolRegistry = None  # Standalone script usage

logger = logging.getLogger(__name__)

# Add local tools directory to path for imports
TOOLS_DIR = os.path.join(os.path.dirname(__file__), 'tools')
if TOOLS_DIR not in sys.path:
    sys.path.insert(0, TOOLS_DIR)


def register(api) -> List[str]:
    """
    Extension entry point - register all DeBank tools.

    Args:
        api: ExtensionApi instance with registry and config

    Returns:
        List of registered tool names
    """
    registered = []

    try:
        from .debank import (
            # Chain tools (3)
            DebankChainListTool,
            DebankChainTool,
            DebankGasMarketTool,
            # Token tools (4)
            DebankTokenTool,
            DebankTokenHistoryPriceTool,
            DebankTokenListByIdsTool,
            DebankTokenTopHoldersTool,
            # User balance tools (3)
            DebankUserTotalBalanceTool,
            DebankUserTokenListTool,
            DebankUserAllTokenListTool,
            # User history tools (2)
            DebankUserHistoryListTool,
            DebankUserAllHistoryListTool,
            # User protocol tools (5)
            DebankUserSimpleProtocolListTool,
            DebankUserAllSimpleProtocolListTool,
            DebankUserComplexProtocolListTool,
            DebankUserAllComplexProtocolListTool,
            DebankUserComplexAppListTool,
            # User NFT tools (2)
            DebankUserNftListTool,
            DebankUserAllNftListTool,
            # User misc tools (8)
            DebankUserChainBalanceTool,
            DebankUserTokenTool,
            DebankUserProtocolTool,
            DebankUserUsedChainListTool,
            DebankUserTokenAuthorizedListTool,
            DebankUserNftAuthorizedListTool,
            DebankUserChainNetCurveTool,
            DebankUserTotalNetCurveTool,
            # Wallet tools (2)
            DebankPreExecTxTool,
            DebankExplainTxTool,
            # Protocol tools (5)
            DebankProtocolTool,
            DebankProtocolListTool,
            DebankProtocolAllListTool,
            DebankAppProtocolListTool,
            DebankPoolTool,
        )

        # Register chain tools
        api.register_tool(DebankChainListTool())
        api.register_tool(DebankChainTool())
        api.register_tool(DebankGasMarketTool())

        # Register token tools
        api.register_tool(DebankTokenTool())
        api.register_tool(DebankTokenHistoryPriceTool())
        api.register_tool(DebankTokenListByIdsTool())
        api.register_tool(DebankTokenTopHoldersTool())

        # Register user balance tools
        api.register_tool(DebankUserTotalBalanceTool())
        api.register_tool(DebankUserTokenListTool())
        api.register_tool(DebankUserAllTokenListTool())

        # Register user history tools
        api.register_tool(DebankUserHistoryListTool())
        api.register_tool(DebankUserAllHistoryListTool())

        # Register user protocol tools
        api.register_tool(DebankUserSimpleProtocolListTool())
        api.register_tool(DebankUserAllSimpleProtocolListTool())
        api.register_tool(DebankUserComplexProtocolListTool())
        api.register_tool(DebankUserAllComplexProtocolListTool())
        api.register_tool(DebankUserComplexAppListTool())

        # Register user NFT tools
        api.register_tool(DebankUserNftListTool())
        api.register_tool(DebankUserAllNftListTool())

        # Register user misc tools
        api.register_tool(DebankUserChainBalanceTool())
        api.register_tool(DebankUserTokenTool())
        api.register_tool(DebankUserProtocolTool())
        api.register_tool(DebankUserUsedChainListTool())
        api.register_tool(DebankUserTokenAuthorizedListTool())
        api.register_tool(DebankUserNftAuthorizedListTool())
        api.register_tool(DebankUserChainNetCurveTool())
        api.register_tool(DebankUserTotalNetCurveTool())

        # Register wallet tools
        api.register_tool(DebankPreExecTxTool())
        api.register_tool(DebankExplainTxTool())

        # Register protocol tools
        api.register_tool(DebankProtocolTool())
        api.register_tool(DebankProtocolListTool())
        api.register_tool(DebankProtocolAllListTool())
        api.register_tool(DebankAppProtocolListTool())
        api.register_tool(DebankPoolTool())

        registered.extend([
            # Chain (3)
            "db_chain_list",
            "db_chain",
            "db_gas_market",
            # Token (4)
            "db_token",
            "db_token_history_price",
            "db_token_list_by_ids",
            "db_token_top_holders",
            # User Balance (3)
            "db_user_total_balance",
            "db_user_token_list",
            "db_user_all_token_list",
            # User History (2)
            "db_user_history_list",
            "db_user_all_history_list",
            # User Protocol (5)
            "db_user_simple_protocol_list",
            "db_user_all_simple_protocol_list",
            "db_user_complex_protocol_list",
            "db_user_all_complex_protocol_list",
            "db_user_complex_app_list",
            # User NFT (2)
            "db_user_nft_list",
            "db_user_all_nft_list",
            # User Misc (8)
            "db_user_chain_balance",
            "db_user_token",
            "db_user_protocol",
            "db_user_used_chain_list",
            "db_user_token_authorized_list",
            "db_user_nft_authorized_list",
            "db_user_chain_net_curve",
            "db_user_total_net_curve",
            # Wallet (2)
            "db_pre_exec_tx",
            "db_explain_tx",
            # Protocol (5)
            "db_protocol",
            "db_protocol_list",
            "db_protocol_all_list",
            "db_app_protocol_list",
            "db_pool",
        ])
        logger.info("Registered DeBank tools (34 tools)")
    except Exception as e:
        logger.warning(f"Failed to load DeBank tools: {e}")

    return registered


# Extension metadata
EXTENSION_INFO = {
    "name": "debank",
    "version": "1.0.0",
    "description": "DeBank blockchain data tools",
    "tools": [
        # Chain (3)
        "db_chain_list",
        "db_chain",
        "db_gas_market",
        # Token (4)
        "db_token",
        "db_token_history_price",
        "db_token_list_by_ids",
        "db_token_top_holders",
        # User Balance (3)
        "db_user_total_balance",
        "db_user_token_list",
        "db_user_all_token_list",
        # User History (2)
        "db_user_history_list",
        "db_user_all_history_list",
        # User Protocol (5)
        "db_user_simple_protocol_list",
        "db_user_all_simple_protocol_list",
        "db_user_complex_protocol_list",
        "db_user_all_complex_protocol_list",
        "db_user_complex_app_list",
        # User NFT (2)
        "db_user_nft_list",
        "db_user_all_nft_list",
        # User Misc (8)
        "db_user_chain_balance",
        "db_user_token",
        "db_user_protocol",
        "db_user_used_chain_list",
        "db_user_token_authorized_list",
        "db_user_nft_authorized_list",
        "db_user_chain_net_curve",
        "db_user_total_net_curve",
        # Wallet (2)
        "db_pre_exec_tx",
        "db_explain_tx",
        # Protocol (5)
        "db_protocol",
        "db_protocol_list",
        "db_protocol_all_list",
        "db_app_protocol_list",
        "db_pool",
    ],
    "env_vars": [
        "DEBANK_API_KEY",
    ],
}

"""
DeBank Tool Wrappers

Wraps tools from /tools/debank/ for use in Agent framework.
Provides blockchain data, user portfolios, DeFi positions, and transaction simulation.
"""
import asyncio
import logging
from typing import Any, Dict, List, Optional

from core.tool import BaseTool, ToolContext, ToolResult

logger = logging.getLogger(__name__)

# Import tools from local tools directory
try:
    from .tools.chain import (
        get_chain_list,
        get_chain,
        get_gas_market,
    )
    from .tools.token import (
        get_token,
        get_token_history_price,
        get_token_list_by_ids,
        get_token_top_holders,
    )
    from .tools.user import (
        get_user_total_balance,
        get_user_token_list,
        get_user_all_token_list,
        get_user_history_list,
        get_user_all_history_list,
        get_user_simple_protocol_list,
        get_user_all_simple_protocol_list,
        get_user_complex_protocol_list,
        get_user_all_complex_protocol_list,
        get_user_complex_app_list,
        get_user_nft_list,
        get_user_all_nft_list,
        get_user_chain_balance,
        get_user_token,
        get_user_protocol,
        get_user_used_chain_list,
        get_user_token_authorized_list,
        get_user_nft_authorized_list,
        get_user_chain_net_curve,
        get_user_total_net_curve,
    )
    from .tools.wallet import (
        pre_exec_tx,
        explain_tx,
    )
    from .tools.protocol import (
        get_protocol,
        get_protocol_list,
        get_protocol_all_list,
        get_app_protocol_list,
        get_pool,
    )
    DEBANK_AVAILABLE = True
except ImportError as e:
    logger.warning(f"DeBank tools not available: {e}")
    DEBANK_AVAILABLE = False


# ==================== Chain Tools ====================

class DebankChainListTool(BaseTool):
    """Get list of all supported chains."""

    @property
    def name(self) -> str:
        return "db_chain_list"

    @property
    def description(self) -> str:
        return "Get the list of all chains supported by DeBank."

    @property
    def parameters(self) -> dict:
        return {"type": "object", "properties": {}}

    async def execute(self, ctx: ToolContext) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_chain_list)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankChainTool(BaseTool):
    """Get details of a specific chain."""

    @property
    def name(self) -> str:
        return "db_chain"

    @property
    def description(self) -> str:
        return "Get details of a specific blockchain by chain ID."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "chain_id": {
                    "type": "string",
                    "description": "Chain identifier (eth, bsc, polygon, etc.)"
                }
            },
            "required": ["chain_id"]
        }

    async def execute(self, ctx: ToolContext, chain_id: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_chain, chain_id)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankGasMarketTool(BaseTool):
    """Get gas prices for a chain."""

    @property
    def name(self) -> str:
        return "db_gas_market"

    @property
    def description(self) -> str:
        return "Get current gas prices for a specific chain."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "chain_id": {
                    "type": "string",
                    "description": "Chain identifier"
                }
            },
            "required": ["chain_id"]
        }

    async def execute(self, ctx: ToolContext, chain_id: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_gas_market, chain_id)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


# ==================== Token Tools ====================

class DebankTokenTool(BaseTool):
    """Get token details."""

    @property
    def name(self) -> str:
        return "db_token"

    @property
    def description(self) -> str:
        return "Get token details including symbol, name, decimals, and price."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "chain_id": {"type": "string", "description": "Chain identifier"},
                "token_id": {"type": "string", "description": "Token contract address"}
            },
            "required": ["chain_id", "token_id"]
        }

    async def execute(self, ctx: ToolContext, chain_id: str, token_id: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_token, chain_id, token_id)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankTokenHistoryPriceTool(BaseTool):
    """Get token price history."""

    @property
    def name(self) -> str:
        return "db_token_history_price"

    @property
    def description(self) -> str:
        return "Get historical price data for a token."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "chain_id": {"type": "string", "description": "Chain identifier"},
                "token_id": {"type": "string", "description": "Token contract address"},
                "start_time": {"type": "integer", "description": "Start timestamp (Unix)"},
                "end_time": {"type": "integer", "description": "End timestamp (Unix, optional)"}
            },
            "required": ["chain_id", "token_id", "start_time"]
        }

    async def execute(
        self,
        ctx: ToolContext,
        chain_id: str,
        token_id: str,
        start_time: int,
        end_time: Optional[int] = None
    ) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(
                get_token_history_price, chain_id, token_id, start_time, end_time
            )
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankTokenListByIdsTool(BaseTool):
    """Batch fetch multiple tokens."""

    @property
    def name(self) -> str:
        return "db_token_list_by_ids"

    @property
    def description(self) -> str:
        return "Batch fetch multiple tokens on a chain by their addresses."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "chain_id": {"type": "string", "description": "Chain identifier"},
                "token_ids": {
                    "type": "array",
                    "items": {"type": "string"},
                    "description": "List of token contract addresses"
                }
            },
            "required": ["chain_id", "token_ids"]
        }

    async def execute(self, ctx: ToolContext, chain_id: str, token_ids: List[str]) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_token_list_by_ids, chain_id, token_ids)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankTokenTopHoldersTool(BaseTool):
    """Get top holders of a token."""

    @property
    def name(self) -> str:
        return "db_token_top_holders"

    @property
    def description(self) -> str:
        return "Get top holders of a token on a chain."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "chain_id": {"type": "string", "description": "Chain identifier"},
                "token_id": {"type": "string", "description": "Token contract address"},
                "start": {"type": "integer", "description": "Start index for pagination", "default": 0}
            },
            "required": ["chain_id", "token_id"]
        }

    async def execute(
        self,
        ctx: ToolContext,
        chain_id: str,
        token_id: str,
        start: int = 0
    ) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_token_top_holders, chain_id, token_id, start)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


# ==================== User Balance Tools ====================

class DebankUserTotalBalanceTool(BaseTool):
    """Get user total balance across all chains."""

    @property
    def name(self) -> str:
        return "db_user_total_balance"

    @property
    def description(self) -> str:
        return "Get user's total portfolio balance across all supported chains."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address (0x...)"}
            },
            "required": ["user_addr"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_total_balance, user_addr)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserTokenListTool(BaseTool):
    """Get user token list on a chain."""

    @property
    def name(self) -> str:
        return "db_user_token_list"

    @property
    def description(self) -> str:
        return "Get user's token balances on a specific chain."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "chain_id": {"type": "string", "description": "Chain identifier"},
                "is_all": {"type": "boolean", "description": "Include zero balances", "default": False}
            },
            "required": ["user_addr", "chain_id"]
        }

    async def execute(
        self,
        ctx: ToolContext,
        user_addr: str,
        chain_id: str,
        is_all: Optional[bool] = None
    ) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_token_list, user_addr, chain_id, is_all)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserAllTokenListTool(BaseTool):
    """Get user token list on all chains."""

    @property
    def name(self) -> str:
        return "db_user_all_token_list"

    @property
    def description(self) -> str:
        return "Get user's token balances across all supported chains."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "is_all": {"type": "boolean", "description": "Include zero balances"}
            },
            "required": ["user_addr"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str, is_all: Optional[bool] = None) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_all_token_list, user_addr, is_all)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


# ==================== User History Tools ====================

class DebankUserHistoryListTool(BaseTool):
    """Get user transaction history on a chain."""

    @property
    def name(self) -> str:
        return "db_user_history_list"

    @property
    def description(self) -> str:
        return "Get user's transaction history on a specific chain."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "chain_id": {"type": "string", "description": "Chain identifier"},
                "start_time": {"type": "integer", "description": "Start timestamp (Unix)"},
                "page_count": {"type": "integer", "description": "Number of records (max 20)"}
            },
            "required": ["user_addr", "chain_id"]
        }

    async def execute(
        self,
        ctx: ToolContext,
        user_addr: str,
        chain_id: str,
        start_time: Optional[int] = None,
        page_count: Optional[int] = None
    ) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(
                get_user_history_list, user_addr, chain_id, start_time, page_count
            )
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserAllHistoryListTool(BaseTool):
    """Get user transaction history on all chains."""

    @property
    def name(self) -> str:
        return "db_user_all_history_list"

    @property
    def description(self) -> str:
        return "Get user's transaction history across all supported chains."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "start_time": {"type": "integer", "description": "Start timestamp"},
                "page_count": {"type": "integer", "description": "Number of records (max 20)"}
            },
            "required": ["user_addr"]
        }

    async def execute(
        self,
        ctx: ToolContext,
        user_addr: str,
        start_time: Optional[int] = None,
        page_count: Optional[int] = None
    ) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(
                get_user_all_history_list, user_addr, start_time, page_count
            )
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


# ==================== User Protocol Tools ====================

class DebankUserSimpleProtocolListTool(BaseTool):
    """Get user simple protocol list on a chain."""

    @property
    def name(self) -> str:
        return "db_user_simple_protocol_list"

    @property
    def description(self) -> str:
        return "Get user's simple protocol balances on a specific chain."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "chain_id": {"type": "string", "description": "Chain identifier"}
            },
            "required": ["user_addr", "chain_id"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str, chain_id: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_simple_protocol_list, user_addr, chain_id)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserAllSimpleProtocolListTool(BaseTool):
    """Get user simple protocol list on all chains."""

    @property
    def name(self) -> str:
        return "db_user_all_simple_protocol_list"

    @property
    def description(self) -> str:
        return "Get user's simple protocol balances across all chains."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"}
            },
            "required": ["user_addr"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_all_simple_protocol_list, user_addr)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserComplexProtocolListTool(BaseTool):
    """Get user detailed protocol positions on a chain."""

    @property
    def name(self) -> str:
        return "db_user_complex_protocol_list"

    @property
    def description(self) -> str:
        return "Get user's detailed protocol positions on a specific chain."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "chain_id": {"type": "string", "description": "Chain identifier"}
            },
            "required": ["user_addr", "chain_id"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str, chain_id: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_complex_protocol_list, user_addr, chain_id)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserAllComplexProtocolListTool(BaseTool):
    """Get user detailed protocol positions on all chains."""

    @property
    def name(self) -> str:
        return "db_user_all_complex_protocol_list"

    @property
    def description(self) -> str:
        return "Get user's detailed protocol positions across all chains."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"}
            },
            "required": ["user_addr"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_all_complex_protocol_list, user_addr)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserComplexAppListTool(BaseTool):
    """Get user app-chain protocol positions."""

    @property
    def name(self) -> str:
        return "db_user_complex_app_list"

    @property
    def description(self) -> str:
        return "Get user's detailed positions on app-chain protocols."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"}
            },
            "required": ["user_addr"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_complex_app_list, user_addr)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


# ==================== User NFT Tools ====================

class DebankUserNftListTool(BaseTool):
    """Get user NFT list on a chain."""

    @property
    def name(self) -> str:
        return "db_user_nft_list"

    @property
    def description(self) -> str:
        return "Get user's NFT collections on a specific chain."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "chain_id": {"type": "string", "description": "Chain identifier"},
                "is_all": {"type": "boolean", "description": "Include all NFTs"}
            },
            "required": ["user_addr", "chain_id"]
        }

    async def execute(
        self,
        ctx: ToolContext,
        user_addr: str,
        chain_id: str,
        is_all: Optional[bool] = None
    ) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_nft_list, user_addr, chain_id, is_all)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserAllNftListTool(BaseTool):
    """Get user NFT list on all chains."""

    @property
    def name(self) -> str:
        return "db_user_all_nft_list"

    @property
    def description(self) -> str:
        return "Get user's NFT collections across all chains."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "is_all": {"type": "boolean", "description": "Include all NFTs"}
            },
            "required": ["user_addr"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str, is_all: Optional[bool] = None) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_all_nft_list, user_addr, is_all)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


# ==================== User Misc Tools ====================

class DebankUserChainBalanceTool(BaseTool):
    """Get user balance on a specific chain."""

    @property
    def name(self) -> str:
        return "db_user_chain_balance"

    @property
    def description(self) -> str:
        return "Get user's total balance on a specific chain."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "chain_id": {"type": "string", "description": "Chain identifier"}
            },
            "required": ["user_addr", "chain_id"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str, chain_id: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_chain_balance, user_addr, chain_id)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserTokenTool(BaseTool):
    """Get user balance of a specific token."""

    @property
    def name(self) -> str:
        return "db_user_token"

    @property
    def description(self) -> str:
        return "Get user's balance of a specific token."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "chain_id": {"type": "string", "description": "Chain identifier"},
                "token_id": {"type": "string", "description": "Token contract address"}
            },
            "required": ["user_addr", "chain_id", "token_id"]
        }

    async def execute(
        self,
        ctx: ToolContext,
        user_addr: str,
        chain_id: str,
        token_id: str
    ) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_token, user_addr, chain_id, token_id)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserProtocolTool(BaseTool):
    """Get user realtime portfolio in a protocol."""

    @property
    def name(self) -> str:
        return "db_user_protocol"

    @property
    def description(self) -> str:
        return "Get user's realtime portfolio in a specific protocol."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "protocol_id": {"type": "string", "description": "Protocol identifier"}
            },
            "required": ["user_addr", "protocol_id"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str, protocol_id: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_protocol, user_addr, protocol_id)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserUsedChainListTool(BaseTool):
    """Get list of chains used by user."""

    @property
    def name(self) -> str:
        return "db_user_used_chain_list"

    @property
    def description(self) -> str:
        return "Get list of chains the user has activity on."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"}
            },
            "required": ["user_addr"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_used_chain_list, user_addr)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserTokenAuthorizedListTool(BaseTool):
    """Get user token authorization list."""

    @property
    def name(self) -> str:
        return "db_user_token_authorized_list"

    @property
    def description(self) -> str:
        return "Get user's current token approvals/authorizations on a chain."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "chain_id": {"type": "string", "description": "Chain identifier"}
            },
            "required": ["user_addr", "chain_id"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str, chain_id: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_token_authorized_list, user_addr, chain_id)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserNftAuthorizedListTool(BaseTool):
    """Get user NFT authorization list."""

    @property
    def name(self) -> str:
        return "db_user_nft_authorized_list"

    @property
    def description(self) -> str:
        return "Get user's current NFT approvals/authorizations on a chain."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "chain_id": {"type": "string", "description": "Chain identifier"}
            },
            "required": ["user_addr", "chain_id"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str, chain_id: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_nft_authorized_list, user_addr, chain_id)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserChainNetCurveTool(BaseTool):
    """Get user 24h net curve on a chain."""

    @property
    def name(self) -> str:
        return "db_user_chain_net_curve"

    @property
    def description(self) -> str:
        return "Get user's 24-hour net worth curve on a specific chain."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "chain_id": {"type": "string", "description": "Chain identifier"}
            },
            "required": ["user_addr", "chain_id"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str, chain_id: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_chain_net_curve, user_addr, chain_id)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankUserTotalNetCurveTool(BaseTool):
    """Get user 24h net curve on all chains."""

    @property
    def name(self) -> str:
        return "db_user_total_net_curve"

    @property
    def description(self) -> str:
        return "Get user's 24-hour total net worth curve across all chains."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"}
            },
            "required": ["user_addr"]
        }

    async def execute(self, ctx: ToolContext, user_addr: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_user_total_net_curve, user_addr)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


# ==================== Wallet Tools ====================

class DebankPreExecTxTool(BaseTool):
    """Enhanced pre-execute transaction."""

    @property
    def name(self) -> str:
        return "db_pre_exec_tx"

    @property
    def description(self) -> str:
        return "Simulate a transaction before sending it to the blockchain."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "chain_id": {"type": "string", "description": "Chain identifier"},
                "tx": {
                    "type": "object",
                    "description": "Transaction object with from, to, value, data fields"
                }
            },
            "required": ["user_addr", "chain_id", "tx"]
        }

    async def execute(
        self,
        ctx: ToolContext,
        user_addr: str,
        chain_id: str,
        tx: Dict[str, Any]
    ) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(pre_exec_tx, user_addr, chain_id, tx)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankExplainTxTool(BaseTool):
    """Explain transaction."""

    @property
    def name(self) -> str:
        return "db_explain_tx"

    @property
    def description(self) -> str:
        return "Get human-readable explanation of what a transaction does."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "user_addr": {"type": "string", "description": "User wallet address"},
                "chain_id": {"type": "string", "description": "Chain identifier"},
                "tx": {
                    "type": "object",
                    "description": "Transaction object with from, to, value, data fields"
                }
            },
            "required": ["user_addr", "chain_id", "tx"]
        }

    async def execute(
        self,
        ctx: ToolContext,
        user_addr: str,
        chain_id: str,
        tx: Dict[str, Any]
    ) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(explain_tx, user_addr, chain_id, tx)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


# ==================== Protocol Tools ====================

class DebankProtocolTool(BaseTool):
    """Get protocol details."""

    @property
    def name(self) -> str:
        return "db_protocol"

    @property
    def description(self) -> str:
        return "Get details of a DeFi protocol."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "protocol_id": {"type": "string", "description": "Protocol identifier (e.g., uniswap, aave)"}
            },
            "required": ["protocol_id"]
        }

    async def execute(self, ctx: ToolContext, protocol_id: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_protocol, protocol_id)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankProtocolListTool(BaseTool):
    """Get protocols on a chain."""

    @property
    def name(self) -> str:
        return "db_protocol_list"

    @property
    def description(self) -> str:
        return "Get list of protocols on a specific chain."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "chain_id": {"type": "string", "description": "Chain identifier"}
            },
            "required": ["chain_id"]
        }

    async def execute(self, ctx: ToolContext, chain_id: str) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_protocol_list, chain_id)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankProtocolAllListTool(BaseTool):
    """Get all protocols across all chains."""

    @property
    def name(self) -> str:
        return "db_protocol_all_list"

    @property
    def description(self) -> str:
        return "Get list of all protocols across all supported chains."

    @property
    def parameters(self) -> dict:
        return {"type": "object", "properties": {}}

    async def execute(self, ctx: ToolContext) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_protocol_all_list)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankAppProtocolListTool(BaseTool):
    """Get all app-protocols."""

    @property
    def name(self) -> str:
        return "db_app_protocol_list"

    @property
    def description(self) -> str:
        return "Get list of all app-chain protocols."

    @property
    def parameters(self) -> dict:
        return {"type": "object", "properties": {}}

    async def execute(self, ctx: ToolContext) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_app_protocol_list)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))


class DebankPoolTool(BaseTool):
    """Get pool details."""

    @property
    def name(self) -> str:
        return "db_pool"

    @property
    def description(self) -> str:
        return "Get details of a DeFi pool."

    @property
    def parameters(self) -> dict:
        return {
            "type": "object",
            "properties": {
                "protocol_id": {"type": "string", "description": "Protocol identifier"},
                "chain_id": {"type": "string", "description": "Chain identifier"},
                "pool_id": {"type": "string", "description": "Pool identifier (contract address)"}
            },
            "required": ["protocol_id", "chain_id", "pool_id"]
        }

    async def execute(
        self,
        ctx: ToolContext,
        protocol_id: str,
        chain_id: str,
        pool_id: str
    ) -> ToolResult:
        if not DEBANK_AVAILABLE:
            return ToolResult(success=False, output=None, error="DeBank tools not available")

        try:
            result = await asyncio.to_thread(get_pool, protocol_id, chain_id, pool_id)
            return ToolResult(success=True, output=result)
        except Exception as e:
            return ToolResult(success=False, output=None, error=str(e))

"""
DeBank skill exports — script-mode skill.

Usage from a bash block:
    python3 - <<'EOF'
    import sys
    sys.path.insert(0, "/data/workspace/skills/debank")
    from exports import db_chain_list, db_user_total_balance
    print(db_chain_list())
    EOF

IMPORTANT NOTE on imports:
This skill's tools/ contains files named token.py, chain.py, wallet.py,
user.py — several would shadow Python stdlib modules if we naively put
tools/ on sys.path. Specifically `import token` triggers a circular
import via stdlib `tokenize`.

Strategy: load tools/utils.py manually first (so its symbols are
discoverable), then load each module by file path via importlib. This
fully bypasses sys.path-based `import` resolution and avoids stdlib
shadowing entirely.

For tools/*.py that internally do `from utils import ...`, we register
the loaded utils module under sys.modules['utils'] BEFORE loading any
other tool, so their bare `from utils import ...` resolves to our copy
rather than failing or hitting some other utils on the path.
"""
import os
import sys
import importlib.util

_TOOLS_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "tools")


def _load(modname, register_as=None):
    """Load tools/<modname>.py and optionally register in sys.modules."""
    path = os.path.join(_TOOLS_DIR, f"{modname}.py")
    spec = importlib.util.spec_from_file_location(
        register_as or f"_debank_{modname}", path
    )
    mod = importlib.util.module_from_spec(spec)
    if register_as:
        # Register first so `from <register_as> import ...` works even
        # while this module is still being executed (avoids cycles).
        sys.modules[register_as] = mod
    spec.loader.exec_module(mod)
    return mod


# Step 1: load utils first and register under bare name 'utils' so the
# subsequent tools/*.py files can do `from utils import debank_api_request`.
_utils = _load("utils", register_as="utils")
debank_api_request = _utils.debank_api_request
validate_chain_id = _utils.validate_chain_id

# Step 2: load each tool module. `_debank_*` namespace prevents stdlib
# `token` from being shadowed.
_chain = _load("chain")
_token = _load("token")
_user = _load("user")
_protocol = _load("protocol")
_wallet = _load("wallet")

# --- Chain ---
def db_chain_list():
    """Get list of supported chains."""
    return _chain.get_chain_list()

def db_chain(chain_id):
    """Get details of a specific chain."""
    return _chain.get_chain(chain_id=chain_id)

def db_gas_market(chain_id):
    """Get gas prices for a chain."""
    return _chain.get_gas_market(chain_id=chain_id)

# --- Token ---
def db_token(chain_id, token_id):
    """Get token details."""
    return _token.get_token(chain_id=chain_id, token_id=token_id)

def db_token_history_price(chain_id, token_id, start_time, end_time=None):
    """Get token historical price."""
    return _token.get_token_history_price(chain_id=chain_id, token_id=token_id, start_time=start_time, end_time=end_time)

def db_token_list_by_ids(chain_id, token_ids):
    """Batch fetch multiple tokens on a chain."""
    return _token.get_token_list_by_ids(chain_id=chain_id, token_ids=token_ids)

def db_token_top_holders(chain_id, token_id, start=0):
    """Get top holders of a token."""
    return _token.get_token_top_holders(chain_id=chain_id, token_id=token_id, start=start)

# --- User ---
def db_user_total_balance(user_addr):
    return _user.get_user_total_balance(user_addr=user_addr)

def db_user_token_list(user_addr, chain_id, is_all=None):
    return _user.get_user_token_list(user_addr=user_addr, chain_id=chain_id, is_all=is_all)

def db_user_all_token_list(user_addr, is_all=None):
    return _user.get_user_all_token_list(user_addr=user_addr, is_all=is_all)

def db_user_history_list(user_addr, chain_id, start_time=None, page_count=None):
    return _user.get_user_history_list(user_addr=user_addr, chain_id=chain_id, start_time=start_time, page_count=page_count)

def db_user_all_history_list(user_addr, start_time=None, page_count=None):
    return _user.get_user_all_history_list(user_addr=user_addr, start_time=start_time, page_count=page_count)

def db_user_simple_protocol_list(user_addr, chain_id):
    return _user.get_user_simple_protocol_list(user_addr=user_addr, chain_id=chain_id)

def db_user_all_simple_protocol_list(user_addr):
    return _user.get_user_all_simple_protocol_list(user_addr=user_addr)

def db_user_complex_protocol_list(user_addr, chain_id):
    return _user.get_user_complex_protocol_list(user_addr=user_addr, chain_id=chain_id)

def db_user_all_complex_protocol_list(user_addr):
    return _user.get_user_all_complex_protocol_list(user_addr=user_addr)

def db_user_complex_app_list(user_addr):
    return _user.get_user_complex_app_list(user_addr=user_addr)

def db_user_nft_list(user_addr, chain_id, is_all=None):
    return _user.get_user_nft_list(user_addr=user_addr, chain_id=chain_id, is_all=is_all)

def db_user_all_nft_list(user_addr, is_all=None):
    return _user.get_user_all_nft_list(user_addr=user_addr, is_all=is_all)

def db_user_chain_balance(user_addr, chain_id):
    return _user.get_user_chain_balance(user_addr=user_addr, chain_id=chain_id)

def db_user_token(user_addr, chain_id, token_id):
    return _user.get_user_token(user_addr=user_addr, chain_id=chain_id, token_id=token_id)

def db_user_protocol(user_addr, protocol_id):
    return _user.get_user_protocol(user_addr=user_addr, protocol_id=protocol_id)

def db_user_used_chain_list(user_addr):
    return _user.get_user_used_chain_list(user_addr=user_addr)

def db_user_token_authorized_list(user_addr, chain_id):
    return _user.get_user_token_authorized_list(user_addr=user_addr, chain_id=chain_id)

def db_user_nft_authorized_list(user_addr, chain_id):
    return _user.get_user_nft_authorized_list(user_addr=user_addr, chain_id=chain_id)

def db_user_chain_net_curve(user_addr, chain_id):
    return _user.get_user_chain_net_curve(user_addr=user_addr, chain_id=chain_id)

def db_user_total_net_curve(user_addr):
    return _user.get_user_total_net_curve(user_addr=user_addr)

# --- Protocol ---
def db_protocol(protocol_id):
    return _protocol.get_protocol(protocol_id=protocol_id)

def db_protocol_list(chain_id):
    return _protocol.get_protocol_list(chain_id=chain_id)

def db_protocol_all_list():
    return _protocol.get_protocol_all_list()

def db_app_protocol_list():
    return _protocol.get_app_protocol_list()

def db_pool(protocol_id, chain_id, pool_id):
    return _protocol.get_pool(protocol_id=protocol_id, chain_id=chain_id, pool_id=pool_id)

# --- Wallet / Tx ---
def db_pre_exec_tx(user_addr, chain_id, tx):
    return _wallet.pre_exec_tx(user_addr=user_addr, chain_id=chain_id, tx=tx)

def db_explain_tx(user_addr, chain_id, tx):
    return _wallet.explain_tx(user_addr=user_addr, chain_id=chain_id, tx=tx)

# DeBank Tools Module

#!/usr/bin/env python3
"""
DeBank Chain API Tools

Get information about supported blockchains.
"""

from typing import Dict, Any

try:
    from .utils import debank_api_request, validate_chain_id
except ImportError:
    from utils import debank_api_request, validate_chain_id


def get_chain_list() -> Dict[str, Any]:
    """
    Get the list of current support chains.

    Returns:
        Dict with list of supported chains and their metadata

    Example:
        >>> chains = get_chain_list()
        >>> print(chains)
    """
    return debank_api_request("/v1/chain/list")


def get_chain(chain_id: str) -> Dict[str, Any]:
    """
    Get details of a specific chain.

    Args:
        chain_id: Chain identifier (e.g., "eth", "bsc", "polygon")

    Returns:
        Dict with chain details including name, native token, etc.

    Example:
        >>> chain = get_chain("eth")
        >>> print(chain)
    """
    chain_id = validate_chain_id(chain_id)

    params = {"id": chain_id}
    return debank_api_request("/v1/chain", params=params)


def get_gas_market(chain_id: str) -> Dict[str, Any]:
    """
    Get gas prices for a specific chain.

    Args:
        chain_id: Chain identifier (e.g., "eth", "bsc", "polygon")

    Returns:
        Dict with gas market data including slow, normal, fast, and rapid prices

    Example:
        >>> gas = get_gas_market("eth")
        >>> print(f"Fast gas: {gas['fast']}")
    """
    chain_id = validate_chain_id(chain_id)

    params = {"chain_id": chain_id}
    return debank_api_request("/v1/wallet/gas_market", params=params)

#!/usr/bin/env python3
"""
DeBank Protocol API Tools

Get DeFi protocol and pool information.
"""

from typing import Dict, Any

try:
    from .utils import debank_api_request, validate_chain_id
except ImportError:
    from utils import debank_api_request, validate_chain_id


def get_protocol(protocol_id: str) -> Dict[str, Any]:
    """
    Get details of a protocol.

    Args:
        protocol_id: Protocol identifier (e.g., "uniswap", "aave", "compound")

    Returns:
        Dict with protocol details including name, logo, chains, TVL

    Example:
        >>> protocol = get_protocol("uniswap")
        >>> print(f"{protocol['name']}: ${protocol['tvl']}")
    """
    params = {"id": protocol_id}
    return debank_api_request("/v1/protocol", params=params)


def get_protocol_list(chain_id: str) -> Dict[str, Any]:
    """
    Get protocols of a chain.

    Args:
        chain_id: Chain identifier

    Returns:
        Dict with list of protocols on the chain

    Example:
        >>> protocols = get_protocol_list("eth")
    """
    chain_id = validate_chain_id(chain_id)

    params = {"chain_id": chain_id}
    return debank_api_request("/v1/protocol/list", params=params)


def get_protocol_all_list() -> Dict[str, Any]:
    """
    Get all protocols of supported chains.

    Returns:
        Dict with all protocols across all chains

    Example:
        >>> protocols = get_protocol_all_list()
    """
    return debank_api_request("/v1/protocol/all_list")


def get_app_protocol_list() -> Dict[str, Any]:
    """
    Get all app-protocols.

    Returns:
        Dict with app-chain protocols

    Example:
        >>> app_protocols = get_app_protocol_list()
    """
    return debank_api_request("/v1/app_protocol/list")


def get_pool(
    protocol_id: str,
    chain_id: str,
    pool_id: str
) -> Dict[str, Any]:
    """
    Get details of a pool.

    Args:
        protocol_id: Protocol identifier
        chain_id: Chain identifier
        pool_id: Pool identifier (usually contract address)

    Returns:
        Dict with pool details including tokens, TVL, APY

    Example:
        >>> pool = get_pool("uniswap", "eth", "0x...")
        >>> print(f"APY: {pool['apy']}%")
    """
    chain_id = validate_chain_id(chain_id)

    params = {
        "protocol_id": protocol_id,
        "chain_id": chain_id,
        "id": pool_id
    }
    return debank_api_request("/v1/pool", params=params)

#!/usr/bin/env python3
"""
DeBank Token API Tools

Get token information, prices, and holder data.
"""

from typing import Dict, Any, Optional, List

try:
    from .utils import debank_api_request, validate_chain_id
except ImportError:
    from utils import debank_api_request, validate_chain_id


def get_token(chain_id: str, token_id: str) -> Dict[str, Any]:
    """
    Get token details.

    Args:
        chain_id: Chain identifier (e.g., "eth", "bsc")
        token_id: Token contract address

    Returns:
        Dict with token details including symbol, name, decimals, price

    Example:
        >>> token = get_token("eth", "0x6b175474e89094c44da98b954eedeac495271d0f")
        >>> print(f"{token['symbol']}: ${token['price']}")
    """
    chain_id = validate_chain_id(chain_id)

    params = {
        "chain_id": chain_id,
        "id": token_id
    }
    return debank_api_request("/v1/token", params=params)


def get_token_history_price(
    chain_id: str,
    token_id: str,
    start_time: int,
    end_time: Optional[int] = None
) -> Dict[str, Any]:
    """
    Get token history price.

    Args:
        chain_id: Chain identifier
        token_id: Token contract address
        start_time: Start timestamp (Unix timestamp in seconds)
        end_time: End timestamp (Unix timestamp in seconds). If not provided, uses current time

    Returns:
        Dict with historical price data

    Example:
        >>> prices = get_token_history_price("eth", "0x...", 1640995200, 1672531200)
    """
    chain_id = validate_chain_id(chain_id)

    params = {
        "chain_id": chain_id,
        "id": token_id,
        "start_time": start_time
    }

    if end_time is not None:
        params["end_time"] = end_time

    return debank_api_request("/v1/token/history_price", params=params)


def get_token_list_by_ids(chain_id: str, token_ids: List[str]) -> Dict[str, Any]:
    """
    Batch fetch multiple tokens on a chain.

    Args:
        chain_id: Chain identifier
        token_ids: List of token contract addresses

    Returns:
        Dict with token data for each requested token

    Example:
        >>> tokens = get_token_list_by_ids("eth", ["0x...", "0x..."])
    """
    chain_id = validate_chain_id(chain_id)

    params = {
        "chain_id": chain_id,
        "ids": ",".join(token_ids)
    }
    return debank_api_request("/v1/token/list_by_ids", params=params)


def get_token_top_holders(
    chain_id: str,
    token_id: str,
    start: Optional[int] = 0
) -> Dict[str, Any]:
    """
    Get top holders of token on a chain.

    Args:
        chain_id: Chain identifier
        token_id: Token contract address
        start: Start index for pagination (default: 0)

    Returns:
        Dict with top holders data

    Example:
        >>> holders = get_token_top_holders("eth", "0x...")
        >>> print(f"Top holder: {holders[0]['address']}")
    """
    chain_id = validate_chain_id(chain_id)

    params = {
        "chain_id": chain_id,
        "id": token_id,
        "start": start
    }
    return debank_api_request("/v1/token/top_holders", params=params)