wayfinder-paths 0.1.9__py3-none-any.whl → 0.1.11__py3-none-any.whl

wayfinder_paths/core/services/local_evm_txn.py

@@ -6,10 +6,6 @@ from eth_utils import to_checksum_address
 from loguru import logger
 from web3 import AsyncHTTPProvider, AsyncWeb3
 
-from wayfinder_paths.core.constants import (
-    DEFAULT_GAS_ESTIMATE_FALLBACK,
-    ONE_GWEI,
-)
 from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
 from wayfinder_paths.core.services.base import EvmTxn
 from wayfinder_paths.core.utils.evm_helpers import (
@@ -17,59 +13,31 @@ from wayfinder_paths.core.utils.evm_helpers import (
     resolve_rpc_url,
 )
 
-# Gas management constants for ERC20 approval transactions
-ERC20_APPROVAL_GAS_LIMIT = 120_000
-MAX_FEE_PER_GAS_RATE = 1.2
-
-
-class NonceManager:
-    """
-    Thread-safe nonce manager to track and increment nonces per address/chain.
-    Prevents nonce conflicts when multiple transactions are sent in quick succession.
-    """
-
-    def __init__(self):
-        # Dictionary: (address, chain_id) -> current_nonce
-        self._nonces: dict[tuple[str, int], int] = {}
-        self._lock: asyncio.Lock | None = None
-
-    def _get_lock(self) -> asyncio.Lock:
-        """Get or create the async lock."""
-        if self._lock is None:
-            self._lock = asyncio.Lock()
-        return self._lock
-
-    async def get_next_nonce(self, address: str, chain_id: int, w3: AsyncWeb3) -> int:
-        """
-        Get the next nonce for an address on a chain.
-        Tracks nonces locally and syncs with chain when needed.
-        """
-        async with self._get_lock():
-            key = (address.lower(), chain_id)
-
-            # If we don't have a tracked nonce, fetch from chain
-            if key not in self._nonces:
-                chain_nonce = await w3.eth.get_transaction_count(address, "pending")
-                self._nonces[key] = chain_nonce
-                return chain_nonce
-
-            # Return the tracked nonce and increment for next time
-            current_nonce = self._nonces[key]
-            self._nonces[key] = current_nonce + 1
-            return current_nonce
-
-    async def sync_nonce(self, address: str, chain_id: int, chain_nonce: int) -> None:
-        """
-        Sync the tracked nonce with the chain nonce.
-        Used when we detect a mismatch or after a transaction fails.
-        """
-        async with self._get_lock():
-            key = (address.lower(), chain_id)
-            # Use the higher of the two to avoid going backwards
-            if key in self._nonces:
-                self._nonces[key] = max(self._nonces[key], chain_nonce)
-            else:
-                self._nonces[key] = chain_nonce
+SUGGESTED_GAS_PRICE_MULTIPLIER = 1.5
+SUGGESTED_PRIORITY_FEE_MULTIPLIER = 1.5
+MAX_BASE_FEE_GROWTH_MULTIPLIER = 2
+GAS_LIMIT_BUFFER_MULTIPLIER = 1.5
+
+# Chains that don't support EIP-1559 (London) and need legacy gas pricing
+PRE_LONDON_GAS_CHAIN_IDS: set[int] = {56, 42161}
+
+
+def _looks_like_revert_error(error: Any) -> bool:
+    msg = str(error).lower()
+    return any(
+        needle in msg
+        for needle in (
+            "execution reverted",
+            "revert",
+            "always failing transaction",
+            "gas required exceeds",
+            "out of gas",
+            "insufficient funds",
+            "transfer amount exceeds balance",
+            "insufficient balance",
+            "insufficient allowance",
+        )
+    )
 
 
 class LocalEvmTxn(EvmTxn):
@@ -83,24 +51,112 @@ class LocalEvmTxn(EvmTxn):
     """
 
     def __init__(self, config: dict[str, Any] | None = None):
-        """
-        Initialize local wallet provider.
-
-        Args:
-            config: Configuration dictionary containing wallet information
-        """
         self.config = config or {}
         self.logger = logger.bind(provider="LocalWalletProvider")
-        self._nonce_manager = NonceManager()
 
     def get_web3(self, chain_id: int) -> AsyncWeb3:
-        """
-        Return an AsyncWeb3 configured for the requested chain.
-
-        Callers are responsible for closing the provider session when finished.
-        """
         rpc_url = self._resolve_rpc_url(chain_id)
-        return AsyncWeb3(AsyncHTTPProvider(rpc_url))
+        w3 = AsyncWeb3(AsyncHTTPProvider(rpc_url))
+        return w3
+
+    def _validate_transaction(self, transaction: dict[str, Any]) -> dict[str, Any]:
+        tx = dict(transaction)
+
+        assert "from" in tx, "Transaction missing 'from' address"
+        assert "to" in tx, "Transaction missing 'to' address"
+        assert "chainId" in tx, "Transaction missing 'chainId'"
+
+        tx["from"] = to_checksum_address(tx["from"])
+        tx["to"] = to_checksum_address(tx["to"])
+        if "value" in tx:
+            tx["value"] = self._normalize_int(tx["value"])
+
+        tx.pop("gas", None)
+        tx.pop("gasPrice", None)
+        tx.pop("maxFeePerGas", None)
+        tx.pop("maxPriorityFeePerGas", None)
+        tx.pop("nonce", None)
+
+        return tx
+
+    async def _nonce_transaction(
+        self, transaction: dict[str, Any], w3: AsyncWeb3
+    ) -> dict[str, Any]:
+        transaction["nonce"] = await w3.eth.get_transaction_count(
+            transaction["from"], "pending"
+        )
+        return transaction
+
+    async def _gas_limit_transaction(
+        self, transaction: dict[str, Any], w3: AsyncWeb3
+    ) -> dict[str, Any]:
+        # Pop existing gas limit before estimating - if present, the node uses it as
+        # a ceiling and fails with "out of gas" instead of returning actual estimate
+        existing_gas = transaction.pop("gas", None)
+        try:
+            transaction.pop("gas", None)  # Remove any existing gas limit
+            estimated = await w3.eth.estimate_gas(transaction)
+            transaction["gas"] = int(estimated * GAS_LIMIT_BUFFER_MULTIPLIER)
+            self.logger.debug(
+                f"Estimated gas with buffer: {estimated} -> {transaction['gas']}"
+            )
+        except Exception as exc:  # noqa: BLE001
+            if _looks_like_revert_error(exc):
+                raise ValueError(
+                    f"Gas estimation failed (tx likely to revert): {exc}"
+                ) from exc
+            self.logger.warning(f"Gas estimation failed. Reason: {exc}")
+            # Restore existing gas limit if estimation failed, otherwise error
+            if existing_gas is not None:
+                transaction["gas"] = existing_gas
+            else:
+                raise ValueError(
+                    f"Gas estimation failed and no gas limit set: {exc}"
+                ) from exc
+
+        return transaction
+
+    async def _get_gas_price(self, w3: AsyncWeb3) -> int:
+        return await w3.eth.gas_price
+
+    async def _get_base_fee(self, w3: AsyncWeb3) -> int:
+        latest_block = await w3.eth.get_block("latest")
+        return latest_block.baseFeePerGas
+
+    async def _get_priority_fee(self, w3: AsyncWeb3) -> int:
+        lookback_blocks = 10
+        percentile = 80
+        fee_history = await w3.eth.fee_history(lookback_blocks, "latest", [percentile])
+        historical_priority_fees = [i[0] for i in fee_history.reward]
+        return sum(historical_priority_fees) // len(historical_priority_fees)
+
+    async def _gas_price_transaction(
+        self, transaction: dict[str, Any], chain_id: int, w3: AsyncWeb3
+    ) -> dict[str, Any]:
+        if chain_id in PRE_LONDON_GAS_CHAIN_IDS:
+            gas_price = await self._get_gas_price(w3)
+
+            transaction["gasPrice"] = int(gas_price * SUGGESTED_GAS_PRICE_MULTIPLIER)
+        elif chain_id == 999:
+            big_block_gas_price = await w3.hype.big_block_gas_price()
+
+            transaction["maxFeePerGas"] = int(
+                big_block_gas_price * SUGGESTED_PRIORITY_FEE_MULTIPLIER
+            )
+            transaction["maxPriorityFeePerGas"] = 0
+        else:
+            base_fee = await self._get_base_fee(w3)
+            priority_fee = await self._get_priority_fee(w3)
+
+            transaction["maxFeePerGas"] = int(
+                base_fee * MAX_BASE_FEE_GROWTH_MULTIPLIER
+                + priority_fee * SUGGESTED_PRIORITY_FEE_MULTIPLIER
+            )
+            transaction["maxPriorityFeePerGas"] = int(
+                priority_fee * SUGGESTED_PRIORITY_FEE_MULTIPLIER
+            )
+
+        return transaction
 
     async def broadcast_transaction(
         self,
@@ -108,157 +164,55 @@ class LocalEvmTxn(EvmTxn):
         *,
         wait_for_receipt: bool = True,
         timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
+        confirmations: int = 1,
     ) -> tuple[bool, Any]:
-        """
-        Sign and broadcast a transaction dict.
-        """
         try:
-            tx = dict(transaction)
-            from_address = tx.get("from")
-            if not from_address:
-                return (False, "Transaction missing 'from' address")
-            checksum_from = to_checksum_address(from_address)
-            tx["from"] = checksum_from
-
-            chain_id = tx.get("chainId") or tx.get("chain_id")
-            if chain_id is None:
-                return (False, "Transaction missing chainId")
-            tx["chainId"] = int(chain_id)
-
-            w3 = self.get_web3(tx["chainId"])
-            try:
-                if "value" in tx:
-                    tx["value"] = self._normalize_int(tx["value"])
-                else:
-                    tx["value"] = 0
-
-                if "nonce" in tx:
-                    tx["nonce"] = self._normalize_int(tx["nonce"])
-                    # Sync our tracked nonce with the provided nonce
-                    await self._nonce_manager.sync_nonce(
-                        checksum_from, tx["chainId"], tx["nonce"]
-                    )
-                else:
-                    # Use nonce manager to get and track the next nonce
-                    tx["nonce"] = await self._nonce_manager.get_next_nonce(
-                        checksum_from, tx["chainId"], w3
-                    )
+            chain_id = transaction["chainId"]
+            from_address = transaction["from"]
 
-                if "data" in tx and isinstance(tx["data"], str):
-                    calldata = tx["data"]
-                    tx["data"] = (
-                        calldata if calldata.startswith("0x") else f"0x{calldata}"
+            web3 = self.get_web3(chain_id)
+            try:
+                transaction = self._validate_transaction(transaction)
+                transaction = await self._nonce_transaction(transaction, web3)
+                transaction = await self._gas_limit_transaction(transaction, web3)
+                transaction = await self._gas_price_transaction(
+                    transaction, chain_id, web3
+                )
+
+                signed_tx = self._sign_transaction(transaction, from_address)
+
+                tx_hash = await web3.eth.send_raw_transaction(signed_tx)
+                tx_hash_hex = tx_hash.hex()
+
+                result: dict[str, Any] = {"tx_hash": tx_hash_hex}
+                if wait_for_receipt:
+                    receipt = await web3.eth.wait_for_transaction_receipt(
+                        tx_hash, timeout=timeout
                     )
-
-                if "gas" in tx:
-                    tx["gas"] = self._normalize_int(tx["gas"])
-                else:
-                    estimate_request = {
-                        "to": tx.get("to"),
-                        "from": tx["from"],
-                        "value": tx.get("value", 0),
-                        "data": tx.get("data", "0x"),
-                    }
-                    try:
-                        tx["gas"] = await w3.eth.estimate_gas(estimate_request)
-                    except Exception as exc:  # noqa: BLE001
-                        self.logger.warning(
-                            "Gas estimation failed; using fallback %s. Reason: %s",
-                            DEFAULT_GAS_ESTIMATE_FALLBACK,
-                            exc,
-                        )
-                        tx["gas"] = DEFAULT_GAS_ESTIMATE_FALLBACK
-
-                if "maxFeePerGas" in tx or "maxPriorityFeePerGas" in tx:
-                    if "maxFeePerGas" in tx:
-                        tx["maxFeePerGas"] = self._normalize_int(tx["maxFeePerGas"])
-                    else:
-                        base = await w3.eth.gas_price
-                        tx["maxFeePerGas"] = int(base * 2)
-
-                    if "maxPriorityFeePerGas" in tx:
-                        tx["maxPriorityFeePerGas"] = self._normalize_int(
-                            tx["maxPriorityFeePerGas"]
-                        )
-                    else:
-                        tx["maxPriorityFeePerGas"] = int(ONE_GWEI)
-                    tx["type"] = 2
-                else:
-                    if "gasPrice" in tx:
-                        tx["gasPrice"] = self._normalize_int(tx["gasPrice"])
-                    else:
-                        gas_price = await w3.eth.gas_price
-                        tx["gasPrice"] = int(gas_price)
-
-                signed_tx = self._sign_transaction(tx, checksum_from)
-                try:
-                    tx_hash = await w3.eth.send_raw_transaction(signed_tx)
-                    tx_hash_hex = tx_hash.hex() if hasattr(tx_hash, "hex") else tx_hash
-
-                    result: dict[str, Any] = {"tx_hash": tx_hash_hex}
-                    if wait_for_receipt:
-                        receipt = await w3.eth.wait_for_transaction_receipt(
-                            tx_hash, timeout=timeout
-                        )
-                        result["receipt"] = self._format_receipt(receipt)
-                        # After successful receipt, sync nonce from chain to ensure accuracy
-                        chain_nonce = await w3.eth.get_transaction_count(
-                            checksum_from, "latest"
-                        )
-                        await self._nonce_manager.sync_nonce(
-                            checksum_from, tx["chainId"], chain_nonce
-                        )
-
-                    return (True, result)
-                except Exception as send_exc:
-                    # If transaction fails due to nonce error, sync with chain and retry once
-                    # Handle both string errors and dict errors (like {'code': -32000, 'message': '...'})
-                    error_msg = str(send_exc)
-                    if isinstance(send_exc, dict):
-                        error_msg = send_exc.get("message", str(send_exc))
-                    elif hasattr(send_exc, "message"):
-                        error_msg = str(send_exc.message)
-
-                    if "nonce" in error_msg.lower() and "too low" in error_msg.lower():
-                        self.logger.warning(
-                            f"Nonce error detected, syncing with chain: {error_msg}"
-                        )
-                        # Sync with chain nonce
-                        chain_nonce = await w3.eth.get_transaction_count(
-                            checksum_from, "pending"
-                        )
-                        await self._nonce_manager.sync_nonce(
-                            checksum_from, tx["chainId"], chain_nonce
-                        )
-                        # Update tx nonce and retry
-                        tx["nonce"] = await self._nonce_manager.get_next_nonce(
-                            checksum_from, tx["chainId"], w3
-                        )
-                        signed_tx = self._sign_transaction(tx, checksum_from)
-                        tx_hash = await w3.eth.send_raw_transaction(signed_tx)
-                        tx_hash_hex = (
-                            tx_hash.hex() if hasattr(tx_hash, "hex") else tx_hash
+                    result["receipt"] = self._format_receipt(receipt)
+                    # Add block_number at top level for convenience
+                    result["block_number"] = result["receipt"].get("blockNumber")
+
+                    receipt_status = result["receipt"].get("status")
+                    if receipt_status is not None and int(receipt_status) != 1:
+                        return (
+                            False,
+                            f"Transaction reverted (status={receipt_status}): {tx_hash_hex}",
                         )
 
-                        result: dict[str, Any] = {"tx_hash": tx_hash_hex}
-                        if wait_for_receipt:
-                            receipt = await w3.eth.wait_for_transaction_receipt(
-                                tx_hash, timeout=timeout
-                            )
-                            result["receipt"] = self._format_receipt(receipt)
-                            # Sync again after successful receipt
-                            chain_nonce = await w3.eth.get_transaction_count(
-                                checksum_from, "latest"
-                            )
-                            await self._nonce_manager.sync_nonce(
-                                checksum_from, tx["chainId"], chain_nonce
+                    # Wait for additional confirmations if requested
+                    if confirmations > 0:
+                        tx_block = result["receipt"].get("blockNumber")
+                        if tx_block:
+                            await self._wait_for_confirmations(
+                                web3, tx_block, confirmations
                             )
 
-                        return (True, result)
-                    # Re-raise if it's not a nonce error
-                    raise
+                return (True, result)
+
             finally:
-                await self._close_web3(w3)
+                await self._close_web3(web3)
+
         except Exception as exc:  # noqa: BLE001
             self.logger.error(f"Transaction broadcast failed: {exc}")
             return (False, f"Transaction broadcast failed: {exc}")
@@ -266,7 +220,6 @@ class LocalEvmTxn(EvmTxn):
     async def transaction_succeeded(
         self, tx_hash: str, chain_id: int, timeout: int = 120
     ) -> bool:
-        """Return True if the transaction hash completed successfully on-chain."""
         w3 = self.get_web3(chain_id)
         try:
             receipt = await w3.eth.wait_for_transaction_receipt(
@@ -296,11 +249,23 @@ class LocalEvmTxn(EvmTxn):
     def _resolve_rpc_url(self, chain_id: int) -> str:
         return resolve_rpc_url(chain_id, self.config or {}, None)
 
-    async def _close_web3(self, w3: AsyncWeb3) -> None:
+    async def _close_web3(self, web3: AsyncWeb3) -> None:
         try:
-            await w3.provider.session.close()
-        except Exception:  # noqa: BLE001
-            pass
+            if hasattr(web3.provider, "disconnect"):
+                await web3.provider.disconnect()
+        except Exception as e:  # noqa: BLE001
+            self.logger.debug(f"Error disconnecting provider: {e}")
+
+    async def _wait_for_confirmations(
+        self, w3: AsyncWeb3, tx_block: int, confirmations: int
+    ) -> None:
+        """Wait until the transaction has the specified number of confirmations."""
+        target_block = tx_block + confirmations
+        while True:
+            current_block = await w3.eth.block_number
+            if current_block >= target_block:
+                break
+            await asyncio.sleep(1)
 
     def _format_receipt(self, receipt: Any) -> dict[str, Any]:
         tx_hash = getattr(receipt, "transactionHash", None)

wayfinder_paths/core/services/local_token_txn.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 from decimal import ROUND_DOWN, Decimal
 from typing import Any
 
@@ -27,7 +28,6 @@ class LocalTokenTxnService(TokenTxn):
         self.wallet_provider = wallet_provider
         self.logger = logger.bind(service="DefaultEvmTransactionService")
         self.token_client = TokenClient()
-        self.builder = _EvmTransactionBuilder(wallet_provider)
 
     async def build_send(
         self,
@@ -61,7 +61,7 @@ class LocalTokenTxnService(TokenTxn):
             amount_wei = self._to_base_units(amount, decimals)
 
         try:
-            tx = await self.builder.build_send_transaction(
+            tx = await self.build_send_transaction(
                 from_address=from_address,
                 to_address=to_address,
                 token_address=token_address,
@@ -93,7 +93,7 @@ class LocalTokenTxnService(TokenTxn):
         except (TypeError, ValueError) as exc:
             return False, str(exc)
 
-        approve_tx = self.builder.build_erc20_approval_transaction(
+        approve_tx = self.build_erc20_approval_transaction(
             chain_id=chain_id,
             token_address=token_checksum,
             from_address=from_checksum,
@@ -104,28 +104,53 @@ class LocalTokenTxnService(TokenTxn):
         return True, approve_tx
 
     async def read_erc20_allowance(
-        self, chain: Any, token_address: str, from_address: str, spender_address: str
+        self,
+        chain: Any,
+        token_address: str,
+        from_address: str,
+        spender_address: str,
+        max_retries: int = 3,
     ) -> dict[str, Any]:
         try:
             chain_id = self._chain_id(chain)
         except (TypeError, ValueError) as exc:
             return {"error": str(exc), "allowance": 0}
 
-        w3 = self.get_web3(chain_id)
-        try:
-            contract = w3.eth.contract(
-                address=to_checksum_address(token_address), abi=ERC20_APPROVAL_ABI
-            )
-            allowance = await contract.functions.allowance(
-                to_checksum_address(from_address),
-                to_checksum_address(spender_address),
-            ).call()
-            return (True, {"allowance": int(allowance)})
-        except Exception as exc:  # noqa: BLE001
-            self.logger.error(f"Failed to read allowance: {exc}")
-            return {"error": f"Allowance query failed: {exc}", "allowance": 0}
-        finally:
-            await self._close_web3(w3)
+        last_error = None
+        for attempt in range(max_retries):
+            w3 = self.wallet_provider.get_web3(chain_id)
+            try:
+                contract = w3.eth.contract(
+                    address=to_checksum_address(token_address), abi=ERC20_APPROVAL_ABI
+                )
+                allowance = await contract.functions.allowance(
+                    to_checksum_address(from_address),
+                    to_checksum_address(spender_address),
+                ).call()
+                return {"allowance": int(allowance)}
+            except Exception as exc:  # noqa: BLE001
+                last_error = exc
+                error_str = str(exc)
+                if "429" in error_str or "Too Many Requests" in error_str:
+                    if attempt < max_retries - 1:
+                        wait_time = 3.0 * (2**attempt)  # 3, 6, 12 seconds
+                        self.logger.warning(
+                            f"Rate limited reading allowance, retrying in {wait_time}s..."
+                        )
+                        await asyncio.sleep(wait_time)
+                        continue
+                self.logger.error(f"Failed to read allowance: {exc}")
+                return {"error": f"Allowance query failed: {exc}", "allowance": 0}
+            finally:
+                await self.wallet_provider._close_web3(w3)
+
+        self.logger.error(
+            f"Failed to read allowance after {max_retries} retries: {last_error}"
+        )
+        return {
+            "error": f"Allowance query failed after retries: {last_error}",
+            "allowance": 0,
+        }
 
     def _chain_id(self, chain: Any) -> int:
         if isinstance(chain, dict):
@@ -144,13 +169,6 @@ class LocalTokenTxnService(TokenTxn):
         )
         return int(quantized)
 
-
-class _EvmTransactionBuilder:
-    """Helpers that only build transaction dictionaries for sends and approvals."""
-
-    def __init__(self, wallet_provider: EvmTxn) -> None:
-        self.wallet_provider = wallet_provider
-
     async def build_send_transaction(
         self,
         *,
@@ -200,6 +218,7 @@ class _EvmTransactionBuilder:
         web3: AsyncWeb3,
     ) -> dict[str, Any]:
         """Build an ERC20 approval transaction dict."""
+        del web3  # Use sync Web3 for encoding (AsyncContract doesn't have encodeABI)
         token_checksum = to_checksum_address(token_address)
         spender_checksum = to_checksum_address(spender)
         from_checksum = to_checksum_address(from_address)
@@ -208,6 +227,7 @@ class _EvmTransactionBuilder:
         # Use synchronous Web3 for encoding (encodeABI doesn't exist in web3.py v7)
         w3_sync = Web3()
         contract = w3_sync.eth.contract(address=token_checksum, abi=ERC20_APPROVAL_ABI)
+
         # In web3.py v7, use _encode_transaction_data to encode without network calls
         data = contract.functions.approve(
             spender_checksum, amount_int

wayfinder_paths/core/strategies/descriptors.py

@@ -66,7 +66,7 @@ class StratDescriptor(BaseModel):
 
     # risk indicators
     volatility: Volatility
-    volatility_description_short: str
+    volatility_description: str
     directionality: Directionality
     directionality_description: str
     complexity: Complexity

wayfinder_paths/core/utils/evm_helpers.py

@@ -11,7 +11,6 @@ from pathlib import Path
 from typing import Any
 
 from loguru import logger
-from web3 import AsyncHTTPProvider, AsyncWeb3
 
 from wayfinder_paths.core.constants.base import CHAIN_CODE_TO_ID
 
@@ -86,32 +85,6 @@ def resolve_rpc_url(
     raise ValueError("RPC URL not provided. Set strategy.rpc_urls in config.json.")
 
 
-async def get_next_nonce(
-    from_address: str, rpc_url: str, use_latest: bool = False
-) -> int:
-    """
-    Get the next nonce for the given address.
-
-    Args:
-        from_address: Address to get nonce for
-        rpc_url: RPC URL to connect to
-        use_latest: If True, use 'latest' block instead of 'pending'
-
-    Returns:
-        Next nonce as integer
-    """
-    w3 = AsyncWeb3(AsyncHTTPProvider(rpc_url))
-    try:
-        if use_latest:
-            return await w3.eth.get_transaction_count(from_address, "latest")
-        return await w3.eth.get_transaction_count(from_address)
-    finally:
-        try:
-            await w3.provider.session.close()
-        except Exception:
-            pass
-
-
 def resolve_private_key_for_from_address(
     from_address: str, config: dict[str, Any]
 ) -> str | None: