intentkit 0.8.32.dev1__tar.gz → 0.8.33.dev1__tar.gz

{intentkit-0.8.32.dev1 → intentkit-0.8.33.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: intentkit
-Version: 0.8.32.dev1
+Version: 0.8.33.dev1
 Summary: Intent-based AI Agent Platform - Core Package
 Project-URL: Homepage, https://github.com/crestalnetwork/intentkit
 Project-URL: Repository, https://github.com/crestalnetwork/intentkit

{intentkit-0.8.32.dev1 → intentkit-0.8.33.dev1}/intentkit/__init__.py

@@ -3,7 +3,7 @@
 A powerful platform for building AI agents with blockchain and cryptocurrency capabilities.
 """
 
-__version__ = "0.8.32-dev1"
+__version__ = "0.8.33-dev1"
 __author__ = "Ruihua"
 __email__ = "ruihua@crestal.network"
 

{intentkit-0.8.32.dev1 → intentkit-0.8.33.dev1}/intentkit/clients/__init__.py

@@ -1,4 +1,9 @@
-from intentkit.clients.cdp import get_cdp_client, get_evm_account, get_wallet_provider
+from intentkit.clients.cdp import (
+    get_cdp_client,
+    get_cdp_network,
+    get_evm_account,
+    get_wallet_provider,
+)
 from intentkit.clients.twitter import (
     TwitterClient,
     TwitterClientConfig,
@@ -13,5 +18,6 @@ __all__ = [
     "get_evm_account",
     "get_cdp_client",
     "get_wallet_provider",
+    "get_cdp_network",
     "get_web3_client",
 ]

{intentkit-0.8.32.dev1 → intentkit-0.8.33.dev1}/intentkit/clients/cdp.py

@@ -83,6 +83,33 @@ async def get_evm_account(agent: Agent) -> EvmServerAccount:
     return account
 
 
+def get_cdp_network(agent: Agent) -> str:
+    if not agent.network_id:
+        raise IntentKitAPIError(
+            400,
+            "BadNetworkID",
+            "Your agent network ID is not set. Please set it in the agent config.",
+        )
+    mapping = {
+        "ethereum-mainnet": "ethereum",
+        "base-mainnet": "base",
+        "arbitrum-mainnet": "arbitrum",
+        "optimism-mainnet": "optimism",
+        "polygon-mainnet": "polygon",
+        "base-sepolia": "base-sepolia",
+    }
+    if agent.network_id == "solana":
+        raise IntentKitAPIError(
+            400, "BadNetworkID", "Solana is not supported by CDP EVM."
+        )
+    cdp_network = mapping.get(agent.network_id)
+    if not cdp_network:
+        raise IntentKitAPIError(
+            400, "BadNetworkID", f"Unsupported network ID: {agent.network_id}"
+        )
+    return cdp_network
+
+
 async def get_wallet_provider(agent: Agent) -> CdpEvmWalletProvider:
     _assert_cdp_wallet_provider(agent)
     if not agent.network_id:

{intentkit-0.8.32.dev1 → intentkit-0.8.33.dev1}/intentkit/skills/lifi/base.py

@@ -1,9 +1,9 @@
 from pydantic import BaseModel, Field
 
-from intentkit.skills.base import IntentKitSkill
+from intentkit.skills.onchain import IntentKitOnChainSkill
 
 
-class LiFiBaseTool(IntentKitSkill):
+class LiFiBaseTool(IntentKitOnChainSkill):
     """Base class for LiFi tools."""
 
     name: str = Field(description="The name of the tool")

{intentkit-0.8.32.dev1 → intentkit-0.8.33.dev1}/intentkit/skills/lifi/token_execute.py

@@ -2,12 +2,11 @@ import asyncio
 from typing import Any
 
 import httpx
-from coinbase_agentkit import CdpEvmWalletProvider
+from cdp import EvmServerAccount, TransactionRequestEIP1559
 from pydantic import BaseModel, Field
 from web3 import Web3
+from web3.exceptions import TimeExhausted
 
-from intentkit.clients import get_wallet_provider as get_agent_wallet_provider
-from intentkit.models.agent import Agent
 from intentkit.skills.lifi.base import LiFiBaseTool
 from intentkit.skills.lifi.token_quote import TokenQuote
 from intentkit.skills.lifi.utils import (
@@ -23,6 +22,7 @@ from intentkit.skills.lifi.utils import (
     prepare_transaction_params,
     validate_inputs,
 )
+from intentkit.utils.error import IntentKitAPIError
 
 
 class TokenExecuteInput(BaseModel):
@@ -52,7 +52,7 @@ class TokenExecuteInput(BaseModel):
 class TokenExecute(LiFiBaseTool):
     """Tool for executing token transfers across chains using LiFi.
 
-    This tool executes actual token transfers and swaps using the CDP wallet provider.
+    This tool executes actual token transfers and swaps using the CDP EVM account.
     Requires a properly configured CDP wallet to work.
     """
 
@@ -129,21 +129,35 @@ class TokenExecute(LiFiBaseTool):
             # Get agent context for CDP wallet
             context = self.get_context()
             agent = context.agent
+            network_id = agent.network_id
+            if not network_id:
+                return "Agent network ID is not configured. Please set it before executing on-chain transactions."
+
+            try:
+                cdp_network = self.get_cdp_network()
+            except Exception as e:
+                self.logger.error("LiFi_CDP_Network_Error: %s", str(e))
+                return f"Invalid agent network for CDP: {str(e)}"
 
             self.logger.info(
                 f"Executing LiFi transfer: {from_amount} {from_token} on {from_chain} -> {to_token} on {to_chain}"
             )
 
-            # Get CDP wallet provider
-            cdp_wallet_provider = await self._get_cdp_wallet_provider(agent)
-            if isinstance(cdp_wallet_provider, str):  # Error message
-                return cdp_wallet_provider
+            # Get CDP EVM account and web3 client
+            evm_account = await self._get_evm_account()
+            if isinstance(evm_account, str):  # Error message
+                return evm_account
 
-            # Get wallet address
-            from_address = cdp_wallet_provider.get_address()
+            from_address = evm_account.address
             if not from_address:
                 return "No wallet address available. Please check your CDP wallet configuration."
 
+            try:
+                web3 = self.web3_client()
+            except Exception as e:
+                self.logger.error("LiFi_Web3_Error: %s", str(e))
+                return "Unable to initialize Web3 client. Please verify the agent's network configuration."
+
             # Get quote and execute transfer
             async with httpx.AsyncClient() as client:
                 # Step 1: Get quote
@@ -162,16 +176,22 @@ class TokenExecute(LiFiBaseTool):
 
                 # Step 2: Handle token approval if needed
                 approval_result = await self._handle_token_approval(
-                    cdp_wallet_provider, quote_data
+                    evm_account,
+                    quote_data,
+                    web3,
+                    cdp_network,
+                    from_address,
                 )
                 if approval_result:
                     self.logger.info(f"Token approval completed: {approval_result}")
 
                 # Step 3: Execute transaction
                 tx_hash = await self._execute_transfer_transaction(
-                    cdp_wallet_provider,
+                    evm_account,
                     quote_data,
                     from_address,
+                    cdp_network,
+                    web3,
                 )
 
                 # Step 4: Monitor status and return result
@@ -183,17 +203,18 @@ class TokenExecute(LiFiBaseTool):
             self.logger.error("LiFi_Error: %s", str(e))
             return f"An unexpected error occurred: {str(e)}"
 
-    async def _get_cdp_wallet_provider(
-        self, agent: Agent
-    ) -> CdpEvmWalletProvider | str:
-        """Get CDP wallet provider with error handling."""
+    async def _get_evm_account(self) -> EvmServerAccount | str:
+        """Get CDP EVM account with error handling."""
         try:
-            cdp_wallet_provider = await get_agent_wallet_provider(agent)
-            if not cdp_wallet_provider:
-                return "CDP wallet provider not configured. Please set up your agent's CDP wallet first."
+            evm_account = await self.get_evm_account()
+            if not evm_account:
+                return "CDP wallet account not configured. Please set up your agent's CDP wallet first."
 
-            return cdp_wallet_provider
+            return evm_account
 
+        except IntentKitAPIError as e:
+            self.logger.error("LiFi_CDP_Error: %s", str(e))
+            return f"Cannot access CDP wallet: {str(e)}\n\nPlease ensure your agent has a properly configured CDP wallet with sufficient funds."
         except Exception as e:
             self.logger.error("LiFi_CDP_Error: %s", str(e))
             return f"Cannot access CDP wallet: {str(e)}\n\nPlease ensure your agent has a properly configured CDP wallet with sufficient funds."
@@ -250,7 +271,12 @@ class TokenExecute(LiFiBaseTool):
         return data
 
     async def _handle_token_approval(
-        self, wallet_provider: CdpEvmWalletProvider, quote_data: dict[str, Any]
+        self,
+        evm_account: EvmServerAccount,
+        quote_data: dict[str, Any],
+        web3: Web3,
+        network_id: str,
+        wallet_address: str,
     ) -> str | None:
         """Handle ERC20 token approval if needed."""
         estimate = quote_data.get("estimate", {})
@@ -267,7 +293,13 @@ class TokenExecute(LiFiBaseTool):
 
         try:
             return await self._check_and_set_allowance(
-                wallet_provider, from_token_address, approval_address, from_amount
+                evm_account,
+                from_token_address,
+                approval_address,
+                from_amount,
+                web3,
+                network_id,
+                wallet_address,
             )
         except Exception as e:
             self.logger.error("LiFi_Token_Approval_Error: %s", str(e))
@@ -275,9 +307,11 @@ class TokenExecute(LiFiBaseTool):
 
     async def _execute_transfer_transaction(
         self,
-        wallet_provider: CdpEvmWalletProvider,
+        evm_account: EvmServerAccount,
         quote_data: dict[str, Any],
         from_address: str,
+        network_id: str,
+        web3: Web3,
     ) -> str:
         """Execute the main transfer transaction."""
         transaction_request = quote_data.get("transactionRequest")
@@ -286,16 +320,17 @@ class TokenExecute(LiFiBaseTool):
             tx_params = prepare_transaction_params(
                 transaction_request, wallet_address=from_address
             )
+            tx_request = self._build_transaction_request(tx_params)
             self.logger.info(
-                f"Sending transaction to {tx_params['to']} with value {tx_params['value']}"
+                f"Sending transaction to {tx_params['to']} with value {tx_params.get('value', 0)}"
             )
 
             # Send transaction
-            tx_hash = wallet_provider.send_transaction(tx_params)
+            tx_hash = await evm_account.send_transaction(tx_request, network=network_id)
 
             # Wait for confirmation
-            receipt = wallet_provider.wait_for_transaction_receipt(tx_hash)
-            if not receipt or receipt.get("status") == 0:
+            receipt = await self._wait_for_receipt(web3, tx_hash)
+            if not receipt or receipt.get("status") != 1:
                 raise Exception(f"Transaction failed: {tx_hash}")
 
             return tx_hash
@@ -304,6 +339,52 @@ class TokenExecute(LiFiBaseTool):
             self.logger.error("LiFi_Execution_Error: %s", str(e))
             raise Exception(f"Failed to execute transaction: {str(e)}")
 
+    def _build_transaction_request(
+        self, tx_params: dict[str, Any]
+    ) -> TransactionRequestEIP1559:
+        """Convert prepared transaction parameters to an EIP-1559 request."""
+        request_kwargs: dict[str, Any] = {
+            "to": Web3.to_checksum_address(tx_params["to"]),
+            "data": tx_params.get("data", "0x"),
+        }
+
+        for key in ("value", "gas", "maxPriorityFeePerGas", "nonce", "chainId"):
+            value = tx_params.get(key)
+            if value is not None:
+                request_kwargs[key] = value
+
+        max_fee_per_gas = tx_params.get("maxFeePerGas") or tx_params.get("gasPrice")
+        if max_fee_per_gas is not None:
+            request_kwargs["maxFeePerGas"] = max_fee_per_gas
+
+        return TransactionRequestEIP1559(**request_kwargs)
+
+    async def _wait_for_receipt(
+        self, web3: Web3, tx_hash: str
+    ) -> dict[str, Any] | None:
+        """Wait for a transaction receipt using Web3 in a non-blocking way."""
+
+        try:
+            receipt = await asyncio.to_thread(
+                web3.eth.wait_for_transaction_receipt, tx_hash
+            )
+        except TimeExhausted as exc:
+            self.logger.error("LiFi_Execution_Error: %s", str(exc))
+            raise Exception(
+                f"Transaction not confirmed before timeout: {tx_hash}"
+            ) from exc
+        except Exception as exc:
+            self.logger.error("LiFi_Execution_Error: %s", str(exc))
+            raise
+
+        if receipt is None:
+            return None
+
+        if isinstance(receipt, dict):
+            return receipt
+
+        return dict(receipt)
+
     async def _finalize_transfer(
         self,
         client: httpx.AsyncClient,
@@ -413,25 +494,27 @@ class TokenExecute(LiFiBaseTool):
 
     async def _check_and_set_allowance(
         self,
-        wallet_provider: CdpEvmWalletProvider,
+        evm_account: EvmServerAccount,
         token_address: str,
         approval_address: str,
         amount: str,
+        web3: Web3,
+        network_id: str,
+        wallet_address: str,
     ) -> str | None:
         """Check if token allowance is sufficient and set approval if needed."""
         try:
             # Normalize addresses
             token_address = Web3.to_checksum_address(token_address)
             approval_address = Web3.to_checksum_address(approval_address)
-            wallet_address = wallet_provider.get_address()
+            wallet_checksum = Web3.to_checksum_address(wallet_address)
+
+            contract = web3.eth.contract(address=token_address, abi=ERC20_ABI)
 
             # Check current allowance
             try:
-                current_allowance = wallet_provider.read_contract(
-                    contract_address=token_address,
-                    abi=ERC20_ABI,
-                    function_name="allowance",
-                    args=[wallet_address, approval_address],
+                current_allowance = await asyncio.to_thread(
+                    contract.functions.allowance(wallet_checksum, approval_address).call
                 )
 
                 required_amount = int(amount)
@@ -453,20 +536,21 @@ class TokenExecute(LiFiBaseTool):
 
             # Create approval transaction
             approve_data = create_erc20_approve_data(approval_address, amount)
+            approval_request = TransactionRequestEIP1559(
+                to=token_address,
+                data=approve_data,
+                value=0,
+            )
 
             # Send approval transaction
-            approval_tx_hash = wallet_provider.send_transaction(
-                {
-                    "to": token_address,
-                    "data": approve_data,
-                    "value": 0,
-                }
+            approval_tx_hash = await evm_account.send_transaction(
+                approval_request, network=network_id
             )
 
             # Wait for approval transaction confirmation
-            receipt = wallet_provider.wait_for_transaction_receipt(approval_tx_hash)
+            receipt = await self._wait_for_receipt(web3, approval_tx_hash)
 
-            if not receipt or receipt.get("status") == 0:
+            if not receipt or receipt.get("status") != 1:
                 raise Exception(f"Approval transaction failed: {approval_tx_hash}")
 
             return approval_tx_hash

{intentkit-0.8.32.dev1 → intentkit-0.8.33.dev1}/intentkit/skills/onchain.py

@@ -1,6 +1,7 @@
 from cdp import EvmServerAccount
 from web3 import Web3
 
+from intentkit.clients import get_cdp_network as resolve_cdp_network
 from intentkit.clients import get_evm_account as fetch_evm_account
 from intentkit.clients.web3 import get_web3_client
 from intentkit.skills.base import IntentKitSkill
@@ -21,3 +22,9 @@ class IntentKitOnChainSkill(IntentKitSkill):
         context = self.get_context()
         agent = context.agent
         return await fetch_evm_account(agent)
+
+    def get_cdp_network(self) -> str:
+        """Get CDP network mapped from the agent's network id."""
+        context = self.get_context()
+        agent = context.agent
+        return resolve_cdp_network(agent)

{intentkit-0.8.32.dev1 → intentkit-0.8.33.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "intentkit"
-version = "0.8.32-dev1"
+version = "0.8.33-dev1"
 description = "Intent-based AI Agent Platform - Core Package"
 authors = [
     { name = "Ruihua", email = "ruihua@crestal.network" },