intentkit 0.7.5.dev3__py3-none-any.whl → 0.8.34.dev7__py3-none-any.whl

intentkit/skills/enso/route.py

@@ -1,12 +1,10 @@
-from typing import Type
-
 import httpx
-from langchain.tools.base import ToolException
+from langchain_core.tools.base import ToolException
 from pydantic import BaseModel, Field
 
 from intentkit.skills.enso.networks import EnsoGetNetworks
 
-from .base import EnsoBaseTool, base_url, default_chain_id
+from .base import EnsoBaseTool, base_url, format_amount_with_decimals
 
 
 class EnsoRouteShortcutInput(BaseModel):
@@ -18,9 +16,9 @@ class EnsoRouteShortcutInput(BaseModel):
         False,
         description="Whether to broadcast the transaction or not, this is false by default.",
     )
-    chainId: int = Field(
-        default_chain_id,
-        description="(Optional) Chain ID of the network to execute the transaction on. the default value is the chain_id extracted from networks according to tokenIn and tokenOut",
+    chainId: int | None = Field(
+        None,
+        description="(Optional) Chain ID of the network to execute the transaction on. Defaults to the agent's configured network.",
     )
     amountIn: list[int] = Field(
         description="Amount of tokenIn to swap in wei, you should multiply user's requested value by token decimals."
@@ -155,14 +153,14 @@ class EnsoRouteShortcut(EnsoBaseTool):
 
     name: str = "enso_route_shortcut"
     description: str = "This tool is used specifically for broadcasting a route transaction calldata to the network. It should only be used when the user explicitly requests to broadcast a route transaction with routeId."
-    args_schema: Type[BaseModel] = EnsoRouteShortcutInput
+    args_schema: type[BaseModel] = EnsoRouteShortcutInput
 
     async def _arun(
         self,
         amountIn: list[int],
         tokenIn: list[str],
         tokenOut: list[str],
-        chainId: int = default_chain_id,
+        chainId: int | None = None,
         broadcast_requested: bool = False,
         **kwargs,
     ) -> EnsoRouteShortcutOutput:
@@ -173,7 +171,7 @@ class EnsoRouteShortcut(EnsoBaseTool):
             amountIn (list[int]): Amount of tokenIn to swap in wei, you should multiply user's requested value by token decimals.
             tokenIn (list[str]): Ethereum address of the token to swap or enter into a position from (For ETH, use 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee).
             tokenOut (list[str]): Ethereum address of the token to swap or enter into a position to (For ETH, use 0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee).
-            chainId (int): The chain id of the network to be used for swap, deposit and routing.
+            chainId (int | None): The chain id of the network to be used for swap, deposit and routing. Defaults to the agent's configured network.
             broadcast_requested (bool): User should ask for broadcasting the transaction explicitly, otherwise it is always false.
 
         Returns:
@@ -181,35 +179,36 @@ class EnsoRouteShortcut(EnsoBaseTool):
         """
 
         context = self.get_context()
-        agent_id = context.agent_id
+        resolved_chain_id = self.resolve_chain_id(context, chainId)
         api_token = self.get_api_token(context)
-        account = await self.get_account(context)
+        # Use the wallet provider to send the transaction
+        wallet_provider = await self.get_wallet_provider(context)
+        wallet_address = wallet_provider.get_address()
 
         async with httpx.AsyncClient() as client:
             try:
                 network_name = None
-                networks = await self.skill_store.get_agent_skill_data(
-                    agent_id, "enso_get_networks", "networks"
+                networks = await self.get_agent_skill_data_raw(
+                    "enso_get_networks", "networks"
                 )
 
                 if networks:
+                    resolved_key = str(resolved_chain_id)
                     network_name = (
-                        networks.get(str(chainId)).get("name")
-                        if networks.get(str(chainId))
+                        networks.get(resolved_key).get("name")
+                        if networks.get(resolved_key)
                         else None
                     )
                 if network_name is None:
-                    networks = await EnsoGetNetworks(
-                        skill_store=self.skill_store,
-                    ).arun()
+                    networks = await EnsoGetNetworks().arun()
 
                     for network in networks.res:
-                        if network.id == chainId:
+                        if network.id == resolved_chain_id:
                             network_name = network.name
 
                 if not network_name:
                     raise ToolException(
-                        f"network name not found for chainId: {chainId}"
+                        f"network name not found for chainId: {resolved_chain_id}"
                     )
 
                 headers = {
@@ -217,8 +216,7 @@ class EnsoRouteShortcut(EnsoBaseTool):
                     "Authorization": f"Bearer {api_token}",
                 }
 
-                token_decimals = await self.skill_store.get_agent_skill_data(
-                    agent_id,
+                token_decimals = await self.get_agent_skill_data_raw(
                     "enso_get_tokens",
                     "decimals",
                 )
@@ -242,13 +240,13 @@ class EnsoRouteShortcut(EnsoBaseTool):
 
                 # Prepare query parameters
                 params = EnsoRouteShortcutInput(
-                    chainId=chainId,
+                    chainId=resolved_chain_id,
                     amountIn=amountIn,
                     tokenIn=tokenIn,
                     tokenOut=tokenOut,
                 ).model_dump(exclude_none=True)
 
-                params["fromAddress"] = account.address
+                params["fromAddress"] = wallet_address
 
                 response = await client.get(url, headers=headers, params=params)
                 response.raise_for_status()  # Raise HTTPError for non-2xx responses
@@ -256,26 +254,24 @@ class EnsoRouteShortcut(EnsoBaseTool):
 
                 res = EnsoRouteShortcutOutput(**json_dict)
                 res.network = network_name
-
-                res.amountOut = str(
-                    float(res.amountOut) / 10 ** token_decimals[tokenOut[0]]
+                decimals = token_decimals.get(tokenOut[0])
+                amount_out = format_amount_with_decimals(
+                    json_dict.get("amountOut"), decimals
                 )
+                if amount_out is not None:
+                    res.amountOut = amount_out
 
                 if broadcast_requested:
-                    # Use the wallet provider to send the transaction
-                    wallet_provider = await self.get_wallet_provider(context)
-
                     # Extract transaction data from the Enso API response
                     tx_data = json_dict.get("tx", {})
                     if tx_data:
                         # Send the transaction using the wallet provider
-                        tx_hash = wallet_provider.send_transaction(
-                            {
-                                "to": tx_data.get("to"),
-                                "data": tx_data.get("data", "0x"),
-                                "value": tx_data.get("value", 0),
-                            }
-                        )
+                        tx_params = {
+                            "to": tx_data.get("to"),
+                            "data": tx_data.get("data", "0x"),
+                            "value": tx_data.get("value", 0),
+                        }
+                        tx_hash = wallet_provider.send_transaction(tx_params)
 
                         # Wait for transaction confirmation
                         wallet_provider.wait_for_transaction_receipt(tx_hash)

intentkit/skills/enso/schema.json

@@ -5,7 +5,8 @@
   "description": "Integration with Enso Finance API providing DeFi trading and portfolio management capabilities across multiple blockchain networks",
   "x-icon": "https://ai.service.crestal.dev/skills/enso/enso.jpg",
   "x-tags": [
-    "Blockchain"
+    "Analytics",
+    "DeFi"
   ],
   "properties": {
     "enabled": {
@@ -209,4 +210,4 @@
     }
   },
   "additionalProperties": true
-}
+}

intentkit/skills/enso/tokens.py

@@ -1,14 +1,8 @@
-from typing import Type
-
 import httpx
-from langchain.tools.base import ToolException
+from langchain_core.tools.base import ToolException
 from pydantic import BaseModel, Field
 
-from intentkit.skills.enso.base import (
-    EnsoBaseTool,
-    base_url,
-    default_chain_id,
-)
+from intentkit.skills.enso.base import EnsoBaseTool, base_url
 
 # Actual Enso output types
 # class UnderlyingToken(BaseModel):
@@ -50,9 +44,9 @@ from intentkit.skills.enso.base import (
 
 
 class EnsoGetTokensInput(BaseModel):
-    chainId: int = Field(
-        default_chain_id,
-        description="The blockchain chain ID",
+    chainId: int | None = Field(
+        None,
+        description="The blockchain chain ID. Defaults to the agent's configured network.",
     )
     protocolSlug: str | None = Field(
         None,
@@ -110,7 +104,10 @@ class TokenResponseCompact(BaseModel):
 
 
 class EnsoGetTokensOutput(BaseModel):
-    res: list[TokenResponseCompact] | None
+    res: list[TokenResponseCompact] = Field(
+        default_factory=list,
+        description="List of token information entries",
+    )
 
 
 class EnsoGetTokens(EnsoBaseTool):
@@ -134,11 +131,11 @@ class EnsoGetTokens(EnsoBaseTool):
         "Enso Finance Token Information Tool: Retrieves detailed token information from the Enso Finance API, "
         "including APY, symbol, address, protocol slug, token type, and underlying tokens."
     )
-    args_schema: Type[BaseModel] = EnsoGetTokensInput
+    args_schema: type[BaseModel] = EnsoGetTokensInput
 
     async def _arun(
         self,
-        chainId: int = default_chain_id,
+        chainId: int | None = None,
         protocolSlug: str | None = None,
         **kwargs,
     ) -> EnsoGetTokensOutput:
@@ -155,16 +152,17 @@ class EnsoGetTokens(EnsoBaseTool):
         url = f"{base_url}/api/v1/tokens"
 
         context = self.get_context()
-        agent_id = context.agent_id
+        resolved_chain_id = self.resolve_chain_id(context, chainId)
         api_token = self.get_api_token(context)
         main_tokens = self.get_main_tokens(context)
+        main_tokens_upper = {token.upper() for token in main_tokens}
         headers = {
             "accept": "application/json",
             "Authorization": f"Bearer {api_token}",
         }
 
         params = EnsoGetTokensInput(
-            chainId=chainId,
+            chainId=resolved_chain_id,
             protocolSlug=protocolSlug,
         ).model_dump(exclude_none=True)
 
@@ -177,35 +175,28 @@ class EnsoGetTokens(EnsoBaseTool):
                 response.raise_for_status()
                 json_dict = response.json()
 
-                token_decimals = await self.skill_store.get_agent_skill_data(
-                    agent_id,
-                    "enso_get_tokens",
-                    "decimals",
-                )
+                token_decimals = await self.get_agent_skill_data("decimals")
                 if not token_decimals:
                     token_decimals = {}
 
                 # filter the main tokens from config or the ones that have apy assigned.
-                res = EnsoGetTokensOutput(res=list[TokenResponseCompact]())
-                for item in json_dict["data"]:
-                    main_tokens = [item.upper() for item in main_tokens]
-                    if item.get("apy") or (item.get("symbol").upper() in main_tokens):
+                res = EnsoGetTokensOutput()
+                for item in json_dict.get("data", []):
+                    symbol = item.get("symbol", "").upper()
+                    has_apy = bool(item.get("apy"))
+                    if has_apy or symbol in main_tokens_upper:
                         token_response = TokenResponseCompact(**item)
                         res.res.append(token_response)
-                        token_decimals[token_response.address] = token_response.decimals
-                        if (
-                            token_response.underlyingTokens
-                            and len(token_response.underlyingTokens) > 0
-                        ):
+                        if token_response.address:
+                            token_decimals[token_response.address] = (
+                                token_response.decimals
+                            )
+                        if token_response.underlyingTokens:
                             for u_token in token_response.underlyingTokens:
-                                token_decimals[u_token.address] = u_token.decimals
-
-                await self.skill_store.save_agent_skill_data(
-                    agent_id,
-                    "enso_get_tokens",
-                    "decimals",
-                    token_decimals,
-                )
+                                if u_token.address:
+                                    token_decimals[u_token.address] = u_token.decimals
+
+                await self.save_agent_skill_data("decimals", token_decimals)
 
                 return res
             except httpx.RequestError as req_err: