intentkit 0.6.13.dev2__py3-none-any.whl → 0.8.17__py3-none-any.whl

intentkit/skills/cdp/swap.py

@@ -1,121 +0,0 @@
-from typing import Optional, Type, Union
-
-from pydantic import BaseModel, Field
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.clients import get_cdp_client
-from intentkit.skills.cdp.base import CDPBaseTool
-
-
-class SwapInput(BaseModel):
-    """Input for Swap tool."""
-
-    from_token: str = Field(
-        description="The contract address of the token to swap from (e.g., '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913' for USDC on Base)"
-    )
-    to_token: str = Field(
-        description="The contract address of the token to swap to (e.g., '0x4200000000000000000000000000000000000006' for WETH on Base)"
-    )
-    from_amount: Union[str, int] = Field(
-        description="The amount to swap from in smallest unit (e.g., 1000000 for 1 USDC with 6 decimals)"
-    )
-    slippage_bps: Optional[int] = Field(
-        default=100,
-        description="Maximum slippage in basis points (100 = 1%). Defaults to 100 (1%)",
-    )
-
-
-class Swap(CDPBaseTool):
-    """Tool for swapping tokens using CDP wallet.
-
-    This tool uses the CDP API to execute token swaps on supported networks.
-    It wraps the swap functionality from the EVM account.
-
-    Attributes:
-        name: The name of the tool.
-        description: A description of what the tool does.
-        args_schema: The schema for the tool's input arguments.
-    """
-
-    agent_id: str
-    skill_store: SkillStoreABC
-
-    name: str = "cdp_swap"
-    description: str = (
-        "This tool will swap tokens using the CDP wallet. "
-        "It supports swapping between any ERC-20 tokens on supported networks (Base and Ethereum). "
-        "You need to provide the contract addresses of both tokens and the amount to swap. "
-        "The amount should be in the smallest unit of the token (e.g., wei for ETH, or atomic units for ERC-20 tokens). "
-        "Common token addresses on Base: USDC=0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913, WETH=0x4200000000000000000000000000000000000006. "
-        "The tool will automatically handle gas estimation and transaction submission."
-    )
-    args_schema: Type[BaseModel] = SwapInput
-
-    async def _arun(
-        self,
-        from_token: str,
-        to_token: str,
-        from_amount: Union[str, int],
-        slippage_bps: Optional[int] = 100,
-    ) -> str:
-        """Async implementation of the tool to swap tokens.
-
-        Args:
-            from_token (str): The contract address of the token to swap from.
-            to_token (str): The contract address of the token to swap to.
-            from_amount (Union[str, int]): The amount to swap from in smallest unit.
-            slippage_bps (Optional[int]): Maximum slippage in basis points. Defaults to 100 (1%).
-
-        Returns:
-            str: A message containing the swap result or error message.
-        """
-        try:
-            # Get CDP client and network information
-            cdp_client = await get_cdp_client(self.agent_id, self.skill_store)
-            provider = await cdp_client.get_wallet_provider()
-            provider_config = await cdp_client.get_provider_config()
-            network_id = provider_config.network_id
-
-            # Map network_id to the format expected by the swap API
-            network_mapping = {
-                "base-mainnet": "base",
-                "ethereum-mainnet": "ethereum",
-            }
-            api_network = network_mapping.get(network_id, network_id)
-
-            # Validate network is supported
-            supported_networks = ["base", "ethereum"]
-            if api_network not in supported_networks:
-                return f"Error: Network {api_network} is not supported for swaps. Supported networks: {', '.join(supported_networks)}"
-
-            # Get the EVM account
-            client = provider.get_client()
-            async with client:
-                account = await client.evm.get_account(provider.get_address())
-
-                # Import AccountSwapOptions here to avoid circular imports
-                from cdp.actions.evm.swap.types import AccountSwapOptions
-
-                # Create swap options
-                swap_options = AccountSwapOptions(
-                    network=api_network,
-                    from_token=from_token,
-                    to_token=to_token,
-                    from_amount=str(from_amount),
-                    slippage_bps=slippage_bps,
-                )
-
-                # Execute the swap
-                result = await account.swap(swap_options)
-
-                return (
-                    f"Swap executed successfully!\n"
-                    f"Transaction hash: {result.transaction_hash}\n"
-                    f"Swapped from {from_token} to {to_token}\n"
-                    f"Amount: {from_amount} (smallest units)\n"
-                    f"Network: {api_network}\n"
-                    f"Slippage tolerance: {slippage_bps} basis points ({slippage_bps / 100 if slippage_bps else 0}%)"
-                )
-
-        except Exception as e:
-            return f"Error executing swap: {e!s}"

intentkit/skills/moralis/tests/test_wallet.py

@@ -1,511 +0,0 @@
-"""Tests for the Moralis Wallet Portfolio skills."""
-
-import asyncio
-import json
-import unittest
-from unittest.mock import AsyncMock, MagicMock, patch
-
-from intentkit.skills.moralis import (
-    FetchChainPortfolio,
-    FetchSolanaPortfolio,
-    FetchWalletPortfolio,
-    get_skills,
-)
-from intentkit.skills.moralis.api import (
-    fetch_moralis_data,
-    fetch_wallet_balances,
-    get_solana_portfolio,
-)
-from intentkit.skills.moralis.base import WalletBaseTool
-
-
-class DummyResponse:
-    """Mock HTTP response for testing."""
-
-    def __init__(self, status_code, json_data):
-        self.status_code = status_code
-        self._json_data = json_data
-        self.text = json.dumps(json_data) if json_data else ""
-
-    def json(self):
-        return self._json_data
-
-    async def raise_for_status(self):
-        if self.status_code >= 400:
-            raise Exception(f"HTTP Error: {self.status_code}")
-
-
-class TestWalletBaseClass(unittest.TestCase):
-    """Test the base wallet portfolio tool class."""
-
-    def setUp(self):
-        self.loop = asyncio.new_event_loop()
-        asyncio.set_event_loop(self.loop)
-
-        self.mock_skill_store = MagicMock()
-
-    def tearDown(self):
-        self.loop.close()
-
-    def test_base_class_init(self):
-        """Test base class initialization."""
-
-        # Create a concrete subclass for testing
-        class TestTool(WalletBaseTool):
-            async def _arun(self, *args, **kwargs):
-                return "test"
-
-        tool = TestTool(
-            name="test_tool",
-            description="Test tool",
-            args_schema=MagicMock(),
-            api_key="test_key",
-            skill_store=self.mock_skill_store,
-            agent_id="test_agent",
-        )
-
-        self.assertEqual(tool.api_key, "test_key")
-        self.assertEqual(tool.agent_id, "test_agent")
-        self.assertEqual(tool.skill_store, self.mock_skill_store)
-        self.assertEqual(tool.category, "moralis")
-
-    def test_get_chain_name(self):
-        """Test chain name conversion."""
-
-        class TestTool(WalletBaseTool):
-            async def _arun(self, *args, **kwargs):
-                return "test"
-
-        tool = TestTool(
-            name="test_tool",
-            description="Test tool",
-            args_schema=MagicMock(),
-            api_key="test_key",
-            skill_store=self.mock_skill_store,
-            agent_id="test_agent",
-        )
-
-        # Test with known chain IDs
-        self.assertEqual(tool._get_chain_name(1), "eth")
-        self.assertEqual(tool._get_chain_name(56), "bsc")
-        self.assertEqual(tool._get_chain_name(137), "polygon")
-
-        # Test with unknown chain ID
-        self.assertEqual(tool._get_chain_name(999999), "eth")
-
-
-class TestAPIFunctions(unittest.IsolatedAsyncioTestCase):
-    """Test the API interaction functions."""
-
-    async def test_fetch_moralis_data(self):
-        """Test the base Moralis API function."""
-        with patch("httpx.AsyncClient") as MockClient:
-            client_instance = AsyncMock()
-            client_instance.get.return_value = DummyResponse(
-                200, {"success": True, "data": "test_data"}
-            )
-            MockClient.return_value.__aenter__.return_value = client_instance
-
-            result = await fetch_moralis_data(
-                "test_api_key", "test_endpoint", "0xAddress", 1
-            )
-
-            self.assertEqual(result, {"success": True, "data": "test_data"})
-
-            # Test error handling
-            client_instance.get.return_value = DummyResponse(404, None)
-            client_instance.get.return_value.raise_for_status = AsyncMock(
-                side_effect=Exception("HTTP error 404")
-            )
-
-            result = await fetch_moralis_data(
-                "test_api_key", "test_endpoint", "0xAddress", 1
-            )
-            self.assertIn("error", result)
-
-    async def test_fetch_wallet_balances(self):
-        """Test fetching wallet balances."""
-        with patch("skills.moralis.api.fetch_moralis_data") as mock_fetch:
-            mock_fetch.return_value = {
-                "result": [
-                    {
-                        "token_address": "0x123",
-                        "symbol": "TEST",
-                        "balance": "1000000",
-                        "usd_value": 100,
-                    }
-                ]
-            }
-
-            result = await fetch_wallet_balances("test_api_key", "0xAddress", 1)
-
-            self.assertEqual(result["result"][0]["symbol"], "TEST")
-            mock_fetch.assert_called_once_with(
-                "test_api_key", "wallets/{address}/tokens", "0xAddress", 1, None
-            )
-
-    async def test_get_solana_portfolio(self):
-        """Test getting Solana portfolio."""
-        with patch("skills.moralis.api.fetch_solana_api") as mock_fetch:
-            mock_fetch.return_value = {
-                "nativeBalance": {"solana": 1.5, "lamports": 1500000000},
-                "tokens": [
-                    {
-                        "symbol": "TEST",
-                        "name": "Test Token",
-                        "mint": "TokenMintAddress",
-                        "associatedTokenAddress": "AssocTokenAddress",
-                        "amount": 10,
-                        "decimals": 9,
-                        "amountRaw": "10000000000",
-                    }
-                ],
-            }
-
-            result = await get_solana_portfolio("test_api_key", "SolAddress", "mainnet")
-
-            mock_fetch.assert_called_once_with(
-                "test_api_key", "/account/mainnet/SolAddress/portfolio"
-            )
-            self.assertEqual(result["nativeBalance"]["solana"], 1.5)
-            self.assertEqual(len(result["tokens"]), 1)
-            self.assertEqual(result["tokens"][0]["symbol"], "TEST")
-
-
-class TestFetchWalletPortfolio(unittest.IsolatedAsyncioTestCase):
-    """Test the FetchWalletPortfolio skill."""
-
-    async def test_wallet_portfolio_success(self):
-        """Test successful wallet portfolio fetch."""
-        mock_skill_store = MagicMock()
-
-        with (
-            patch(
-                "skills.moralis.moralis_fetch_wallet_portfolio.fetch_wallet_balances"
-            ) as mock_balances,
-            patch(
-                "skills.moralis.moralis_fetch_wallet_portfolio.fetch_net_worth"
-            ) as mock_net_worth,
-        ):
-            # Mock successful responses
-            mock_balances.return_value = {
-                "result": [
-                    {
-                        "token_address": "0x123",
-                        "symbol": "TEST",
-                        "name": "Test Token",
-                        "balance": "1000000000000000000",
-                        "balance_formatted": "1.0",
-                        "usd_value": 100,
-                    }
-                ]
-            }
-            mock_net_worth.return_value = {"result": {"total_networth_usd": 1000}}
-
-            tool = FetchWalletPortfolio(
-                name="fetch_wallet_portfolio",
-                description="Test description",
-                args_schema=MagicMock(),
-                api_key="test_key",
-                skill_store=mock_skill_store,
-                agent_id="test_agent",
-            )
-
-            result = await tool._arun(address="0xAddress")
-
-            self.assertEqual(result.address, "0xAddress")
-            self.assertEqual(result.total_net_worth, 1000)
-            self.assertEqual(len(result.tokens), 1)
-            self.assertEqual(result.tokens[0].symbol, "TEST")
-
-    async def test_wallet_portfolio_with_solana(self):
-        """Test wallet portfolio with Solana support."""
-        mock_skill_store = MagicMock()
-
-        with (
-            patch(
-                "skills.moralis.moralis_fetch_wallet_portfolio.fetch_wallet_balances"
-            ) as mock_evm_balances,
-            patch(
-                "skills.moralis.moralis_fetch_wallet_portfolio.fetch_net_worth"
-            ) as mock_net_worth,
-            patch(
-                "skills.moralis.moralis_fetch_wallet_portfolio.get_solana_portfolio"
-            ) as mock_sol_portfolio,
-            patch(
-                "skills.moralis.moralis_fetch_wallet_portfolio.get_token_price"
-            ) as mock_token_price,
-        ):
-            # Mock EVM responses
-            mock_evm_balances.return_value = {
-                "result": [
-                    {
-                        "token_address": "0x123",
-                        "symbol": "ETH",
-                        "name": "Ethereum",
-                        "balance": "1000000000000000000",
-                        "balance_formatted": "1.0",
-                        "usd_value": 2000,
-                    }
-                ]
-            }
-            mock_net_worth.return_value = {"result": {"total_networth_usd": 3000}}
-
-            # Mock Solana responses
-            mock_sol_portfolio.return_value = {
-                "nativeBalance": {"solana": 2.0, "lamports": 2000000000},
-                "tokens": [
-                    {
-                        "symbol": "SOL",
-                        "name": "Solana",
-                        "mint": "So11111111111111111111111111111111111111112",
-                        "associatedTokenAddress": "AssocTokenAddress",
-                        "amount": 2.0,
-                        "decimals": 9,
-                        "amountRaw": "2000000000",
-                    }
-                ],
-            }
-
-            mock_token_price.return_value = {"usdPrice": 500}
-
-            tool = FetchWalletPortfolio(
-                name="fetch_wallet_portfolio",
-                description="Test description",
-                args_schema=MagicMock(),
-                api_key="test_key",
-                skill_store=mock_skill_store,
-                agent_id="test_agent",
-            )
-
-            result = await tool._arun(address="0xAddress", include_solana=True)
-
-            self.assertEqual(result.address, "0xAddress")
-            self.assertEqual(
-                result.total_net_worth, 3000
-            )  # Using the net worth from mock
-            self.assertIn("eth", result.chains)
-            self.assertIn("solana", result.chains)
-
-            # Check that we have both EVM and Solana tokens
-            token_symbols = [token.symbol for token in result.tokens]
-            self.assertIn("ETH", token_symbols)
-            self.assertIn("SOL", token_symbols)
-
-
-class TestFetchSolanaPortfolio(unittest.IsolatedAsyncioTestCase):
-    """Test the FetchSolanaPortfolio skill."""
-
-    async def test_solana_portfolio_success(self):
-        """Test successful Solana portfolio fetch."""
-        mock_skill_store = MagicMock()
-
-        with (
-            patch(
-                "skills.moralis.moralis_fetch_solana_portfolio.get_solana_portfolio"
-            ) as mock_portfolio,
-            patch(
-                "skills.moralis.moralis_fetch_solana_portfolio.get_solana_nfts"
-            ) as mock_nfts,
-            patch(
-                "skills.moralis.moralis_fetch_solana_portfolio.get_token_price"
-            ) as mock_token_price,
-        ):
-            # Mock successful responses
-            mock_portfolio.return_value = {
-                "nativeBalance": {"solana": 1.5, "lamports": 1500000000},
-                "tokens": [
-                    {
-                        "symbol": "TEST",
-                        "name": "Test Token",
-                        "mint": "TokenMintAddress",
-                        "associatedTokenAddress": "AssocTokenAddress",
-                        "amount": 10,
-                        "decimals": 9,
-                        "amountRaw": "10000000000",
-                    }
-                ],
-            }
-
-            mock_nfts.return_value = [
-                {
-                    "mint": "NFTMintAddress",
-                    "name": "Test NFT",
-                    "symbol": "TNFT",
-                    "associatedTokenAddress": "AssocTokenAddress",
-                    "metadata": {"name": "Test NFT", "image": "image.png"},
-                }
-            ]
-
-            mock_token_price.return_value = {"usdPrice": 25}
-
-            tool = FetchSolanaPortfolio(
-                name="fetch_solana_portfolio",
-                description="Test description",
-                args_schema=MagicMock(),
-                api_key="test_key",
-                skill_store=mock_skill_store,
-                agent_id="test_agent",
-            )
-
-            result = await tool._arun(address="SolanaAddress", include_nfts=True)
-
-            self.assertEqual(result.address, "SolanaAddress")
-            self.assertEqual(result.sol_balance, 1.5)
-            self.assertEqual(len(result.tokens), 1)
-            self.assertEqual(result.tokens[0].token_info.symbol, "TEST")
-            self.assertEqual(len(result.nfts), 1)
-            self.assertEqual(result.nfts[0].name, "Test NFT")
-            self.assertEqual(result.sol_price_usd, 25)
-            self.assertEqual(result.sol_value_usd, 37.5)  # 1.5 SOL * $25
-
-
-class TestFetchChainPortfolio(unittest.IsolatedAsyncioTestCase):
-    """Test the FetchChainPortfolio skill."""
-
-    async def test_chain_portfolio_success(self):
-        """Test successful chain portfolio fetch."""
-        mock_skill_store = MagicMock()
-
-        with patch(
-            "skills.moralis.moralis_fetch_chain_portfolio.fetch_wallet_balances"
-        ) as mock_balances:
-            # Mock successful responses
-            mock_balances.return_value = {
-                "result": [
-                    {
-                        "token_address": "0x123",
-                        "symbol": "ETH",
-                        "name": "Ethereum",
-                        "logo": "logo.png",
-                        "decimals": 18,
-                        "balance": "1000000000000000000",
-                        "balance_formatted": "1.0",
-                        "usd_value": 2000,
-                        "native_token": True,
-                    },
-                    {
-                        "token_address": "0x456",
-                        "symbol": "TOKEN",
-                        "name": "Test Token",
-                        "logo": "logo2.png",
-                        "decimals": 18,
-                        "balance": "2000000000000000000",
-                        "balance_formatted": "2.0",
-                        "usd_value": 200,
-                        "native_token": False,
-                    },
-                ]
-            }
-
-            tool = FetchChainPortfolio(
-                name="fetch_chain_portfolio",
-                description="Test description",
-                args_schema=MagicMock(),
-                api_key="test_key",
-                skill_store=mock_skill_store,
-                agent_id="test_agent",
-            )
-
-            result = await tool._arun(address="0xAddress", chain_id=1)
-
-            self.assertEqual(result.address, "0xAddress")
-            self.assertEqual(result.chain_id, 1)
-            self.assertEqual(result.chain_name, "eth")
-            self.assertEqual(result.total_usd_value, 2200)  # 2000 + 200
-            self.assertEqual(len(result.tokens), 1)  # Regular tokens, not native
-            self.assertIsNotNone(result.native_token)
-            self.assertEqual(result.native_token.symbol, "ETH")
-            self.assertEqual(result.tokens[0].symbol, "TOKEN")
-
-
-class TestSkillInitialization(unittest.TestCase):
-    """Test skill initialization and configuration."""
-
-    def setUp(self):
-        self.mock_skill_store = MagicMock()
-
-    def test_get_skills(self):
-        """Test getting multiple skills from config."""
-        config = {
-            "api_key": "test_api_key",
-            "states": {
-                "fetch_wallet_portfolio": "public",
-                "fetch_chain_portfolio": "public",
-                "fetch_nft_portfolio": "private",
-                "fetch_transaction_history": "private",
-                "fetch_solana_portfolio": "public",
-            },
-            "supported_chains": {"evm": True, "solana": True},
-        }
-
-        # Test with mock implementation
-        with patch("skills.moralis.base.WalletBaseTool") as mock_tool:
-            mock_tool.return_value = MagicMock()
-
-            # This is just a test structure - actual implementation would create the skills
-            skills = get_skills(
-                config,
-                is_private=False,  # Only get public skills
-                skill_store=self.mock_skill_store,
-                agent_id="test_agent",
-            )
-
-            # In a real implementation, we'd test that the correct skills were returned
-            # For now, we just verify the function exists
-            self.assertIsNotNone(skills)
-
-
-class TestIntegration(unittest.TestCase):
-    """Integration tests for wallet skills."""
-
-    def test_wallet_skill_configuration(self):
-        """Test wallet skill configuration in agent config."""
-        # Example agent configuration
-        agent_config = {
-            "id": "crypto-agent",
-            "skills": {
-                "moralis": {
-                    "api_key": "test_api_key",
-                    "states": {
-                        "fetch_wallet_portfolio": "public",
-                        "fetch_chain_portfolio": "public",
-                        "fetch_nft_portfolio": "private",
-                        "fetch_transaction_history": "private",
-                        "fetch_solana_portfolio": "public",
-                    },
-                    "supported_chains": {"evm": True, "solana": True},
-                }
-            },
-        }
-
-        # Verify the configuration structure is valid
-        moralis_config = agent_config["skills"]["moralis"]
-        self.assertIn("api_key", moralis_config)
-        self.assertIn("states", moralis_config)
-        self.assertIn("supported_chains", moralis_config)
-
-        # Check that all required skills are configured
-        states = moralis_config["states"]
-        required_skills = [
-            "fetch_wallet_portfolio",
-            "fetch_chain_portfolio",
-            "fetch_nft_portfolio",
-            "fetch_transaction_history",
-            "fetch_solana_portfolio",
-        ]
-
-        for skill in required_skills:
-            self.assertIn(skill, states)
-            self.assertIn(states[skill], ["public", "private", "disabled"])
-
-        # Check chain configuration
-        chains = moralis_config["supported_chains"]
-        self.assertIn("evm", chains)
-        self.assertIn("solana", chains)
-        self.assertTrue(isinstance(chains["evm"], bool))
-        self.assertTrue(isinstance(chains["solana"], bool))
-
-
-if __name__ == "__main__":
-    unittest.main()