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

intentkit/skills/moralis/fetch_nft_portfolio.py

@@ -0,0 +1,284 @@
+"""fetching NFT portfolio for a wallet."""
+
+import json
+import logging
+from typing import Any, Dict, List, Optional, Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.skills.moralis.api import fetch_nft_data, get_solana_nfts
+from intentkit.skills.moralis.base import WalletBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class FetchNftPortfolioInput(BaseModel):
+    """Input for FetchNftPortfolio tool."""
+
+    address: str = Field(..., description="Wallet address")
+    chain_id: Optional[int] = Field(
+        None,
+        description="Chain ID (if not specified, fetches from all supported chains)",
+    )
+    include_solana: bool = Field(
+        default=False, description="Whether to include Solana NFTs"
+    )
+    solana_network: str = Field(
+        default="mainnet", description="Solana network to use (mainnet or devnet)"
+    )
+    limit: Optional[int] = Field(100, description="Maximum number of NFTs to return")
+    normalize_metadata: bool = Field(
+        True, description="Whether to normalize metadata across different standards"
+    )
+
+
+class NftMetadata(BaseModel):
+    """Model for NFT metadata."""
+
+    name: Optional[str] = Field(None, description="NFT name")
+    description: Optional[str] = Field(None, description="NFT description")
+    image: Optional[str] = Field(None, description="NFT image URL")
+    animation_url: Optional[str] = Field(None, description="NFT animation URL")
+    attributes: Optional[List[Dict]] = Field(None, description="NFT attributes/traits")
+    external_url: Optional[str] = Field(None, description="External URL")
+
+
+class NftItem(BaseModel):
+    """Model for an NFT item."""
+
+    token_id: str = Field(..., description="NFT token ID")
+    token_address: str = Field(..., description="NFT contract address")
+    contract_type: Optional[str] = Field(
+        None, description="NFT contract type (ERC721, ERC1155, etc.)"
+    )
+    name: Optional[str] = Field(None, description="NFT name")
+    symbol: Optional[str] = Field(None, description="NFT symbol")
+    owner_of: str = Field(..., description="Owner address")
+    metadata: Optional[NftMetadata] = Field(None, description="NFT metadata")
+    floor_price: Optional[float] = Field(None, description="Floor price if available")
+    chain: str = Field("eth", description="Blockchain network")
+
+
+class NftPortfolioOutput(BaseModel):
+    """Output for FetchNftPortfolio tool."""
+
+    address: str = Field(..., description="Wallet address")
+    nfts: List[NftItem] = Field(default_factory=list, description="List of NFT items")
+    total_count: int = Field(0, description="Total count of NFTs")
+    chains: List[str] = Field(
+        default_factory=list, description="Chains included in the response"
+    )
+    cursor: Optional[str] = Field(None, description="Cursor for pagination")
+    error: Optional[str] = Field(None, description="Error message if any")
+
+
+class FetchNftPortfolio(WalletBaseTool):
+    """Tool for fetching NFT portfolio for a wallet.
+
+    This tool retrieves detailed information about NFTs owned by a wallet address,
+    including metadata, media URLs, and floor prices when available.
+    """
+
+    name: str = "moralis_fetch_nft_portfolio"
+    description: str = (
+        "This tool fetches NFT holdings for a wallet address.\n"
+        "Provide a wallet address and optionally a chain ID to get detailed information about NFTs.\n"
+        "Returns:\n"
+        "- NFT collection data\n"
+        "- NFT metadata and attributes\n"
+        "- Media URLs if available\n"
+        "- Floor prices if available\n"
+        "Use this tool whenever a user asks about their NFTs or digital collectibles."
+    )
+    args_schema: Type[BaseModel] = FetchNftPortfolioInput
+
+    async def _arun(
+        self,
+        address: str,
+        chain_id: Optional[int] = None,
+        include_solana: bool = False,
+        solana_network: str = "mainnet",
+        limit: int = 100,
+        normalize_metadata: bool = True,
+        **kwargs,
+    ) -> NftPortfolioOutput:
+        """Fetch NFT portfolio for a wallet.
+
+        Args:
+            address: Wallet address to fetch NFTs for
+            chain_id: Chain ID to fetch NFTs for (if None, fetches from all supported chains)
+            include_solana: Whether to include Solana NFTs
+            solana_network: Solana network to use (mainnet or devnet)
+            limit: Maximum number of NFTs to return
+            normalize_metadata: Whether to normalize metadata across different standards
+
+        Returns:
+            NftPortfolioOutput containing NFT portfolio data
+        """
+        try:
+            # Initialize result
+            result = {"address": address, "nfts": [], "total_count": 0, "chains": []}
+
+            # Fetch EVM NFTs
+            if chain_id is not None:
+                # Fetch from specific chain
+                await self._fetch_evm_nfts(
+                    address, chain_id, limit, normalize_metadata, result
+                )
+            else:
+                # Fetch from all supported chains
+                from intentkit.skills.moralis.base import CHAIN_MAPPING
+
+                for chain_id in CHAIN_MAPPING.keys():
+                    await self._fetch_evm_nfts(
+                        address,
+                        chain_id,
+                        limit // len(CHAIN_MAPPING),
+                        normalize_metadata,
+                        result,
+                    )
+
+            # Fetch Solana NFTs if requested
+            if include_solana:
+                await self._fetch_solana_nfts(address, solana_network, limit, result)
+
+            return NftPortfolioOutput(**result)
+
+        except Exception as e:
+            logger.error(f"Error fetching NFT portfolio: {str(e)}")
+            return NftPortfolioOutput(
+                address=address, nfts=[], total_count=0, chains=[], error=str(e)
+            )
+
+    async def _fetch_evm_nfts(
+        self,
+        address: str,
+        chain_id: int,
+        limit: int,
+        normalize_metadata: bool,
+        result: Dict[str, Any],
+    ) -> None:
+        """Fetch NFTs from an EVM chain.
+
+        Args:
+            address: Wallet address
+            chain_id: Chain ID
+            limit: Maximum number of NFTs to return
+            normalize_metadata: Whether to normalize metadata
+            result: Result dictionary to update
+        """
+        params = {"limit": limit, "normalizeMetadata": normalize_metadata}
+
+        nft_data = await fetch_nft_data(self.api_key, address, chain_id, params)
+
+        if "error" in nft_data:
+            return
+
+        chain_name = self._get_chain_name(chain_id)
+        if chain_name not in result["chains"]:
+            result["chains"].append(chain_name)
+
+        result["total_count"] += nft_data.get("total", 0)
+
+        if "cursor" in nft_data:
+            result["cursor"] = nft_data["cursor"]
+
+        for nft in nft_data.get("result", []):
+            # Extract metadata
+            metadata = None
+            if "metadata" in nft and nft["metadata"]:
+                try:
+                    if isinstance(nft["metadata"], str):
+                        metadata_dict = json.loads(nft["metadata"])
+                    else:
+                        metadata_dict = nft["metadata"]
+
+                    metadata = NftMetadata(
+                        name=metadata_dict.get("name"),
+                        description=metadata_dict.get("description"),
+                        image=metadata_dict.get("image"),
+                        animation_url=metadata_dict.get("animation_url"),
+                        attributes=metadata_dict.get("attributes"),
+                        external_url=metadata_dict.get("external_url"),
+                    )
+                except Exception as e:
+                    logger.warning(f"Error parsing NFT metadata: {str(e)}")
+                    # If metadata parsing fails, continue without it
+                    pass
+
+            # Create NFT item
+            nft_item = NftItem(
+                token_id=nft.get("token_id", ""),
+                token_address=nft.get("token_address", ""),
+                contract_type=nft.get("contract_type"),
+                name=nft.get("name"),
+                symbol=nft.get("symbol"),
+                owner_of=nft.get("owner_of", address),
+                metadata=metadata,
+                floor_price=nft.get("floor_price"),
+                chain=chain_name,
+            )
+
+            result["nfts"].append(nft_item)
+
+    async def _fetch_solana_nfts(
+        self, address: str, network: str, limit: int, result: Dict[str, Any]
+    ) -> None:
+        """Fetch NFTs from Solana.
+
+        Args:
+            address: Wallet address
+            network: Solana network
+            limit: Maximum number of NFTs to return
+            result: Result dictionary to update
+        """
+        chain_name = "solana"
+        if chain_name not in result["chains"]:
+            result["chains"].append(chain_name)
+
+        nfts_result = await get_solana_nfts(self.api_key, address, network)
+
+        if "error" in nfts_result:
+            return
+
+        if not isinstance(nfts_result, list):
+            return
+
+        count = min(limit, len(nfts_result))
+        result["total_count"] += count
+
+        for i, nft in enumerate(nfts_result):
+            if i >= limit:
+                break
+
+            # Create NFT item
+            metadata = None
+            if "metadata" in nft and nft["metadata"]:
+                try:
+                    metadata_dict = nft["metadata"]
+                    if isinstance(metadata_dict, str):
+                        metadata_dict = json.loads(metadata_dict)
+
+                    metadata = NftMetadata(
+                        name=metadata_dict.get("name"),
+                        description=metadata_dict.get("description"),
+                        image=metadata_dict.get("image"),
+                        animation_url=metadata_dict.get("animation_url"),
+                        attributes=metadata_dict.get("attributes"),
+                        external_url=metadata_dict.get("external_url"),
+                    )
+                except Exception as e:
+                    logger.warning(f"Error parsing Solana NFT metadata: {str(e)}")
+                    pass
+
+            nft_item = NftItem(
+                token_id=nft.get("mint", ""),  # Use mint address as token ID
+                token_address=nft.get("mint", ""),  # Use mint address as token address
+                name=nft.get("name"),
+                symbol=nft.get("symbol"),
+                owner_of=address,
+                metadata=metadata,
+                chain=chain_name,
+            )
+
+            result["nfts"].append(nft_item)

intentkit/skills/moralis/fetch_solana_portfolio.py

@@ -0,0 +1,331 @@
+"""fetching Solana wallet portfolio."""
+
+import logging
+from typing import Dict, List, Optional, Type
+
+from pydantic import BaseModel, Field
+
+from intentkit.skills.moralis.api import (
+    get_solana_balance,
+    get_solana_nfts,
+    get_solana_portfolio,
+    get_solana_spl_tokens,
+    get_token_price,
+)
+from intentkit.skills.moralis.base import WalletBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class SolanaPortfolioInput(BaseModel):
+    """Input for FetchSolanaPortfolio tool."""
+
+    address: str = Field(..., description="Solana wallet address")
+    network: str = Field(
+        default="mainnet", description="Solana network to use (mainnet or devnet)"
+    )
+    include_nfts: bool = Field(
+        default=False, description="Whether to include NFTs in the response"
+    )
+    include_price_data: bool = Field(
+        default=True, description="Whether to include price data for tokens"
+    )
+
+
+class SolanaTokenInfo(BaseModel):
+    """Model for Solana token information."""
+
+    symbol: str
+    name: str
+    decimals: int
+    mint: str
+    associated_token_address: str
+
+
+class SolanaTokenBalance(BaseModel):
+    """Model for Solana token balance."""
+
+    token_info: SolanaTokenInfo
+    amount: float
+    amount_raw: str
+    usd_value: Optional[float] = 0.0
+
+
+class SolanaNftInfo(BaseModel):
+    """Model for Solana NFT information."""
+
+    mint: str
+    name: Optional[str] = None
+    symbol: Optional[str] = None
+    associated_token_address: str
+    metadata: Optional[Dict] = None
+
+
+class SolanaPortfolioOutput(BaseModel):
+    """Output for FetchSolanaPortfolio tool."""
+
+    address: str
+    sol_balance: float
+    sol_balance_lamports: int
+    sol_price_usd: Optional[float] = None
+    sol_value_usd: Optional[float] = None
+    tokens: List[SolanaTokenBalance] = []
+    nfts: List[SolanaNftInfo] = []
+    total_value_usd: float = 0.0
+    error: Optional[str] = None
+
+
+class FetchSolanaPortfolio(WalletBaseTool):
+    """Tool for fetching Solana wallet portfolio.
+
+    This tool retrieves detailed information about a Solana wallet's holdings,
+    including native SOL, SPL tokens, and optionally NFTs.
+    """
+
+    name: str = "moralis_fetch_solana_portfolio"
+    description: str = (
+        "Get comprehensive portfolio data for a Solana wallet including:\n"
+        "- Native SOL balance\n"
+        "- SPL token balances\n"
+        "- NFT holdings (optional)\n"
+        "- USD values of assets\n"
+        "Use this tool whenever the user asks specifically about Solana holdings."
+    )
+    args_schema: Type[BaseModel] = SolanaPortfolioInput
+
+    async def _arun(
+        self,
+        address: str,
+        network: str = "mainnet",
+        include_nfts: bool = False,
+        include_price_data: bool = True,
+        **kwargs,
+    ) -> SolanaPortfolioOutput:
+        """Fetch Solana wallet portfolio data.
+
+        Args:
+            address: Solana wallet address
+            network: Solana network to use (mainnet or devnet)
+            include_nfts: Whether to include NFTs in the response
+            include_price_data: Whether to include price data for tokens
+
+        Returns:
+            SolanaPortfolioOutput containing the Solana wallet's portfolio data
+        """
+        try:
+            # Try to get complete portfolio
+            sol_portfolio = await get_solana_portfolio(self.api_key, address, network)
+
+            if "error" not in sol_portfolio:
+                return await self._process_portfolio_data(
+                    address, network, sol_portfolio, include_nfts, include_price_data
+                )
+            else:
+                # If portfolio endpoint fails, try to fetch data separately
+                return await self._fetch_separate_portfolio_data(
+                    address, network, include_nfts, include_price_data
+                )
+
+        except Exception as e:
+            logger.error(f"Error fetching Solana portfolio: {str(e)}")
+            return SolanaPortfolioOutput(
+                address=address, sol_balance=0, sol_balance_lamports=0, error=str(e)
+            )
+
+    async def _process_portfolio_data(
+        self,
+        address: str,
+        network: str,
+        sol_portfolio: Dict,
+        include_nfts: bool,
+        include_price_data: bool,
+    ) -> SolanaPortfolioOutput:
+        """Process portfolio data from the API.
+
+        Args:
+            address: Solana wallet address
+            network: Solana network
+            sol_portfolio: Portfolio data from the API
+            include_nfts: Whether to include NFTs
+            include_price_data: Whether to include price data
+
+        Returns:
+            SolanaPortfolioOutput with processed data
+        """
+        result = SolanaPortfolioOutput(
+            address=address,
+            sol_balance=float(sol_portfolio.get("nativeBalance", {}).get("solana", 0)),
+            sol_balance_lamports=int(
+                sol_portfolio.get("nativeBalance", {}).get("lamports", 0)
+            ),
+        )
+
+        # Process tokens
+        tokens = []
+        for token in sol_portfolio.get("tokens", []):
+            token_info = SolanaTokenInfo(
+                symbol=token.get("symbol", ""),
+                name=token.get("name", ""),
+                decimals=int(token.get("decimals", 0)),
+                mint=token.get("mint", ""),
+                associated_token_address=token.get("associatedTokenAddress", ""),
+            )
+
+            token_balance = SolanaTokenBalance(
+                token_info=token_info,
+                amount=float(token.get("amount", 0)),
+                amount_raw=token.get("amountRaw", "0"),
+            )
+
+            tokens.append(token_balance)
+
+        result.tokens = tokens
+
+        # Fetch NFTs if requested
+        if include_nfts:
+            nfts_result = await get_solana_nfts(self.api_key, address, network)
+
+            if "error" not in nfts_result and isinstance(nfts_result, list):
+                nfts = []
+                for nft in nfts_result:
+                    nft_info = SolanaNftInfo(
+                        mint=nft.get("mint", ""),
+                        name=nft.get("name"),
+                        symbol=nft.get("symbol"),
+                        associated_token_address=nft.get("associatedTokenAddress", ""),
+                        metadata=nft.get("metadata"),
+                    )
+                    nfts.append(nft_info)
+
+                result.nfts = nfts
+
+        # Fetch price data if requested
+        if include_price_data:
+            # Fetch SOL price
+            sol_price_result = await get_token_price(
+                self.api_key,
+                "So11111111111111111111111111111111111111112",  # SOL mint address
+                network,
+            )
+
+            if "error" not in sol_price_result:
+                sol_price_usd = float(sol_price_result.get("usdPrice", 0))
+                result.sol_price_usd = sol_price_usd
+                result.sol_value_usd = sol_price_usd * result.sol_balance
+                result.total_value_usd += result.sol_value_usd or 0
+
+            # Fetch token prices
+            for token in result.tokens:
+                if token.token_info.mint:
+                    price_result = await get_token_price(
+                        self.api_key, token.token_info.mint, network
+                    )
+
+                    if "error" not in price_result:
+                        token_price_usd = float(price_result.get("usdPrice", 0))
+                        token.usd_value = token_price_usd * token.amount
+                        result.total_value_usd += token.usd_value
+
+        return result
+
+    async def _fetch_separate_portfolio_data(
+        self, address: str, network: str, include_nfts: bool, include_price_data: bool
+    ) -> SolanaPortfolioOutput:
+        """Fetch portfolio data using separate API calls.
+
+        Args:
+            address: Solana wallet address
+            network: Solana network
+            include_nfts: Whether to include NFTs
+            include_price_data: Whether to include price data
+
+        Returns:
+            SolanaPortfolioOutput with processed data
+        """
+        # Get SOL balance
+        balance_result = await get_solana_balance(self.api_key, address, network)
+
+        if "error" in balance_result:
+            return SolanaPortfolioOutput(
+                address=address,
+                sol_balance=0,
+                sol_balance_lamports=0,
+                error=balance_result["error"],
+            )
+
+        result = SolanaPortfolioOutput(
+            address=address,
+            sol_balance=float(balance_result.get("solana", 0)),
+            sol_balance_lamports=int(balance_result.get("lamports", 0)),
+        )
+
+        # Get SPL tokens
+        tokens_result = await get_solana_spl_tokens(self.api_key, address, network)
+
+        if "error" not in tokens_result and isinstance(tokens_result, list):
+            tokens = []
+            for token in tokens_result:
+                token_info = SolanaTokenInfo(
+                    symbol=token.get("symbol", ""),
+                    name=token.get("name", ""),
+                    decimals=int(token.get("decimals", 0)),
+                    mint=token.get("mint", ""),
+                    associated_token_address=token.get("associatedTokenAddress", ""),
+                )
+
+                token_balance = SolanaTokenBalance(
+                    token_info=token_info,
+                    amount=float(token.get("amount", 0)),
+                    amount_raw=token.get("amountRaw", "0"),
+                )
+
+                tokens.append(token_balance)
+
+            result.tokens = tokens
+
+        # Fetch NFTs if requested
+        if include_nfts:
+            nfts_result = await get_solana_nfts(self.api_key, address, network)
+
+            if "error" not in nfts_result and isinstance(nfts_result, list):
+                nfts = []
+                for nft in nfts_result:
+                    nft_info = SolanaNftInfo(
+                        mint=nft.get("mint", ""),
+                        name=nft.get("name"),
+                        symbol=nft.get("symbol"),
+                        associated_token_address=nft.get("associatedTokenAddress", ""),
+                        metadata=nft.get("metadata"),
+                    )
+                    nfts.append(nft_info)
+
+                result.nfts = nfts
+
+        # Fetch price data if requested
+        if include_price_data:
+            # Fetch SOL price
+            sol_price_result = await get_token_price(
+                self.api_key,
+                "So11111111111111111111111111111111111111112",  # SOL mint address
+                network,
+            )
+
+            if "error" not in sol_price_result:
+                sol_price_usd = float(sol_price_result.get("usdPrice", 0))
+                result.sol_price_usd = sol_price_usd
+                result.sol_value_usd = sol_price_usd * result.sol_balance
+                result.total_value_usd += result.sol_value_usd or 0
+
+            # Fetch token prices
+            for token in result.tokens:
+                if token.token_info.mint:
+                    price_result = await get_token_price(
+                        self.api_key, token.token_info.mint, network
+                    )
+
+                    if "error" not in price_result:
+                        token_price_usd = float(price_result.get("usdPrice", 0))
+                        token.usd_value = token_price_usd * token.amount
+                        result.total_value_usd += token.usd_value
+
+        return result