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

intentkit/skills/lifi/token_quote.py

@@ -1,9 +1,8 @@
-from typing import Any, Dict, List, Optional, Type
+from typing import Any
 
 import httpx
 from pydantic import BaseModel, Field
 
-from intentkit.abstracts.skill import SkillStoreABC
 from intentkit.skills.lifi.base import LiFiBaseTool
 from intentkit.skills.lifi.utils import (
     LIFI_API_URL,
@@ -53,21 +52,20 @@ class TokenQuote(LiFiBaseTool):
         "Use this tool to check rates, fees, and estimated time for token transfers without executing them.\n"
         "Supports all major chains like Ethereum, Polygon, Arbitrum, Optimism, Base, and more."
     )
-    args_schema: Type[BaseModel] = TokenQuoteInput
+    args_schema: type[BaseModel] = TokenQuoteInput
     api_url: str = LIFI_API_URL
 
     # Configuration options
     default_slippage: float = 0.03
-    allowed_chains: Optional[List[str]] = None
+    allowed_chains: list[str] | None = None
 
     def __init__(
         self,
-        skill_store: SkillStoreABC,
         default_slippage: float = 0.03,
-        allowed_chains: Optional[List[str]] = None,
-    ):
+        allowed_chains: list[str] | None = None,
+    ) -> None:
         """Initialize the TokenQuote skill with configuration options."""
-        super().__init__(skill_store=skill_store)
+        super().__init__()
         self.default_slippage = default_slippage
         self.allowed_chains = allowed_chains
 
@@ -78,7 +76,7 @@ class TokenQuote(LiFiBaseTool):
         from_token: str,
         to_token: str,
         from_amount: str,
-        slippage: float = None,
+        slippage: float | None = None,
         **kwargs,
     ) -> str:
         """Get a quote for token transfer."""
@@ -140,7 +138,7 @@ class TokenQuote(LiFiBaseTool):
             self.logger.error("LiFi_Error: %s", str(e))
             return f"An unexpected error occurred: {str(e)}"
 
-    def _format_quote_result(self, data: Dict[str, Any]) -> str:
+    def _format_quote_result(self, data: dict[str, Any]) -> str:
         """Format quote result into human-readable text."""
         try:
             # Get basic info

intentkit/skills/lifi/utils.py

@@ -4,7 +4,8 @@ LiFi Skills Utilities
 Common utilities and helper functions for LiFi token transfer skills.
 """
 
-from typing import Any, Dict, List, Optional, Tuple
+from decimal import ROUND_DOWN, Decimal, InvalidOperation
+from typing import Any
 
 import httpx
 from web3 import Web3
@@ -71,8 +72,8 @@ def validate_inputs(
     to_token: str,
     from_amount: str,
     slippage: float,
-    allowed_chains: Optional[List[str]] = None,
-) -> Optional[str]:
+    allowed_chains: list[str] | None = None,
+) -> str | None:
     """
     Validate all input parameters for LiFi operations.
 
@@ -179,7 +180,7 @@ def handle_api_response(
     from_chain: str,
     to_token: str,
     to_chain: str,
-) -> Tuple[Optional[Dict], Optional[str]]:
+) -> tuple[dict[str, Any] | None, str | None]:
     """
     Handle LiFi API response and return data or error message.
 
@@ -293,17 +294,20 @@ def convert_chain_to_id(chain: str) -> int:
 
 
 def convert_amount_to_wei(amount: str, token_symbol: str = "ETH") -> str:
-    """
-    Convert human-readable amount to wei format for LiFi API.
+    """Convert a token amount into the smallest denomination expected by LiFi."""
 
-    Args:
-        amount: Amount in human readable format (e.g., "0.0015")
-        token_symbol: Token symbol to determine decimals
+    if amount is None:
+        raise ValueError("Amount is required")
+
+    normalized_amount = amount.strip()
+    if not normalized_amount:
+        raise ValueError("Amount cannot be empty")
+
+    # If the user already provided an integer amount without a decimal point,
+    # assume it is already in the token's smallest denomination.
+    if normalized_amount.isdigit():
+        return normalized_amount
 
-    Returns:
-        Amount in wei format as string
-    """
-    # Default decimals for common tokens
     token_decimals = {
         "ETH": 18,
         "USDC": 6,
@@ -318,13 +322,16 @@ def convert_amount_to_wei(amount: str, token_symbol: str = "ETH") -> str:
     decimals = token_decimals.get(token_symbol.upper(), 18)
 
     try:
-        # Convert string to float, then to wei
-        amount_float = float(amount)
-        amount_wei = int(amount_float * (10**decimals))
-        return str(amount_wei)
-    except (ValueError, TypeError):
-        # If conversion fails, return original amount
-        return amount
+        decimal_amount = Decimal(normalized_amount)
+        scaled_amount = (decimal_amount * (Decimal(10) ** decimals)).quantize(
+            Decimal("1"),
+            rounding=ROUND_DOWN,
+        )
+        return str(int(scaled_amount))
+    except (InvalidOperation, ValueError, TypeError):
+        # If conversion fails, fall back to the original value to avoid
+        # accidentally submitting an incorrect amount.
+        return normalized_amount
 
 
 def build_quote_params(
@@ -334,8 +341,8 @@ def build_quote_params(
     to_token: str,
     from_amount: str,
     slippage: float,
-    from_address: Optional[str] = None,
-) -> Dict[str, Any]:
+    from_address: str | None = None,
+) -> dict[str, Any]:
     """
     Build parameters for LiFi quote API request.
 
@@ -350,15 +357,12 @@ def build_quote_params(
     Raises:
         ValueError: If chain identifiers are not recognized
     """
-    # Convert amount to wei format for API
-    wei_amount = convert_amount_to_wei(from_amount, from_token)
-
     return {
         "fromChain": convert_chain_to_id(from_chain),
         "toChain": convert_chain_to_id(to_chain),
         "fromToken": from_token,
         "toToken": to_token,
-        "fromAmount": wei_amount,
+        "fromAmount": convert_amount_to_wei(from_amount, from_token),
         "fromAddress": from_address or DUMMY_ADDRESS,
         "slippage": slippage,
     }
@@ -381,38 +385,87 @@ def is_native_token(token_address: str) -> bool:
     )
 
 
-def prepare_transaction_params(transaction_request: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Prepare transaction parameters for CDP wallet provider.
+def _convert_hex_or_decimal(value: Any) -> int | None:
+    """Convert LiFi transaction numeric values into integers."""
 
-    Args:
-        transaction_request: Transaction request from LiFi API
+    if value is None:
+        return None
 
-    Returns:
-        Formatted transaction parameters
+    if isinstance(value, int):
+        return value
+
+    if isinstance(value, str):
+        stripped = value.strip()
+        if not stripped:
+            return None
+        if stripped.startswith("0x"):
+            return int(stripped, 16)
+        try:
+            return int(Decimal(stripped))
+        except (InvalidOperation, ValueError):
+            return None
+
+    return None
+
+
+def prepare_transaction_params(
+    transaction_request: dict[str, Any],
+    wallet_address: str | None = None,
+) -> dict[str, Any]:
+    """Prepare transaction parameters for the CDP wallet provider."""
 
-    Raises:
-        Exception: If required parameters are missing
-    """
     to_address = transaction_request.get("to")
-    value = transaction_request.get("value", "0")
+    value = transaction_request.get("value", "0x0")
     data = transaction_request.get("data", "0x")
 
     if not to_address:
-        raise Exception("No destination address in transaction request")
-
-    # Convert value to integer if it's a string
-    if isinstance(value, str):
-        value = int(value, 16) if value.startswith("0x") else int(value)
+        raise Exception("Transaction request is missing destination address")
 
-    return {
+    tx_params: dict[str, Any] = {
         "to": Web3.to_checksum_address(to_address),
-        "value": value,
         "data": data,
     }
 
+    int_value = _convert_hex_or_decimal(value)
+    if int_value is not None:
+        tx_params["value"] = int_value
+
+    chain_id = _convert_hex_or_decimal(transaction_request.get("chainId"))
+    if chain_id is not None:
+        tx_params["chainId"] = chain_id
+
+    gas_limit = _convert_hex_or_decimal(
+        transaction_request.get("gasLimit") or transaction_request.get("gas")
+    )
+    if gas_limit is not None:
+        tx_params["gas"] = gas_limit
+
+    gas_price = _convert_hex_or_decimal(transaction_request.get("gasPrice"))
+    if gas_price is not None:
+        tx_params["gasPrice"] = gas_price
+
+    max_fee_per_gas = _convert_hex_or_decimal(transaction_request.get("maxFeePerGas"))
+    if max_fee_per_gas is not None:
+        tx_params["maxFeePerGas"] = max_fee_per_gas
+
+    max_priority_fee_per_gas = _convert_hex_or_decimal(
+        transaction_request.get("maxPriorityFeePerGas")
+    )
+    if max_priority_fee_per_gas is not None:
+        tx_params["maxPriorityFeePerGas"] = max_priority_fee_per_gas
+
+    nonce = _convert_hex_or_decimal(transaction_request.get("nonce"))
+    if nonce is not None:
+        tx_params["nonce"] = nonce
+
+    from_address = transaction_request.get("from") or wallet_address
+    if from_address:
+        tx_params["from"] = Web3.to_checksum_address(from_address)
+
+    return tx_params
+
 
-def format_quote_basic_info(data: Dict[str, Any]) -> Dict[str, Any]:
+def format_quote_basic_info(data: dict[str, Any]) -> dict[str, Any]:
     """
     Extract and format basic quote information.
 
@@ -450,7 +503,7 @@ def format_quote_basic_info(data: Dict[str, Any]) -> Dict[str, Any]:
     }
 
 
-def format_fees_and_gas(data: Dict[str, Any]) -> Tuple[str, str]:
+def format_fees_and_gas(data: dict[str, Any]) -> tuple[str, str]:
     """
     Format fee and gas cost information from quote data.
 
@@ -464,7 +517,7 @@ def format_fees_and_gas(data: Dict[str, Any]) -> Tuple[str, str]:
 
     # Extract gas and fee costs
     gas_costs = estimate.get("gasCosts", [])
-    fee_costs = []
+    fee_costs: list[dict[str, Any]] = []
 
     # Collect fee information from included steps
     for step in data.get("includedSteps", []):
@@ -476,7 +529,7 @@ def format_fees_and_gas(data: Dict[str, Any]) -> Tuple[str, str]:
     fees_text = ""
     if fee_costs:
         fees_text = "**Fees:**\n"
-        total_fee_usd = 0
+        total_fee_usd = 0.0
         for fee in fee_costs:
             fee_name = fee.get("name", "Unknown fee")
             fee_amount = fee.get("amount", "0")
@@ -508,7 +561,7 @@ def format_fees_and_gas(data: Dict[str, Any]) -> Tuple[str, str]:
     gas_text = ""
     if gas_costs:
         gas_text = "**Gas Cost:**\n"
-        total_gas_usd = 0
+        total_gas_usd = 0.0
         for gas in gas_costs:
             gas_amount = gas.get("amount", "0")
             gas_token = gas.get("token", {}).get("symbol", "ETH")
@@ -531,7 +584,7 @@ def format_fees_and_gas(data: Dict[str, Any]) -> Tuple[str, str]:
     return fees_text, gas_text
 
 
-def format_route_info(data: Dict[str, Any]) -> str:
+def format_route_info(data: dict[str, Any]) -> str:
     """
     Format routing information from quote data.
 
@@ -628,7 +681,7 @@ def get_explorer_url(chain_id: int, tx_hash: str) -> str:
 
 
 def format_transaction_result(
-    tx_hash: str, chain_id: int, token_info: dict = None
+    tx_hash: str, chain_id: int, token_info: dict[str, str] | None = None
 ) -> str:
     """
     Format transaction result with explorer link.

intentkit/skills/moralis/__init__.py

@@ -1,9 +1,9 @@
 """Wallet Portfolio Skills for IntentKit."""
 
 import logging
-from typing import Dict, List, NotRequired, TypedDict
+from typing import NotRequired, TypedDict
 
-from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.config.config import config as system_config
 from intentkit.skills.base import SkillConfig, SkillState
 from intentkit.skills.moralis.base import WalletBaseTool
 from intentkit.skills.moralis.fetch_chain_portfolio import FetchChainPortfolio
@@ -28,21 +28,19 @@ class Config(SkillConfig):
 
     api_key: str
     states: SkillStates
-    supported_chains: NotRequired[Dict[str, bool]] = {"evm": True, "solana": True}
+    supported_chains: NotRequired[dict[str, bool]] = {"evm": True, "solana": True}
 
 
 async def get_skills(
     config: "Config",
     is_private: bool,
-    store: SkillStoreABC,
     **_,
-) -> List[WalletBaseTool]:
+) -> list[WalletBaseTool]:
     """Get all Wallet Portfolio skills.
 
     Args:
         config: Skill configuration
         is_private: Whether the request is from an authenticated user
-        store: Skill store for persistence
         chain_provider: Optional chain provider for blockchain interactions
         **_: Additional arguments
 
@@ -67,12 +65,12 @@ async def get_skills(
     if config.get("api_key_provider") == "agent_owner":
         api_key = config.get("api_key")
     else:
-        api_key = store.get_system_config("moralis_api_key")
+        api_key = system_config.moralis_api_key
 
     # Get each skill using the getter
     result = []
     for name in available_skills:
-        skill = get_wallet_skill(name, api_key, store)
+        skill = get_wallet_skill(name, api_key)
         if skill:
             result.append(skill)
     return result
@@ -81,7 +79,6 @@ async def get_skills(
 def get_wallet_skill(
     name: str,
     api_key: str,
-    store: SkillStoreABC,
 ) -> WalletBaseTool:
     """Get a specific Wallet Portfolio skill by name.
 
@@ -106,5 +103,4 @@ def get_wallet_skill(
 
     return skill_classes[name](
         api_key=api_key,
-        skill_store=store,
     )

intentkit/skills/moralis/api.py

@@ -1,7 +1,6 @@
 """API interface for wallet data providers (EVM chains and Solana)."""
 
 import logging
-from typing import Dict
 
 import httpx
 
@@ -163,7 +162,7 @@ async def fetch_net_worth(api_key: str, address: str) -> dict:
 #############################################
 
 
-async def fetch_solana_api(api_key: str, endpoint: str, params: Dict = None) -> Dict:
+async def fetch_solana_api(api_key: str, endpoint: str, params: dict = None) -> dict:
     """Base function for Solana API calls using Moralis.
 
     Args:
@@ -200,7 +199,7 @@ async def fetch_solana_api(api_key: str, endpoint: str, params: Dict = None) ->
 
 async def get_solana_portfolio(
     api_key: str, address: str, network: str = "mainnet"
-) -> Dict:
+) -> dict:
     """Get complete portfolio for a Solana wallet.
 
     Args:
@@ -217,7 +216,7 @@ async def get_solana_portfolio(
 
 async def get_solana_balance(
     api_key: str, address: str, network: str = "mainnet"
-) -> Dict:
+) -> dict:
     """Get native SOL balance.
 
     Args:
@@ -234,7 +233,7 @@ async def get_solana_balance(
 
 async def get_solana_spl_tokens(
     api_key: str, address: str, network: str = "mainnet"
-) -> Dict:
+) -> dict:
     """Get SPL token balances.
 
     Args:
@@ -249,7 +248,7 @@ async def get_solana_spl_tokens(
     return await fetch_solana_api(api_key, endpoint)
 
 
-async def get_solana_nfts(api_key: str, address: str, network: str = "mainnet") -> Dict:
+async def get_solana_nfts(api_key: str, address: str, network: str = "mainnet") -> dict:
     """Get NFTs owned by a Solana wallet.
 
     Args:
@@ -266,7 +265,7 @@ async def get_solana_nfts(api_key: str, address: str, network: str = "mainnet")
 
 async def get_token_price(
     api_key: str, token_address: str, network: str = "mainnet"
-) -> Dict:
+) -> dict:
     """Get token price by mint address.
 
     Args:

intentkit/skills/moralis/base.py

@@ -1,11 +1,9 @@
 """Base class for Wallet Portfolio tools."""
 
-from typing import List, Optional, Type
-
-from langchain.tools.base import ToolException
+from langchain_core.tools.base import ToolException
 from pydantic import BaseModel, Field
 
-from intentkit.abstracts.skill import SkillStoreABC
+from intentkit.config.config import config
 from intentkit.skills.base import IntentKitSkill
 
 # Chain ID to chain name mapping for EVM chains
@@ -29,13 +27,10 @@ class WalletBaseTool(IntentKitSkill):
 
     name: str = Field(description="The name of the tool")
     description: str = Field(description="A description of what the tool does")
-    args_schema: Type[BaseModel]
-    skill_store: SkillStoreABC = Field(
-        description="The skill store for persisting data"
-    )
+    args_schema: type[BaseModel]
 
     # Optional fields for blockchain providers
-    solana_networks: Optional[List[str]] = Field(
+    solana_networks: list[str] | None = Field(
         default=SOLANA_NETWORKS, description="Supported Solana networks"
     )
 
@@ -44,7 +39,7 @@ class WalletBaseTool(IntentKitSkill):
         skill_config = context.agent.skill_config(self.category)
         api_key_provider = skill_config.get("api_key_provider")
         if api_key_provider == "platform":
-            return self.skill_store.get_system_config("moralis_api_key")
+            return config.moralis_api_key
         # for backward compatibility, may only have api_key in skill_config
         elif skill_config.get("api_key"):
             return skill_config.get("api_key")

intentkit/skills/moralis/fetch_chain_portfolio.py

@@ -1,7 +1,6 @@
 """fetching wallet portfolio for a specific blockchain."""
 
 import logging
-from typing import List, Optional, Type
 
 from pydantic import BaseModel, Field
 
@@ -27,7 +26,7 @@ class ChainTokenBalance(BaseModel):
     contract_address: str = Field(..., description="Token contract address")
     symbol: str = Field(..., description="Token symbol")
     name: str = Field(..., description="Token name")
-    logo: Optional[str] = Field(None, description="Token logo URL")
+    logo: str | None = Field(None, description="Token logo URL")
     decimals: int = Field(..., description="Token decimals")
     balance: float = Field(..., description="Token balance")
     balance_raw: str = Field(..., description="Raw token balance")
@@ -38,12 +37,12 @@ class TokenApproval(BaseModel):
     """Model for token approval."""
 
     token_address: str = Field(..., description="Token contract address")
-    token_symbol: Optional[str] = Field(None, description="Token symbol")
-    token_name: Optional[str] = Field(None, description="Token name")
+    token_symbol: str | None = Field(None, description="Token symbol")
+    token_name: str | None = Field(None, description="Token name")
     spender: str = Field(..., description="Spender address (contract)")
-    spender_name: Optional[str] = Field(None, description="Spender name if known")
+    spender_name: str | None = Field(None, description="Spender name if known")
     allowance: str = Field(..., description="Raw approval amount")
-    allowance_formatted: Optional[float] = Field(
+    allowance_formatted: float | None = Field(
         None, description="Formatted approval amount"
     )
     unlimited: bool = Field(False, description="Whether the approval is unlimited")
@@ -55,17 +54,17 @@ class ChainPortfolioOutput(BaseModel):
     address: str = Field(..., description="Wallet address")
     chain_id: int = Field(..., description="Chain ID")
     chain_name: str = Field(..., description="Chain name")
-    native_token: Optional[ChainTokenBalance] = Field(
+    native_token: ChainTokenBalance | None = Field(
         None, description="Native token balance"
     )
-    tokens: List[ChainTokenBalance] = Field(
+    tokens: list[ChainTokenBalance] = Field(
         default_factory=list, description="List of token balances"
     )
     total_usd_value: float = Field(0.0, description="Total USD value on this chain")
-    approvals: Optional[List[TokenApproval]] = Field(
+    approvals: list[TokenApproval] | None = Field(
         None, description="Token approvals if requested"
     )
-    error: Optional[str] = Field(None, description="Error message if any")
+    error: str | None = Field(None, description="Error message if any")
 
 
 class FetchChainPortfolio(WalletBaseTool):
@@ -87,7 +86,7 @@ class FetchChainPortfolio(WalletBaseTool):
         "- Token approvals (optional)\n"
         "Use this tool whenever a user wants to see their holdings on a specific blockchain."
     )
-    args_schema: Type[BaseModel] = FetchChainPortfolioInput
+    args_schema: type[BaseModel] = FetchChainPortfolioInput
 
     async def _arun(
         self, address: str, chain_id: int, include_approvals: bool = False, **kwargs

intentkit/skills/moralis/fetch_nft_portfolio.py

@@ -2,7 +2,7 @@
 
 import json
 import logging
-from typing import Any, Dict, List, Optional, Type
+from typing import Any
 
 from pydantic import BaseModel, Field
 
@@ -16,7 +16,7 @@ class FetchNftPortfolioInput(BaseModel):
     """Input for FetchNftPortfolio tool."""
 
     address: str = Field(..., description="Wallet address")
-    chain_id: Optional[int] = Field(
+    chain_id: int | None = Field(
         None,
         description="Chain ID (if not specified, fetches from all supported chains)",
     )
@@ -26,7 +26,7 @@ class FetchNftPortfolioInput(BaseModel):
     solana_network: str = Field(
         default="mainnet", description="Solana network to use (mainnet or devnet)"
     )
-    limit: Optional[int] = Field(100, description="Maximum number of NFTs to return")
+    limit: int | None = Field(100, description="Maximum number of NFTs to return")
     normalize_metadata: bool = Field(
         True, description="Whether to normalize metadata across different standards"
     )
@@ -35,12 +35,12 @@ class FetchNftPortfolioInput(BaseModel):
 class NftMetadata(BaseModel):
     """Model for NFT metadata."""
 
-    name: Optional[str] = Field(None, description="NFT name")
-    description: Optional[str] = Field(None, description="NFT description")
-    image: Optional[str] = Field(None, description="NFT image URL")
-    animation_url: Optional[str] = Field(None, description="NFT animation URL")
-    attributes: Optional[List[Dict]] = Field(None, description="NFT attributes/traits")
-    external_url: Optional[str] = Field(None, description="External URL")
+    name: str | None = Field(None, description="NFT name")
+    description: str | None = Field(None, description="NFT description")
+    image: str | None = Field(None, description="NFT image URL")
+    animation_url: str | None = Field(None, description="NFT animation URL")
+    attributes: list[dict] | None = Field(None, description="NFT attributes/traits")
+    external_url: str | None = Field(None, description="External URL")
 
 
 class NftItem(BaseModel):
@@ -48,14 +48,14 @@ class NftItem(BaseModel):
 
     token_id: str = Field(..., description="NFT token ID")
     token_address: str = Field(..., description="NFT contract address")
-    contract_type: Optional[str] = Field(
+    contract_type: str | None = Field(
         None, description="NFT contract type (ERC721, ERC1155, etc.)"
     )
-    name: Optional[str] = Field(None, description="NFT name")
-    symbol: Optional[str] = Field(None, description="NFT symbol")
+    name: str | None = Field(None, description="NFT name")
+    symbol: str | None = Field(None, description="NFT symbol")
     owner_of: str = Field(..., description="Owner address")
-    metadata: Optional[NftMetadata] = Field(None, description="NFT metadata")
-    floor_price: Optional[float] = Field(None, description="Floor price if available")
+    metadata: NftMetadata | None = Field(None, description="NFT metadata")
+    floor_price: float | None = Field(None, description="Floor price if available")
     chain: str = Field("eth", description="Blockchain network")
 
 
@@ -63,13 +63,13 @@ class NftPortfolioOutput(BaseModel):
     """Output for FetchNftPortfolio tool."""
 
     address: str = Field(..., description="Wallet address")
-    nfts: List[NftItem] = Field(default_factory=list, description="List of NFT items")
+    nfts: list[NftItem] = Field(default_factory=list, description="List of NFT items")
     total_count: int = Field(0, description="Total count of NFTs")
-    chains: List[str] = Field(
+    chains: list[str] = Field(
         default_factory=list, description="Chains included in the response"
     )
-    cursor: Optional[str] = Field(None, description="Cursor for pagination")
-    error: Optional[str] = Field(None, description="Error message if any")
+    cursor: str | None = Field(None, description="Cursor for pagination")
+    error: str | None = Field(None, description="Error message if any")
 
 
 class FetchNftPortfolio(WalletBaseTool):
@@ -90,12 +90,12 @@ class FetchNftPortfolio(WalletBaseTool):
         "- Floor prices if available\n"
         "Use this tool whenever a user asks about their NFTs or digital collectibles."
     )
-    args_schema: Type[BaseModel] = FetchNftPortfolioInput
+    args_schema: type[BaseModel] = FetchNftPortfolioInput
 
     async def _arun(
         self,
         address: str,
-        chain_id: Optional[int] = None,
+        chain_id: int | None = None,
         include_solana: bool = False,
         solana_network: str = "mainnet",
         limit: int = 100,
@@ -156,7 +156,7 @@ class FetchNftPortfolio(WalletBaseTool):
         chain_id: int,
         limit: int,
         normalize_metadata: bool,
-        result: Dict[str, Any],
+        result: dict[str, Any],
     ) -> None:
         """Fetch NFTs from an EVM chain.
 
@@ -222,7 +222,7 @@ class FetchNftPortfolio(WalletBaseTool):
             result["nfts"].append(nft_item)
 
     async def _fetch_solana_nfts(
-        self, address: str, network: str, limit: int, result: Dict[str, Any]
+        self, address: str, network: str, limit: int, result: dict[str, Any]
     ) -> None:
         """Fetch NFTs from Solana.