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

wayfinder_paths/core/services/local_evm_txn.py

@@ -4,72 +4,47 @@ from typing import Any
 from eth_account import Account
 from eth_utils import to_checksum_address
 from loguru import logger
-from web3 import AsyncHTTPProvider, AsyncWeb3
+from web3 import AsyncHTTPProvider, AsyncWeb3, Web3
 
 from wayfinder_paths.core.constants import (
-    DEFAULT_GAS_ESTIMATE_FALLBACK,
-    ONE_GWEI,
+    ZERO_ADDRESS,
 )
 from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
+from wayfinder_paths.core.constants.erc20_abi import (
+    ERC20_APPROVAL_ABI,
+    ERC20_MINIMAL_ABI,
+)
 from wayfinder_paths.core.services.base import EvmTxn
 from wayfinder_paths.core.utils.evm_helpers import (
     resolve_private_key_for_from_address,
     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 +58,205 @@ 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()
+        # Cache web3 instances per chain to avoid load balancer inconsistency
+        self._web3_cache: dict[int, AsyncWeb3] = {}
 
     def get_web3(self, chain_id: int) -> AsyncWeb3:
+        # Reuse cached instance to ensure consistent RPC node for reads after writes
+        if chain_id in self._web3_cache:
+            return self._web3_cache[chain_id]
+        rpc_url = self._resolve_rpc_url(chain_id)
+        w3 = AsyncWeb3(AsyncHTTPProvider(rpc_url))
+        self._web3_cache[chain_id] = w3
+        return w3
+
+    async def get_balance(
+        self,
+        address: str,
+        token_address: str | None,
+        chain_id: int,
+        block_identifier: int | str | None = None,
+    ) -> tuple[bool, Any]:
         """
-        Return an AsyncWeb3 configured for the requested chain.
+        Get balance for an address at a specific block.
 
-        Callers are responsible for closing the provider session when finished.
+        Args:
+            address: Address to query balance for
+            token_address: ERC20 token address, or None for native token
+            chain_id: Chain ID
+            block_identifier: Block to query at. Can be:
+                - int: specific block number (for pinning to tx block)
+                - "safe": OP Stack safe block (data posted to L1)
+                - "finalized": fully finalized block
+                - None/"latest": current head (default, but avoid after txs)
+
+        Returns:
+            Tuple of (success, balance_integer_or_error_message)
         """
-        rpc_url = self._resolve_rpc_url(chain_id)
-        return AsyncWeb3(AsyncHTTPProvider(rpc_url))
+        w3 = self.get_web3(chain_id)
+        try:
+            checksum_addr = to_checksum_address(address)
+            block_id = block_identifier if block_identifier is not None else "latest"
+
+            if not token_address or token_address.lower() == ZERO_ADDRESS:
+                balance = await w3.eth.get_balance(
+                    checksum_addr, block_identifier=block_id
+                )
+                return (True, int(balance))
+
+            token_checksum = to_checksum_address(token_address)
+            contract = w3.eth.contract(address=token_checksum, abi=ERC20_MINIMAL_ABI)
+            balance = await contract.functions.balanceOf(checksum_addr).call(
+                block_identifier=block_id
+            )
+            return (True, int(balance))
+
+        except Exception as exc:  # noqa: BLE001
+            self.logger.error(f"Failed to get balance: {exc}")
+            return (False, f"Balance query failed: {exc}")
+        finally:
+            await self._close_web3(w3)
+
+    async def approve_token(
+        self,
+        token_address: str,
+        spender: str,
+        amount: int,
+        from_address: str,
+        chain_id: int,
+        wait_for_receipt: bool = True,
+        timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
+    ) -> tuple[bool, Any]:
+        try:
+            token_checksum = to_checksum_address(token_address)
+            spender_checksum = to_checksum_address(spender)
+            from_checksum = to_checksum_address(from_address)
+            amount_int = int(amount)
+
+            w3_sync = Web3()
+            contract = w3_sync.eth.contract(
+                address=token_checksum, abi=ERC20_APPROVAL_ABI
+            )
+            transaction_data = contract.encode_abi(
+                "approve", args=[spender_checksum, amount_int]
+            )
+
+            approve_txn = {
+                "from": from_checksum,
+                "chainId": int(chain_id),
+                "to": token_checksum,
+                "data": transaction_data,
+            }
+
+            return await self.broadcast_transaction(
+                approve_txn,
+                wait_for_receipt=wait_for_receipt,
+                timeout=timeout,
+            )
+        except Exception as exc:  # noqa: BLE001
+            self.logger.error(f"ERC20 approval failed: {exc}")
+            return (False, f"ERC20 approval failed: {exc}")
+
+    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 +264,68 @@ class LocalEvmTxn(EvmTxn):
         *,
         wait_for_receipt: bool = True,
         timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
+        confirmations: int = 0,
     ) -> 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}"
+            w3 = self.get_web3(chain_id)
+            try:
+                transaction = self._validate_transaction(transaction)
+                transaction = await self._nonce_transaction(transaction, w3)
+                transaction = await self._gas_limit_transaction(transaction, w3)
+                transaction = await self._gas_price_transaction(
+                    transaction, chain_id, w3
+                )
+
+                signed_tx = self._sign_transaction(transaction, from_address)
+
+                tx_hash = await w3.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 w3.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
+                    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}",
                         )
-                        # Update tx nonce and retry
-                        tx["nonce"] = await self._nonce_manager.get_next_nonce(
-                            checksum_from, tx["chainId"], w3
+                        # Check if transaction reverted (status=0)
+                        # Handle both dict-like and attribute access for web3.py receipts
+                        receipt_status = (
+                            receipt.get("status")
+                            if hasattr(receipt, "get")
+                            else getattr(receipt, "status", None)
                         )
-                        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
+                        self.logger.debug(
+                            f"Transaction {tx_hash_hex} receipt status: {receipt_status} (type: {type(receipt_status).__name__})"
                         )
-
-                        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
+                        if receipt_status == 0:
+                            self.logger.error(f"Transaction reverted: {tx_hash_hex}")
+                            return (False, f"Transaction reverted: {tx_hash_hex}")
+
+                    # Wait for additional confirmations if requested
+                    if confirmations > 0:
+                        tx_block = result["receipt"].get("blockNumber")
+                        if tx_block:
+                            await self._wait_for_confirmations(
+                                w3, 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)
+
         except Exception as exc:  # noqa: BLE001
             self.logger.error(f"Transaction broadcast failed: {exc}")
             return (False, f"Transaction broadcast failed: {exc}")
@@ -266,7 +333,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(
@@ -297,11 +363,25 @@ class LocalEvmTxn(EvmTxn):
         return resolve_rpc_url(chain_id, self.config or {}, None)
 
     async def _close_web3(self, w3: AsyncWeb3) -> None:
+        # Don't close cached connections - we want to reuse them for consistency
+        if w3 in self._web3_cache.values():
+            return
         try:
             await w3.provider.session.close()
         except Exception:  # noqa: BLE001
             pass
 
+    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)
         if hasattr(tx_hash, "hex"):