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

intentkit/skills/portfolio/wallet_history.py

@@ -0,0 +1,155 @@
+import logging
+from typing import Any, Dict, Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.portfolio.base import PortfolioBaseTool
+from intentkit.skills.portfolio.constants import (
+    DEFAULT_CHAIN,
+    DEFAULT_LIMIT,
+    DEFAULT_ORDER,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class WalletHistoryInput(BaseModel):
+    """Input for wallet transaction history tool."""
+
+    address: str = Field(
+        description="The address of the wallet to get transaction history for."
+    )
+    chain: str = Field(
+        description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
+        default=DEFAULT_CHAIN,
+    )
+    limit: Optional[int] = Field(
+        description="The desired page size of the result.",
+        default=DEFAULT_LIMIT,
+    )
+    cursor: Optional[str] = Field(
+        description="The cursor returned in the previous response (for pagination).",
+        default=None,
+    )
+    from_block: Optional[int] = Field(
+        description="The minimum block number to get transactions from.",
+        default=None,
+    )
+    to_block: Optional[int] = Field(
+        description="The maximum block number to get transactions from.",
+        default=None,
+    )
+    from_date: Optional[str] = Field(
+        description="The start date to get transactions from (format in seconds or datestring).",
+        default=None,
+    )
+    to_date: Optional[str] = Field(
+        description="The end date to get transactions from (format in seconds or datestring).",
+        default=None,
+    )
+    include_internal_transactions: Optional[bool] = Field(
+        description="If the result should contain the internal transactions.",
+        default=None,
+    )
+    nft_metadata: Optional[bool] = Field(
+        description="If the result should contain the NFT metadata.",
+        default=None,
+    )
+    order: Optional[str] = Field(
+        description="The order of the result, in ascending (ASC) or descending (DESC).",
+        default=DEFAULT_ORDER,
+    )
+
+
+class WalletHistory(PortfolioBaseTool):
+    """Tool for retrieving wallet transaction history using Moralis.
+
+    This tool uses Moralis' API to fetch the full transaction history of a specified wallet address,
+    including sends, receives, token and NFT transfers, and contract interactions.
+    """
+
+    name: str = "portfolio_wallet_history"
+    description: str = (
+        "Retrieve the full transaction history of a specified wallet address, including sends, "
+        "receives, token and NFT transfers, and contract interactions."
+    )
+    args_schema: Type[BaseModel] = WalletHistoryInput
+
+    async def _arun(
+        self,
+        address: str,
+        chain: str = DEFAULT_CHAIN,
+        limit: Optional[int] = DEFAULT_LIMIT,
+        cursor: Optional[str] = None,
+        from_block: Optional[int] = None,
+        to_block: Optional[int] = None,
+        from_date: Optional[str] = None,
+        to_date: Optional[str] = None,
+        include_internal_transactions: Optional[bool] = None,
+        nft_metadata: Optional[bool] = None,
+        order: Optional[str] = DEFAULT_ORDER,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Fetch wallet transaction history from Moralis.
+
+        Args:
+            address: The wallet address to get history for
+            chain: The blockchain to query
+            limit: Number of results per page
+            cursor: Pagination cursor
+            from_block: Minimum block number
+            to_block: Maximum block number
+            from_date: Start date for transactions
+            to_date: End date for transactions
+            include_internal_transactions: Include internal txs
+            nft_metadata: Include NFT metadata
+            order: Order of results (ASC/DESC)
+            config: The configuration for the tool call
+
+        Returns:
+            Dict containing transaction history data
+        """
+        context = self.context_from_config(config)
+        logger.debug(
+            f"wallet_history.py: Fetching wallet history with context {context}"
+        )
+
+        # Get the API key from the agent's configuration
+        api_key = self.get_api_key(context)
+        if not api_key:
+            return {"error": "No Moralis API key provided in the configuration."}
+
+        # Build query parameters
+        params = {"chain": chain, "limit": limit, "order": order}
+
+        # Add optional parameters if they exist
+        if cursor:
+            params["cursor"] = cursor
+        if from_block:
+            params["from_block"] = from_block
+        if to_block:
+            params["to_block"] = to_block
+        if from_date:
+            params["from_date"] = from_date
+        if to_date:
+            params["to_date"] = to_date
+        if include_internal_transactions is not None:
+            params["include_internal_transactions"] = include_internal_transactions
+        if nft_metadata is not None:
+            params["nft_metadata"] = nft_metadata
+
+        # Call Moralis API
+        try:
+            endpoint = f"/wallets/{address}/history"
+            return await self._make_request(
+                method="GET", endpoint=endpoint, api_key=api_key, params=params
+            )
+        except Exception as e:
+            logger.error(
+                f"wallet_history.py: Error fetching wallet history: {e}", exc_info=True
+            )
+            return {
+                "error": "An error occurred while fetching wallet history. Please try again later."
+            }

intentkit/skills/portfolio/wallet_net_worth.py

@@ -0,0 +1,112 @@
+import logging
+from typing import Any, Dict, List, Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.portfolio.base import PortfolioBaseTool
+
+logger = logging.getLogger(__name__)
+
+
+class WalletNetWorthInput(BaseModel):
+    """Input for wallet net worth tool."""
+
+    address: str = Field(description="The wallet address to calculate net worth for.")
+    chains: Optional[List[str]] = Field(
+        description="The chains to query (e.g., ['eth', 'bsc', 'polygon']).",
+        default=None,
+    )
+    exclude_spam: Optional[bool] = Field(
+        description="Exclude spam tokens from the result.",
+        default=True,
+    )
+    exclude_unverified_contracts: Optional[bool] = Field(
+        description="Exclude unverified contracts from the result.",
+        default=True,
+    )
+    max_token_inactivity: Optional[int] = Field(
+        description="Exclude tokens inactive for more than the given amount of days.",
+        default=1,
+    )
+    min_pair_side_liquidity_usd: Optional[float] = Field(
+        description="Exclude tokens with liquidity less than the specified amount in USD.",
+        default=1000,
+    )
+
+
+class WalletNetWorth(PortfolioBaseTool):
+    """Tool for calculating a wallet's total net worth using Moralis.
+
+    This tool uses Moralis' API to calculate the net worth of a wallet in USD across
+    multiple chains, with options to filter out spam and low-liquidity tokens.
+    """
+
+    name: str = "portfolio_wallet_net_worth"
+    description: str = (
+        "Get the net worth of a wallet in USD across multiple chains. "
+        "Filters out spam tokens and low-liquidity assets for more accurate results."
+    )
+    args_schema: Type[BaseModel] = WalletNetWorthInput
+
+    async def _arun(
+        self,
+        address: str,
+        chains: Optional[List[str]] = None,
+        exclude_spam: Optional[bool] = True,
+        exclude_unverified_contracts: Optional[bool] = True,
+        max_token_inactivity: Optional[int] = 1,
+        min_pair_side_liquidity_usd: Optional[float] = 1000,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Calculate wallet net worth from Moralis.
+
+        Args:
+            address: The wallet address to calculate net worth for
+            chains: List of chains to query
+            exclude_spam: Whether to exclude spam tokens
+            exclude_unverified_contracts: Whether to exclude unverified contracts
+            max_token_inactivity: Exclude tokens inactive for more than the given days
+            min_pair_side_liquidity_usd: Exclude tokens with liquidity less than specified
+            config: The configuration for the tool call
+
+        Returns:
+            Dict containing wallet net worth data
+        """
+        context = self.context_from_config(config)
+        logger.debug(
+            f"wallet_net_worth.py: Calculating wallet net worth with context {context}"
+        )
+
+        # Get the API key from the agent's configuration
+        api_key = self.get_api_key(context)
+        if not api_key:
+            return {"error": "No Moralis API key provided in the configuration."}
+
+        # Build query parameters
+        params = {
+            "exclude_spam": exclude_spam,
+            "exclude_unverified_contracts": exclude_unverified_contracts,
+            "max_token_inactivity": max_token_inactivity,
+            "min_pair_side_liquidity_usd": min_pair_side_liquidity_usd,
+        }
+
+        # Add chains if specified
+        if chains:
+            params["chains"] = chains
+
+        # Call Moralis API
+        try:
+            endpoint = f"/wallets/{address}/net-worth"
+            return await self._make_request(
+                method="GET", endpoint=endpoint, api_key=api_key, params=params
+            )
+        except Exception as e:
+            logger.error(
+                f"wallet_net_worth.py: Error calculating wallet net worth: {e}",
+                exc_info=True,
+            )
+            return {
+                "error": "An error occurred while calculating wallet net worth. Please try again later."
+            }

intentkit/skills/portfolio/wallet_nfts.py

@@ -0,0 +1,139 @@
+import logging
+from typing import Any, Dict, List, Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.portfolio.base import PortfolioBaseTool
+from intentkit.skills.portfolio.constants import DEFAULT_CHAIN, DEFAULT_LIMIT
+
+logger = logging.getLogger(__name__)
+
+
+class WalletNFTsInput(BaseModel):
+    """Input for wallet NFTs tool."""
+
+    address: str = Field(description="The address of the wallet to get NFTs for.")
+    chain: str = Field(
+        description="The chain to query (e.g., 'eth', 'base', 'polygon').",
+        default=DEFAULT_CHAIN,
+    )
+    format: Optional[str] = Field(
+        description="The format of the token ID ('decimal' or 'hex').",
+        default="decimal",
+    )
+    limit: Optional[int] = Field(
+        description="The desired page size of the result.",
+        default=DEFAULT_LIMIT,
+    )
+    exclude_spam: Optional[bool] = Field(
+        description="Should spam NFTs be excluded from the result?",
+        default=True,
+    )
+    token_addresses: Optional[List[str]] = Field(
+        description="The non-fungible token (NFT) addresses to get balances for.",
+        default=None,
+    )
+    cursor: Optional[str] = Field(
+        description="The cursor returned in the previous response (for pagination).",
+        default=None,
+    )
+    normalize_metadata: Optional[bool] = Field(
+        description="The option to enable metadata normalization.",
+        default=True,
+    )
+    media_items: Optional[bool] = Field(
+        description="Should preview media data be returned?",
+        default=False,
+    )
+    include_prices: Optional[bool] = Field(
+        description="Should NFT last sale prices be included in the result?",
+        default=False,
+    )
+
+
+class WalletNFTs(PortfolioBaseTool):
+    """Tool for retrieving NFTs owned by a wallet using Moralis.
+
+    This tool uses Moralis' API to fetch NFTs owned by a given address, with options
+    to filter and format the results.
+    """
+
+    name: str = "portfolio_wallet_nfts"
+    description: str = (
+        "Get NFTs owned by a given wallet address. Results include token details, "
+        "metadata, collection information, and optionally prices."
+    )
+    args_schema: Type[BaseModel] = WalletNFTsInput
+
+    async def _arun(
+        self,
+        address: str,
+        chain: str = DEFAULT_CHAIN,
+        format: Optional[str] = "decimal",
+        limit: Optional[int] = DEFAULT_LIMIT,
+        exclude_spam: Optional[bool] = True,
+        token_addresses: Optional[List[str]] = None,
+        cursor: Optional[str] = None,
+        normalize_metadata: Optional[bool] = True,
+        media_items: Optional[bool] = False,
+        include_prices: Optional[bool] = False,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Fetch NFTs owned by a wallet from Moralis.
+
+        Args:
+            address: The wallet address
+            chain: The blockchain to query
+            format: The format of the token ID ('decimal' or 'hex')
+            limit: Number of results per page
+            exclude_spam: Whether to exclude spam NFTs
+            token_addresses: Specific NFT contracts to filter by
+            cursor: Pagination cursor
+            normalize_metadata: Enable metadata normalization
+            media_items: Include preview media data
+            include_prices: Include NFT last sale prices
+            config: The configuration for the tool call
+
+        Returns:
+            Dict containing wallet NFTs data
+        """
+        context = self.context_from_config(config)
+        logger.debug(f"wallet_nfts.py: Fetching wallet NFTs with context {context}")
+
+        # Get the API key from the agent's configuration
+        api_key = self.get_api_key(context)
+        if not api_key:
+            return {"error": "No Moralis API key provided in the configuration."}
+
+        # Build query parameters
+        params = {
+            "chain": chain,
+            "format": format,
+            "limit": limit,
+            "exclude_spam": exclude_spam,
+            "normalizeMetadata": normalize_metadata,
+            "media_items": media_items,
+            "include_prices": include_prices,
+        }
+
+        # Add optional parameters if they exist
+        if token_addresses:
+            params["token_addresses"] = token_addresses
+        if cursor:
+            params["cursor"] = cursor
+
+        # Call Moralis API
+        try:
+            endpoint = f"/{address}/nft"
+            return await self._make_request(
+                method="GET", endpoint=endpoint, api_key=api_key, params=params
+            )
+        except Exception as e:
+            logger.error(
+                f"wallet_nfts.py: Error fetching wallet NFTs: {e}", exc_info=True
+            )
+            return {
+                "error": "An error occurred while fetching wallet NFTs. Please try again later."
+            }

intentkit/skills/portfolio/wallet_profitability.py

@@ -0,0 +1,101 @@
+import logging
+from typing import Any, Dict, List, Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.portfolio.base import PortfolioBaseTool
+from intentkit.skills.portfolio.constants import DEFAULT_CHAIN
+
+logger = logging.getLogger(__name__)
+
+
+class WalletProfitabilityInput(BaseModel):
+    """Input for wallet profitability breakdown tool."""
+
+    address: str = Field(
+        description="The wallet address to get profitability breakdown for."
+    )
+    chain: str = Field(
+        description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
+        default=DEFAULT_CHAIN,
+    )
+    days: Optional[str] = Field(
+        description="Timeframe in days for which profitability is calculated. Options: 'all', '7', '30', '60', '90'.",
+        default="all",
+    )
+    token_addresses: Optional[List[str]] = Field(
+        description="The token addresses list to filter the result with.",
+        default=None,
+    )
+
+
+class WalletProfitability(PortfolioBaseTool):
+    """Tool for retrieving detailed wallet profitability breakdown using Moralis.
+
+    This tool uses Moralis' API to retrieve detailed profitability information for a
+    specific wallet address, with the option to filter by one or more tokens.
+    """
+
+    name: str = "portfolio_wallet_profitability"
+    description: str = (
+        "Retrieve detailed profitability breakdown for a wallet, including profit/loss per token, "
+        "average buy/sell prices, and realized profits. Can be filtered by specific tokens."
+    )
+    args_schema: Type[BaseModel] = WalletProfitabilityInput
+
+    async def _arun(
+        self,
+        address: str,
+        chain: str = DEFAULT_CHAIN,
+        days: Optional[str] = "all",
+        token_addresses: Optional[List[str]] = None,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Fetch detailed wallet profitability from Moralis.
+
+        Args:
+            address: The wallet address to get profitability for
+            chain: The blockchain to query
+            days: Timeframe in days for the profitability data
+            token_addresses: List of token addresses to filter results
+            config: The configuration for the tool call
+
+        Returns:
+            Dict containing wallet profitability breakdown data
+        """
+        context = self.context_from_config(config)
+        logger.debug(
+            f"wallet_profitability.py: Fetching profitability breakdown with context {context}"
+        )
+
+        # Get the API key from the agent's configuration
+        api_key = self.get_api_key(context)
+        if not api_key:
+            return {"error": "No Moralis API key provided in the configuration."}
+
+        # Build query parameters
+        params = {
+            "chain": chain,
+            "days": days,
+        }
+
+        # Add token_addresses if specified
+        if token_addresses:
+            params["token_addresses"] = token_addresses
+
+        # Call Moralis API
+        try:
+            endpoint = f"/wallets/{address}/profitability"
+            return await self._make_request(
+                method="GET", endpoint=endpoint, api_key=api_key, params=params
+            )
+        except Exception as e:
+            logger.error(
+                f"wallet_profitability.py: Error fetching profitability breakdown: {e}",
+                exc_info=True,
+            )
+            return {
+                "error": "An error occurred while fetching profitability breakdown. Please try again later."
+            }

intentkit/skills/portfolio/wallet_profitability_summary.py

@@ -0,0 +1,91 @@
+import logging
+from typing import Any, Dict, Optional, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.portfolio.base import PortfolioBaseTool
+from intentkit.skills.portfolio.constants import DEFAULT_CHAIN
+
+logger = logging.getLogger(__name__)
+
+
+class WalletProfitabilitySummaryInput(BaseModel):
+    """Input for wallet profitability summary tool."""
+
+    address: str = Field(
+        description="The wallet address to get profitability summary for."
+    )
+    chain: str = Field(
+        description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
+        default=DEFAULT_CHAIN,
+    )
+    days: Optional[str] = Field(
+        description="Timeframe in days for the profitability summary. Options: 'all', '7', '30', '60', '90'.",
+        default="all",
+    )
+
+
+class WalletProfitabilitySummary(PortfolioBaseTool):
+    """Tool for retrieving wallet profitability summary using Moralis.
+
+    This tool uses Moralis' API to retrieve a summary of wallet profitability
+    based on specified parameters.
+    """
+
+    name: str = "portfolio_wallet_profitability_summary"
+    description: str = (
+        "Retrieve a summary of wallet profitability including total profit/loss, "
+        "trade volume, and other metrics. Filter by time period."
+    )
+    args_schema: Type[BaseModel] = WalletProfitabilitySummaryInput
+
+    async def _arun(
+        self,
+        address: str,
+        chain: str = DEFAULT_CHAIN,
+        days: Optional[str] = "all",
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Fetch wallet profitability summary from Moralis.
+
+        Args:
+            address: The wallet address to get profitability for
+            chain: The blockchain to query
+            days: Timeframe in days for the summary
+            config: The configuration for the tool call
+
+        Returns:
+            Dict containing wallet profitability summary data
+        """
+        context = self.context_from_config(config)
+        logger.debug(
+            f"wallet_profitability_summary.py: Fetching profitability summary with context {context}"
+        )
+
+        # Get the API key from the agent's configuration
+        api_key = self.get_api_key(context)
+        if not api_key:
+            return {"error": "No Moralis API key provided in the configuration."}
+
+        # Build query parameters
+        params = {
+            "chain": chain,
+            "days": days,
+        }
+
+        # Call Moralis API
+        try:
+            endpoint = f"/wallets/{address}/profitability/summary"
+            return await self._make_request(
+                method="GET", endpoint=endpoint, api_key=api_key, params=params
+            )
+        except Exception as e:
+            logger.error(
+                f"wallet_profitability_summary.py: Error fetching profitability summary: {e}",
+                exc_info=True,
+            )
+            return {
+                "error": "An error occurred while fetching profitability summary. Please try again later."
+            }

intentkit/skills/portfolio/wallet_stats.py

@@ -0,0 +1,79 @@
+import logging
+from typing import Any, Dict, Type
+
+from langchain_core.runnables import RunnableConfig
+from pydantic import BaseModel, Field
+
+from intentkit.skills.portfolio.base import PortfolioBaseTool
+from intentkit.skills.portfolio.constants import DEFAULT_CHAIN
+
+logger = logging.getLogger(__name__)
+
+
+class WalletStatsInput(BaseModel):
+    """Input for wallet stats tool."""
+
+    address: str = Field(description="The wallet address to get stats for.")
+    chain: str = Field(
+        description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
+        default=DEFAULT_CHAIN,
+    )
+
+
+class WalletStats(PortfolioBaseTool):
+    """Tool for retrieving wallet statistics using Moralis.
+
+    This tool uses Moralis' API to get high-level statistical information about
+    a wallet, including NFT counts, collection counts, and transaction counts.
+    """
+
+    name: str = "portfolio_wallet_stats"
+    description: str = (
+        "Get statistical information about a wallet, including the number of NFTs, "
+        "collections, and transaction counts."
+    )
+    args_schema: Type[BaseModel] = WalletStatsInput
+
+    async def _arun(
+        self,
+        address: str,
+        chain: str = DEFAULT_CHAIN,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Fetch wallet stats from Moralis.
+
+        Args:
+            address: The wallet address to get stats for
+            chain: The blockchain to query
+            config: The configuration for the tool call
+
+        Returns:
+            Dict containing wallet stats data
+        """
+        context = self.context_from_config(config)
+        logger.debug(f"wallet_stats.py: Fetching wallet stats with context {context}")
+
+        # Get the API key from the agent's configuration
+        api_key = self.get_api_key(context)
+        if not api_key:
+            return {"error": "No Moralis API key provided in the configuration."}
+
+        # Build query parameters
+        params = {
+            "chain": chain,
+        }
+
+        # Call Moralis API
+        try:
+            endpoint = f"/wallets/{address}/stats"
+            return await self._make_request(
+                method="GET", endpoint=endpoint, api_key=api_key, params=params
+            )
+        except Exception as e:
+            logger.error(
+                f"wallet_stats.py: Error fetching wallet stats: {e}", exc_info=True
+            )
+            return {
+                "error": "An error occurred while fetching wallet stats. Please try again later."
+            }