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

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,
@@ -207,15 +206,6 @@ class StablecoinYieldStrategy(Strategy):
                 strategy_wallet_signing_callback=self.strategy_wallet_signing_callback,
             )
 
-            self.register_adapters(
-                [
-                    balance,
-                    token_adapter,
-                    ledger_adapter,
-                    pool_adapter,
-                    brap_adapter,
-                ]
-            )
             self.balance_adapter = balance
             self.token_adapter = token_adapter
             self.ledger_adapter = ledger_adapter
@@ -260,7 +250,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 +363,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 +380,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 +478,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,
                 )
@@ -506,7 +495,6 @@ class StablecoinYieldStrategy(Strategy):
             == self.current_pool.get("chain").get("id")
             else None
         )
-        # Refresh all tracked balances from blockchain
         await self._refresh_tracked_balances()
         logger.info(
             f"Refreshed balances for {len(self.tracked_balances)} tracked tokens"
@@ -537,7 +525,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:
@@ -575,7 +563,6 @@ class StablecoinYieldStrategy(Strategy):
 
     async def _infer_active_pool_from_tracked_tokens(self):
         try:
-            # Refresh balances for tracked tokens
             await self._refresh_tracked_balances()
 
             usdc_token_id = self.usdc_token_info.get("token_id")
@@ -584,7 +571,6 @@ class StablecoinYieldStrategy(Strategy):
             best_token_id = None
             best_balance_wei = 0
 
-            # Find the non-gas, non-USDC token with the largest balance
             for token_id, balance_wei in self.tracked_balances.items():
                 if balance_wei <= 0:
                     continue
@@ -593,7 +579,6 @@ class StablecoinYieldStrategy(Strategy):
                 if token_id == usdc_token_id:
                     continue
 
-                # Prefer tokens with larger balances
                 if balance_wei > best_balance_wei:
                     best_token_id = token_id
                     best_balance_wei = balance_wei
@@ -608,7 +593,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 +671,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 +715,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 +739,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 = (
@@ -794,7 +779,6 @@ class StablecoinYieldStrategy(Strategy):
                         f"Need at least {required_gas} {gas_symbol} on Base for gas. You have: {total_gas}",
                     )
 
-            # Transfer main token if provided
             if main_token_amount > 0:
                 self.current_pool_balance = int(
                     main_token_amount * (10 ** self.current_pool.get("decimals"))
@@ -802,7 +786,6 @@ class StablecoinYieldStrategy(Strategy):
                 self.DEPOSIT_USDC = main_token_amount
                 logger.info(f"Set deposit amount to {main_token_amount} USDC")
 
-                # Transfer USDC from main to strategy wallet
                 logger.info("Initiating USDC transfer from main to strategy wallet")
                 (
                     success,
@@ -885,7 +868,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 +884,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 +915,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 +927,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:
@@ -1030,7 +963,6 @@ class StablecoinYieldStrategy(Strategy):
 
         transferred_items = []
 
-        # Transfer USDC to main wallet
         usdc_ok, usdc_raw = await self.balance_adapter.get_balance(
             token_id="usd-coin-base",
             wallet_address=strategy_address,
@@ -1043,7 +975,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,
@@ -1053,7 +985,6 @@ class StablecoinYieldStrategy(Strategy):
                 else:
                     logger.warning(f"USDC transfer failed: {msg}")
 
-        # Transfer ETH (minus reserve for tx fees) to main wallet
         eth_ok, eth_raw = await self.balance_adapter.get_balance(
             token_id="ethereum-base",
             wallet_address=strategy_address,
@@ -1068,7 +999,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 +1022,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 +1197,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"),
             )
@@ -1271,7 +1206,6 @@ class StablecoinYieldStrategy(Strategy):
             pass
 
     async def _sweep_wallet(self, target_token):
-        # Refresh tracked balances
         await self._refresh_tracked_balances()
 
         target_token_id = target_token.get("token_id")
@@ -1279,23 +1213,19 @@ class StablecoinYieldStrategy(Strategy):
         target_address = target_token.get("address", "").lower()
         gas_token_id = self.gas_token.get("token_id") if self.gas_token else None
 
-        # Swap all non-target, non-gas tokens to the target
         for token_id, balance_wei in list(self.tracked_balances.items()):
-            # Skip if no balance
             if balance_wei <= 0:
                 continue
 
-            # Skip gas token
             if token_id == gas_token_id:
                 continue
 
-            # Skip if it's already the target token
             if token_id == target_token_id:
                 continue
 
             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:
@@ -1329,12 +1259,10 @@ class StablecoinYieldStrategy(Strategy):
                 logger.error(f"Error sweeping {token_id}: {e}")
                 continue
 
-        # Track the target token
         self._track_token(target_token_id)
-        # 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 +1279,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 +1327,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")
 
@@ -1423,18 +1344,15 @@ class StablecoinYieldStrategy(Strategy):
         )
 
     async def _get_non_gas_balances(self) -> list[dict[str, Any]]:
-        # Refresh tracked balances
         await self._refresh_tracked_balances()
 
         gas_token_id = self.gas_token.get("token_id") if self.gas_token else None
         results = []
 
         for token_id, balance_wei in self.tracked_balances.items():
-            # Skip gas token
             if token_id == gas_token_id:
                 continue
 
-            # Skip zero balances
             if balance_wei <= 0:
                 continue
 
@@ -1538,21 +1456,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 +1514,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 = (
@@ -1612,7 +1524,6 @@ class StablecoinYieldStrategy(Strategy):
         )
 
         if not self.DEPOSIT_USDC:
-            # No deposits recorded - report minimal status
             status_payload = {
                 "info": "No recorded strategy deposits.",
                 "idle_usd": 0.0,
@@ -1692,7 +1603,6 @@ class StablecoinYieldStrategy(Strategy):
         return [f"({wallet_id}) && (({approve_enso}) || ({swap_enso})) "]
 
     async def partial_liquidate(self, usd_value: float) -> StatusTuple:
-        # Refresh tracked balances
         await self._refresh_tracked_balances()
 
         usdc_token_id = self.usdc_token_info.get("token_id")
@@ -1702,12 +1612,10 @@ class StablecoinYieldStrategy(Strategy):
         available_usdc_wei = self.tracked_balances.get(usdc_token_id, 0)
         available_usdc_usd = float(available_usdc_wei) / (10**usdc_decimals)
 
-        # Liquidate non-USDC, non-gas, non-current-pool tokens first
         for token_id, balance_wei in list(self.tracked_balances.items()):
             if available_usdc_usd >= usd_value:
                 break
 
-            # Skip USDC, gas, and current pool
             if token_id == usdc_token_id:
                 continue
             if token_id == gas_token_id:
@@ -1715,7 +1623,6 @@ class StablecoinYieldStrategy(Strategy):
             if self.current_pool and token_id == self.current_pool.get("token_id"):
                 continue
 
-            # Skip zero balances
             if balance_wei <= 0:
                 continue
 
@@ -1759,7 +1666,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:
@@ -1767,7 +1674,6 @@ class StablecoinYieldStrategy(Strategy):
             available_usdc_usd = float(available_usdc_wei) / (10**usdc_decimals)
             self._update_balance(usdc_token_id, available_usdc_wei)
 
-        # If still not enough, liquidate from current pool
         if (
             available_usdc_usd < usd_value
             and self.current_pool
@@ -1802,9 +1708,8 @@ class StablecoinYieldStrategy(Strategy):
                 except Exception as e:
                     logger.error(f"Error swapping pool to USDC: {e}")
 
-                # 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: