intentkit 0.6.0.dev16__tar.gz → 0.6.0.dev18__tar.gz

{intentkit-0.6.0.dev16 → intentkit-0.6.0.dev18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.6.0.dev16
+Version: 0.6.0.dev18
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestal-network/intentkit
 Project-URL: Repository, https://github.com/crestal-network/intentkit

{intentkit-0.6.0.dev16 → intentkit-0.6.0.dev18}/__init__.py

@@ -3,7 +3,7 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.6.0-dev.16"
+__version__ = "0.6.0-dev.18"
 __author__ = "hyacinthus"
 __email__ = "hyacinthus@gmail.com"
 

intentkit-0.6.0.dev18/clients/cdp.py

@@ -0,0 +1,151 @@
+import json
+import logging
+from typing import Dict, Optional
+
+from bip32 import BIP32
+from cdp import CdpClient as OriginCdpClient
+from cdp import EvmServerAccount
+from coinbase_agentkit import (
+    CdpEvmServerWalletProvider,
+    CdpEvmServerWalletProviderConfig,
+)
+from eth_keys.datatypes import PrivateKey
+from eth_utils import to_checksum_address
+
+from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.models.agent import Agent
+from intentkit.models.agent_data import AgentData
+
+_clients: Dict[str, "CdpClient"] = {}
+
+logger = logging.getLogger(__name__)
+
+
+def bip39_seed_to_eth_keys(seed_hex: str) -> Dict[str, str]:
+    """
+    Converts a BIP39 seed to an Ethereum private key, public key, and address.
+
+    Args:
+        seed_hex: The BIP39 seed in hexadecimal format
+
+    Returns:
+        Dict containing private_key, public_key, and address
+    """
+    # Convert the hex seed to bytes
+    seed_bytes = bytes.fromhex(seed_hex)
+
+    # Derive the master key from the seed
+    bip32 = BIP32.from_seed(seed_bytes)
+
+    # Derive the Ethereum address using the standard derivation path
+    private_key_bytes = bip32.get_privkey_from_path("m/44'/60'/0'/0/0")
+
+    # Create a private key object
+    private_key = PrivateKey(private_key_bytes)
+
+    # Get the public key
+    public_key = private_key.public_key
+
+    # Get the Ethereum address
+    address = public_key.to_address()
+
+    return {
+        "private_key": private_key.to_hex(),
+        "public_key": public_key.to_hex(),
+        "address": to_checksum_address(address),
+    }
+
+
+class CdpClient:
+    def __init__(self, agent_id: str, skill_store: SkillStoreABC) -> None:
+        self._agent_id = agent_id
+        self._skill_store = skill_store
+        self._wallet_provider: Optional[CdpEvmServerWalletProvider] = None
+        self._wallet_provider_config: Optional[CdpEvmServerWalletProviderConfig] = None
+
+    async def get_wallet_provider(self) -> CdpEvmServerWalletProvider:
+        if self._wallet_provider:
+            return self._wallet_provider
+        agent: Agent = await self._skill_store.get_agent_config(self._agent_id)
+        agent_data: AgentData = await self._skill_store.get_agent_data(self._agent_id)
+        network_id = agent.network_id or agent.cdp_network_id
+
+        # Get credentials from skill store system config
+        api_key_id = self._skill_store.get_system_config("cdp_api_key_id")
+        api_key_secret = self._skill_store.get_system_config("cdp_api_key_secret")
+        wallet_secret = self._skill_store.get_system_config("cdp_wallet_secret")
+
+        # already have address
+        address = agent_data.evm_wallet_address
+
+        # new agent or address not migrated yet
+        if not address:
+            # create cdp client for later use
+            cdp_client = OriginCdpClient(
+                api_key_id=api_key_id,
+                api_key_secret=api_key_secret,
+                wallet_secret=wallet_secret,
+            )
+            # try migrating from v1 cdp_wallet_data
+            if agent_data.cdp_wallet_data:
+                wallet_data = json.loads(agent_data.cdp_wallet_data)
+                if not isinstance(wallet_data, dict):
+                    raise ValueError("Invalid wallet data format")
+                if wallet_data.get("default_address_id") and wallet_data.get("seed"):
+                    # verify seed and convert to pk
+                    keys = bip39_seed_to_eth_keys(wallet_data["seed"])
+                    if keys["address"] != wallet_data["default_address_id"]:
+                        raise ValueError(
+                            "Bad wallet data, seed does not match default_address_id"
+                        )
+                    # try to import wallet to v2
+                    logger.info("Migrating wallet data to v2...")
+                    await cdp_client.evm.import_account(
+                        name=agent.id,
+                        private_key=keys["private_key"],
+                    )
+                    address = keys["address"]
+                    logger.info("Migrated wallet data to v2 successfully: %s", address)
+            # still not address
+            if not address:
+                logger.info("Creating new wallet...")
+                new_account = await cdp_client.evm.create_account(
+                    name=agent.id,
+                )
+                address = new_account.address
+                logger.info("Created new wallet: %s", address)
+            # now it should be created or migrated, store it
+            agent_data.evm_wallet_address = address
+            await agent_data.save()
+
+        # it must have v2 account now, load agentkit wallet provider
+        self._wallet_provider_config = CdpEvmServerWalletProviderConfig(
+            api_key_id=api_key_id,
+            api_key_secret=api_key_secret,
+            network_id=network_id,
+            address=address,
+            wallet_secret=wallet_secret,
+        )
+        self._wallet_provider = CdpEvmServerWalletProvider(self._wallet_provider_config)
+        return self._wallet_provider
+
+    async def get_account(self) -> EvmServerAccount:
+        """Get the account object from the wallet provider.
+
+        Returns:
+            EvmServerAccount: The account object that can be used for balance checks, transfers, etc.
+        """
+        wallet_provider = await self.get_wallet_provider()
+        # Access the internal account object
+        return wallet_provider._account
+
+    async def get_provider_config(self) -> CdpEvmServerWalletProviderConfig:
+        if not self._wallet_provider_config:
+            await self.get_wallet_provider()
+        return self._wallet_provider_config
+
+
+async def get_cdp_client(agent_id: str, skill_store: SkillStoreABC) -> "CdpClient":
+    if agent_id not in _clients:
+        _clients[agent_id] = CdpClient(agent_id, skill_store)
+    return _clients[agent_id]

{intentkit-0.6.0.dev16 → intentkit-0.6.0.dev18}/core/prompt.py

@@ -1,5 +1,3 @@
-import json
-
 from intentkit.config.config import config
 from intentkit.models.agent import Agent
 from intentkit.models.agent_data import AgentData
@@ -34,10 +32,11 @@ def agent_prompt(agent: Agent, agent_data: AgentData) -> str:
         if agent_data.telegram_name:
             prompt += f"Your telegram bot name is {agent_data.telegram_name}.\n"
         # CDP
-        if agent_data.cdp_wallet_data:
-            network_id = agent.network_id or agent.cdp_network_id
-            wallet_data = json.loads(agent_data.cdp_wallet_data)
-            prompt += f"Your wallet address in {network_id} is {wallet_data['default_address_id']} .\n"
+        network_id = agent.network_id or agent.cdp_network_id
+        if agent_data.evm_wallet_address and network_id != "solana":
+            prompt += f"Your wallet address in {network_id} is {agent_data.evm_wallet_address} .\n"
+        if agent_data.solana_wallet_address and network_id == "solana":
+            prompt += f"Your wallet address in {network_id} is {agent_data.solana_wallet_address} .\n"
     prompt += "\n"
     if agent.purpose:
         prompt += f"## Purpose\n\n{agent.purpose}\n\n"

{intentkit-0.6.0.dev16 → intentkit-0.6.0.dev18}/models/agent.py

@@ -1564,7 +1564,6 @@ class AgentResponse(BaseModel):
             str: ETag value for the agent
         """
         import hashlib
-        import json
 
         # Generate hash from the entire object data using json mode to handle datetime objects
         # Sort keys to ensure consistent ordering of dictionary keys
@@ -1622,13 +1621,7 @@ class AgentResponse(BaseModel):
             data["skills"] = filtered_skills
 
         # Process CDP wallet address
-        cdp_wallet_address = None
-        if agent_data and agent_data.cdp_wallet_data:
-            try:
-                wallet_data = json.loads(agent_data.cdp_wallet_data)
-                cdp_wallet_address = wallet_data.get("default_address_id")
-            except (json.JSONDecodeError, AttributeError):
-                pass
+        cdp_wallet_address = agent_data.evm_wallet_address if agent_data else None
 
         # Process Twitter linked status
         has_twitter_linked = False

{intentkit-0.6.0.dev16 → intentkit-0.6.0.dev18}/models/agent_data.py

@@ -29,6 +29,10 @@ class AgentDataTable(Base):
     __tablename__ = "agent_data"
 
     id = Column(String, primary_key=True, comment="Same as Agent.id")
+    evm_wallet_address = Column(String, nullable=True, comment="EVM wallet address")
+    solana_wallet_address = Column(
+        String, nullable=True, comment="Solana wallet address"
+    )
     cdp_wallet_data = Column(String, nullable=True, comment="CDP wallet data")
     crossmint_wallet_data = Column(
         JSON().with_variant(JSONB(), "postgresql"),
@@ -94,6 +98,20 @@ class AgentData(BaseModel):
             description="Same as Agent.id",
         ),
     ]
+    evm_wallet_address: Annotated[
+        Optional[str],
+        PydanticField(
+            default=None,
+            description="EVM wallet address",
+        ),
+    ]
+    solana_wallet_address: Annotated[
+        Optional[str],
+        PydanticField(
+            default=None,
+            description="Solana wallet address",
+        ),
+    ]
     cdp_wallet_data: Annotated[
         Optional[str],
         PydanticField(

{intentkit-0.6.0.dev16 → intentkit-0.6.0.dev18}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intentkit"
-version = "0.6.0-dev.16"
+version = "0.6.0-dev.18"
 description = "Intent-based AI Agent Platform - Core Package"
 authors = [{ name = "hyacinthus", email = "hyacinthus@gmail.com" }]
 requires-python = ">=3.12"

{intentkit-0.6.0.dev16 → intentkit-0.6.0.dev18}/skills/cdp/__init__.py

@@ -25,9 +25,6 @@ from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.cdp.base import CDPBaseTool
 from intentkit.skills.cdp.get_balance import GetBalance
 
-# Cache skills at the system level, because they are stateless
-_cache: dict[str, CDPBaseTool] = {}
-
 
 class SkillStates(TypedDict):
     get_balance: SkillState
@@ -117,10 +114,8 @@ async def get_skills(
     for skill in available_skills:
         if skill == "get_balance":
             # Get the account object for the custom GetBalance skill
-            account = await cdp_client.get_account()
             tools.append(
                 GetBalance(
-                    account=account,
                     agent_id=agent_id,
                     skill_store=store,
                 )

{intentkit-0.6.0.dev16 → intentkit-0.6.0.dev18}/skills/cdp/get_balance.py

@@ -1,4 +1,4 @@
-from typing import Type
+from typing import Optional, Type
 
 from cdp import EvmServerAccount
 from pydantic import BaseModel, Field
@@ -11,8 +11,9 @@ from intentkit.skills.cdp.base import CDPBaseTool
 class GetBalanceInput(BaseModel):
     """Input for GetBalance tool."""
 
-    asset_id: str = Field(
-        description="The asset ID to get the balance for (e.g., 'eth', 'usdc', or a valid contract address)"
+    asset_id: Optional[str] = Field(
+        default=None,
+        description="The asset ID to get the balance for (e.g., 'eth', 'usdc', or a valid contract address). If not provided, returns all token balances.",
     )
 
 
@@ -29,69 +30,92 @@ class GetBalance(CDPBaseTool):
 
     agent_id: str
     skill_store: SkillStoreABC
-    account: EvmServerAccount | None = None
 
     name: str = "cdp_get_balance"
     description: str = (
-        "This tool will get the balance of all the addresses in the wallet for a given asset. It takes the asset ID as input."
+        "This tool will get the balance of all the addresses in the wallet. If asset_id is provided, it returns the balance for that specific asset. "
+        "If no asset_id is provided, it returns all token balances. "
         "Always use 'eth' for the native asset ETH and 'usdc' for USDC. "
         "Other valid asset IDs are: weth,dai,reth,brett,w,cbeth,axl,iotx,prime,aero,rsr,mog,tbtc,npc,yfi"
     )
     args_schema: Type[BaseModel] = GetBalanceInput
 
-    async def _arun(self, asset_id: str) -> str:
+    async def _arun(self, asset_id: Optional[str] = None) -> str:
         """Async implementation of the tool to get balance.
 
         Args:
-            asset_id (str): The asset ID to get the balance for.
+            asset_id (Optional[str]): The asset ID to get the balance for. If None, returns all token balances.
 
         Returns:
             str: A message containing the balance information or error message.
         """
         try:
-            if not self.account:
-                return "Failed to get account."
-
             # Get network information from CDP client
             cdp_client = await get_cdp_client(self.agent_id, self.skill_store)
+            provider = await cdp_client.get_wallet_provider()
+            account: EvmServerAccount = provider._account
             provider_config = await cdp_client.get_provider_config()
             network_id = provider_config.network_id
 
             # Map network_id to the format expected by the API
             network_mapping = {
                 "base-mainnet": "base",
-                "base-sepolia": "base-sepolia",
-                "ethereum": "ethereum",
                 "ethereum-mainnet": "ethereum",
             }
             api_network = network_mapping.get(network_id, network_id)
 
+            # If no asset_id provided, return all token balances
+            if asset_id is None:
+                try:
+                    # Get native ETH balance
+                    balance_wei = provider.get_balance()
+                    balance_eth = balance_wei / (10**18)  # Convert from wei to ETH
+
+                    # Get all token balances
+                    token_balances = await account.list_token_balances(api_network)
+
+                    result = [f"ETH balance: {balance_eth} ETH"]
+
+                    for balance in token_balances.balances:
+                        result.append(
+                            f"{balance.token.symbol} balance: {balance.amount.decimals} {balance.token.name}"
+                        )
+
+                    return f"All balances for account {account.address}:\n" + "\n".join(
+                        result
+                    )
+
+                except Exception as e:
+                    return f"Error getting all balances: {e!s}"
+
             # For native ETH balance, use the account's balance directly
             if asset_id.lower() == "eth":
                 try:
                     # Get native balance using Web3
-                    balance_wei = await self.account.get_balance()
+                    balance_wei = provider.get_balance()
                     balance_eth = balance_wei / (10**18)  # Convert from wei to ETH
-                    return f"ETH balance for account {self.account.address}: {balance_eth} ETH"
+                    return (
+                        f"ETH balance for account {account.address}: {balance_eth} ETH"
+                    )
                 except Exception as e:
                     return f"Error getting ETH balance: {e!s}"
 
             # For other tokens, try the list_token_balances API
             try:
                 # list_token_balances returns all token balances for the account
-                token_balances = await self.account.list_token_balances(api_network)
+                token_balances = await account.list_token_balances(api_network)
 
                 # Find the balance for the specific asset
                 target_balance = None
-                for balance in token_balances:
-                    if balance.asset_id.lower() == asset_id.lower():
+                for balance in token_balances.balances:
+                    if balance.token.symbol.lower() == asset_id.lower():
                         target_balance = balance
                         break
 
                 if target_balance:
-                    return f"Balance for {asset_id} in account {self.account.address}: {target_balance.amount} {target_balance.asset_id}"
+                    return f"Balance for {asset_id} in account {account.address}: {target_balance.amount.decimals} {target_balance.token.name}"
                 else:
-                    return f"No balance found for asset {asset_id} in account {self.account.address}"
+                    return f"No balance found for asset {asset_id} in account {account.address}"
 
             except Exception as e:
                 return f"Error getting balance for account: {e!s}"
@@ -99,7 +123,7 @@ class GetBalance(CDPBaseTool):
         except Exception as e:
             return f"Error getting balance: {str(e)}"
 
-    def _run(self, asset_id: str) -> str:
+    def _run(self, asset_id: Optional[str] = None) -> str:
         """Sync implementation of the tool.
 
         This method is deprecated since we now have native async implementation in _arun.

intentkit-0.6.0.dev16/clients/cdp.py

@@ -1,92 +0,0 @@
-import json
-import logging
-from typing import Dict, Optional
-
-from cdp import EvmServerAccount
-from coinbase_agentkit import (
-    CdpEvmServerWalletProvider,
-    CdpEvmServerWalletProviderConfig,
-)
-
-from intentkit.abstracts.skill import SkillStoreABC
-from intentkit.models.agent import Agent
-from intentkit.models.agent_data import AgentData
-
-_clients: Dict[str, "CdpClient"] = {}
-
-
-class CdpClient:
-    def __init__(self, agent_id: str, skill_store: SkillStoreABC) -> None:
-        self._agent_id = agent_id
-        self._skill_store = skill_store
-        self._wallet_provider: Optional[CdpEvmServerWalletProvider] = None
-        self._wallet_provider_config: Optional[CdpEvmServerWalletProviderConfig] = None
-
-    async def get_wallet_provider(self) -> CdpEvmServerWalletProvider:
-        if self._wallet_provider:
-            return self._wallet_provider
-        agent: Agent = await self._skill_store.get_agent_config(self._agent_id)
-        agent_data: AgentData = await self._skill_store.get_agent_data(self._agent_id)
-        network_id = agent.network_id or agent.cdp_network_id
-
-        logger = logging.getLogger(__name__)
-
-        # Get credentials from skill store system config
-        api_key_id = self._skill_store.get_system_config("cdp_api_key_id")
-        api_key_secret = self._skill_store.get_system_config("cdp_api_key_secret")
-        wallet_secret = self._skill_store.get_system_config("cdp_wallet_secret")
-
-        address = None
-
-        # Attempt to override with any wallet-specific secret stored in wallet_data
-        if agent_data.cdp_wallet_data:
-            try:
-                wallet_data = json.loads(agent_data.cdp_wallet_data)
-                # Try to get address from the new format or fallback to old format
-                if "default_address_id" in wallet_data:
-                    address = wallet_data["default_address_id"]
-
-                # Prefer wallet_secret stored alongside the wallet data if present
-                if "wallet_secret" in wallet_data:
-                    wallet_secret = wallet_data["wallet_secret"]
-                elif "account_data" in wallet_data and wallet_data["account_data"]:
-                    # Some versions may nest the secret inside account_data
-                    wallet_secret = (
-                        wallet_data["account_data"].get("wallet_secret")
-                        or wallet_secret
-                    )
-            except json.JSONDecodeError:
-                logger.warning(
-                    "Invalid JSON in cdp_wallet_data for agent %s", self._agent_id
-                )
-
-        self._wallet_provider_config = CdpEvmServerWalletProviderConfig(
-            api_key_id=api_key_id,
-            api_key_secret=api_key_secret,
-            network_id=network_id,
-            address=address,
-            wallet_secret=wallet_secret,
-        )
-        self._wallet_provider = CdpEvmServerWalletProvider(self._wallet_provider_config)
-        return self._wallet_provider
-
-    async def get_account(self) -> EvmServerAccount:
-        """Get the account object from the wallet provider.
-
-        Returns:
-            EvmServerAccount: The account object that can be used for balance checks, transfers, etc.
-        """
-        wallet_provider = await self.get_wallet_provider()
-        # Access the internal account object
-        return wallet_provider._account
-
-    async def get_provider_config(self) -> CdpEvmServerWalletProviderConfig:
-        if not self._wallet_provider_config:
-            await self.get_wallet_provider()
-        return self._wallet_provider_config
-
-
-async def get_cdp_client(agent_id: str, skill_store: SkillStoreABC) -> "CdpClient":
-    if agent_id not in _clients:
-        _clients[agent_id] = CdpClient(agent_id, skill_store)
-    return _clients[agent_id]