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

intentkit/utils/ens.py

@@ -0,0 +1,135 @@
+"""Utilities for resolving ENS domains to wallet addresses."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+
+from ens import ENS
+from web3 import Web3
+from web3.middleware import ExtraDataToPOAMiddleware
+
+from intentkit.config.config import config
+from intentkit.models.redis import get_redis
+from intentkit.utils.error import IntentKitAPIError
+
+logger = logging.getLogger(__name__)
+
+_CACHE_PREFIX = "intentkit:ens:"
+_CACHE_TTL_SECONDS = 4 * 60 * 60
+
+_NETWORKS_BY_SUFFIX: dict[str, tuple[str, ...]] = {
+    ".base.eth": ("base-mainnet", "ethereum-mainnet"),
+    ".eth": ("ethereum-mainnet",),
+}
+
+_POA_NETWORK_PREFIXES: tuple[str, ...] = ("base",)
+
+
+async def resolve_ens_to_address(name: str) -> str:
+    """Resolve an ENS domain to a checksum wallet address.
+
+    Args:
+        name: ENS name to resolve.
+
+    Returns:
+        The checksum wallet address associated with the ENS name.
+
+    Raises:
+        IntentKitAPIError: If the ENS name cannot be resolved to a wallet address.
+    """
+
+    normalized = name.strip().lower()
+    if not normalized:
+        raise IntentKitAPIError(404, "ENSNameNotFound", "ENS name is empty.")
+
+    redis_client = None
+    cache_key = f"{_CACHE_PREFIX}{normalized}"
+    try:
+        redis_client = get_redis()
+    except Exception:  # Redis is optional; ignore if unavailable
+        redis_client = None
+
+    if redis_client is not None:
+        cached_address = await redis_client.get(cache_key)
+        if cached_address:
+            return cached_address
+
+    networks = _networks_for_name(normalized)
+    if not networks:
+        raise IntentKitAPIError(
+            404,
+            "ENSNameNotFound",
+            "Unsupported ENS name suffix.",
+        )
+
+    for network in networks:
+        address = await _resolve_on_network(normalized, network)
+        if address:
+            if redis_client is not None:
+                try:
+                    await redis_client.set(cache_key, address, ex=_CACHE_TTL_SECONDS)
+                except Exception as exc:  # pragma: no cover - optional cache
+                    logger.debug("Failed to cache ENS resolution: %s", exc)
+            return address
+
+    raise IntentKitAPIError(
+        404,
+        "ENSNameNotFound",
+        f"ENS name {name} could not be resolved.",
+    )
+
+
+def _networks_for_name(name: str) -> tuple[str, ...]:
+    for suffix, networks in _NETWORKS_BY_SUFFIX.items():
+        if name.endswith(suffix):
+            return networks
+    return tuple()
+
+
+def _requires_poa_middleware(network: str) -> bool:
+    return network.startswith(_POA_NETWORK_PREFIXES)
+
+
+def _build_ens_client(rpc_url: str, network: str) -> ENS:
+    web3_client = Web3(Web3.HTTPProvider(rpc_url))
+    if _requires_poa_middleware(network):
+        web3_client.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
+
+    return ENS.from_web3(web3_client)
+
+
+async def _resolve_on_network(name: str, network: str) -> str | None:
+    chain_provider = getattr(config, "chain_provider", None)
+    if chain_provider is None:
+        logger.debug("No chain provider configured; cannot resolve ENS name.")
+        return None
+
+    try:
+        chain_config = chain_provider.get_chain_config(network)
+    except Exception as exc:  # pragma: no cover - dependent on external config
+        logger.debug("Chain config for %s unavailable: %s", network, exc)
+        return None
+
+    rpc_url = chain_config.ens_url or chain_config.rpc_url
+    if not rpc_url:
+        logger.debug("No RPC/ENS URL configured for %s", network)
+        return None
+
+    def _resolve() -> str | None:
+        ens_client = _build_ens_client(rpc_url, network)
+        try:
+            resolved = ens_client.address(name)
+        except Exception as exc:  # pragma: no cover - dependent on external provider
+            logger.debug("Error resolving %s on %s: %s", name, network, exc)
+            return None
+
+        if not resolved:
+            return None
+
+        try:
+            return Web3.to_checksum_address(resolved)
+        except ValueError:
+            return None
+
+    return await asyncio.to_thread(_resolve)

intentkit/utils/error.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Optional, Sequence
+from collections.abc import Sequence
 
 from fastapi.exceptions import RequestValidationError
 from fastapi.utils import is_body_allowed_for_status_code
@@ -17,12 +17,15 @@ logger = logging.getLogger(__name__)
 class RateLimitExceeded(Exception):
     """Rate limit exceeded"""
 
-    def __init__(self, message: Optional[str] = "Rate limit exceeded"):
+    def __init__(self, message: str | None = "Rate limit exceeded"):
         self.message = message
         super().__init__(self.message)
 
 
 class IntentKitAPIError(Exception):
+    """All 3 parameters: status_code, key and message is required.
+    The key is PascalCase string, to allow the frontend to test errors."""
+
     def __init__(self, status_code: int, key: str, message: str):
         self.key = key
         self.message = message

intentkit/utils/logging.py

@@ -4,17 +4,17 @@ Logging configuration module
 
 import json
 import logging
-from typing import Callable, Optional
+from collections.abc import Callable
+from typing import override
 
 
 class JsonFormatter(logging.Formatter):
-    def __init__(
-        self, filter_func: Optional[Callable[[logging.LogRecord], bool]] = None
-    ):
+    def __init__(self, filter_func: Callable[[logging.LogRecord], bool] | None = None):
         super().__init__()
         self.filter_func = filter_func
 
-    def format(self, record):
+    @override
+    def format(self, record: logging.LogRecord) -> str:
         if self.filter_func and not self.filter_func(record):
             return ""
 
@@ -24,17 +24,15 @@ class JsonFormatter(logging.Formatter):
             "level": record.levelname,
             "message": record.getMessage(),
         }
-        # Include any extra attributes
-        if hasattr(record, "extra"):
-            log_obj.update(record.extra)
-        elif record.__dict__.get("extra"):
-            log_obj.update(record.__dict__["extra"])
+        extra = record.__dict__.get("extra")
+        if isinstance(extra, dict):
+            log_obj.update(extra)
         if record.exc_info:
             log_obj["exc_info"] = self.formatException(record.exc_info)
         return json.dumps(log_obj)
 
 
-def setup_logging(env: str, debug: bool = False):
+def setup_logging(env: str, debug: bool = False) -> None:
     """
     Setup global logging configuration.
 

intentkit/utils/schema.py

@@ -0,0 +1,100 @@
+"""JSON Schema utilities for IntentKit.
+
+This module provides utilities for working with JSON schemas, including
+resolving $defs references and generating nested schemas.
+"""
+
+import copy
+from typing import Any
+
+
+def resolve_schema_refs(schema: dict[str, Any]) -> dict[str, Any]:
+    """Recursively resolve $defs references in a JSON schema.
+
+    This function takes a JSON schema with $defs references and returns
+    a fully nested schema without any $ref pointers. This is useful for
+    creating schemas that can be easily consumed by external systems
+    that don't support JSON Schema references.
+
+    Args:
+        schema: The JSON schema dictionary that may contain $defs and $ref
+
+    Returns:
+        dict: A new schema with all $ref resolved to nested objects
+
+    Example:
+        >>> schema = {
+        ...     "type": "object",
+        ...     "properties": {
+        ...         "user": {"$ref": "#/$defs/User"}
+        ...     },
+        ...     "$defs": {
+        ...         "User": {
+        ...             "type": "object",
+        ...             "properties": {"name": {"type": "string"}}
+        ...         }
+        ...     }
+        ... }
+        >>> resolved = resolve_schema_refs(schema)
+        >>> # resolved will have the User definition inlined
+    """
+    # Deep copy to avoid modifying the original
+    resolved_schema = copy.deepcopy(schema)
+
+    # Extract $defs if they exist
+    defs = resolved_schema.pop("$defs", {})
+
+    def resolve_refs(obj: Any, defs_dict: dict[str, Any]) -> Any:
+        """Recursively resolve $ref in an object."""
+        if isinstance(obj, dict):
+            if "$ref" in obj:
+                ref_path = obj["$ref"]
+                if ref_path.startswith("#/$defs/"):
+                    def_name = ref_path.replace("#/$defs/", "")
+                    if def_name in defs_dict:
+                        # Recursively resolve the referenced definition
+                        resolved_def = resolve_refs(defs_dict[def_name], defs_dict)
+                        return resolved_def
+                    else:
+                        # Keep the reference if definition not found
+                        return obj
+                else:
+                    # Keep non-$defs references as is
+                    return obj
+            else:
+                # Recursively process all values in the dictionary
+                return {
+                    key: resolve_refs(value, defs_dict) for key, value in obj.items()
+                }
+        elif isinstance(obj, list):
+            # Recursively process all items in the list
+            return [resolve_refs(item, defs_dict) for item in obj]
+        else:
+            # Return primitive values as is
+            return obj
+
+    # Resolve all references in the schema
+    return resolve_refs(resolved_schema, defs)
+
+
+def create_array_schema(
+    item_schema: dict[str, Any], resolve_refs: bool = True
+) -> dict[str, Any]:
+    """Create an array schema with the given item schema.
+
+    Args:
+        item_schema: The schema for array items
+        resolve_refs: Whether to resolve $defs references in the item schema
+
+    Returns:
+        dict: Array schema with resolved item schema
+    """
+    if resolve_refs:
+        resolved_item_schema = resolve_schema_refs(item_schema)
+    else:
+        resolved_item_schema = item_schema
+
+    return {
+        "type": "array",
+        "items": resolved_item_schema,
+    }

intentkit/utils/slack_alert.py

@@ -3,7 +3,7 @@ Slack notification module for sending messages to Slack channels.
 """
 
 import logging
-from typing import Optional
+from typing import Any, Sequence
 
 from slack_sdk import WebClient
 from slack_sdk.errors import SlackApiError
@@ -11,9 +11,9 @@ from slack_sdk.errors import SlackApiError
 logger = logging.getLogger(__name__)
 
 # Global variables for Slack configuration
-_slack_token: Optional[str] = None
-_slack_channel: Optional[str] = None
-_slack_client: Optional[WebClient] = None
+_slack_token: str | None = None
+_slack_channel: str | None = None
+_slack_client: WebClient | None = None
 
 
 def init_slack(token: str, channel: str) -> None:
@@ -36,10 +36,10 @@ def init_slack(token: str, channel: str) -> None:
 
 def send_slack_message(
     message: str,
-    blocks: Optional[list] = None,
-    attachments: Optional[list] = None,
-    thread_ts: Optional[str] = None,
-    channel: Optional[str] = None,
+    blocks: Sequence[dict[str, Any]] | None = None,
+    attachments: Sequence[dict[str, Any]] | None = None,
+    thread_ts: str | None = None,
+    channel: str | None = None,
 ):
     """
     Send a message to a Slack channel.

intentkit/utils/tx.py

@@ -1,13 +1,17 @@
+from typing import Any, Dict, Tuple
+
 from pydantic import BaseModel, Field
 from web3 import Web3
 
 
 class EvmContractWrapper:
-    def __init__(self, rpc_url: str, abi: list[dict], tx_data: str):
+    def __init__(
+        self, rpc_url: str, abi: list[dict[str, Any]], tx_data: Dict[str, Any]
+    ):
         w3 = Web3(Web3.HTTPProvider(rpc_url))
         contract = w3.eth.contract(abi=abi)
 
-        self.evm_tx = EvmTx(**tx_data)
+        self.evm_tx = EvmTx.model_validate(tx_data)
         self.fn, self.fn_args = contract.decode_function_input(self.evm_tx.data)
 
         for i, arg in self.fn_args.items():
@@ -19,19 +23,23 @@ class EvmContractWrapper:
                 ]  # Convert list of bytes to list of hex strings
 
     @property
-    def fn_and_args(self):
+    def fn_and_args(self) -> Tuple[Any, Dict[str, Any]]:
         return self.fn, self.fn_args
 
     @property
-    def dst_addr(self):
+    def dst_addr(self) -> str | None:
         return self.evm_tx.to
 
 
 class EvmTx(BaseModel):
-    data: str = Field(None, description="Data of the transaction.")
-    to: str = Field(None, description="Address of the receiver of the transaction.")
-    from_: str = Field(None, description="Address of the sender of the transaction.")
-    value: str = Field(None, description="Amount of token to send.")
+    data: str | None = Field(None, description="Data of the transaction.")
+    to: str | None = Field(
+        None, description="Address of the receiver of the transaction."
+    )
+    from_: str | None = Field(
+        None, description="Address of the sender of the transaction."
+    )
+    value: str | None = Field(None, description="Amount of token to send.")
     gas: int | None = Field(None, description="Gas amount.")
     gasPrice: int | None = Field(None, description="Gas Price.")
     nonce: int | None = Field(None, description="Nonce of transaction.")