wayfinder-paths 0.1.10__tar.gz → 0.1.11__tar.gz

{wayfinder_paths-0.1.10 → wayfinder_paths-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wayfinder-paths
-Version: 0.1.10
+Version: 0.1.11
 Summary: Wayfinder Path: strategies and adapters
 Author: Wayfinder
 Author-email: dev@wayfinder.ai
@@ -48,7 +48,7 @@ just create-wallets
 # Or manually: poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
 
 # To test a specific strategy
-just just create-wallet stablecoin_yield_strategy
+just create-wallet stablecoin_yield_strategy
 
 # Copy and configure
 cp wayfinder_paths/config.example.json config.json
@@ -374,11 +374,11 @@ class MyStrategy(Strategy):
 
 The following strategies are available and can be run using the CLI:
 
-| Strategy | Description | Chain |
-|----------|-------------|-------|
-| `basis_trading_strategy` | Delta-neutral basis trading | - |
-| `hyperlend_stable_yield_strategy` | Stable yield on HyperLend | HyperEVM |
-| `moonwell_wsteth_loop_strategy` | Leveraged wstETH yield loop | Base |
+| Strategy                          | Description                 | Chain    |
+| --------------------------------- | --------------------------- | -------- |
+| `basis_trading_strategy`          | Delta-neutral basis trading | -        |
+| `hyperlend_stable_yield_strategy` | Stable yield on HyperLend   | HyperEVM |
+| `moonwell_wsteth_loop_strategy`   | Leveraged wstETH yield loop | Base     |
 
 #### Running Strategies
 

{wayfinder_paths-0.1.10 → wayfinder_paths-0.1.11}/README.md

@@ -25,7 +25,7 @@ just create-wallets
 # Or manually: poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
 
 # To test a specific strategy
-just just create-wallet stablecoin_yield_strategy
+just create-wallet stablecoin_yield_strategy
 
 # Copy and configure
 cp wayfinder_paths/config.example.json config.json
@@ -351,11 +351,11 @@ class MyStrategy(Strategy):
 
 The following strategies are available and can be run using the CLI:
 
-| Strategy | Description | Chain |
-|----------|-------------|-------|
-| `basis_trading_strategy` | Delta-neutral basis trading | - |
-| `hyperlend_stable_yield_strategy` | Stable yield on HyperLend | HyperEVM |
-| `moonwell_wsteth_loop_strategy` | Leveraged wstETH yield loop | Base |
+| Strategy                          | Description                 | Chain    |
+| --------------------------------- | --------------------------- | -------- |
+| `basis_trading_strategy`          | Delta-neutral basis trading | -        |
+| `hyperlend_stable_yield_strategy` | Stable yield on HyperLend   | HyperEVM |
+| `moonwell_wsteth_loop_strategy`   | Leveraged wstETH yield loop | Base     |
 
 #### Running Strategies
 

{wayfinder_paths-0.1.10 → wayfinder_paths-0.1.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wayfinder-paths"
-version = "0.1.10"
+version = "0.1.11"
 description = "Wayfinder Path: strategies and adapters"
 readme = "README.md"
 authors = ["Wayfinder <dev@wayfinder.ai>"]

{wayfinder_paths-0.1.10 → wayfinder_paths-0.1.11}/wayfinder_paths/core/services/base.py

@@ -50,61 +50,6 @@ class EvmTxn(ABC):
     transaction confirmations.
     """
 
-    @abstractmethod
-    async def get_balance(
-        self,
-        address: str,
-        token_address: str | None,
-        chain_id: int,
-        block_identifier: int | str | None = None,
-    ) -> tuple[bool, Any]:
-        """
-        Get balance for an address at a specific block.
-
-        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)
-        """
-        pass
-
-    @abstractmethod
-    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]:
-        """
-        Approve a spender to spend tokens on behalf of from_address.
-
-        Args:
-            token_address: ERC20 token contract address
-            spender: Address being approved to spend tokens
-            amount: Amount to approve (in token units, not human-readable)
-            from_address: Address approving the tokens
-            chain_id: Chain ID
-            wait_for_receipt: Whether to wait for the transaction receipt
-            timeout: Receipt timeout in seconds
-
-        Returns:
-            Tuple of (success, transaction_result_dict_or_error_message)
-            Transaction result should include 'tx_hash' and optionally 'receipt'
-        """
-        pass
-
     @abstractmethod
     async def broadcast_transaction(
         self,

{wayfinder_paths-0.1.10 → wayfinder_paths-0.1.11}/wayfinder_paths/core/services/local_evm_txn.py

@@ -4,16 +4,9 @@ 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, Web3
+from web3 import AsyncHTTPProvider, AsyncWeb3
 
-from wayfinder_paths.core.constants import (
-    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,
@@ -60,105 +53,12 @@ class LocalEvmTxn(EvmTxn):
     def __init__(self, config: dict[str, Any] | None = None):
         self.config = config or {}
         self.logger = logger.bind(provider="LocalWalletProvider")
-        # 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]:
-        """
-        Get balance for an address at a specific block.
-
-        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)
-        """
-        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)
 
@@ -264,29 +164,29 @@ class LocalEvmTxn(EvmTxn):
         *,
         wait_for_receipt: bool = True,
         timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
-        confirmations: int = 0,
+        confirmations: int = 1,
     ) -> tuple[bool, Any]:
         try:
             chain_id = transaction["chainId"]
             from_address = transaction["from"]
 
-            w3 = self.get_web3(chain_id)
+            web3 = 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._nonce_transaction(transaction, web3)
+                transaction = await self._gas_limit_transaction(transaction, web3)
                 transaction = await self._gas_price_transaction(
-                    transaction, chain_id, w3
+                    transaction, chain_id, web3
                 )
 
                 signed_tx = self._sign_transaction(transaction, from_address)
 
-                tx_hash = await w3.eth.send_raw_transaction(signed_tx)
+                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 w3.eth.wait_for_transaction_receipt(
+                    receipt = await web3.eth.wait_for_transaction_receipt(
                         tx_hash, timeout=timeout
                     )
                     result["receipt"] = self._format_receipt(receipt)
@@ -299,32 +199,19 @@ class LocalEvmTxn(EvmTxn):
                             False,
                             f"Transaction reverted (status={receipt_status}): {tx_hash_hex}",
                         )
-                        # 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)
-                        )
-                        self.logger.debug(
-                            f"Transaction {tx_hash_hex} receipt status: {receipt_status} (type: {type(receipt_status).__name__})"
-                        )
-                        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
+                                web3, tx_block, confirmations
                             )
 
                 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}")
@@ -362,14 +249,12 @@ 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:
-        # Don't close cached connections - we want to reuse them for consistency
-        if w3 in self._web3_cache.values():
-            return
+    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

{wayfinder_paths-0.1.10 → wayfinder_paths-0.1.11}/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: