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

wayfinder_paths/core/strategies/Strategy.py

@@ -57,12 +57,10 @@ class Strategy(ABC):
         main_wallet: WalletConfig | dict[str, Any] | None = None,
         strategy_wallet: WalletConfig | dict[str, Any] | None = None,
         web3_service: Web3Service | None = None,
-        api_key: str | None = None,
     ):
         self.adapters = {}
         self.ledger_adapter = None
         self.logger = logger.bind(strategy=self.__class__.__name__)
-        # Note: api_key is passed to ClientManager, not set in environment
         self.config = config
 
     async def setup(self) -> None:
@@ -145,8 +143,22 @@ class Strategy(ABC):
     @abstractmethod
     async def update(self) -> StatusTuple:
         """
-        Update strategy positions/rebalance
-        Returns: (success: bool, message: str)
+        Deploy funds to protocols (no main wallet access).
+        Called after deposit() has transferred assets to strategy wallet.
+
+        Returns:
+            Tuple of (success: bool, message: str)
+        """
+        pass
+
+    @abstractmethod
+    async def exit(self, **kwargs) -> StatusTuple:
+        """
+        Transfer funds from strategy wallet to main wallet.
+        Called after withdraw() has liquidated all positions.
+
+        Returns:
+            Tuple of (success: bool, message: str)
         """
         pass
 

wayfinder_paths/core/utils/evm_helpers.py

@@ -7,7 +7,6 @@ across multiple adapters, extracted from evm_transaction_adapter.
 
 import json
 import os
-from pathlib import Path
 from typing import Any
 
 from loguru import logger
@@ -43,12 +42,12 @@ def resolve_chain_id(token_info: dict[str, Any], logger_instance=None) -> int |
     """
     log = logger_instance or logger
     chain_meta = token_info.get("chain") or {}
-    chain_id = chain_meta.get("chain_id")
+    chain_id = chain_meta.get("id")
     try:
         if chain_id is not None:
             return int(chain_id)
     except (ValueError, TypeError):
-        log.debug("Invalid chain_id in token_info.chain_id: %s", chain_id)
+        log.debug("Invalid chain_id in token_info.chain: %s", chain_id)
     return chain_code_to_chain_id(chain_meta.get("code"))
 
 
@@ -170,9 +169,3 @@ async def get_abi_filtered(
         if item.get("type") == "function" and item.get("name") in function_names
     ]
     return filtered_abi
-
-
-with open(Path(__file__).parent.parent.parent.joinpath("abis/generic/erc20.json")) as f:
-    erc20_abi_raw = f.read()
-
-ERC20_ABI = json.loads(erc20_abi_raw)

wayfinder_paths/policies/erc20.py

@@ -1,4 +1,4 @@
-from wayfinder_paths.core.utils.evm_helpers import ERC20_ABI
+from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
 
 
 def any_erc20_function(token_address: str) -> dict:

wayfinder_paths/run_strategy.py

@@ -20,7 +20,6 @@ def load_strategy(
     strategy_name: str,
     *,
     strategy_config: dict | None = None,
-    api_key: str | None = None,
 ):
     """
     Dynamically load a strategy by name
@@ -28,7 +27,6 @@ def load_strategy(
     Args:
         strategy_name: Name of the strategy to load (directory name in strategies/)
         strategy_config: Configuration dict for the strategy
-        api_key: Optional API key for service account authentication
 
     Returns:
         Strategy instance
@@ -70,7 +68,7 @@ def load_strategy(
     if strategy_class is None:
         raise ValueError(f"No Strategy class found in {module_path}")
 
-    return strategy_class(config=strategy_config, api_key=api_key)
+    return strategy_class(config=strategy_config)
 
 
 def load_config(
@@ -135,18 +133,15 @@ async def run_strategy(
         # Load configuration with strategy name for wallet lookup
         logger.debug(f"Config path provided: {config_path}")
         config = load_config(config_path, strategy_name=strategy_name)
-        creds = (
-            "yes"
-            if (config.user.username and config.user.password)
-            or config.user.refresh_token
-            else "no"
-        )
-        main_wallet = config.user.main_wallet_address or "none"
-        strategy_wallet = config.user.strategy_wallet_address or "none"
         logger.debug(
-            f"Loaded config: creds={creds} wallets(main={main_wallet} strategy={strategy_wallet})"
+            "Loaded config: wallets(main={} strategy={})",
+            config.user.main_wallet_address or "none",
+            config.user.strategy_wallet_address or "none",
         )
 
+        # Validate required configuration
+        # Authentication is via system.api_key in config.json
+
         # Load strategy with the enriched config
         strategy = load_strategy(
             strategy_name,
@@ -159,13 +154,7 @@ async def run_strategy(
 
         # Setup strategy job
         logger.info("Setting up strategy job...")
-        auth_mode = (
-            "credentials"
-            if (config.user.username and config.user.password)
-            or config.user.refresh_token
-            else "missing"
-        )
-        logger.debug(f"Auth mode: {auth_mode}")
+        logger.debug("Auth mode: API key (from system.api_key)")
         await strategy_job.setup()
 
         # Execute action
@@ -208,6 +197,10 @@ async def run_strategy(
             result = await strategy_job.execute_strategy("update")
             logger.info(f"Update result: {result}")
 
+        elif action == "exit":
+            result = await strategy_job.execute_strategy("exit")
+            logger.info(f"Exit result: {result}")
+
         elif action == "partial-liquidate":
             usd_value = kwargs.get("amount")
             if not usd_value:
@@ -303,6 +296,7 @@ def main():
             "withdraw",
             "status",
             "update",
+            "exit",
             "policy",
             "script",
             "partial-liquidate",

wayfinder_paths/strategies/basis_trading_strategy/strategy.py

@@ -203,9 +203,8 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         strategy_wallet: dict[str, Any] | None = None,
         web3_service: Web3Service | None = None,
         hyperliquid_executor: HyperliquidExecutor | None = None,
-        api_key: str | None = None,
     ) -> None:
-        super().__init__(api_key=api_key)
+        super().__init__()
 
         merged_config = dict(config or {})
         if main_wallet:
@@ -479,7 +478,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 gas_ok,
                 gas_res,
             ) = await self.balance_adapter.move_from_main_wallet_to_strategy_wallet(
-                token_id="ethereum-arbitrum",  # Native ETH on Arbitrum
+                query="ethereum-arbitrum",  # Native ETH on Arbitrum
                 amount=gas_token_amount,
                 strategy_name=self.name or "basis_trading_strategy",
                 skip_ledger=True,
@@ -500,7 +499,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 strategy_balance_ok,
                 strategy_balance,
             ) = await self.balance_adapter.get_balance(
-                token_id=USDC_ARBITRUM_TOKEN_ID,
+                query=USDC_ARBITRUM_TOKEN_ID,
                 wallet_address=strategy_address,
             )
             strategy_usdc = 0.0
@@ -518,7 +517,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     move_ok,
                     move_res,
                 ) = await self.balance_adapter.move_from_main_wallet_to_strategy_wallet(
-                    token_id=USDC_ARBITRUM_TOKEN_ID,
+                    query=USDC_ARBITRUM_TOKEN_ID,
                     amount=need_to_move,
                     strategy_name=self.name or "basis_trading_strategy",
                     skip_ledger=True,
@@ -543,7 +542,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
             # Send USDC to bridge address (deposit credits the sender address on Hyperliquid)
             success, result = await self.balance_adapter.send_to_address(
-                token_id=USDC_ARBITRUM_TOKEN_ID,
+                query=USDC_ARBITRUM_TOKEN_ID,
                 amount=main_token_amount,
                 from_wallet=strategy_wallet,
                 to_address=HYPERLIQUID_BRIDGE_ADDRESS,
@@ -821,7 +820,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         strategy_usdc = 0.0
         try:
             success, balance_data = await self.balance_adapter.get_balance(
-                token_id=usdc_token_id,
+                query=usdc_token_id,
                 wallet_address=address,
             )
             if success:
@@ -866,7 +865,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     send_success,
                     send_result,
                 ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                    token_id=usdc_token_id,
+                    query=usdc_token_id,
                     amount=amount_to_send,
                     strategy_name=self.name,
                     skip_ledger=False,
@@ -1011,7 +1010,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         final_balance = 0.0
         try:
             success, balance_data = await self.balance_adapter.get_balance(
-                token_id=usdc_token_id,
+                query=usdc_token_id,
                 wallet_address=address,
             )
             if success:
@@ -1032,7 +1031,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     send_success,
                     send_result,
                 ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                    token_id=usdc_token_id,
+                    query=usdc_token_id,
                     amount=amount_to_send,
                     strategy_name=self.name,
                     skip_ledger=False,  # Record in ledger
@@ -1073,6 +1072,73 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             f"Withdrew ${total_withdrawn:.2f} total to main wallet ({main_address}).",
         )
 
+    async def exit(self, **kwargs) -> StatusTuple:
+        """Transfer funds from strategy wallet to main wallet."""
+        self.logger.info("EXIT: Transferring remaining funds to main wallet")
+
+        strategy_address = self._get_strategy_wallet_address()
+        main_address = self._get_main_wallet_address()
+
+        if strategy_address.lower() == main_address.lower():
+            return (True, "Main wallet is strategy wallet, no transfer needed")
+
+        transferred_items = []
+
+        # Transfer USDC to main wallet
+        usdc_ok, usdc_raw = await self.balance_adapter.get_balance(
+            token_id=USDC_ARBITRUM_TOKEN_ID,
+            wallet_address=strategy_address,
+        )
+        if usdc_ok and usdc_raw:
+            usdc_balance = float(usdc_raw.get("balance", 0))
+            if usdc_balance > 1.0:
+                self.logger.info(f"Transferring {usdc_balance:.2f} USDC to main wallet")
+                (
+                    success,
+                    msg,
+                ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
+                    query=USDC_ARBITRUM_TOKEN_ID,
+                    amount=usdc_balance,
+                    strategy_name=self.name,
+                    skip_ledger=False,
+                )
+                if success:
+                    transferred_items.append(f"{usdc_balance:.2f} USDC")
+                else:
+                    self.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-arbitrum",
+            wallet_address=strategy_address,
+        )
+        if eth_ok and eth_raw:
+            eth_balance = float(eth_raw.get("balance", 0))
+            tx_fee_reserve = 0.0002
+            transferable_eth = eth_balance - tx_fee_reserve
+            if transferable_eth > 0.0001:
+                self.logger.info(
+                    f"Transferring {transferable_eth:.6f} ETH to main wallet"
+                )
+                (
+                    success,
+                    msg,
+                ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
+                    query="ethereum-arbitrum",
+                    amount=transferable_eth,
+                    strategy_name=self.name,
+                    skip_ledger=False,
+                )
+                if success:
+                    transferred_items.append(f"{transferable_eth:.6f} ETH")
+                else:
+                    self.logger.warning(f"ETH transfer failed: {msg}")
+
+        if not transferred_items:
+            return (True, "No funds to transfer to main wallet")
+
+        return (True, f"Transferred to main wallet: {', '.join(transferred_items)}")
+
     async def _status(self) -> StatusDict:
         """Return portfolio value and strategy status with live data."""
         total_value, hl_value, vault_value = await self._get_total_portfolio_value()
@@ -2569,7 +2635,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         try:
             strategy_address = self._get_strategy_wallet_address()
             success, balance = await self.balance_adapter.get_balance(
-                token_id=USDC_ARBITRUM_TOKEN_ID,
+                query=USDC_ARBITRUM_TOKEN_ID,
                 wallet_address=strategy_address,
             )
             if success and balance:

wayfinder_paths/strategies/basis_trading_strategy/test_strategy.py

@@ -461,7 +461,7 @@ class TestBasisTradingStrategy:
         # Try to scale with $5 (below $10 minimum notional)
         # With 2x leverage, order_usd = 5 * (2/3) = 3.33, below $10
         success, msg = await strategy._scale_up_position(5.0)
-        assert success is True  # Returns success=True but with message
+        assert success  # Returns success=True but with message
         assert "below minimum notional" in msg
 
     @pytest.mark.asyncio
@@ -563,7 +563,7 @@ class TestBasisTradingStrategy:
 
             # Should have called fill_pair_units to scale up
             assert mock_filler.fill_pair_units.called
-            assert success is True
+            assert success
 
     @pytest.mark.asyncio
     async def test_ensure_builder_fee_approved_already_approved(
@@ -612,7 +612,7 @@ class TestBasisTradingStrategy:
                             )
 
                             success, msg = await s.ensure_builder_fee_approved()
-                            assert success is True
+                            assert success
                             assert "already approved" in msg.lower()
                             # Should not have called approve_builder_fee
                             mock_hyperliquid_adapter.approve_builder_fee.assert_not_called()
@@ -661,7 +661,7 @@ class TestBasisTradingStrategy:
                             )
 
                             success, msg = await s.ensure_builder_fee_approved()
-                            assert success is True
+                            assert success
                             assert "approved" in msg.lower()
                             # Should have called approve_builder_fee
                             mock_hyperliquid_adapter.approve_builder_fee.assert_called_once()
@@ -832,7 +832,7 @@ class TestBasisTradingStrategy:
             mock_filler_class.return_value = mock_filler
 
             success, _ = await strategy.update()
-            assert success is True
+            assert success
 
         # Target spot was $66.67, so we should transfer $33.33 spot->perp.
         mock_hyperliquid_adapter.transfer_spot_to_perp.assert_called_once()
@@ -907,7 +907,7 @@ class TestBasisTradingStrategy:
         strategy._find_and_open_position = AsyncMock(return_value=(True, "redeployed"))
 
         success, msg = await strategy.update()
-        assert success is True
+        assert success
         assert msg == "redeployed"
         strategy._close_position.assert_awaited_once()
         strategy._find_and_open_position.assert_awaited_once()

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/strategy.py

@@ -197,9 +197,8 @@ class HyperlendStableYieldStrategy(Strategy):
         main_wallet: dict[str, Any] | None = None,
         strategy_wallet: dict[str, Any] | None = None,
         web3_service: Web3Service = None,
-        api_key: str | None = None,
     ):
-        super().__init__(api_key=api_key)
+        super().__init__()
         merged_config: dict[str, Any] = dict(config or {})
         if main_wallet is not None:
             merged_config["main_wallet"] = main_wallet
@@ -350,7 +349,7 @@ class HyperlendStableYieldStrategy(Strategy):
             success,
             main_usdt0_balance,
         ) = await self.balance_adapter.get_balance(
-            token_id=self.usdt_token_info.get("token_id"),
+            query=self.usdt_token_info.get("token_id"),
             wallet_address=self._get_main_wallet_address(),
         )
         if not success:
@@ -363,7 +362,7 @@ class HyperlendStableYieldStrategy(Strategy):
             success,
             main_hype_balance,
         ) = await self.balance_adapter.get_balance(
-            token_id=self.hype_token_info.get("token_id"),
+            query=self.hype_token_info.get("token_id"),
             wallet_address=self._get_main_wallet_address(),
         )
         if not success:
@@ -530,11 +529,10 @@ class HyperlendStableYieldStrategy(Strategy):
                 return self._assets_snapshot
 
             _, snapshot = await self.hyperlend_adapter.get_assets_view(
-                chain_id=self.hype_token_info.get("chain").get("id"),
                 user_address=self._get_strategy_wallet_address(),
             )
 
-            assets = snapshot.get("assets_view", {}).get("assets", [])
+            assets = snapshot.get("assets", [])
             asset_map = {}
 
             for asset in assets:
@@ -582,11 +580,9 @@ class HyperlendStableYieldStrategy(Strategy):
 
         try:
             _, data = await self.hyperlend_adapter.get_stable_markets(
-                chain_id=self.hype_token_info.get("chain").get("id"),
                 required_underlying_tokens=required_tokens,
                 buffer_bps=self.SUPPLY_CAP_BUFFER_BPS,
                 min_buffer_tokens=self.SUPPLY_CAP_MIN_BUFFER_TOKENS,
-                is_stable_symbol=True,
             )
             markets = data.get("markets", {}) if isinstance(data, dict) else {}
         except Exception:
@@ -609,7 +605,7 @@ class HyperlendStableYieldStrategy(Strategy):
     async def _get_lent_positions(self, snapshot=None) -> dict[str, dict[str, Any]]:
         if not snapshot:
             snapshot = await self._get_assets_snapshot()
-        assets = snapshot.get("assets_view", {}).get("assets", None)
+        assets = snapshot.get("assets", None)
 
         if not assets:
             return {}
@@ -630,7 +626,14 @@ class HyperlendStableYieldStrategy(Strategy):
                 continue
 
             try:
-                success, token = await self.token_adapter.get_token(checksum)
+                chain_id = None
+                try:
+                    chain_id = int((self.hype_token_info.get("chain") or {}).get("id"))
+                except Exception:
+                    chain_id = None
+                success, token = await self.token_adapter.get_token(
+                    checksum, chain_id=chain_id
+                )
                 if not success or not isinstance(token, dict):
                     logger.info(f"Error getting token for asset: {asset}")
                     continue
@@ -862,7 +865,7 @@ class HyperlendStableYieldStrategy(Strategy):
 
         try:
             _, total_usdt_wei = await self.balance_adapter.get_balance(
-                token_id=self.usdt_token_info.get("token_id"),
+                query=self.usdt_token_info.get("token_id"),
                 wallet_address=self._get_strategy_wallet_address(),
             )
         except Exception:
@@ -891,7 +894,7 @@ class HyperlendStableYieldStrategy(Strategy):
 
         try:
             _, total_hype_wei = await self.balance_adapter.get_balance(
-                token_id=self.hype_token_info.get("token_id"),
+                query=self.hype_token_info.get("token_id"),
                 wallet_address=self._get_strategy_wallet_address(),
             )
         except Exception:
@@ -932,6 +935,75 @@ class HyperlendStableYieldStrategy(Strategy):
 
         return (True, ". ".join(messages))
 
+    async def exit(self, **kwargs) -> StatusTuple:
+        """Transfer funds from strategy wallet to main wallet."""
+        self.logger.info("EXIT: Transferring remaining funds to main wallet")
+
+        strategy_address = self._get_strategy_wallet_address()
+        main_address = self._get_main_wallet_address()
+
+        if strategy_address.lower() == main_address.lower():
+            return (True, "Main wallet is strategy wallet, no transfer needed")
+
+        transferred_items = []
+
+        # Transfer USDT0 to main wallet
+        usdt_ok, usdt_raw = await self.balance_adapter.get_balance(
+            token_id="usdt0-hyperevm",
+            wallet_address=strategy_address,
+        )
+        if usdt_ok and usdt_raw:
+            usdt_balance = float(usdt_raw.get("balance", 0))
+            if usdt_balance > 1.0:
+                self.logger.info(
+                    f"Transferring {usdt_balance:.2f} USDT0 to main wallet"
+                )
+                (
+                    success,
+                    msg,
+                ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
+                    query="usdt0-hyperevm",
+                    amount=usdt_balance,
+                    strategy_name=self.name,
+                    skip_ledger=False,
+                )
+                if success:
+                    transferred_items.append(f"{usdt_balance:.2f} USDT0")
+                else:
+                    self.logger.warning(f"USDT0 transfer failed: {msg}")
+
+        # Transfer HYPE (minus reserve for tx fees) to main wallet
+        hype_ok, hype_raw = await self.balance_adapter.get_balance(
+            token_id="hyperliquid-hyperevm",
+            wallet_address=strategy_address,
+        )
+        if hype_ok and hype_raw:
+            hype_balance = float(hype_raw.get("balance", 0))
+            tx_fee_reserve = 0.1  # Reserve 0.1 HYPE for tx fees
+            transferable_hype = hype_balance - tx_fee_reserve
+            if transferable_hype > 0.01:
+                self.logger.info(
+                    f"Transferring {transferable_hype:.4f} HYPE to main wallet"
+                )
+                (
+                    success,
+                    msg,
+                ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
+                    query="hyperliquid-hyperevm",
+                    amount=transferable_hype,
+                    strategy_name=self.name,
+                    skip_ledger=False,
+                )
+                if success:
+                    transferred_items.append(f"{transferable_hype:.4f} HYPE")
+                else:
+                    self.logger.warning(f"HYPE transfer failed: {msg}")
+
+        if not transferred_items:
+            return (True, "No funds to transfer to main wallet")
+
+        return (True, f"Transferred to main wallet: {', '.join(transferred_items)}")
+
     async def _swap_residual_balances_to_token(
         self, token_info: dict[str, Any], include_native: bool = False
     ) -> list[str]:
@@ -987,7 +1059,7 @@ class HyperlendStableYieldStrategy(Strategy):
                     success,
                     message,
                 ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                    token_id=token_info.get("token_id"),
+                    query=token_info.get("token_id"),
                     amount=amount_tokens,
                     strategy_name=self.name,
                 )
@@ -1549,11 +1621,9 @@ class HyperlendStableYieldStrategy(Strategy):
         )
 
         _, stable_markets = await self.hyperlend_adapter.get_stable_markets(
-            chain_id=self.hype_token_info.get("chain").get("id"),
             required_underlying_tokens=required_underlying_tokens,
             buffer_bps=self.SUPPLY_CAP_BUFFER_BPS,
             min_buffer_tokens=self.SUPPLY_CAP_MIN_BUFFER_TOKENS,
-            is_stable_symbol=True,
         )
         filtered_notes = stable_markets.get("notes", [])
         filtered_map = stable_markets.get("markets", {})
@@ -1585,8 +1655,7 @@ class HyperlendStableYieldStrategy(Strategy):
             if current_checksum_lower not in existing_addresses:
                 try:
                     _, current_entry = await self.hyperlend_adapter.get_market_entry(
-                        chain_id=self.hype_token_info.get("chain").get("id"),
-                        token_address=current_checksum_value,
+                        token=current_checksum_value,
                     )
                 except Exception:
                     current_entry = None
@@ -1633,8 +1702,7 @@ class HyperlendStableYieldStrategy(Strategy):
         histories = await asyncio.gather(
             *[
                 self.hyperlend_adapter.get_lend_rate_history(
-                    chain_id=self.hype_token_info.get("chain").get("id"),
-                    token_address=addr,
+                    token=addr,
                     lookback_hours=lookback_hours,
                 )
                 for addr, _ in filtered
@@ -1656,7 +1724,7 @@ class HyperlendStableYieldStrategy(Strategy):
             if not history_status:
                 continue
             history_data = history[1]
-            for row in history_data.get("rate_history", []):
+            for row in history_data.get("history", []):
                 ts_ms = row.get("timestamp_ms")
                 if ts_ms is None:
                     continue
@@ -1812,7 +1880,14 @@ class HyperlendStableYieldStrategy(Strategy):
         token = None
         if address:
             try:
-                success, token = await self.token_adapter.get_token(address.lower())
+                chain_id = None
+                try:
+                    chain_id = int((self.hype_token_info.get("chain") or {}).get("id"))
+                except Exception:
+                    chain_id = None
+                success, token = await self.token_adapter.get_token(
+                    address.lower(), chain_id=chain_id
+                )
             except Exception:
                 token = None
             if not success:
@@ -2128,7 +2203,16 @@ class HyperlendStableYieldStrategy(Strategy):
                     continue
 
                 try:
-                    success, token = await self.token_adapter.get_token(checksum)
+                    chain_id = None
+                    try:
+                        chain_id = int(
+                            (self.hype_token_info.get("chain") or {}).get("id")
+                        )
+                    except Exception:
+                        chain_id = None
+                    success, token = await self.token_adapter.get_token(
+                        checksum, chain_id=chain_id
+                    )
                     if not success or not isinstance(token, dict):
                         continue
                 except Exception:
@@ -2239,7 +2323,7 @@ class HyperlendStableYieldStrategy(Strategy):
             success,
             strategy_hype_balance_wei,
         ) = await self.balance_adapter.get_balance(
-            token_id=self.hype_token_info.get("token_id"),
+            query=self.hype_token_info.get("token_id"),
             wallet_address=self._get_strategy_wallet_address(),
         )
         hype_price = asset_map.get(WRAPPED_HYPE_ADDRESS, {}).get("price_usd") or 0.0