wayfinder-paths 0.1.22__py3-none-any.whl → 0.1.23__py3-none-any.whl

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/test_strategy.py

@@ -48,10 +48,9 @@ def strategy():
 
     if hasattr(s, "balance_adapter") and s.balance_adapter:
         # Mock balances: 1000 USDT0 (with 6 decimals) and 2 HYPE (with 18 decimals)
-        def get_balance_side_effect(query, wallet_address, **kwargs):
-            token_id = (
-                query if isinstance(query, str) else (query or {}).get("token_id")
-            )
+        def get_balance_side_effect(
+            *, wallet_address, token_id=None, token_address=None, chain_id=None
+        ):
             token_id_str = str(token_id).lower() if token_id else ""
             if "usdt0" in token_id_str or token_id_str == "usdt0":
                 # 1000 USDT0 with 6 decimals = 1000 * 10^6 = 1000000000
@@ -145,9 +144,7 @@ def strategy():
             )
 
     if hasattr(s, "ledger_adapter") and s.ledger_adapter:
-        s.ledger_adapter.get_strategy_net_deposit = AsyncMock(
-            return_value=(True, {"net_deposit": 0})
-        )
+        s.ledger_adapter.get_strategy_net_deposit = AsyncMock(return_value=(True, 0.0))
         s.ledger_adapter.get_strategy_transactions = AsyncMock(
             return_value=(True, {"transactions": []})
         )
@@ -155,46 +152,36 @@ def strategy():
     if hasattr(s, "brap_adapter") and s.brap_adapter:
         usdt0_address = "0x1234567890123456789012345678901234567890"
 
-        def get_swap_quote_side_effect(*args, **kwargs):
+        def best_quote_side_effect(*args, **kwargs):
             to_token_address = kwargs.get("to_token_address", "")
             if to_token_address == usdt0_address:
-                return (
-                    True,
-                    {
-                        "quotes": {
-                            "best_quote": {
-                                "output_amount": "99900000",
-                            }
-                        }
-                    },
-                )
+                return (True, {"output_amount": "99900000"})
             return (
                 True,
                 {
-                    "quotes": {
-                        "best_quote": {
-                            "output_amount": "105000000",
-                            "input_amount": "50000000000000",
-                            "toAmount": "105000000",
-                            "estimatedGas": "1000000000",
-                            "fromAmount": "100000000",
-                            "fromToken": {"symbol": "USDT0"},
-                            "toToken": {"symbol": "HYPE"},
-                        }
-                    }
+                    "output_amount": "105000000",
+                    "input_amount": "50000000000000",
+                    "toAmount": "105000000",
+                    "estimatedGas": "1000000000",
+                    "fromAmount": "100000000",
+                    "fromToken": {"symbol": "USDT0"},
+                    "toToken": {"symbol": "HYPE"},
                 },
             )
 
-        s.brap_adapter.get_swap_quote = AsyncMock(
-            side_effect=get_swap_quote_side_effect
-        )
+        s.brap_adapter.best_quote = AsyncMock(side_effect=best_quote_side_effect)
 
     if (
         hasattr(s, "brap_adapter")
         and s.brap_adapter
         and hasattr(s.brap_adapter, "swap_from_quote")
     ):
-        s.brap_adapter.swap_from_quote = AsyncMock(return_value=None)
+        s.brap_adapter.swap_from_quote = AsyncMock(
+            return_value=(
+                True,
+                {"tx_hash": "0xmockhash", "from_amount": "100", "to_amount": "99"},
+            )
+        )
 
     if hasattr(s, "hyperlend_adapter") and s.hyperlend_adapter:
         s.hyperlend_adapter.get_assets_view = AsyncMock(

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/strategy.py

@@ -13,7 +13,17 @@ from wayfinder_paths.adapters.brap_adapter.adapter import BRAPAdapter
 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.chains import CHAIN_ID_BASE
+from wayfinder_paths.core.constants.contracts import BASE_USDC, BASE_WSTETH
 from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
+from wayfinder_paths.core.constants.tokens import (
+    TOKEN_ID_ETH_BASE,
+    TOKEN_ID_STETH,
+    TOKEN_ID_USDC_BASE,
+    TOKEN_ID_WELL_BASE,
+    TOKEN_ID_WETH_BASE,
+    TOKEN_ID_WSTETH_BASE,
+)
 from wayfinder_paths.core.strategies.descriptors import (
     Complexity,
     Directionality,
@@ -38,23 +48,17 @@ from wayfinder_paths.policies.moonwell import (
     weth_deposit,
 )
 
-# Token addresses on Base
-USDC = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"
-WSTETH = "0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452"
-
-# Token IDs
-USDC_TOKEN_ID = "usd-coin-base"
-WETH_TOKEN_ID = "l2-standard-bridged-weth-base-base"
-WSTETH_TOKEN_ID = "superbridge-bridged-wsteth-base-base"
-ETH_TOKEN_ID = "ethereum-base"
-WELL_TOKEN_ID = "moonwell-artemis-base"
-STETH_TOKEN_ID = "staked-ether-ethereum"
+USDC = BASE_USDC
+WSTETH = BASE_WSTETH
 
-# Base chain ID
-BASE_CHAIN_ID = 8453
+USDC_TOKEN_ID = TOKEN_ID_USDC_BASE
+WETH_TOKEN_ID = TOKEN_ID_WETH_BASE
+WSTETH_TOKEN_ID = TOKEN_ID_WSTETH_BASE
+ETH_TOKEN_ID = TOKEN_ID_ETH_BASE
+WELL_TOKEN_ID = TOKEN_ID_WELL_BASE
+STETH_TOKEN_ID = TOKEN_ID_STETH
 
-# Safety parameters
-# 0.98 = 2% safety margin when borrowing to avoid hitting exact liquidation threshold
+BASE_CHAIN_ID = CHAIN_ID_BASE
 COLLATERAL_SAFETY_FACTOR = 0.98
 
 
@@ -3410,7 +3414,7 @@ class MoonwellWstethLoopStrategy(Strategy):
         err: Exception | None = None
 
         try:
-            status = await self._withdraw_impl(amount)
+            status = await self._withdraw_impl()
         except Exception as exc:
             err = exc
             if isinstance(exc, SwapOutcomeUnknownError):
@@ -3428,8 +3432,7 @@ class MoonwellWstethLoopStrategy(Strategy):
         )
         return (False, f"{status[1]} | {suffix}")
 
-    async def _withdraw_impl(self, amount: float | None = None) -> StatusTuple:
-        # NOTE: amount is currently unused; withdraw() is all-or-nothing in this strategy.
+    async def _withdraw_impl(self) -> StatusTuple:
         logger.info("=" * 60)
         logger.info("WITHDRAW START - Full position unwind")
         logger.info("=" * 60)

wayfinder_paths/strategies/stablecoin_yield_strategy/strategy.py

@@ -12,7 +12,6 @@ from wayfinder_paths.adapters.brap_adapter.adapter import BRAPAdapter
 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.strategies.descriptors import (
     Complexity,
     Directionality,
@@ -260,7 +259,7 @@ class StablecoinYieldStrategy(Strategy):
         for token_id in self.tracked_token_ids:
             try:
                 success, balance_wei = await self.balance_adapter.get_balance(
-                    query=token_id,
+                    token_id=token_id,
                     wallet_address=strategy_address,
                 )
                 if success and balance_wei:
@@ -373,11 +372,9 @@ class StablecoinYieldStrategy(Strategy):
                 logger.info(f"Found {len(txns)} non-deposit transactions")
 
                 for txn in txns:
-                    op_data = txn.get("data", {}).get("op_data", {})
-                    # Track any token that was swapped TO
+                    op_data = txn.get("op_data", {})
                     if op_data.get("to_token_id"):
                         self._track_token(op_data.get("to_token_id"))
-                    # Track any token that was swapped FROM
                     if op_data.get("from_token_id"):
                         self._track_token(op_data.get("from_token_id"))
 
@@ -392,29 +389,30 @@ class StablecoinYieldStrategy(Strategy):
             txns = []
 
         if txns and txns[-1].get("operation") != "WITHDRAW":
-            pos = txns[-1].get("data").get("op_data")
-            success, token_info = await self.token_adapter.get_token(
-                pos.get("to_token_id")
-            )
-            if not success:
-                token_info = {}
-            self.current_pool = {
-                "token_id": token_info.get("token_id"),
-                "name": token_info.get("name"),
-                "symbol": token_info.get("symbol"),
-                "decimals": token_info.get("decimals"),
-                "address": token_info.get("address"),
-                "chain": token_info.get("chain"),
-            }
-            # Track the current pool token
-            if token_info.get("token_id"):
-                self._track_token(token_info.get("token_id"))
+            last_txn = txns[-1]
+            pos = last_txn.get("op_data", {})
+            if pos and pos.get("to_token_id"):
+                success, token_info = await self.token_adapter.get_token(
+                    pos.get("to_token_id")
+                )
+                if not success:
+                    token_info = {}
+                self.current_pool = {
+                    "token_id": token_info.get("token_id"),
+                    "name": token_info.get("name"),
+                    "symbol": token_info.get("symbol"),
+                    "decimals": token_info.get("decimals"),
+                    "address": token_info.get("address"),
+                    "chain": token_info.get("chain"),
+                }
+                if token_info.get("token_id"):
+                    self._track_token(token_info.get("token_id"))
 
-            success, reports = await self.pool_adapter.get_pools_by_ids(
-                pool_ids=[self.current_pool.get("token_id")]
-            )
-            if success and reports.get("pools"):
-                self.current_pool_data = reports.get("pools", [])[0]
+                success, reports = await self.pool_adapter.get_pools_by_ids(
+                    pool_ids=[self.current_pool.get("token_id")]
+                )
+                if success and reports.get("pools"):
+                    self.current_pool_data = reports.get("pools", [])[0]
 
         pool_ids = []
         pool_id = self.current_pool.get("token_id", None)
@@ -489,7 +487,7 @@ class StablecoinYieldStrategy(Strategy):
                     success,
                     current_pool_balance_raw,
                 ) = await self.balance_adapter.get_balance(
-                    query=pool_address,
+                    token_address=pool_address,
                     wallet_address=user_address,
                     chain_id=chain_id,
                 )
@@ -537,7 +535,7 @@ class StablecoinYieldStrategy(Strategy):
 
         if self.usdc_token_info:
             status, raw_balance = await self.balance_adapter.get_balance(
-                query=self.usdc_token_info.get("token_id"),
+                token_id=self.usdc_token_info.get("token_id"),
                 wallet_address=self._get_strategy_wallet_address(),
             )
             if not status or not raw_balance:
@@ -608,7 +606,7 @@ class StablecoinYieldStrategy(Strategy):
             strategy_address = self._get_strategy_wallet_address()
             try:
                 success, onchain_balance = await self.balance_adapter.get_balance(
-                    query=token.get("token_id"),
+                    token_id=token.get("token_id"),
                     wallet_address=strategy_address,
                 )
                 if success and onchain_balance:
@@ -686,7 +684,7 @@ class StablecoinYieldStrategy(Strategy):
                     main_usdc_status,
                     main_usdc_balance,
                 ) = await self.balance_adapter.get_balance(
-                    query=token_info.get("token_id"),
+                    token_id=token_info.get("token_id"),
                     wallet_address=self._get_main_wallet_address(),
                 )
                 if main_usdc_status and main_usdc_balance is not None:
@@ -730,7 +728,7 @@ class StablecoinYieldStrategy(Strategy):
                     _,
                     main_gas_raw,
                 ) = await self.balance_adapter.get_balance(
-                    query=gas_token_id,
+                    token_id=gas_token_id,
                     wallet_address=self._get_main_wallet_address(),
                 )
                 main_gas_int = (
@@ -754,14 +752,14 @@ class StablecoinYieldStrategy(Strategy):
                     _,
                     main_gas_raw,
                 ) = await self.balance_adapter.get_balance(
-                    query=gas_token_id,
+                    token_id=gas_token_id,
                     wallet_address=self._get_main_wallet_address(),
                 )
                 (
                     _,
                     strategy_gas_raw,
                 ) = await self.balance_adapter.get_balance(
-                    query=gas_token_id,
+                    token_id=gas_token_id,
                     wallet_address=self._get_strategy_wallet_address(),
                 )
                 main_gas_int = (
@@ -885,7 +883,7 @@ class StablecoinYieldStrategy(Strategy):
                 _,
                 self.current_pool_balance,
             ) = await self.balance_adapter.get_balance(
-                query=self.current_pool.get("address"),
+                token_address=self.current_pool.get("address"),
                 wallet_address=self._get_strategy_wallet_address(),
                 chain_id=self.current_pool.get("chain").get("id"),
             )
@@ -901,76 +899,26 @@ class StablecoinYieldStrategy(Strategy):
             logger.info(
                 f"Need to swap from {self.current_pool.get('symbol')} to USDC before withdrawal"
             )
-            quotes = {}
-            for attempt in range(4):
-                logger.info(
-                    f"Getting swap quote (attempt {attempt + 1}/4) with slippage: {DEFAULT_SLIPPAGE * (attempt + 1)}"
-                )
-                try:
-                    success, quotes = await self.brap_adapter.get_swap_quote(
-                        from_token_address=self.current_pool.get("address"),
-                        to_token_address=self.usdc_token_info.get("address"),
-                        from_chain_id=self.current_pool.get("chain").get("id"),
-                        to_chain_id=self.usdc_token_info.get("chain").get("id"),
-                        from_address=self._get_strategy_wallet_address(),
-                        to_address=self._get_strategy_wallet_address(),
-                        amount=str(self.current_pool_balance),
-                        slippage=DEFAULT_SLIPPAGE * (attempt + 1),
-                    )
-                    if (
-                        success
-                        and isinstance(quotes, dict)
-                        and quotes.get("best_quote")
-                    ):
-                        logger.info("Successfully obtained swap quote")
-                        break
-                except Exception as e:
-                    logger.warning(f"Quote attempt {attempt + 1} failed: {e}")
-                    if attempt == 3:
-                        logger.error("All quote attempts failed")
-
-            best_quote = quotes.get("best_quote") if isinstance(quotes, dict) else None
-            if not best_quote:
+            success, quote = await self.brap_adapter.best_quote(
+                from_token_address=self.current_pool.get("address"),
+                to_token_address=self.usdc_token_info.get("address"),
+                from_chain_id=self.current_pool.get("chain").get("id"),
+                to_chain_id=self.usdc_token_info.get("chain").get("id"),
+                from_address=self._get_strategy_wallet_address(),
+                amount=str(self.current_pool_balance),
+                retries=4,
+            )
+            if not success:
                 return (
                     False,
                     "Could not swap tokens out due to market conditions (balances too small to move or slippage required is too high) please manually move funds out",
                 )
 
-            if not best_quote.get("output_amount") or not best_quote.get(
-                "input_amount"
-            ):
-                return (False, "Swap quote missing required fields")
-
-            if not best_quote.get("from_amount_usd"):
-                input_amount = int(best_quote.get("input_amount"))
-                if self.current_pool.get("token_id") == self.usdc_token_info.get(
-                    "token_id"
-                ):
-                    best_quote["from_amount_usd"] = float(input_amount) / (
-                        10 ** self.current_pool.get("decimals")
-                    )
-                else:
-                    best_quote["from_amount_usd"] = await self._get_pool_usd_value(
-                        self.current_pool, input_amount
-                    )
-
-            if not best_quote.get("to_amount_usd"):
-                output_amount = int(best_quote.get("output_amount"))
-                best_quote["to_amount_usd"] = float(
-                    output_amount
-                ) / 10 ** self.usdc_token_info.get("decimals")
-
-            if not self.brap_adapter:
-                return (
-                    False,
-                    "BRAP adapter not initialized; cannot unwind position.",
-                )
-
             success, swap_result = await self.brap_adapter.swap_from_quote(
                 self.current_pool,
                 self.usdc_token_info,
                 self._get_strategy_wallet_address(),
-                best_quote,
+                quote,
                 strategy_name=self.name,
             )
             if not success:
@@ -982,7 +930,7 @@ class StablecoinYieldStrategy(Strategy):
         await self._sweep_wallet(self.usdc_token_info)
 
         status, raw_balance = await self.balance_adapter.get_balance(
-            query=self.usdc_token_info.get("token_id"),
+            token_id=self.usdc_token_info.get("token_id"),
             wallet_address=self._get_strategy_wallet_address(),
         )
         usdc_amount = 0.0
@@ -994,7 +942,7 @@ class StablecoinYieldStrategy(Strategy):
         gas_amount = 0.0
         if self.gas_token:
             status, raw_gas = await self.balance_adapter.get_balance(
-                query=self.gas_token.get("token_id"),
+                token_id=self.gas_token.get("token_id"),
                 wallet_address=self._get_strategy_wallet_address(),
             )
             if status and raw_gas:
@@ -1043,7 +991,7 @@ class StablecoinYieldStrategy(Strategy):
                     success,
                     msg,
                 ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                    query="usd-coin-base",
+                    token_id="usd-coin-base",
                     amount=usdc_balance,
                     strategy_name=self.name,
                     skip_ledger=False,
@@ -1068,7 +1016,7 @@ class StablecoinYieldStrategy(Strategy):
                     success,
                     msg,
                 ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                    query="ethereum-base",
+                    token_id="ethereum-base",
                     amount=transferable_eth,
                     strategy_name=self.name,
                     skip_ledger=False,
@@ -1091,12 +1039,16 @@ class StablecoinYieldStrategy(Strategy):
             return None
         for transaction in data.get("transactions", []):
             op_data = transaction.get("op_data", {})
-            if op_data.get("type") == "SWAP" and op_data.get(
-                "to_token_id"
-            ).lower() not in [
-                "usd-coin-base",
-                "base_0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
-            ]:
+            to_token = op_data.get("to_token_id")
+            if (
+                op_data.get("type") == "SWAP"
+                and to_token
+                and str(to_token).lower()
+                not in [
+                    "usd-coin-base",
+                    "base_0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+                ]
+            ):
                 created_str = transaction.get("created")
                 if not created_str:
                     continue
@@ -1262,7 +1214,7 @@ class StablecoinYieldStrategy(Strategy):
                 _,
                 refreshed_pool_balance,
             ) = await self.balance_adapter.get_balance(
-                query=pool.get("address"),
+                token_address=pool.get("address"),
                 wallet_address=strategy_address,
                 chain_id=pool.get("chain").get("id"),
             )
@@ -1295,7 +1247,7 @@ class StablecoinYieldStrategy(Strategy):
 
             try:
                 success, fresh_balance = await self.balance_adapter.get_balance(
-                    query=token_id,
+                    token_id=token_id,
                     wallet_address=self._get_strategy_wallet_address(),
                 )
                 if not success or not fresh_balance or int(fresh_balance) <= 0:
@@ -1334,7 +1286,7 @@ class StablecoinYieldStrategy(Strategy):
         # Refresh target token balance
         try:
             success, target_balance = await self.balance_adapter.get_balance(
-                query=target_token_id,
+                token_id=target_token_id,
                 wallet_address=self._get_strategy_wallet_address(),
             )
             if success and target_balance:
@@ -1351,7 +1303,7 @@ class StablecoinYieldStrategy(Strategy):
 
         required_gas = int(self.MIN_GAS * (10 ** self.gas_token.get("decimals")))
         _, current_gas = await self.balance_adapter.get_balance(
-            query=self.gas_token.get("token_id"),
+            token_id=self.gas_token.get("token_id"),
             wallet_address=strategy_address,
         )
         if current_gas >= required_gas:
@@ -1399,22 +1351,15 @@ class StablecoinYieldStrategy(Strategy):
         if chain_id != self.usdc_token_info.get("chain").get("id"):
             return 0.0
 
-        success, exit_quotes = await self.brap_adapter.get_swap_quote(
+        success, best_quote = await self.brap_adapter.best_quote(
             from_token_address=token.get("address"),
             to_token_address=self.usdc_token_info.get("address"),
             from_chain_id=chain_id,
             to_chain_id=self.usdc_token_info.get("chain").get("id"),
             from_address=self._get_strategy_wallet_address(),
-            to_address=self._get_strategy_wallet_address(),
             amount=str(amount),
         )
-        if not success:
-            return 0.0
-
-        best_quote = (
-            exit_quotes.get("best_quote") if isinstance(exit_quotes, dict) else None
-        )
-        if not best_quote:
+        if not success or not isinstance(best_quote, dict):
             return None
         current_pool_usd_value = best_quote.get("output_amount")
 
@@ -1538,21 +1483,15 @@ class StablecoinYieldStrategy(Strategy):
         try:
             apy_pct = pool_data.get("combined_apy_pct") or pool_data.get("apy") or 0
             combined_apy_pct = float(apy_pct) / 100
-            success, quotes = await self.brap_adapter.get_swap_quote(
+            success, best_quote = await self.brap_adapter.best_quote(
                 from_token_address=current_token.get("address"),
                 to_token_address=token.get("address"),
                 from_chain_id=current_token.get("chain").get("id"),
                 to_chain_id=token.get("chain").get("id"),
                 from_address=self._get_strategy_wallet_address(),
-                to_address=self._get_strategy_wallet_address(),
                 amount=str(current_token_balance),
             )
-            if not success:
-                return None
-            if not isinstance(quotes, dict):
-                return None
-            best_quote = quotes.get("best_quote")
-            if not best_quote:
+            if not success or not isinstance(best_quote, dict):
                 return None
 
             target_pool_usd_val = await self._get_pool_usd_value(
@@ -1602,7 +1541,7 @@ class StablecoinYieldStrategy(Strategy):
 
     async def _status(self) -> StatusDict:
         gas_success, gas_balance_wei = await self.balance_adapter.get_balance(
-            query=self.gas_token.get("token_id"),
+            token_id=self.gas_token.get("token_id"),
             wallet_address=self._get_strategy_wallet_address(),
         )
         gas_balance = (
@@ -1759,7 +1698,7 @@ class StablecoinYieldStrategy(Strategy):
 
         # Refresh USDC balance after swaps
         success, usdc_wei = await self.balance_adapter.get_balance(
-            query=usdc_token_id,
+            token_id=usdc_token_id,
             wallet_address=self._get_strategy_wallet_address(),
         )
         if success and usdc_wei:
@@ -1804,7 +1743,7 @@ class StablecoinYieldStrategy(Strategy):
 
                 # Refresh USDC balance again
                 success, usdc_wei = await self.balance_adapter.get_balance(
-                    query=usdc_token_id,
+                    token_id=usdc_token_id,
                     wallet_address=self._get_strategy_wallet_address(),
                 )
                 if success and usdc_wei: