wayfinder-paths 0.1.15__py3-none-any.whl → 0.1.16__py3-none-any.whl

wayfinder_paths/core/services/local_evm_txn.py

@@ -1,350 +0,0 @@
-import asyncio
-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.middleware import ExtraDataToPOAMiddleware
-from web3.module import Module
-
-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 (
-    resolve_private_key_for_from_address,
-    resolve_rpc_url,
-)
-
-SUGGESTED_GAS_PRICE_MULTIPLIER = 1.5
-SUGGESTED_PRIORITY_FEE_MULTIPLIER = 1.5
-MAX_BASE_FEE_GROWTH_MULTIPLIER = 2
-GAS_LIMIT_BUFFER_MULTIPLIER = 1.5
-
-# Base chain ID (Base mainnet)
-BASE_CHAIN_ID = 8453
-
-# Chains that don't support EIP-1559 (London) and need legacy gas pricing
-PRE_LONDON_GAS_CHAIN_IDS: set[int] = {56, 42161}
-POA_MIDDLEWARE_CHAIN_IDS: set = {56, 137, 43114}
-
-
-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 HyperModule(Module):
-    def __init__(self, w3):
-        super().__init__(w3)
-
-    async def big_block_gas_price(self):
-        big_block_gas_price = await self.w3.manager.coro_request(
-            "eth_bigBlockGasPrice", []
-        )
-        return int(big_block_gas_price, 16)
-
-
-class LocalEvmTxn(EvmTxn):
-    """
-    Local wallet provider using private keys stored in config.json or config.json.
-
-    This provider implements the current default behavior:
-    - Resolves private keys from config.json or config.json
-    - Signs transactions using eth_account
-    - Broadcasts transactions via RPC
-    """
-
-    def __init__(self, config: dict[str, Any] | None = None):
-        self.config = config or {}
-        self.logger = logger.bind(provider="LocalWalletProvider")
-
-    def get_web3(self, chain_id: int) -> AsyncWeb3:
-        rpc_url = self._resolve_rpc_url(chain_id)
-        web3 = AsyncWeb3(AsyncHTTPProvider(rpc_url))
-        if chain_id in POA_MIDDLEWARE_CHAIN_IDS:
-            web3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
-        if chain_id == 999:
-            web3.attach_modules({"hype": (HyperModule)})
-        return web3
-
-    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,
-        transaction: dict[str, Any],
-        *,
-        wait_for_receipt: bool = True,
-        timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
-        confirmations: int | None = None,
-    ) -> tuple[bool, Any]:
-        try:
-            chain_id = transaction["chainId"]
-            from_address = transaction["from"]
-
-            # Default confirmation behavior:
-            # - Base: wait for 2 additional blocks after the receipt block
-            # - Others: do not wait for additional confirmations
-            effective_confirmations = confirmations
-            if effective_confirmations is None:
-                effective_confirmations = 2 if int(chain_id) == BASE_CHAIN_ID else 0
-            effective_confirmations = max(0, int(effective_confirmations))
-
-            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
-                    )
-                    result["receipt"] = self._format_receipt(receipt)
-                    # Add block_number at top level for convenience
-                    result["block_number"] = result["receipt"].get("blockNumber")
-                    result["confirmations"] = effective_confirmations
-                    result["confirmed_block_number"] = result["block_number"]
-
-                    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}",
-                        )
-
-                    # Wait for additional confirmations if requested
-                    if effective_confirmations > 0:
-                        tx_block = result["receipt"].get("blockNumber")
-                        if tx_block:
-                            await self._wait_for_confirmations(
-                                web3, tx_block, effective_confirmations
-                            )
-                            result["confirmed_block_number"] = int(tx_block) + int(
-                                effective_confirmations
-                            )
-
-                return (True, result)
-
-            finally:
-                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}")
-
-    async def transaction_succeeded(
-        self, tx_hash: str, chain_id: int, timeout: int = 120
-    ) -> bool:
-        w3 = self.get_web3(chain_id)
-        try:
-            receipt = await w3.eth.wait_for_transaction_receipt(
-                tx_hash, timeout=timeout
-            )
-            status = getattr(receipt, "status", None)
-            if status is None and isinstance(receipt, dict):
-                status = receipt.get("status")
-            return status == 1
-        except Exception as exc:  # noqa: BLE001
-            self.logger.warning(
-                f"Failed to confirm transaction {tx_hash} on chain {chain_id}: {exc}"
-            )
-            return False
-        finally:
-            await self._close_web3(w3)
-
-    def _sign_transaction(
-        self, transaction: dict[str, Any], from_address: str
-    ) -> bytes:
-        private_key = resolve_private_key_for_from_address(from_address, self.config)
-        if not private_key:
-            raise ValueError(f"No private key available for address {from_address}")
-        signed = Account.sign_transaction(transaction, private_key)
-        return signed.raw_transaction
-
-    def _resolve_rpc_url(self, chain_id: int) -> str:
-        return resolve_rpc_url(chain_id, self.config or {}, None)
-
-    async def _close_web3(self, web3: AsyncWeb3) -> None:
-        try:
-            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)
-        if hasattr(tx_hash, "hex"):
-            tx_hash = tx_hash.hex()
-
-        return {
-            "transactionHash": tx_hash,
-            "status": (
-                getattr(receipt, "status", None)
-                if not isinstance(receipt, dict)
-                else receipt.get("status")
-            ),
-            "blockNumber": (
-                getattr(receipt, "blockNumber", None)
-                if not isinstance(receipt, dict)
-                else receipt.get("blockNumber")
-            ),
-            "gasUsed": (
-                getattr(receipt, "gasUsed", None)
-                if not isinstance(receipt, dict)
-                else receipt.get("gasUsed")
-            ),
-            "logs": (
-                [
-                    dict(log_entry) if not isinstance(log_entry, dict) else log_entry
-                    for log_entry in getattr(receipt, "logs", [])
-                ]
-                if hasattr(receipt, "logs")
-                else receipt.get("logs")
-                if isinstance(receipt, dict)
-                else []
-            ),
-        }
-
-    def _normalize_int(self, value: Any) -> int:
-        if isinstance(value, int):
-            return value
-        if isinstance(value, float):
-            return int(value)
-        if isinstance(value, str):
-            if value.startswith("0x"):
-                return int(value, 16)
-            try:
-                return int(value)
-            except ValueError:
-                return int(float(value))
-        raise ValueError(f"Unable to convert value '{value}' to int")

wayfinder_paths/core/services/local_token_txn.py

@@ -1,238 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from decimal import ROUND_DOWN, Decimal
-from typing import Any
-
-from eth_utils import to_checksum_address
-from loguru import logger
-from web3 import Web3
-
-from wayfinder_paths.core.clients.TokenClient import TokenClient
-from wayfinder_paths.core.constants import ZERO_ADDRESS
-from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI, ERC20_APPROVAL_ABI
-from wayfinder_paths.core.services.base import EvmTxn, TokenTxn
-from wayfinder_paths.core.utils.evm_helpers import resolve_chain_id
-
-
-class LocalTokenTxnService(TokenTxn):
-    """Default transaction builder used by adapters."""
-
-    def __init__(
-        self,
-        config: dict[str, Any] | None,
-        *,
-        wallet_provider: EvmTxn,
-    ) -> None:
-        del config
-        self.wallet_provider = wallet_provider
-        self.logger = logger.bind(service="DefaultEvmTransactionService")
-        self.token_client = TokenClient()
-
-    async def build_send(
-        self,
-        *,
-        token_id: str,
-        amount: float,
-        from_address: str,
-        to_address: str,
-        token_info: dict[str, Any] | None = None,
-    ) -> tuple[bool, dict[str, Any] | str]:
-        """Build the transaction dict for sending tokens between wallets."""
-        token_meta = token_info
-        if token_meta is None:
-            token_meta = await self.token_client.get_token_details(token_id)
-            if not token_meta:
-                return False, f"Token not found: {token_id}"
-
-        chain_id = resolve_chain_id(token_meta, self.logger)
-        if chain_id is None:
-            return False, f"Token {token_id} is missing a chain id"
-
-        token_address = (token_meta or {}).get("address") or ZERO_ADDRESS
-        is_native = not token_address or token_address.lower() == ZERO_ADDRESS.lower()
-
-        if is_native:
-            amount_wei = self._to_base_units(
-                amount, 18
-            )  # Native tokens use 18 decimals
-        else:
-            decimals = int((token_meta or {}).get("decimals") or 18)
-            amount_wei = self._to_base_units(amount, decimals)
-
-        try:
-            tx = await self.build_send_transaction(
-                from_address=from_address,
-                to_address=to_address,
-                token_address=token_address,
-                amount=amount_wei,
-                chain_id=int(chain_id),
-                is_native=is_native,
-            )
-        except Exception as exc:  # noqa: BLE001
-            return False, f"Failed to build send transaction: {exc}"
-
-        return True, tx
-
-    def build_erc20_approve(
-        self,
-        *,
-        chain_id: int,
-        token_address: str,
-        from_address: str,
-        spender: str,
-        amount: int,
-    ) -> tuple[bool, dict[str, Any] | str]:
-        """Build the transaction dictionary for an ERC20 approval."""
-        try:
-            token_checksum = to_checksum_address(token_address)
-            from_checksum = to_checksum_address(from_address)
-            spender_checksum = to_checksum_address(spender)
-            amount_int = int(amount)
-        except (TypeError, ValueError) as exc:
-            return False, str(exc)
-
-        approve_tx = self.build_erc20_approval_transaction(
-            chain_id=chain_id,
-            token_address=token_checksum,
-            from_address=from_checksum,
-            spender=spender_checksum,
-            amount=amount_int,
-        )
-        return True, approve_tx
-
-    async def read_erc20_allowance(
-        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}
-
-        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):
-            chain_id = chain.get("id")
-        else:
-            chain_id = getattr(chain, "id", None)
-        if chain_id is None:
-            raise ValueError("Chain ID is required")
-        return int(chain_id)
-
-    def _to_base_units(self, amount: float, decimals: int) -> int:
-        """Convert human-readable amount to base units (wei for native, token units for ERC20)."""
-        scale = Decimal(10) ** int(decimals)
-        quantized = (Decimal(str(amount)) * scale).to_integral_value(
-            rounding=ROUND_DOWN
-        )
-        return int(quantized)
-
-    async def build_send_transaction(
-        self,
-        *,
-        from_address: str,
-        to_address: str,
-        token_address: str | None,
-        amount: int,
-        chain_id: int,
-        is_native: bool,
-    ) -> dict[str, Any]:
-        """Build the transaction dict for sending native or ERC20 tokens."""
-        from_checksum = to_checksum_address(from_address)
-        to_checksum = to_checksum_address(to_address)
-        chain_id_int = int(chain_id)
-
-        if is_native:
-            return {
-                "chainId": chain_id_int,
-                "from": from_checksum,
-                "to": to_checksum,
-                "value": int(amount),
-            }
-
-        token_checksum = to_checksum_address(token_address or ZERO_ADDRESS)
-        w3_sync = Web3()
-        contract = w3_sync.eth.contract(address=token_checksum, abi=ERC20_ABI)
-        data = contract.functions.transfer(
-            to_checksum, int(amount)
-        )._encode_transaction_data()
-
-        return {
-            "chainId": chain_id_int,
-            "from": from_checksum,
-            "to": token_checksum,
-            "data": data,
-            "value": 0,
-        }
-
-    def build_erc20_approval_transaction(
-        self,
-        *,
-        chain_id: int,
-        token_address: str,
-        from_address: str,
-        spender: str,
-        amount: int,
-    ) -> dict[str, Any]:
-        """Build an ERC20 approval transaction dict."""
-        token_checksum = to_checksum_address(token_address)
-        spender_checksum = to_checksum_address(spender)
-        from_checksum = to_checksum_address(from_address)
-        amount_int = int(amount)
-
-        # 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
-        )._encode_transaction_data()
-
-        return {
-            "chainId": int(chain_id),
-            "from": from_checksum,
-            "to": token_checksum,
-            "data": data,
-            "value": 0,
-        }

wayfinder_paths/core/services/web3_service.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-
-from wayfinder_paths.core.services.base import EvmTxn, TokenTxn, Web3Service
-from wayfinder_paths.core.services.local_evm_txn import LocalEvmTxn
-from wayfinder_paths.core.services.local_token_txn import (
-    LocalTokenTxnService,
-)
-
-
-class DefaultWeb3Service(Web3Service):
-    """Default implementation that simply wires the provided dependencies together."""
-
-    def __init__(
-        self,
-        config: dict | None = None,
-        *,
-        wallet_provider: EvmTxn | None = None,
-        evm_transactions: TokenTxn | None = None,
-    ) -> None:
-        """
-        Initialize the service with optional dependency injection.
-
-        Strategies that already constructed wallet providers or transaction helpers
-        can pass them in directly. Otherwise we fall back to the legacy behavior of
-        building a LocalWalletProvider + DefaultEvmTransactionService from config.
-        """
-        cfg = config or {}
-        self._wallet_provider = wallet_provider or LocalEvmTxn(cfg)
-        if evm_transactions is not None:
-            self._evm_transactions = evm_transactions
-        else:
-            self._evm_transactions = LocalTokenTxnService(
-                config=cfg,
-                wallet_provider=self._wallet_provider,
-            )
-
-    @property
-    def evm_transactions(self) -> EvmTxn:
-        return self._wallet_provider
-
-    @property
-    def token_transactions(self) -> TokenTxn:
-        return self._evm_transactions