wayfinder-paths 0.1.3__py3-none-any.whl → 0.1.5__py3-none-any.whl

wayfinder_paths/{vaults/strategies → strategies}/stablecoin_yield_strategy/strategy.py

@@ -6,6 +6,11 @@ from typing import Any
 
 from loguru import logger
 
+from wayfinder_paths.adapters.balance_adapter.adapter import BalanceAdapter
+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.services.local_token_txn import (
     LocalTokenTxnService,
@@ -21,11 +26,6 @@ from wayfinder_paths.core.strategies.descriptors import (
 )
 from wayfinder_paths.core.strategies.Strategy import StatusDict, StatusTuple, Strategy
 from wayfinder_paths.core.wallets.WalletManager import WalletManager
-from wayfinder_paths.vaults.adapters.balance_adapter.adapter import BalanceAdapter
-from wayfinder_paths.vaults.adapters.brap_adapter.adapter import BRAPAdapter
-from wayfinder_paths.vaults.adapters.ledger_adapter.adapter import LedgerAdapter
-from wayfinder_paths.vaults.adapters.pool_adapter.adapter import PoolAdapter
-from wayfinder_paths.vaults.adapters.token_adapter.adapter import TokenAdapter
 
 
 class StablecoinYieldStrategy(Strategy):
@@ -154,7 +154,7 @@ class StablecoinYieldStrategy(Strategy):
         config: dict[str, Any] | None = None,
         *,
         main_wallet: dict[str, Any] | None = None,
-        vault_wallet: dict[str, Any] | None = None,
+        strategy_wallet: dict[str, Any] | None = None,
         simulation: bool = False,
         web3_service=None,
         api_key: str | None = None,
@@ -163,8 +163,8 @@ class StablecoinYieldStrategy(Strategy):
         merged_config: dict[str, Any] = dict(config or {})
         if main_wallet is not None:
             merged_config["main_wallet"] = main_wallet
-        if vault_wallet is not None:
-            merged_config["vault_wallet"] = vault_wallet
+        if strategy_wallet is not None:
+            merged_config["strategy_wallet"] = strategy_wallet
 
         self.config = merged_config
         self.simulation = simulation
@@ -181,11 +181,11 @@ class StablecoinYieldStrategy(Strategy):
 
         try:
             main_wallet_cfg = self.config.get("main_wallet")
-            vault_wallet_cfg = self.config.get("vault_wallet")
+            strategy_wallet_cfg = self.config.get("strategy_wallet")
 
             adapter_config = {
                 "main_wallet": main_wallet_cfg or None,
-                "vault_wallet": vault_wallet_cfg or None,
+                "strategy_wallet": strategy_wallet_cfg or None,
                 "strategy": self.config,
             }
 
@@ -231,14 +231,14 @@ class StablecoinYieldStrategy(Strategy):
         except Exception:
             pass
 
-    def _get_vault_wallet_address(self) -> str:
-        """Get vault wallet address with validation."""
-        vault_wallet = self.config.get("vault_wallet")
-        if not vault_wallet or not isinstance(vault_wallet, dict):
-            raise ValueError("vault_wallet not configured in strategy config")
-        address = vault_wallet.get("address")
+    def _get_strategy_wallet_address(self) -> str:
+        """Get strategy wallet address with validation."""
+        strategy_wallet = self.config.get("strategy_wallet")
+        if not strategy_wallet or not isinstance(strategy_wallet, dict):
+            raise ValueError("strategy_wallet not configured in strategy config")
+        address = strategy_wallet.get("address")
         if not address:
-            raise ValueError("vault_wallet address not found in config")
+            raise ValueError("strategy_wallet address not found in config")
         return str(address)
 
     def _get_main_wallet_address(self) -> str:
@@ -258,21 +258,21 @@ class StablecoinYieldStrategy(Strategy):
         await super().setup()
         self.current_combined_apy_pct = 0.0
 
-        # Get vault net deposit
+        # Get strategy net deposit
         try:
-            logger.info("Fetching vault net deposit from ledger")
-            vault_address = self._get_vault_wallet_address()
-            success, deposit_data = await self.ledger_adapter.get_vault_net_deposit(
-                wallet_address=vault_address,
+            logger.info("Fetching strategy net deposit from ledger")
+            strategy_address = self._get_strategy_wallet_address()
+            success, deposit_data = await self.ledger_adapter.get_strategy_net_deposit(
+                wallet_address=strategy_address,
             )
             if success:
                 self.DEPOSIT_USDC = deposit_data.get("net_deposit", 0)
-                logger.info(f"Vault net deposit: {self.DEPOSIT_USDC} USDC")
+                logger.info(f"Strategy net deposit: {self.DEPOSIT_USDC} USDC")
             else:
-                logger.error(f"Failed to fetch vault net deposit: {deposit_data}")
+                logger.error(f"Failed to fetch strategy net deposit: {deposit_data}")
                 self.DEPOSIT_USDC = 0
         except Exception as e:
-            logger.error(f"Failed to fetch vault net deposit: {e}")
+            logger.error(f"Failed to fetch strategy net deposit: {e}")
             self.DEPOSIT_USDC = 0
 
         # Get USDC token info
@@ -328,11 +328,11 @@ class StablecoinYieldStrategy(Strategy):
             self.current_pool_balance = 0
             return
 
-        # Get vault transactions to determine current position
+        # Get strategy transactions to determine current position
         try:
-            logger.info("Fetching vault transaction history")
-            success, txns_data = await self.ledger_adapter.get_vault_transactions(
-                wallet_address=self._get_vault_wallet_address(),
+            logger.info("Fetching strategy transaction history")
+            success, txns_data = await self.ledger_adapter.get_strategy_transactions(
+                wallet_address=self._get_strategy_wallet_address(),
             )
             if success:
                 txns = [
@@ -342,10 +342,10 @@ class StablecoinYieldStrategy(Strategy):
                 ]
                 logger.info(f"Found {len(txns)} non-deposit transactions")
             else:
-                logger.error(f"Failed to fetch vault transactions: {txns_data}")
+                logger.error(f"Failed to fetch strategy transactions: {txns_data}")
                 txns = []
         except Exception as e:
-            logger.error(f"Failed to fetch vault transactions: {e}")
+            logger.error(f"Failed to fetch strategy transactions: {e}")
             txns = []
 
         if txns and txns[-1].get("operation") != "WITHDRAW":
@@ -413,7 +413,7 @@ class StablecoinYieldStrategy(Strategy):
 
         pool_address = self.current_pool.get("address")
         chain_id = self.current_pool.get("chain", {}).get("id")
-        user_address = self._get_vault_wallet_address()
+        user_address = self._get_strategy_wallet_address()
         if (
             pool_address
             and chain_id
@@ -467,7 +467,7 @@ class StablecoinYieldStrategy(Strategy):
         if self.usdc_token_info:
             status, raw_balance = await self.balance_adapter.get_balance(
                 token_id=self.usdc_token_info.get("token_id"),
-                wallet_address=self._get_vault_wallet_address(),
+                wallet_address=self._get_strategy_wallet_address(),
             )
             if not status or not raw_balance:
                 return
@@ -508,7 +508,7 @@ class StablecoinYieldStrategy(Strategy):
                 _,
                 wallet_balances,
             ) = await self.balance_adapter.get_all_balances(
-                wallet_address=self._get_vault_wallet_address(),
+                wallet_address=self._get_strategy_wallet_address(),
                 enrich=True,
                 from_cache=False,
                 add_llama=True,
@@ -577,13 +577,13 @@ class StablecoinYieldStrategy(Strategy):
             return None
 
         try:
-            vault_address = self._get_vault_wallet_address()
+            strategy_address = self._get_strategy_wallet_address()
             (
                 success,
                 onchain_balance,
             ) = await self.balance_adapter.get_balance(
                 token_id=token.get("token_id"),
-                wallet_address=vault_address,
+                wallet_address=strategy_address,
             )
             if not success:
                 onchain_balance = best_balance_wei
@@ -733,26 +733,26 @@ class StablecoinYieldStrategy(Strategy):
                 )
                 (
                     _,
-                    vault_gas_raw,
+                    strategy_gas_raw,
                 ) = await self.balance_adapter.get_balance(
                     token_id=gas_token_id,
-                    wallet_address=self._get_vault_wallet_address(),
+                    wallet_address=self._get_strategy_wallet_address(),
                 )
                 main_gas_int = (
                     int(main_gas_raw)
                     if isinstance(main_gas_raw, int)
                     else int(float(main_gas_raw or 0))
                 )
-                vault_gas_int = (
-                    int(vault_gas_raw)
-                    if isinstance(vault_gas_raw, int)
-                    else int(float(vault_gas_raw or 0))
+                strategy_gas_int = (
+                    int(strategy_gas_raw)
+                    if isinstance(strategy_gas_raw, int)
+                    else int(float(strategy_gas_raw or 0))
                 )
                 main_gas_native = float(main_gas_int) / (10**gas_decimals)
-                vault_gas_native = float(vault_gas_int) / (10**gas_decimals)
-                total_gas = main_gas_native + vault_gas_native
+                strategy_gas_native = float(strategy_gas_int) / (10**gas_decimals)
+                total_gas = main_gas_native + strategy_gas_native
                 logger.info(
-                    f"Gas balances - Main: {main_gas_native} {gas_symbol}, Vault: {vault_gas_native} {gas_symbol}, Total: {total_gas} {gas_symbol}"
+                    f"Gas balances - Main: {main_gas_native} {gas_symbol}, Strategy: {strategy_gas_native} {gas_symbol}, Total: {total_gas} {gas_symbol}"
                 )
 
                 # Use provided gas_token_amount if available, otherwise ensure minimum
@@ -776,22 +776,22 @@ 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 vault wallet
-                logger.info("Initiating USDC transfer from main to vault wallet")
+                # Transfer USDC from main to strategy wallet
+                logger.info("Initiating USDC transfer from main to strategy wallet")
                 (
                     success,
                     msg,
-                ) = await self.balance_adapter.move_from_main_wallet_to_vault_wallet(
+                ) = await self.balance_adapter.move_from_main_wallet_to_strategy_wallet(
                     self.usdc_token_info.get("token_id"),
                     main_token_amount,
                     strategy_name=self.name,
                 )
                 if not success:
                     logger.error(f"USDC transfer failed: {msg}")
-                    return (False, f"USDC transfer to vault failed: {msg}")
+                    return (False, f"USDC transfer to strategy failed: {msg}")
                 logger.info("USDC transfer completed successfully")
 
-            # Transfer gas if provided or if vault needs top-up
+            # Transfer gas if provided or if strategy needs top-up
             if gas_token_amount > 0:
                 # Get gas symbol if not already defined
                 if main_token_amount == 0:
@@ -799,33 +799,33 @@ class StablecoinYieldStrategy(Strategy):
 
                 # Transfer the specified gas amount
                 logger.info(
-                    f"Transferring {gas_token_amount} {gas_symbol} from main wallet to vault"
+                    f"Transferring {gas_token_amount} {gas_symbol} from main wallet to strategy"
                 )
                 (
                     success,
                     msg,
-                ) = await self.balance_adapter.move_from_main_wallet_to_vault_wallet(
+                ) = await self.balance_adapter.move_from_main_wallet_to_strategy_wallet(
                     gas_token_id, gas_token_amount, strategy_name=self.name
                 )
                 if not success:
                     logger.error(f"Gas transfer failed: {msg}")
-                    return (False, f"Gas transfer to vault failed: {msg}")
+                    return (False, f"Gas transfer to strategy failed: {msg}")
                 logger.info("Gas transfer completed successfully")
-            elif main_token_amount > 0 and vault_gas_native < self.MIN_GAS:
+            elif main_token_amount > 0 and strategy_gas_native < self.MIN_GAS:
                 # Auto-top-up to minimum if no gas amount specified and depositing main token
-                top_up_amount = self.MIN_GAS - vault_gas_native
+                top_up_amount = self.MIN_GAS - strategy_gas_native
                 logger.info(
-                    f"Vault gas insufficient, transferring {top_up_amount} {gas_symbol} from main wallet"
+                    f"Strategy gas insufficient, transferring {top_up_amount} {gas_symbol} from main wallet"
                 )
                 (
                     success,
                     msg,
-                ) = await self.balance_adapter.move_from_main_wallet_to_vault_wallet(
+                ) = await self.balance_adapter.move_from_main_wallet_to_strategy_wallet(
                     gas_token_id, top_up_amount, strategy_name=self.name
                 )
                 if not success:
                     logger.error(f"Gas transfer failed: {msg}")
-                    return (False, f"Gas transfer to vault failed: {msg}")
+                    return (False, f"Gas transfer to strategy failed: {msg}")
                 logger.info("Gas transfer completed successfully")
 
             elapsed_time = time.time() - start_time
@@ -857,7 +857,7 @@ class StablecoinYieldStrategy(Strategy):
             ) = await self.balance_adapter.get_pool_balance(
                 pool_address=self.current_pool.get("address"),
                 chain_id=self.current_pool.get("chain").get("id"),
-                user_address=self._get_vault_wallet_address(),
+                user_address=self._get_strategy_wallet_address(),
             )
             logger.info(f"Current pool balance: {self.current_pool_balance}")
         except Exception as e:
@@ -883,8 +883,8 @@ class StablecoinYieldStrategy(Strategy):
                         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_vault_wallet_address(),
-                        to_address=self._get_vault_wallet_address(),
+                        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),
                     )
@@ -940,7 +940,7 @@ class StablecoinYieldStrategy(Strategy):
             success, swap_result = await self.brap_adapter.swap_from_quote(
                 self.current_pool,
                 self.usdc_token_info,
-                self._get_vault_wallet_address(),
+                self._get_strategy_wallet_address(),
                 best_quote,
                 strategy_name=self.name,
             )
@@ -958,7 +958,7 @@ class StablecoinYieldStrategy(Strategy):
             pass
         status, raw_balance = await self.balance_adapter.get_balance(
             token_id=self.usdc_token_info.get("token_id"),
-            wallet_address=self._get_vault_wallet_address(),
+            wallet_address=self._get_strategy_wallet_address(),
         )
         if not status or not raw_balance:
             pass
@@ -967,7 +967,7 @@ class StablecoinYieldStrategy(Strategy):
             (
                 move_status,
                 move_message,
-            ) = await self.balance_adapter.move_from_vault_wallet_to_main_wallet(
+            ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
                 self.usdc_token_info.get("token_id"),
                 amount,
                 strategy_name=self.name,
@@ -987,7 +987,7 @@ class StablecoinYieldStrategy(Strategy):
         if self.gas_token and self.gas_token.get("id") not in withdrawn_token_ids:
             status, raw_gas = await self.balance_adapter.get_balance(
                 token_id=self.gas_token.get("id"),
-                wallet_address=self._get_vault_wallet_address(),
+                wallet_address=self._get_strategy_wallet_address(),
             )
             if status and raw_gas:
                 gas_amount = (
@@ -997,7 +997,7 @@ class StablecoinYieldStrategy(Strategy):
                     (
                         move_gas_status,
                         move_gas_message,
-                    ) = await self.balance_adapter.move_from_vault_wallet_to_main_wallet(
+                    ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
                         self.gas_token.get("id"),
                         gas_amount,
                         strategy_name=self.name,
@@ -1016,7 +1016,7 @@ class StablecoinYieldStrategy(Strategy):
         self.current_pool_balance = 0
 
         if not withdrawn_breakdown:
-            return (True, f"Successfully withdrew {amount} USDC from vault")
+            return (True, f"Successfully withdrew {amount} USDC from strategy")
 
         breakdown_msg = ", ".join(
             f"{amount:.6f} {symbol} on {chain.capitalize()}"
@@ -1027,12 +1027,12 @@ class StablecoinYieldStrategy(Strategy):
         logger.info(f"Withdrawal completed successfully in {elapsed_time:.2f} seconds")
         return (
             True,
-            f"Successfully withdrew {amount} USDC from vault: {breakdown_msg}",
+            f"Successfully withdrew {amount} USDC from strategy: {breakdown_msg}",
         )
 
     async def _get_last_rotation_time(self, wallet_address: str) -> datetime | None:
-        success, data = await self.ledger_adapter.get_vault_latest_transactions(
-            wallet_address=self._get_vault_wallet_address(),
+        success, data = await self.ledger_adapter.get_strategy_latest_transactions(
+            wallet_address=self._get_strategy_wallet_address(),
         )
         if success is False:
             return None
@@ -1062,7 +1062,7 @@ class StablecoinYieldStrategy(Strategy):
 
         if not self.DEPOSIT_USDC:
             logger.warning("No deposits found, cannot update strategy")
-            return [False, "Nothing has been deposited in this vault, cannot update"]
+            return [False, "Nothing has been deposited in this strategy, cannot update"]
 
         logger.info("Getting non-gas balances")
         non_gas_balances = await self._get_non_gas_balances()
@@ -1115,7 +1115,7 @@ class StablecoinYieldStrategy(Strategy):
         previous_pool = self.current_pool
 
         last_rotation = await self._get_last_rotation_time(
-            wallet_address=self._get_vault_wallet_address(),
+            wallet_address=self._get_strategy_wallet_address(),
         )
         if (
             previous_pool
@@ -1144,7 +1144,7 @@ class StablecoinYieldStrategy(Strategy):
         await self.brap_adapter.swap_from_quote(
             previous_pool,
             target_pool,
-            self._get_vault_wallet_address(),
+            self._get_strategy_wallet_address(),
             brap_quote,
             strategy_name=self.name,
         )
@@ -1192,7 +1192,7 @@ class StablecoinYieldStrategy(Strategy):
         if not pool or pool.get("chain") is None:
             return
 
-        vault_address = self._get_vault_wallet_address()
+        strategy_address = self._get_strategy_wallet_address()
         try:
             (
                 _,
@@ -1200,7 +1200,7 @@ class StablecoinYieldStrategy(Strategy):
             ) = await self.balance_adapter.get_pool_balance(
                 pool_address=pool.get("address"),
                 chain_id=pool.get("chain").get("id"),
-                user_address=vault_address,
+                user_address=strategy_address,
             )
             self.current_pool_balance = int(refreshed_pool_balance)
         except Exception:
@@ -1212,7 +1212,7 @@ class StablecoinYieldStrategy(Strategy):
             _,
             wallet_balances,
         ) = await self.balance_adapter.get_all_balances(
-            wallet_address=self._get_vault_wallet_address(),
+            wallet_address=self._get_strategy_wallet_address(),
             enrich=True,
             from_cache=False,
             add_llama=True,
@@ -1240,7 +1240,7 @@ class StablecoinYieldStrategy(Strategy):
                 success, msg = await self.brap_adapter.swap_from_token_ids(
                     token_1_id,
                     target_token_id,
-                    self._get_vault_wallet_address(),
+                    self._get_strategy_wallet_address(),
                     balance_raw,
                     strategy_name=self.name,
                 )
@@ -1253,13 +1253,13 @@ class StablecoinYieldStrategy(Strategy):
         if self.gas_token.get("chain").get("id") != target_pool.get("chain").get("id"):
             return False, "Unsupported chain for gas management."
 
-        # TODO: do we need to categorize vault wallet addresses?
-        vault_address = self._get_vault_wallet_address()
+        # TODO: do we need to categorize strategy wallet addresses?
+        strategy_address = self._get_strategy_wallet_address()
 
         required_gas = int(self.MIN_GAS * (10 ** self.gas_token.get("decimals")))
         _, current_gas = await self.balance_adapter.get_balance(
             token_id=self.gas_token.get("id"),
-            wallet_address=vault_address,
+            wallet_address=strategy_address,
         )
         if current_gas >= required_gas:
             return True, "Enough gas balance found."
@@ -1269,7 +1269,7 @@ class StablecoinYieldStrategy(Strategy):
 
         return (
             False,
-            f"Vault wallet does not have enough gas. Shortfall: {shortfall} {self.gas_token.get('symbol')}",
+            f"Strategy wallet does not have enough gas. Shortfall: {shortfall} {self.gas_token.get('symbol')}",
         )
 
     async def _has_idle_assets(self, balances, target_token) -> bool:
@@ -1311,8 +1311,8 @@ class StablecoinYieldStrategy(Strategy):
             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_vault_wallet_address(),
-            to_address=self._get_vault_wallet_address(),
+            from_address=self._get_strategy_wallet_address(),
+            to_address=self._get_strategy_wallet_address(),
             amount=str(amount),
         )
         if not success:
@@ -1334,7 +1334,7 @@ class StablecoinYieldStrategy(Strategy):
                 balance_wei,
             ) = await self.balance_adapter.get_balance(
                 token_id=self.usdc_token_info.get("token_id"),
-                wallet_address=self._get_vault_wallet_address(),
+                wallet_address=self._get_strategy_wallet_address(),
             )
             if not status or not balance_wei:
                 pass
@@ -1362,7 +1362,7 @@ class StablecoinYieldStrategy(Strategy):
                 _,
                 wallet_balances,
             ) = await self.balance_adapter.get_all_balances(
-                wallet_address=self._get_vault_wallet_address(),
+                wallet_address=self._get_strategy_wallet_address(),
                 enrich=True,
                 from_cache=False,
                 add_llama=True,
@@ -1486,8 +1486,8 @@ class StablecoinYieldStrategy(Strategy):
                 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_vault_wallet_address(),
-                to_address=self._get_vault_wallet_address(),
+                from_address=self._get_strategy_wallet_address(),
+                to_address=self._get_strategy_wallet_address(),
                 amount=str(current_token_balance),
             )
             if not success:
@@ -1557,7 +1557,7 @@ class StablecoinYieldStrategy(Strategy):
             )
             total_value = self._sum_non_gas_balance_usd(wallet_balances.get("balances"))
             status_payload = {
-                "info": "No recorded vault deposits; reporting current wallet holdings only.",
+                "info": "No recorded strategy deposits; reporting current wallet holdings only.",
                 "idle_usd": total_value,
             }
 
@@ -1570,7 +1570,7 @@ class StablecoinYieldStrategy(Strategy):
             _,
             wallet_balances,
         ) = await self.balance_adapter.get_all_balances(
-            wallet_address=self._get_vault_wallet_address(),
+            wallet_address=self._get_strategy_wallet_address(),
             enrich=True,
             from_cache=False,
             add_llama=True,
@@ -1615,14 +1615,14 @@ class StablecoinYieldStrategy(Strategy):
             _,
             wallet_balances,
         ) = await self.balance_adapter.get_all_balances(
-            wallet_address=self._get_vault_wallet_address(),
+            wallet_address=self._get_strategy_wallet_address(),
             enrich=True,
             from_cache=False,
             add_llama=True,
         )
         _, total_usdc_wei = await self.balance_adapter.get_balance(
             token_id=self.usdc_token_info.get("token_id"),
-            wallet_address=self._get_vault_wallet_address(),
+            wallet_address=self._get_strategy_wallet_address(),
         )
         available_usdc_usd = float(total_usdc_wei or 0) / (
             10 ** self.usdc_token_info.get("decimals")
@@ -1645,7 +1645,7 @@ class StablecoinYieldStrategy(Strategy):
                 balance_wei,
             ) = await self.balance_adapter.get_balance(
                 token_id=token_id,
-                wallet_address=self._get_vault_wallet_address(),
+                wallet_address=self._get_strategy_wallet_address(),
             )
             if not balance_status or not balance_wei:
                 continue
@@ -1666,7 +1666,7 @@ class StablecoinYieldStrategy(Strategy):
                     await self.brap_adapter.swap_from_token_ids(
                         token_1_id,
                         f"{self.usdc_token_info.get('chain').get('name')}_{self.usdc_token_info.get('address').lower()}",
-                        self._get_vault_wallet_address(),
+                        self._get_strategy_wallet_address(),
                         amount_to_swap,
                         strategy_name=self.name,
                     )
@@ -1677,7 +1677,7 @@ class StablecoinYieldStrategy(Strategy):
 
         _, total_usdc_wei = await self.balance_adapter.get_balance(
             token_id=self.usdc_token_info.get("token_id"),
-            wallet_address=self._get_vault_wallet_address(),
+            wallet_address=self._get_strategy_wallet_address(),
         )
         usdc_decimals = self.usdc_token_info.get("decimals")
         available_usdc_usd = float(total_usdc_wei or 0) / (10**usdc_decimals)
@@ -1695,7 +1695,7 @@ class StablecoinYieldStrategy(Strategy):
             ) = await self.balance_adapter.get_pool_balance(
                 pool_address=self.current_pool.get("address"),
                 chain_id=self.current_pool.get("chain").get("id"),
-                user_address=self._get_vault_wallet_address(),
+                user_address=self._get_strategy_wallet_address(),
             )
             pool_decimals = self.current_pool.get("decimals")
             amount_to_swap = min(
@@ -1706,7 +1706,7 @@ class StablecoinYieldStrategy(Strategy):
                 await self.brap_adapter.swap_from_token_ids(
                     f"{self.current_pool.get('chain').get('code').lower()}_{self.current_pool.get('address').lower()}",
                     f"{self.usdc_token_info.get('chain').get('name')}_{self.usdc_token_info.get('address').lower()}",
-                    self._get_vault_wallet_address(),
+                    self._get_strategy_wallet_address(),
                     amount_to_swap,
                     strategy_name=self.name,
                 )
@@ -1715,7 +1715,7 @@ class StablecoinYieldStrategy(Strategy):
 
             _, total_usdc_wei = await self.balance_adapter.get_balance(
                 token_id=self.usdc_token_info.get("token_id"),
-                wallet_address=self._get_vault_wallet_address(),
+                wallet_address=self._get_strategy_wallet_address(),
             )
         to_pay = min(int(total_usdc_wei or 0), int(usd_value * (10**usdc_decimals)))
         return (True, f"Partial liquidation completed. Paid {to_pay} USDC")

wayfinder_paths/{vaults/strategies → strategies}/stablecoin_yield_strategy/test_strategy.py

@@ -4,7 +4,7 @@ from unittest.mock import AsyncMock
 
 # Ensure wayfinder-paths is on path for tests.test_utils import
 # This is a workaround until conftest loading order is resolved
-_wayfinder_path_dir = Path(__file__).parent.parent.parent.parent.resolve()
+_wayfinder_path_dir = Path(__file__).parent.parent.parent.resolve()
 _wayfinder_path_str = str(_wayfinder_path_dir)
 if _wayfinder_path_str not in sys.path:
     sys.path.insert(0, _wayfinder_path_str)
@@ -29,7 +29,7 @@ except ImportError:
     get_canonical_examples = test_utils.get_canonical_examples
     load_strategy_examples = test_utils.load_strategy_examples
 
-from wayfinder_paths.vaults.strategies.stablecoin_yield_strategy.strategy import (  # noqa: E402
+from wayfinder_paths.strategies.stablecoin_yield_strategy.strategy import (  # noqa: E402
     StablecoinYieldStrategy,
 )
 
@@ -39,13 +39,13 @@ def strategy():
     """Create a strategy instance for testing with minimal config."""
     mock_config = {
         "main_wallet": {"address": "0x1234567890123456789012345678901234567890"},
-        "vault_wallet": {"address": "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"},
+        "strategy_wallet": {"address": "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"},
     }
 
     s = StablecoinYieldStrategy(
         config=mock_config,
         main_wallet=mock_config["main_wallet"],
-        vault_wallet=mock_config["vault_wallet"],
+        strategy_wallet=mock_config["strategy_wallet"],
         simulation=True,
     )
 
@@ -110,10 +110,10 @@ def strategy():
         )
 
     if hasattr(s, "balance_adapter") and s.balance_adapter:
-        s.balance_adapter.move_from_main_wallet_to_vault_wallet = AsyncMock(
+        s.balance_adapter.move_from_main_wallet_to_strategy_wallet = AsyncMock(
             return_value=(True, "Transfer successful (simulated)")
         )
-        s.balance_adapter.move_from_vault_wallet_to_main_wallet = AsyncMock(
+        s.balance_adapter.move_from_strategy_wallet_to_main_wallet = AsyncMock(
             return_value=(True, "Transfer successful (simulated)")
         )
         if hasattr(s.balance_adapter, "wallet_provider"):
@@ -122,10 +122,10 @@ def strategy():
             )
 
     if hasattr(s, "ledger_adapter") and s.ledger_adapter:
-        s.ledger_adapter.get_vault_net_deposit = AsyncMock(
+        s.ledger_adapter.get_strategy_net_deposit = AsyncMock(
             return_value=(True, {"net_deposit": 0})
         )
-        s.ledger_adapter.get_vault_transactions = AsyncMock(
+        s.ledger_adapter.get_strategy_transactions = AsyncMock(
             return_value=(True, {"transactions": []})
         )