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

intentkit/skills/portfolio/base.py

@@ -0,0 +1,107 @@
+"""Base classes for portfolio skills."""
+
+import asyncio
+import logging
+from abc import ABC
+from typing import Any, Dict, Type
+
+import aiohttp
+from pydantic import BaseModel, Field
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.skills.base import IntentKitSkill, SkillContext
+from intentkit.skills.portfolio.constants import MORALIS_API_BASE_URL
+
+logger = logging.getLogger(__name__)
+
+
+class PortfolioBaseTool(IntentKitSkill, ABC):
+    """Base class for portfolio analysis skills."""
+
+    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"
+    )
+
+    def get_api_key(self, context: SkillContext) -> str:
+        skill_config = context.config
+        if skill_config.get("api_key_provider") == "agent_owner":
+            return skill_config.get("api_key")
+        return self.skill_store.get_system_config("moralis_api_key")
+
+    @property
+    def category(self) -> str:
+        return "portfolio"
+
+    def _prepare_params(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Convert boolean values to lowercase strings for API compatibility.
+
+        Args:
+            params: Dictionary with query parameters that may contain boolean values
+
+        Returns:
+            Dictionary with boolean values converted to lowercase strings
+        """
+        if not params:
+            return params
+
+        result = {}
+        for key, value in params.items():
+            if isinstance(value, bool):
+                result[key] = str(value).lower()
+            else:
+                result[key] = value
+        return result
+
+    async def _make_request(
+        self,
+        method: str,
+        endpoint: str,
+        api_key: str,
+        params: Dict[str, Any] = None,
+        data: Dict[str, Any] = None,
+    ) -> Dict[str, Any]:
+        """Make a request to the Moralis API.
+
+        Args:
+            method: HTTP method (GET, POST, etc.)
+            endpoint: API endpoint (without base URL)
+            api_key: Moralis API key
+            params: Query parameters
+            data: Request body data for POST requests
+
+        Returns:
+            Response data as dictionary
+        """
+        url = f"{MORALIS_API_BASE_URL}{endpoint}"
+
+        headers = {"accept": "application/json", "X-API-Key": api_key}
+
+        # Convert boolean params to strings
+        processed_params = self._prepare_params(params) if params else None
+
+        logger.debug(f"portfolio/base.py: Making request to {url}")
+
+        async with aiohttp.ClientSession() as session:
+            async with session.request(
+                method=method,
+                url=url,
+                headers=headers,
+                params=processed_params,
+                json=data,
+            ) as response:
+                if response.status >= 400:
+                    error_text = await response.text()
+                    logger.error(f"portfolio/base.py: API error: {error_text}")
+                    return {
+                        "error": f"API error: {response.status}",
+                        "details": error_text,
+                    }
+
+                return await response.json()
+
+    def _run(self, *args: Any, **kwargs: Any) -> Any:
+        """Execute the tool synchronously by running the async version in a loop."""
+        return asyncio.run(self._arun(*args, **kwargs))

intentkit/skills/portfolio/constants.py

@@ -0,0 +1,9 @@
+"""Constants for the portfolio skills module."""
+
+# Base URLs
+MORALIS_API_BASE_URL = "https://deep-index.moralis.io/api/v2.2"
+
+# Default parameters
+DEFAULT_CHAIN = "base"
+DEFAULT_LIMIT = 10
+DEFAULT_ORDER = "DESC"

intentkit/skills/portfolio/schema.json

@@ -0,0 +1,237 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "title": "Portfolio Analysis",
+  "description": "Access blockchain wallet data and analytics through Moralis APIs for portfolio tracking, token balances, and investment performance",
+  "x-icon": "https://ai.service.crestal.dev/skills/portfolio/moralis.png",
+  "x-tags": [
+    "Blockchain",
+    "Web3",
+    "Crypto",
+    "Portfolio",
+    "Wallet"
+  ],
+  "properties": {
+    "enabled": {
+      "type": "boolean",
+      "title": "Enabled",
+      "description": "Whether this skill is enabled",
+      "default": true
+    },
+    "states": {
+      "type": "object",
+      "properties": {
+        "wallet_history": {
+          "type": "string",
+          "title": "Wallet Transaction History",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Retrieve the full transaction history of a specified wallet address",
+          "default": "private"
+        },
+        "token_balances": {
+          "type": "string",
+          "title": "Token Balances",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Get token balances for a specific wallet address and their token prices in USD",
+          "default": "private"
+        },
+        "wallet_approvals": {
+          "type": "string",
+          "title": "Wallet Approvals",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Retrieve active ERC20 token approvals for a specified wallet address",
+          "default": "disabled"
+        },
+        "wallet_swaps": {
+          "type": "string",
+          "title": "Wallet Swaps",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Get all swap-related transactions (buy, sell) for a wallet address",
+          "default": "disabled"
+        },
+        "wallet_net_worth": {
+          "type": "string",
+          "title": "Wallet Net Worth",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Get the net worth of a wallet in USD across multiple chains",
+          "default": "private"
+        },
+        "wallet_profitability_summary": {
+          "type": "string",
+          "title": "Wallet Profitability Summary",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Retrieve a summary of wallet profitability",
+          "default": "private"
+        },
+        "wallet_profitability": {
+          "type": "string",
+          "title": "Wallet Profitability Breakdown",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Retrieve detailed profitability breakdown for a wallet",
+          "default": "private"
+        },
+        "wallet_stats": {
+          "type": "string",
+          "title": "Wallet Stats",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Get statistical information about a wallet",
+          "default": "disabled"
+        },
+        "wallet_defi_positions": {
+          "type": "string",
+          "title": "Wallet DeFi Positions",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Get the positions summary of a wallet address",
+          "default": "disabled"
+        },
+        "wallet_nfts": {
+          "type": "string",
+          "title": "Wallet NFTs",
+          "enum": [
+            "disabled",
+            "public",
+            "private"
+          ],
+          "x-enum-title": [
+            "Disabled",
+            "Agent Owner + All Users",
+            "Agent Owner Only"
+          ],
+          "description": "Get NFTs owned by a given wallet address",
+          "default": "disabled"
+        }
+      },
+      "description": "States for each portfolio blockchain analysis skill (disabled, public, or private)"
+    },
+    "api_key_provider": {
+      "type": "string",
+      "title": "API Key Provider",
+      "description": "Provider of the API key",
+      "enum": [
+        "platform",
+        "agent_owner"
+      ],
+      "x-enum-title": [
+        "Nation Hosted",
+        "Owner Provided"
+      ],
+      "default": "platform"
+    }
+  },
+  "required": [
+    "states",
+    "enabled"
+  ],
+  "if": {
+    "properties": {
+      "api_key_provider": {
+        "const": "agent_owner"
+      }
+    }
+  },
+  "then": {
+    "properties": {
+      "api_key": {
+        "type": "string",
+        "title": "Moralis API Key",
+        "description": "API key for Moralis API service",
+        "x-link": "[Get your API key](https://moralis.io/)",
+        "x-sensitive": true
+      }
+    },
+    "if": {
+      "properties": {
+        "enabled": {
+          "const": true
+        }
+      }
+    },
+    "then": {
+      "required": [
+        "api_key"
+      ]
+    }
+  },
+  "additionalProperties": true
+}

intentkit/skills/portfolio/token_balances.py

@@ -0,0 +1,155 @@
+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 TokenBalancesInput(BaseModel):
+    """Input for token balances tool."""
+
+    address: str = Field(description="The wallet address to check token balances for.")
+    chain: str = Field(
+        description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
+        default=DEFAULT_CHAIN,
+    )
+    to_block: Optional[int] = Field(
+        description="The block number up to which the balances will be checked.",
+        default=None,
+    )
+    token_addresses: Optional[List[str]] = Field(
+        description="The specific token addresses to get balances for.",
+        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,
+    )
+    cursor: Optional[str] = Field(
+        description="The cursor for pagination.",
+        default=None,
+    )
+    limit: Optional[int] = Field(
+        description="The number of results per page.",
+        default=DEFAULT_LIMIT,
+    )
+    exclude_native: Optional[bool] = Field(
+        description="Exclude native balance from the result.",
+        default=None,
+    )
+    max_token_inactivity: Optional[int] = Field(
+        description="Exclude tokens inactive for more than the given amount of days.",
+        default=None,
+    )
+    min_pair_side_liquidity_usd: Optional[float] = Field(
+        description="Exclude tokens with liquidity less than the specified amount in USD.",
+        default=None,
+    )
+
+
+class TokenBalances(PortfolioBaseTool):
+    """Tool for retrieving native and ERC20 token balances using Moralis.
+
+    This tool uses Moralis' API to fetch token balances for a specific wallet address
+    and their token prices in USD.
+    """
+
+    name: str = "portfolio_token_balances"
+    description: str = (
+        "Get token balances for a specific wallet address and their token prices in USD. "
+        "Includes options to exclude spam and unverified contracts."
+    )
+    args_schema: Type[BaseModel] = TokenBalancesInput
+
+    async def _arun(
+        self,
+        address: str,
+        chain: str = DEFAULT_CHAIN,
+        to_block: Optional[int] = None,
+        token_addresses: Optional[List[str]] = None,
+        exclude_spam: Optional[bool] = True,
+        exclude_unverified_contracts: Optional[bool] = True,
+        cursor: Optional[str] = None,
+        limit: Optional[int] = DEFAULT_LIMIT,
+        exclude_native: Optional[bool] = None,
+        max_token_inactivity: Optional[int] = None,
+        min_pair_side_liquidity_usd: Optional[float] = None,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Fetch token balances from Moralis.
+
+        Args:
+            address: The wallet address to get balances for
+            chain: The blockchain to query
+            to_block: Block number up to which balances will be checked
+            token_addresses: Specific token addresses to get balances for
+            exclude_spam: Whether to exclude spam tokens
+            exclude_unverified_contracts: Whether to exclude unverified contracts
+            cursor: Pagination cursor
+            limit: Number of results per page
+            exclude_native: Whether to exclude native balance
+            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 token balances data
+        """
+        context = self.context_from_config(config)
+        logger.debug(
+            f"token_balances.py: Fetching token balances 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,
+            "exclude_spam": exclude_spam,
+            "exclude_unverified_contracts": exclude_unverified_contracts,
+        }
+
+        # Add optional parameters if they exist
+        if to_block:
+            params["to_block"] = to_block
+        if token_addresses:
+            params["token_addresses"] = token_addresses
+        if cursor:
+            params["cursor"] = cursor
+        if exclude_native is not None:
+            params["exclude_native"] = exclude_native
+        if max_token_inactivity:
+            params["max_token_inactivity"] = max_token_inactivity
+        if min_pair_side_liquidity_usd:
+            params["min_pair_side_liquidity_usd"] = min_pair_side_liquidity_usd
+
+        # Call Moralis API
+        try:
+            endpoint = f"/wallets/{address}/tokens"
+            return await self._make_request(
+                method="GET", endpoint=endpoint, api_key=api_key, params=params
+            )
+        except Exception as e:
+            logger.error(
+                f"token_balances.py: Error fetching token balances: {e}", exc_info=True
+            )
+            return {
+                "error": "An error occurred while fetching token balances. Please try again later."
+            }

intentkit/skills/portfolio/wallet_approvals.py

@@ -0,0 +1,102 @@
+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,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class WalletApprovalsInput(BaseModel):
+    """Input for wallet token approvals tool."""
+
+    address: str = Field(description="The wallet address to check token approvals for.")
+    chain: str = Field(
+        description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
+        default=DEFAULT_CHAIN,
+    )
+    cursor: Optional[str] = Field(
+        description="The cursor for pagination.",
+        default=None,
+    )
+    limit: Optional[int] = Field(
+        description="The number of results per page.",
+        default=DEFAULT_LIMIT,
+    )
+
+
+class WalletApprovals(PortfolioBaseTool):
+    """Tool for retrieving token approvals for a wallet using Moralis.
+
+    This tool uses Moralis' API to fetch active ERC20 token approvals for the
+    specified wallet address.
+    """
+
+    name: str = "portfolio_wallet_approvals"
+    description: str = (
+        "Retrieve active ERC20 token approvals for the specified wallet address. "
+        "This helps identify which contracts have permission to spend tokens."
+    )
+    args_schema: Type[BaseModel] = WalletApprovalsInput
+
+    async def _arun(
+        self,
+        address: str,
+        chain: str = DEFAULT_CHAIN,
+        cursor: Optional[str] = None,
+        limit: Optional[int] = DEFAULT_LIMIT,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Fetch wallet token approvals from Moralis.
+
+        Args:
+            address: The wallet address to get approvals for
+            chain: The blockchain to query
+            cursor: Pagination cursor
+            limit: Number of results per page
+            config: The configuration for the tool call
+
+        Returns:
+            Dict containing wallet approvals data
+        """
+        context = self.context_from_config(config)
+        logger.debug(
+            f"wallet_approvals.py: Fetching wallet approvals 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,
+        }
+
+        # Add optional parameters if they exist
+        if cursor:
+            params["cursor"] = cursor
+
+        # Call Moralis API
+        try:
+            endpoint = f"/wallets/{address}/approvals"
+            return await self._make_request(
+                method="GET", endpoint=endpoint, api_key=api_key, params=params
+            )
+        except Exception as e:
+            logger.error(
+                f"wallet_approvals.py: Error fetching wallet approvals: {e}",
+                exc_info=True,
+            )
+            return {
+                "error": "An error occurred while fetching wallet approvals. Please try again later."
+            }

intentkit/skills/portfolio/wallet_defi_positions.py

@@ -0,0 +1,80 @@
+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 WalletDefiPositionsInput(BaseModel):
+    """Input for wallet DeFi positions tool."""
+
+    address: str = Field(description="The wallet address to get DeFi positions for.")
+    chain: str = Field(
+        description="The chain to query (e.g., 'eth', 'bsc', 'polygon').",
+        default=DEFAULT_CHAIN,
+    )
+
+
+class WalletDefiPositions(PortfolioBaseTool):
+    """Tool for retrieving DeFi positions by wallet using Moralis.
+
+    This tool uses Moralis' API to fetch the positions summary of a wallet address,
+    including liquidity positions, staking, lending, and other DeFi activities.
+    """
+
+    name: str = "portfolio_wallet_defi_positions"
+    description: str = (
+        "Get the DeFi positions summary of a wallet address. "
+        "Returns information about liquidity positions, staking, lending, and other DeFi activities."
+    )
+    args_schema: Type[BaseModel] = WalletDefiPositionsInput
+
+    async def _arun(
+        self,
+        address: str,
+        chain: str = DEFAULT_CHAIN,
+        config: RunnableConfig = None,
+        **kwargs,
+    ) -> Dict[str, Any]:
+        """Fetch wallet DeFi positions from Moralis.
+
+        Args:
+            address: The wallet address
+            chain: The blockchain to query
+            config: The configuration for the tool call
+
+        Returns:
+            Dict containing DeFi positions data
+        """
+        context = self.context_from_config(config)
+        logger.debug(
+            f"wallet_defi_positions.py: Fetching wallet DeFi positions with context {context}"
+        )
+
+        # Get the API key from the agent's configuration
+        api_key = context.config.get("api_key")
+        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}/defi/positions"
+            return await self._make_request(
+                method="GET", endpoint=endpoint, api_key=api_key, params=params
+            )
+        except Exception as e:
+            logger.error(
+                f"wallet_defi_positions.py: Error fetching wallet DeFi positions: {e}",
+                exc_info=True,
+            )
+            return {
+                "error": "An error occurred while fetching wallet DeFi positions. Please try again later."
+            }