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

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/strategy.py

@@ -8,6 +8,7 @@ so the position remains safe under a stETH/ETH depeg.
 
 import asyncio
 import time
+from collections.abc import Awaitable, Callable
 from dataclasses import dataclass
 from typing import Any, Optional
 
@@ -21,9 +22,6 @@ from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
 from wayfinder_paths.adapters.moonwell_adapter.adapter import MoonwellAdapter
 from wayfinder_paths.adapters.token_adapter.adapter import TokenAdapter
 from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
-from wayfinder_paths.core.services.base import Web3Service
-from wayfinder_paths.core.services.local_token_txn import LocalTokenTxnService
-from wayfinder_paths.core.services.web3_service import DefaultWeb3Service
 from wayfinder_paths.core.strategies.descriptors import (
     Complexity,
     Directionality,
@@ -33,7 +31,7 @@ from wayfinder_paths.core.strategies.descriptors import (
     Volatility,
 )
 from wayfinder_paths.core.strategies.Strategy import StatusDict, StatusTuple, Strategy
-from wayfinder_paths.core.wallets.WalletManager import WalletManager
+from wayfinder_paths.core.utils.web3 import web3_from_chain_id
 from wayfinder_paths.policies.enso import ENSO_ROUTER, enso_swap
 from wayfinder_paths.policies.erc20 import erc20_spender_for_any_token
 from wayfinder_paths.policies.moonwell import (
@@ -191,9 +189,16 @@ class MoonwellWstethLoopStrategy(Strategy):
         main_wallet: dict | None = None,
         strategy_wallet: dict | None = None,
         simulation: bool = False,
-        web3_service: Web3Service | None = None,
+        api_key: str | None = None,
+        main_wallet_signing_callback: Callable[[dict], Awaitable[str]] | None = None,
+        strategy_wallet_signing_callback: Callable[[dict], Awaitable[str]]
+        | None = None,
     ):
-        super().__init__()
+        super().__init__(
+            api_key=api_key,
+            main_wallet_signing_callback=main_wallet_signing_callback,
+            strategy_wallet_signing_callback=strategy_wallet_signing_callback,
+        )
         merged_config: dict[str, Any] = dict(config or {})
         if main_wallet is not None:
             merged_config["main_wallet"] = main_wallet
@@ -202,7 +207,6 @@ class MoonwellWstethLoopStrategy(Strategy):
 
         self.config = merged_config
         self.simulation = simulation
-        self.web3_service = web3_service
 
         # Adapter references
         self.balance_adapter: BalanceAdapter | None = None
@@ -231,32 +235,24 @@ class MoonwellWstethLoopStrategy(Strategy):
                 "strategy": self.config,
             }
 
-            # Initialize web3_service if not provided
-            if self.web3_service is None:
-                wallet_provider = WalletManager.get_provider(adapter_config)
-                token_transaction_service = LocalTokenTxnService(
-                    adapter_config,
-                    wallet_provider=wallet_provider,
-                )
-                web3_service = DefaultWeb3Service(
-                    wallet_provider=wallet_provider,
-                    evm_transactions=token_transaction_service,
-                )
-            else:
-                web3_service = self.web3_service
-                token_transaction_service = web3_service.token_transactions
-
             # Initialize adapters
-            balance = BalanceAdapter(adapter_config, web3_service=web3_service)
+            balance = BalanceAdapter(
+                adapter_config,
+                simulation=self.simulation,
+                main_wallet_signing_callback=self.main_wallet_signing_callback,
+                strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
+            )
             token_adapter = TokenAdapter()
             ledger_adapter = LedgerAdapter()
             brap_adapter = BRAPAdapter(
-                web3_service=web3_service,
+                adapter_config,
+                simulation=self.simulation,
+                strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
             )
             moonwell_adapter = MoonwellAdapter(
                 adapter_config,
                 simulation=self.simulation,
-                web3_service=web3_service,
+                strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
             )
 
             self.register_adapters(
@@ -266,7 +262,6 @@ class MoonwellWstethLoopStrategy(Strategy):
                     ledger_adapter,
                     brap_adapter,
                     moonwell_adapter,
-                    token_transaction_service,
                 ]
             )
 
@@ -275,7 +270,6 @@ class MoonwellWstethLoopStrategy(Strategy):
             self.ledger_adapter = ledger_adapter
             self.brap_adapter = brap_adapter
             self.moonwell_adapter = moonwell_adapter
-            self.web3_service = web3_service
 
         except Exception as e:
             logger.error(f"Failed to initialize strategy adapters: {e}")
@@ -1893,7 +1887,7 @@ class MoonwellWstethLoopStrategy(Strategy):
             return 0
 
         # Tests/simulations patch adapters; avoid RPC calls there.
-        if self.simulation or self.web3_service is None:
+        if self.simulation:
             if self.balance_adapter is None:
                 return 0
             success, raw = await self.balance_adapter.get_balance(
@@ -1927,25 +1921,23 @@ class MoonwellWstethLoopStrategy(Strategy):
         last_error: Exception | None = None
 
         for attempt in range(max_retries):
-            w3 = None
             try:
-                w3 = self.web3_service.get_web3(BASE_CHAIN_ID)
+                async with web3_from_chain_id(BASE_CHAIN_ID) as w3:
+                    if token_id == ETH_TOKEN_ID:
+                        bal = await w3.eth.get_balance(
+                            to_checksum_address(wallet_address),
+                            block_identifier=block_id,
+                        )
+                        return int(bal)
 
-                if token_id == ETH_TOKEN_ID:
-                    bal = await w3.eth.get_balance(
-                        to_checksum_address(wallet_address),
-                        block_identifier=block_id,
+                    contract = w3.eth.contract(
+                        address=to_checksum_address(str(token_address)),
+                        abi=ERC20_ABI,
                     )
+                    bal = await contract.functions.balanceOf(
+                        to_checksum_address(wallet_address)
+                    ).call(block_identifier=block_id)
                     return int(bal)
-
-                contract = w3.eth.contract(
-                    address=to_checksum_address(str(token_address)),
-                    abi=ERC20_ABI,
-                )
-                bal = await contract.functions.balanceOf(
-                    to_checksum_address(wallet_address)
-                ).call(block_identifier=block_id)
-                return int(bal)
             except Exception as exc:
                 last_error = exc if isinstance(exc, Exception) else Exception(str(exc))
                 err = str(exc)
@@ -1959,16 +1951,6 @@ class MoonwellWstethLoopStrategy(Strategy):
                     f"On-chain balance read failed for {token_id} at block {block_id}: {exc}"
                 )
                 return 0
-            finally:
-                if w3 is not None:
-                    try:
-                        close_web3 = getattr(
-                            self.web3_service.evm_transactions, "_close_web3", None
-                        )
-                        if close_web3 is not None:
-                            await close_web3(w3)
-                    except Exception:
-                        pass
 
         logger.warning(
             f"On-chain balance read failed after {max_retries} attempts for {token_id} "
@@ -3231,22 +3213,15 @@ class MoonwellWstethLoopStrategy(Strategy):
         logger.info("UPDATE START")
         logger.info("=" * 60)
 
-        # Best-effort top-up if we dipped below MIN_GAS (non-critical).
-        topup_success, topup_msg = await self._transfer_gas_to_vault()
-        if not topup_success:
-            logger.warning(f"Gas top-up failed (non-critical): {topup_msg}")
-
+        # Check gas balance - deposit() should have provided sufficient gas
         gas_amt = await self._get_gas_balance()
         logger.info(
             f"Gas balance: {gas_amt / 10**18:.6f} ETH (min: {self.MAINTENANCE_GAS} ETH)"
         )
         if gas_amt < int(self.MAINTENANCE_GAS * 10**18):
-            logger.error(
-                f"Insufficient gas: {gas_amt / 10**18:.6f} < {self.MAINTENANCE_GAS}"
-            )
-            return (
-                False,
-                f"Less than {self.MAINTENANCE_GAS} ETH in strategy wallet. Please transfer more gas.",
+            logger.warning(
+                f"Low gas: {gas_amt / 10**18:.6f} < {self.MAINTENANCE_GAS} ETH. "
+                f"Transactions may fail. Call deposit() with gas to top up."
             )
 
         # Pre-fetch collateral factors once (saves RPC + makes decisions consistent)

wayfinder_paths/strategies/stablecoin_yield_strategy/README.md

@@ -32,7 +32,6 @@ Transactions are scoped to the strategy wallet and Enso Router approval/swap cal
 - `BRAPAdapter` to source swap quotes and execute rotations.
 - `TokenAdapter` for metadata (gas token, USDC info).
 - `LedgerAdapter` for net-deposit tracking and cooldown enforcement.
-- `LocalTokenTxnService` (via `DefaultWeb3Service`) for lower-level sends/approvals used by adapters.
 
 ## Actions
 

wayfinder_paths/strategies/stablecoin_yield_strategy/strategy.py

@@ -1,6 +1,7 @@
 import asyncio
 import math
 import time
+from collections.abc import Awaitable, Callable
 from datetime import UTC, datetime, timedelta
 from typing import Any
 
@@ -12,10 +13,6 @@ from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
 from wayfinder_paths.adapters.pool_adapter.adapter import PoolAdapter
 from wayfinder_paths.adapters.token_adapter.adapter import TokenAdapter
 from wayfinder_paths.core.constants.base import DEFAULT_SLIPPAGE
-from wayfinder_paths.core.services.local_token_txn import (
-    LocalTokenTxnService,
-)
-from wayfinder_paths.core.services.web3_service import DefaultWeb3Service
 from wayfinder_paths.core.strategies.descriptors import (
     Complexity,
     Directionality,
@@ -25,7 +22,6 @@ from wayfinder_paths.core.strategies.descriptors import (
     Volatility,
 )
 from wayfinder_paths.core.strategies.Strategy import StatusDict, StatusTuple, Strategy
-from wayfinder_paths.core.wallets.WalletManager import WalletManager
 
 
 class StablecoinYieldStrategy(Strategy):
@@ -156,9 +152,16 @@ class StablecoinYieldStrategy(Strategy):
         *,
         main_wallet: dict[str, Any] | None = None,
         strategy_wallet: dict[str, Any] | None = None,
-        web3_service=None,
+        api_key: str | None = None,
+        main_wallet_signing_callback: Callable[[dict], Awaitable[str]] | None = None,
+        strategy_wallet_signing_callback: Callable[[dict], Awaitable[str]]
+        | None = None,
     ):
-        super().__init__()
+        super().__init__(
+            api_key=api_key,
+            main_wallet_signing_callback=main_wallet_signing_callback,
+            strategy_wallet_signing_callback=strategy_wallet_signing_callback,
+        )
         merged_config: dict[str, Any] = dict(config or {})
         if main_wallet is not None:
             merged_config["main_wallet"] = main_wallet
@@ -170,16 +173,16 @@ class StablecoinYieldStrategy(Strategy):
         self.current_pool = None
         self.current_apy = 0
         self.balance_adapter = None
-        self.tx_adapter = None
-        self.web3_service = web3_service
         self.token_adapter = None
         self.ledger_adapter = None
         self.pool_adapter = None
         self.brap_adapter = None
 
         # State tracking for deterministic token management
-        self.tracked_token_ids: set[str] = set()  # All tokens strategy might hold
-        self.tracked_balances: dict[str, int] = {}  # token_id -> balance in wei
+        # All tokens strategy might hold
+        self.tracked_token_ids: set[str] = set()
+        # token_id -> balance in wei
+        self.tracked_balances: dict[str, int] = {}
 
         try:
             main_wallet_cfg = self.config.get("main_wallet")
@@ -191,23 +194,18 @@ class StablecoinYieldStrategy(Strategy):
                 "strategy": self.config,
             }
 
-            if self.web3_service is None:
-                wallet_provider = WalletManager.get_provider(adapter_config)
-                tx_adapter = LocalTokenTxnService(
-                    adapter_config,
-                    wallet_provider=wallet_provider,
-                )
-                web3_service = DefaultWeb3Service(
-                    wallet_provider=wallet_provider, evm_transactions=tx_adapter
-                )
-            else:
-                web3_service = self.web3_service
-                tx_adapter = web3_service.token_transactions
-            balance = BalanceAdapter(adapter_config, web3_service=web3_service)
+            balance = BalanceAdapter(
+                adapter_config,
+                main_wallet_signing_callback=self.main_wallet_signing_callback,
+                strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
+            )
             token_adapter = TokenAdapter()
             ledger_adapter = LedgerAdapter()
             pool_adapter = PoolAdapter()
-            brap_adapter = BRAPAdapter(web3_service=web3_service)
+            brap_adapter = BRAPAdapter(
+                adapter_config,
+                strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
+            )
 
             self.register_adapters(
                 [
@@ -216,12 +214,9 @@ class StablecoinYieldStrategy(Strategy):
                     ledger_adapter,
                     pool_adapter,
                     brap_adapter,
-                    tx_adapter,
                 ]
             )
             self.balance_adapter = balance
-            self.tx_adapter = tx_adapter
-            self.web3_service = web3_service
             self.token_adapter = token_adapter
             self.ledger_adapter = ledger_adapter
             self.pool_adapter = pool_adapter
@@ -1010,83 +1005,45 @@ class StablecoinYieldStrategy(Strategy):
                 )
 
         await self._sweep_wallet(self.usdc_token_info)
-        withdrawn_breakdown = []
-        withdrawn_token_ids = set()
 
-        if self.usdc_token_info.get("token_id") in withdrawn_token_ids:
-            pass
+        # Get final USDC balance in strategy wallet
         status, raw_balance = await self.balance_adapter.get_balance(
             query=self.usdc_token_info.get("token_id"),
             wallet_address=self._get_strategy_wallet_address(),
         )
-        if not status or not raw_balance:
-            pass
-        amount = float(raw_balance) / 10 ** self.usdc_token_info.get("decimals")
-        if amount > 0:
-            (
-                move_status,
-                move_message,
-            ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                self.usdc_token_info.get("token_id"),
-                amount,
-                strategy_name=self.name,
-            )
-            if not move_status:
-                return (False, f"USDC return to main failed: {move_message}")
-
-        withdrawn_breakdown.append(
-            (
-                self.usdc_token_info.get("symbol"),
-                self.usdc_token_info.get("chain").get("name"),
-                float(amount),
+        usdc_amount = 0.0
+        if status and raw_balance:
+            usdc_amount = float(raw_balance) / 10 ** self.usdc_token_info.get(
+                "decimals"
             )
-        )
-        withdrawn_token_ids.add(self.usdc_token_info.get("token_id"))
 
-        if self.gas_token and self.gas_token.get("token_id") not in withdrawn_token_ids:
+        # Get gas balance in strategy wallet
+        gas_amount = 0.0
+        if self.gas_token:
             status, raw_gas = await self.balance_adapter.get_balance(
                 query=self.gas_token.get("token_id"),
                 wallet_address=self._get_strategy_wallet_address(),
             )
             if status and raw_gas:
-                gas_amount = (
-                    float(raw_gas) / 10 ** self.gas_token.get("decimals")
-                ) * 0.9
-                if gas_amount > 0:
-                    (
-                        move_gas_status,
-                        move_gas_message,
-                    ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                        self.gas_token.get("token_id"),
-                        gas_amount,
-                        strategy_name=self.name,
-                    )
-                    if move_gas_status:
-                        withdrawn_breakdown.append(
-                            (
-                                self.gas_token.get("symbol"),
-                                self.gas_token.get("chain").get("name"),
-                                float(gas_amount),
-                            )
-                        )
-                        withdrawn_token_ids.add(self.gas_token.get("token_id"))
+                gas_amount = float(raw_gas) / 10 ** self.gas_token.get("decimals")
 
         self.DEPOSIT_USDC = 0
         self.current_pool_balance = 0
 
-        if not withdrawn_breakdown:
-            return (True, f"Successfully withdrew {amount} USDC from strategy")
-
-        breakdown_msg = ", ".join(
-            f"{amount:.6f} {symbol} on {chain.capitalize()}"
-            for symbol, chain, amount in withdrawn_breakdown
-        )
-
         elapsed_time = time.time() - start_time
         logger.info(f"Withdrawal completed successfully in {elapsed_time:.2f} seconds")
+
+        strategy_address = self._get_strategy_wallet_address()
+        breakdown_parts = [f"{usdc_amount:.2f} USDC"]
+        if gas_amount > 0:
+            breakdown_parts.append(
+                f"{gas_amount:.6f} {self.gas_token.get('symbol', 'ETH')}"
+            )
+
         return (
             True,
-            f"Successfully withdrew {amount} USDC from strategy: {breakdown_msg}",
+            f"Liquidated positions to strategy wallet ({strategy_address}): {', '.join(breakdown_parts)}. "
+            f"Call exit() to transfer to main wallet.",
         )
 
     async def exit(self, **kwargs) -> StatusTuple:

wayfinder_paths/strategies/stablecoin_yield_strategy/test_strategy.py

@@ -118,10 +118,6 @@ def strategy():
         s.balance_adapter.move_from_strategy_wallet_to_main_wallet = AsyncMock(
             return_value=(True, "Transfer successful (simulated)")
         )
-        if hasattr(s.balance_adapter, "wallet_provider"):
-            s.balance_adapter.wallet_provider.broadcast_transaction = AsyncMock(
-                return_value=(True, {"transaction_hash": "0xDEADBEEF"})
-            )
 
     if hasattr(s, "ledger_adapter") and s.ledger_adapter:
         # NOTE: The real LedgerClient returns float, not dict!
@@ -200,10 +196,6 @@ def strategy():
         and hasattr(s.brap_adapter, "swap_from_quote")
     ):
         s.brap_adapter.swap_from_quote = AsyncMock(return_value=None)
-    if hasattr(s, "brap_adapter") and hasattr(s.brap_adapter, "wallet_provider"):
-        s.brap_adapter.wallet_provider.broadcast_transaction = AsyncMock(
-            return_value=(True, {"transaction_hash": "0xBEEF"})
-        )
 
     s.DEPOSIT_USDC = 0
     s.usdc_token_info = {

wayfinder_paths/templates/strategy/README.md

@@ -41,12 +41,10 @@ async def _status(self) -> StatusDict:
 
 Strategies typically:
 
-1. Build a `DefaultWeb3Service` so every adapter shares a wallet provider.
 2. Instantiate adapters (balance, ledger, protocol specific, etc.).
 3. Register adapters via `self.register_adapters([...])` and keep references as attributes.
 
 ```python
-from wayfinder_paths.core.services.web3_service import DefaultWeb3Service
 from wayfinder_paths.core.strategies.Strategy import StatusDict, StatusTuple, Strategy
 from wayfinder_paths.adapters.balance_adapter.adapter import BalanceAdapter
 
@@ -57,8 +55,7 @@ class MyStrategy(Strategy):
     def __init__(self, config: dict | None = None):
         super().__init__()
         self.config = config or {}
-        web3_service = DefaultWeb3Service(self.config)
-        balance_adapter = BalanceAdapter(self.config, web3_service=web3_service)
+        balance_adapter = BalanceAdapter(self.config)
         self.register_adapters([balance_adapter])
         self.balance_adapter = balance_adapter
 
@@ -76,7 +73,6 @@ class MyStrategy(Strategy):
         if not success:
             return (False, "Unable to fetch balances")
 
-        # Use BalanceAdapter (which leverages LocalTokenTxnService builders) for transfers.
         self.last_deposit = main_token_amount
         return (True, f"Deposited {main_token_amount} tokens")
 

{wayfinder_paths-0.1.15.dist-info → wayfinder_paths-0.1.16.dist-info}/METADATA

@@ -1,12 +1,13 @@
 Metadata-Version: 2.1
 Name: wayfinder-paths
-Version: 0.1.15
+Version: 0.1.16
 Summary: Wayfinder Path: strategies and adapters
 Author: Wayfinder
 Author-email: dev@wayfinder.ai
 Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: aiohttp (>=3.13.0,<4.0.0)
 Requires-Dist: eth-account (>=0.13.7,<0.14.0)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
@@ -275,7 +276,6 @@ Strategies implement trading logic using adapters and the unified client system.
 
 ```python
 # wayfinder_paths/strategies/my_strategy/strategy.py
-from wayfinder_paths.core.services.web3_service import DefaultWeb3Service
 from wayfinder_paths.core.strategies.Strategy import StatusDict, StatusTuple, Strategy
 from wayfinder_paths.adapters.balance_adapter.adapter import BalanceAdapter
 
@@ -291,9 +291,8 @@ class MyStrategy(Strategy):
     ):
         super().__init__(api_key=api_key)  # Pass to base class for auto-discovery
         self.config = config or {}
-        web3_service = DefaultWeb3Service(self.config)
         # Adapters automatically discover API key from constructor or config.json
-        balance_adapter = BalanceAdapter(self.config, web3_service=web3_service)
+        balance_adapter = BalanceAdapter(self.config)
         self.register_adapters([balance_adapter])
         self.balance_adapter = balance_adapter
 
@@ -311,7 +310,6 @@ class MyStrategy(Strategy):
         if not success:
             return (False, "Unable to fetch balances")
 
-        # Use BalanceAdapter (which leverages LocalTokenTxnService builders) for transfers here.
         self.last_deposit = main_token_amount
         return (True, f"Deposited {main_token_amount} tokens")
 
@@ -344,42 +342,6 @@ The following strategies are available and can be run using the CLI:
 
 #### Running Strategies
 
-```bash
-# Check strategy status
-poetry run python wayfinder_paths/scripts/run_strategy.py \
-  --strategy moonwell_wsteth_loop_strategy \
-  --main-wallet-label main \
-  --strategy-wallet-label moonwell_wsteth_loop_strategy \
-  status
-
-# Deposit funds (USDC amount, optional ETH for gas)
-poetry run python wayfinder_paths/scripts/run_strategy.py \
-  --strategy moonwell_wsteth_loop_strategy \
-  --main-wallet-label main \
-  --strategy-wallet-label moonwell_wsteth_loop_strategy \
-  deposit --usdc 100 --eth 0.01
-
-# Run periodic update
-poetry run python wayfinder_paths/scripts/run_strategy.py \
-  --strategy moonwell_wsteth_loop_strategy \
-  --main-wallet-label main \
-  --strategy-wallet-label moonwell_wsteth_loop_strategy \
-  update
-
-# Withdraw funds (omit --amount for full withdrawal)
-poetry run python wayfinder_paths/scripts/run_strategy.py \
-  --strategy moonwell_wsteth_loop_strategy \
-  --main-wallet-label main \
-  --strategy-wallet-label moonwell_wsteth_loop_strategy \
-  withdraw --amount 50
-
-# Run in simulation mode (no real transactions)
-poetry run python wayfinder_paths/scripts/run_strategy.py \
-  --strategy moonwell_wsteth_loop_strategy \
-  --simulation \
-  status
-```
-
 ### Built-in adapters
 
 - **BALANCE (BalanceAdapter)**: wraps `WalletClient`/`TokenClient` to read wallet, token, and pool balances and now orchestrates transfers between the main/strategy wallets with ledger bookkeeping. Requires a `Web3Service` so it can share the same wallet provider as the strategy.