intentkit 0.5.0__py3-none-any.whl → 0.5.2__py3-none-any.whl

intentkit/skills/moralis/api.py

@@ -0,0 +1,281 @@
+"""API interface for wallet data providers (EVM chains and Solana)."""
+
+import logging
+from typing import Dict
+
+import httpx
+
+from intentkit.skills.moralis.base import CHAIN_MAPPING
+
+logger = logging.getLogger(__name__)
+
+#############################################
+# EVM Chains API (Ethereum, BSC, etc.)
+#############################################
+
+
+async def fetch_moralis_data(
+    api_key: str, endpoint: str, address: str, chain_id: int = None, params: dict = None
+) -> dict:
+    """Base function for Moralis API calls.
+
+    Args:
+        api_key: Moralis API key
+        endpoint: API endpoint (with {address} placeholder if needed)
+        address: Wallet address to query
+        chain_id: Blockchain network ID
+        params: Additional query parameters
+
+    Returns:
+        Response data from the API or error
+    """
+
+    if not api_key:
+        logger.error("API key not configured")
+        return {"error": "API key not configured"}
+
+    base_url = "https://deep-index.moralis.io/api/v2.2"
+    headers = {"X-API-Key": api_key}
+
+    url = f"{base_url}/{endpoint.format(address=address)}"
+
+    if chain_id:
+        params = params or {}
+        params["chain"] = CHAIN_MAPPING.get(chain_id, "eth")
+
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(url, headers=headers, params=params)
+            response.raise_for_status()
+            return response.json()
+        except httpx.RequestError as e:
+            logger.error(f"API request error: {e}")
+            return {"error": str(e)}
+        except httpx.HTTPStatusError as e:
+            logger.error(f"API error: {e.response.status_code} {e.response.text}")
+            return {"error": f"HTTP error {e.response.status_code}"}
+
+
+# Wallet Balances
+async def fetch_wallet_balances(
+    api_key: str, address: str, chain_id: int = None
+) -> dict:
+    """Get token balances with prices.
+
+    Args:
+        api_key: API key for the data provider
+        address: Wallet address to query
+        chain_id: Blockchain network ID
+
+    Returns:
+        Token balances with additional data
+    """
+    endpoint = "wallets/{address}/tokens"
+    return await fetch_moralis_data(api_key, endpoint, address, chain_id)
+
+
+# NFT Balances
+async def fetch_nft_data(
+    api_key: str, address: str, chain_id: int = None, params: dict = None
+) -> dict:
+    """Get NFT balances.
+
+    Args:
+        api_key: API key for the data provider
+        address: Wallet address to query
+        chain_id: Blockchain network ID
+        params: Additional query parameters
+
+    Returns:
+        NFT data including metadata
+    """
+    endpoint = "{address}/nft"
+    default_params = {"normalizeMetadata": True}
+    if params:
+        default_params.update(params)
+    return await fetch_moralis_data(
+        api_key, endpoint, address, chain_id, default_params
+    )
+
+
+# Transaction History
+async def fetch_transaction_history(
+    api_key: str,
+    address: str,
+    chain_id: int = None,
+    cursor: str = None,
+    limit: int = 100,
+) -> dict:
+    """Get wallet transaction history.
+
+    Args:
+        api_key: API key for the data provider
+        address: Wallet address to query
+        chain_id: Blockchain network ID
+        cursor: Pagination cursor
+        limit: Maximum number of transactions to return
+
+    Returns:
+        Transaction history data
+    """
+    endpoint = "wallets/{address}/history"
+    params = {"limit": limit}
+    if cursor:
+        params["cursor"] = cursor
+    return await fetch_moralis_data(api_key, endpoint, address, chain_id, params)
+
+
+# Token Approvals
+async def fetch_token_approvals(
+    api_key: str, address: str, chain_id: int = None
+) -> dict:
+    """Get token approvals.
+
+    Args:
+        api_key: API key for the data provider
+        address: Wallet address to query
+        chain_id: Blockchain network ID
+
+    Returns:
+        Token approval data
+    """
+    endpoint = "wallets/{address}/approvals"
+    return await fetch_moralis_data(api_key, endpoint, address, chain_id)
+
+
+# Net Worth
+async def fetch_net_worth(api_key: str, address: str) -> dict:
+    """Get wallet net worth.
+
+    Args:
+        api_key: API key for the data provider
+        address: Wallet address to query
+
+    Returns:
+        Net worth data across all chains
+    """
+    endpoint = "wallets/{address}/net-worth"
+    return await fetch_moralis_data(api_key, endpoint, address)
+
+
+#############################################
+# Solana API
+#############################################
+
+
+async def fetch_solana_api(api_key: str, endpoint: str, params: Dict = None) -> Dict:
+    """Base function for Solana API calls using Moralis.
+
+    Args:
+        api_key: API key for the data provider
+        endpoint: API endpoint
+        params: Additional query parameters
+
+    Returns:
+        Response data from the API or error
+    """
+
+    if not api_key:
+        logger.error("API key not configured")
+        return {"error": "API key not configured"}
+
+    base_url = "https://solana-gateway.moralis.io"
+    headers = {"X-API-Key": api_key}
+    url = f"{base_url}{endpoint}"
+
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.get(url, headers=headers, params=params)
+            response.raise_for_status()
+            return response.json()
+        except httpx.RequestError as e:
+            logger.error(f"Solana API request error: {e}")
+            return {"error": str(e)}
+        except httpx.HTTPStatusError as e:
+            logger.error(
+                f"Solana API error: {e.response.status_code} {e.response.text}"
+            )
+            return {"error": f"HTTP error {e.response.status_code}: {e.response.text}"}
+
+
+async def get_solana_portfolio(
+    api_key: str, address: str, network: str = "mainnet"
+) -> Dict:
+    """Get complete portfolio for a Solana wallet.
+
+    Args:
+        api_key: API key for the data provider
+        address: Solana wallet address
+        network: Solana network (mainnet or devnet)
+
+    Returns:
+        Complete portfolio including SOL and SPL tokens
+    """
+    endpoint = f"/account/{network}/{address}/portfolio"
+    return await fetch_solana_api(api_key, endpoint)
+
+
+async def get_solana_balance(
+    api_key: str, address: str, network: str = "mainnet"
+) -> Dict:
+    """Get native SOL balance.
+
+    Args:
+        api_key: API key for the data provider
+        address: Solana wallet address
+        network: Solana network (mainnet or devnet)
+
+    Returns:
+        Native SOL balance
+    """
+    endpoint = f"/account/{network}/{address}/balance"
+    return await fetch_solana_api(api_key, endpoint)
+
+
+async def get_solana_spl_tokens(
+    api_key: str, address: str, network: str = "mainnet"
+) -> Dict:
+    """Get SPL token balances.
+
+    Args:
+        api_key: API key for the data provider
+        address: Solana wallet address
+        network: Solana network (mainnet or devnet)
+
+    Returns:
+        SPL token balances
+    """
+    endpoint = f"/account/{network}/{address}/tokens"
+    return await fetch_solana_api(api_key, endpoint)
+
+
+async def get_solana_nfts(api_key: str, address: str, network: str = "mainnet") -> Dict:
+    """Get NFTs owned by a Solana wallet.
+
+    Args:
+        api_key: API key for the data provider
+        address: Solana wallet address
+        network: Solana network (mainnet or devnet)
+
+    Returns:
+        NFT holdings
+    """
+    endpoint = f"/account/{network}/{address}/nft"
+    return await fetch_solana_api(api_key, endpoint)
+
+
+async def get_token_price(
+    api_key: str, token_address: str, network: str = "mainnet"
+) -> Dict:
+    """Get token price by mint address.
+
+    Args:
+        api_key: API key for the data provider
+        token_address: Token mint address
+        network: Solana network (mainnet or devnet)
+
+    Returns:
+        Token price data
+    """
+    endpoint = f"/token/{network}/{token_address}/price"
+    return await fetch_solana_api(api_key, endpoint)

intentkit/skills/moralis/base.py

@@ -0,0 +1,55 @@
+"""Base class for Wallet Portfolio tools."""
+
+from typing import List, Optional, Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill
+
+# Chain ID to chain name mapping for EVM chains
+CHAIN_MAPPING = {
+    1: "eth",
+    56: "bsc",
+    137: "polygon",
+    42161: "arbitrum",
+    10: "optimism",
+    43114: "avalanche",
+    250: "fantom",
+    8453: "base",
+}
+
+# Solana networks
+SOLANA_NETWORKS = ["mainnet", "devnet"]
+
+
+class WalletBaseTool(IntentKitSkill):
+    """Base class for all wallet portfolio tools."""
+
+    name: str = Field(description="The name of the tool")
+    description: str = Field(description="A description of what the tool does")
+    args_schema: Type[BaseModel]
+    skill_store: SkillStoreABC = Field(
+        description="The skill store for persisting data"
+    )
+    api_key: str = Field(description="API key for Moralis")
+
+    # Optional fields for blockchain providers
+    solana_networks: Optional[List[str]] = Field(
+        default=SOLANA_NETWORKS, description="Supported Solana networks"
+    )
+
+    @property
+    def category(self) -> str:
+        return "moralis"
+
+    def _get_chain_name(self, chain_id: int) -> str:
+        """Convert chain ID to chain name for API calls.
+
+        Args:
+            chain_id: The blockchain network ID
+
+        Returns:
+            The chain name used by the API
+        """
+        return CHAIN_MAPPING.get(chain_id, "eth")

intentkit/skills/moralis/fetch_chain_portfolio.py

@@ -0,0 +1,191 @@
+"""fetching wallet portfolio for a specific blockchain."""
+
+import logging
+from typing import List, Optional, Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.skills.moralis.api import fetch_token_approvals, fetch_wallet_balances
+from intentkit.skills.moralis.base import WalletBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class FetchChainPortfolioInput(BaseModel):
+    """Input for FetchChainPortfolio tool."""
+
+    address: str = Field(..., description="Wallet address")
+    chain_id: int = Field(..., description="Chain ID to fetch portfolio for")
+    include_approvals: bool = Field(
+        default=False, description="Whether to include token approvals in the response"
+    )
+
+
+class ChainTokenBalance(BaseModel):
+    """Model for token balance on a specific chain."""
+
+    contract_address: str = Field(..., description="Token contract address")
+    symbol: str = Field(..., description="Token symbol")
+    name: str = Field(..., description="Token name")
+    logo: Optional[str] = Field(None, description="Token logo URL")
+    decimals: int = Field(..., description="Token decimals")
+    balance: float = Field(..., description="Token balance")
+    balance_raw: str = Field(..., description="Raw token balance")
+    balance_usd: float = Field(0.0, description="USD value of token balance")
+
+
+class TokenApproval(BaseModel):
+    """Model for token approval."""
+
+    token_address: str = Field(..., description="Token contract address")
+    token_symbol: Optional[str] = Field(None, description="Token symbol")
+    token_name: Optional[str] = Field(None, description="Token name")
+    spender: str = Field(..., description="Spender address (contract)")
+    spender_name: Optional[str] = Field(None, description="Spender name if known")
+    allowance: str = Field(..., description="Raw approval amount")
+    allowance_formatted: Optional[float] = Field(
+        None, description="Formatted approval amount"
+    )
+    unlimited: bool = Field(False, description="Whether the approval is unlimited")
+
+
+class ChainPortfolioOutput(BaseModel):
+    """Output for FetchChainPortfolio tool."""
+
+    address: str = Field(..., description="Wallet address")
+    chain_id: int = Field(..., description="Chain ID")
+    chain_name: str = Field(..., description="Chain name")
+    native_token: Optional[ChainTokenBalance] = Field(
+        None, description="Native token balance"
+    )
+    tokens: List[ChainTokenBalance] = Field(
+        default_factory=list, description="List of token balances"
+    )
+    total_usd_value: float = Field(0.0, description="Total USD value on this chain")
+    approvals: Optional[List[TokenApproval]] = Field(
+        None, description="Token approvals if requested"
+    )
+    error: Optional[str] = Field(None, description="Error message if any")
+
+
+class FetchChainPortfolio(WalletBaseTool):
+    """Tool for fetching wallet portfolio for a specific blockchain.
+
+    This tool retrieves detailed information about a wallet's holdings on a specific
+    blockchain, including token balances, USD values, and optionally token approvals.
+    """
+
+    name: str = "moralis_fetch_chain_portfolio"
+    description: str = (
+        "This tool fetches wallet portfolio data for a specific blockchain.\n"
+        "Provide a wallet address and chain ID to get detailed information about tokens and their values.\n"
+        "Returns:\n"
+        "- Token balances for the specified chain\n"
+        "- USD value of each token\n"
+        "- Total chain value\n"
+        "- Token metadata (symbol, name, decimals)\n"
+        "- Token approvals (optional)\n"
+        "Use this tool whenever a user wants to see their holdings on a specific blockchain."
+    )
+    args_schema: Type[BaseModel] = FetchChainPortfolioInput
+
+    async def _arun(
+        self, address: str, chain_id: int, include_approvals: bool = False, **kwargs
+    ) -> ChainPortfolioOutput:
+        """Fetch wallet portfolio for a specific chain.
+
+        Args:
+            address: Wallet address to fetch portfolio for
+            chain_id: Chain ID to fetch portfolio for
+            include_approvals: Whether to include token approvals
+
+        Returns:
+            ChainPortfolioOutput containing portfolio data for the specified chain
+        """
+        try:
+            # Fetch wallet balances for the specified chain
+            balances = await fetch_wallet_balances(self.api_key, address, chain_id)
+
+            if "error" in balances:
+                return ChainPortfolioOutput(
+                    address=address,
+                    chain_id=chain_id,
+                    chain_name=self._get_chain_name(chain_id),
+                    error=balances["error"],
+                )
+
+            # Process the data
+            portfolio = {
+                "address": address,
+                "chain_id": chain_id,
+                "chain_name": self._get_chain_name(chain_id),
+                "tokens": [],
+                "total_usd_value": 0.0,
+            }
+
+            for token in balances.get("result", []):
+                token_balance = ChainTokenBalance(
+                    contract_address=token["token_address"],
+                    symbol=token.get("symbol", "UNKNOWN"),
+                    name=token.get("name", "Unknown Token"),
+                    logo=token.get("logo", None),
+                    decimals=token.get("decimals", 18),
+                    balance=float(token.get("balance_formatted", 0)),
+                    balance_raw=token.get("balance", "0"),
+                    balance_usd=float(token.get("usd_value", 0)),
+                )
+
+                # Identify native token
+                if token.get("native_token", False):
+                    portfolio["native_token"] = token_balance
+                else:
+                    portfolio["tokens"].append(token_balance)
+
+                # Add to total USD value
+                portfolio["total_usd_value"] += token_balance.balance_usd
+
+            # Fetch token approvals if requested
+            if include_approvals:
+                approvals_data = await fetch_token_approvals(
+                    self.api_key, address, chain_id
+                )
+
+                if "error" not in approvals_data:
+                    approvals = []
+
+                    for approval in approvals_data.get("result", []):
+                        # Determine if the approval is unlimited (max uint256)
+                        allowance = approval.get("allowance", "0")
+                        is_unlimited = (
+                            allowance
+                            == "115792089237316195423570985008687907853269984665640564039457584007913129639935"
+                        )
+
+                        # Create approval object
+                        token_approval = TokenApproval(
+                            token_address=approval.get("token_address", ""),
+                            token_symbol=approval.get("token_symbol"),
+                            token_name=approval.get("token_name"),
+                            spender=approval.get("spender", ""),
+                            spender_name=approval.get("spender_name"),
+                            allowance=allowance,
+                            allowance_formatted=float(
+                                approval.get("allowance_formatted", 0)
+                            ),
+                            unlimited=is_unlimited,
+                        )
+
+                        approvals.append(token_approval)
+
+                    portfolio["approvals"] = approvals
+
+            return ChainPortfolioOutput(**portfolio)
+
+        except Exception as e:
+            logger.error(f"Error fetching chain portfolio: {str(e)}")
+            return ChainPortfolioOutput(
+                address=address,
+                chain_id=chain_id,
+                chain_name=self._get_chain_name(chain_id),
+                error=str(e),
+            )