wayfinder-paths 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

wayfinder_paths/strategies/basis_trading_strategy/test_strategy.py

@@ -119,12 +119,32 @@ class TestBasisTradingStrategy:
             return_value=(
                 True,
                 {
-                    "marginSummary": {"accountValue": "0", "withdrawable": "0"},
+                    "marginSummary": {"accountValue": "0"},
+                    "withdrawable": "100.0",  # Top-level withdrawable for withdraw() method
                     "assetPositions": [],
                 },
             )
         )
         mock.get_spot_user_state = AsyncMock(return_value=(True, {"balances": []}))
+        mock.get_max_builder_fee = AsyncMock(return_value=(True, 0))
+        mock.approve_builder_fee = AsyncMock(return_value=(True, {"status": "ok"}))
+        mock.update_leverage = AsyncMock(return_value=(True, {"status": "ok"}))
+        mock.transfer_perp_to_spot = AsyncMock(return_value=(True, {"status": "ok"}))
+        mock.transfer_spot_to_perp = AsyncMock(return_value=(True, {"status": "ok"}))
+        mock.place_market_order = AsyncMock(return_value=(True, {"status": "ok"}))
+        mock.place_limit_order = AsyncMock(return_value=(True, {"status": "ok"}))
+        mock.place_stop_loss = AsyncMock(return_value=(True, {"status": "ok"}))
+        mock.cancel_order = AsyncMock(return_value=(True, {"status": "ok"}))
+        mock.withdraw = AsyncMock(return_value=(True, {"status": "ok"}))
+        mock.get_open_orders = AsyncMock(return_value=(True, []))
+        mock.get_frontend_open_orders = AsyncMock(return_value=(True, []))
+        mock.get_valid_order_size = MagicMock(side_effect=lambda _asset, size: size)
+        mock.wait_for_deposit = AsyncMock(
+            return_value=(True, 100.0)  # (deposit_confirmed, final_balance)
+        )
+        mock.wait_for_withdrawal = AsyncMock(
+            return_value=(True, {"0x123456": 100.0})  # tx_hash -> amount (float)
+        )
         return mock
 
     @pytest.fixture
@@ -162,7 +182,6 @@ class TestBasisTradingStrategy:
                                     "main_wallet": {"address": "0x1234"},
                                     "strategy_wallet": {"address": "0x5678"},
                                 },
-                                simulation=True,
                             )
                             s.hyperliquid_adapter = mock_hyperliquid_adapter
                             s.ledger_adapter = ledger_adapter
@@ -173,9 +192,45 @@ class TestBasisTradingStrategy:
                             s.balance_adapter.move_from_main_wallet_to_strategy_wallet = AsyncMock(
                                 return_value=(True, {})
                             )
+                            s.balance_adapter.move_from_strategy_wallet_to_main_wallet = AsyncMock(
+                                return_value=(True, {})
+                            )
                             s.balance_adapter.send_to_address = AsyncMock(
                                 return_value=(True, {"tx_hash": "0x123"})
                             )
+                            # Mock internal dependencies to prevent MagicMock await errors
+                            # These are needed if the real method somehow gets called
+                            s.balance_adapter.token_client = AsyncMock()
+                            s.balance_adapter.token_client.get_token_details = (
+                                AsyncMock(
+                                    return_value={
+                                        "id": "usdc",
+                                        "address": "0x1234",
+                                        "decimals": 6,
+                                    }
+                                )
+                            )
+                            s.balance_adapter.token_transactions = AsyncMock()
+                            s.balance_adapter.token_transactions.build_send = AsyncMock(
+                                return_value=(True, {"transaction": "0xMOCK"})
+                            )
+                            s.balance_adapter.wallet_provider = AsyncMock()
+                            s.balance_adapter.wallet_provider.broadcast_transaction = (
+                                AsyncMock(
+                                    return_value=(True, {"transaction_hash": "0x123"})
+                                )
+                            )
+                            s.balance_adapter.token_adapter = AsyncMock()
+                            s.balance_adapter.token_adapter.get_token_price = AsyncMock(
+                                return_value=(True, {"current_price": 1.0})
+                            )
+                            # ledger_adapter is real, but ensure its methods are async-mockable
+                            s.balance_adapter.ledger_adapter = ledger_adapter
+                            # Also ensure the balance_adapter's _move_between_wallets won't call real methods
+                            # by making sure all its dependencies return AsyncMock
+                            s.balance_adapter._move_between_wallets = AsyncMock(
+                                return_value=(True, {"transaction_hash": "0x123"})
+                            )
                             return s
 
     @pytest.mark.asyncio
@@ -185,22 +240,32 @@ class TestBasisTradingStrategy:
         examples = load_examples()
         smoke = examples["smoke"]
 
-        # Deposit
-        deposit_params = smoke.get("deposit", {})
-        success, msg = await strategy.deposit(**deposit_params)
-        assert success, f"Deposit failed: {msg}"
+        # Mock PairedFiller for update() and withdraw() to work
+        with patch(
+            "wayfinder_paths.strategies.basis_trading_strategy.strategy.PairedFiller"
+        ) as mock_filler_class:
+            mock_filler = MagicMock()
+            mock_filler.fill_pair_units = AsyncMock(
+                return_value=(0.5, 0.5, 1000.0, 1000.0, [], [])
+            )
+            mock_filler_class.return_value = mock_filler
+
+            # Deposit
+            deposit_params = smoke.get("deposit", {})
+            success, msg = await strategy.deposit(**deposit_params)
+            assert success, f"Deposit failed: {msg}"
 
-        # Update
-        success, msg = await strategy.update()
-        assert success, f"Update failed: {msg}"
+            # Update
+            success, msg = await strategy.update()
+            assert success, f"Update failed: {msg}"
 
-        # Status
-        status = await strategy.status()
-        assert "portfolio_value" in status
+            # Status
+            status = await strategy.status()
+            assert "portfolio_value" in status
 
-        # Withdraw
-        success, msg = await strategy.withdraw()
-        assert success, f"Withdraw failed: {msg}"
+            # Withdraw (needs PairedFiller mock for _close_position)
+            success, msg = await strategy.withdraw()
+            assert success, f"Withdraw failed: {msg}"
 
     @pytest.mark.asyncio
     async def test_deposit_minimum(self, strategy):
@@ -311,8 +376,23 @@ class TestBasisTradingStrategy:
         assert opps[0]["selection"]["net_apy"] is not None
 
     @pytest.mark.asyncio
-    async def test_get_undeployed_capital_empty(self, strategy):
+    async def test_get_undeployed_capital_empty(
+        self, strategy, mock_hyperliquid_adapter
+    ):
         """Test _get_undeployed_capital with no capital."""
+        mock_hyperliquid_adapter.get_user_state = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "marginSummary": {"accountValue": "0", "withdrawable": "0"},
+                    "withdrawable": "0",
+                    "assetPositions": [],
+                },
+            )
+        )
+        mock_hyperliquid_adapter.get_spot_user_state = AsyncMock(
+            return_value=(True, {"balances": []})
+        )
         perp_margin, spot_usdc = await strategy._get_undeployed_capital()
         assert perp_margin == 0.0
         assert spot_usdc == 0.0
@@ -508,7 +588,6 @@ class TestBasisTradingStrategy:
                                     "main_wallet": {"address": "0x1234"},
                                     "strategy_wallet": {"address": "0x5678"},
                                 },
-                                simulation=False,  # Not simulation mode
                             )
                             s.hyperliquid_adapter = mock_hyperliquid_adapter
                             s.ledger_adapter = ledger_adapter
@@ -561,7 +640,6 @@ class TestBasisTradingStrategy:
                                     "main_wallet": {"address": "0x1234"},
                                     "strategy_wallet": {"address": "0x5678"},
                                 },
-                                simulation=False,  # Not simulation mode
                             )
                             s.hyperliquid_adapter = mock_hyperliquid_adapter
                             s.ledger_adapter = ledger_adapter
@@ -580,46 +658,6 @@ class TestBasisTradingStrategy:
                             # Should have called approve_builder_fee
                             mock_hyperliquid_adapter.approve_builder_fee.assert_called_once()
 
-    @pytest.mark.asyncio
-    async def test_ensure_builder_fee_simulation_mode(
-        self, mock_hyperliquid_adapter, ledger_adapter
-    ):
-        """Test ensure_builder_fee_approved in simulation mode."""
-        with patch(
-            "wayfinder_paths.strategies.basis_trading_strategy.strategy.HyperliquidAdapter",
-            return_value=mock_hyperliquid_adapter,
-        ):
-            with patch(
-                "wayfinder_paths.strategies.basis_trading_strategy.strategy.BalanceAdapter"
-            ):
-                with patch(
-                    "wayfinder_paths.strategies.basis_trading_strategy.strategy.TokenAdapter"
-                ):
-                    with patch(
-                        "wayfinder_paths.strategies.basis_trading_strategy.strategy.LedgerAdapter",
-                        return_value=ledger_adapter,
-                    ):
-                        with patch(
-                            "wayfinder_paths.strategies.basis_trading_strategy.strategy.WalletManager"
-                        ):
-                            from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
-                                BasisTradingStrategy,
-                            )
-
-                            s = BasisTradingStrategy(
-                                config={
-                                    "main_wallet": {"address": "0x1234"},
-                                    "strategy_wallet": {"address": "0x5678"},
-                                },
-                                simulation=True,  # Simulation mode
-                            )
-                            s.hyperliquid_adapter = mock_hyperliquid_adapter
-                            s.ledger_adapter = ledger_adapter
-
-                            success, msg = await s.ensure_builder_fee_approved()
-                            assert success is True
-                            assert "simulation" in msg.lower()
-
     @pytest.mark.asyncio
     async def test_portfolio_value_includes_spot_holdings(
         self, strategy, mock_hyperliquid_adapter

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/README.md

@@ -1,4 +1,4 @@
-# Hyperlend Stable Yield Strategy
+# Hyperlend Stable Yield Strategy
 
 - Entrypoint: `strategies.hyperlend_stable_yield_strategy.strategy.HyperlendStableYieldStrategy`
 - Manifest: `manifest.yaml`
@@ -79,7 +79,7 @@ poetry install
 # Creates a main wallet (or use 'just create-strategy' which auto-creates wallets)
 poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
 
-# Copy config and edit credentials (or rely on env vars)
+# Copy config and edit credentials
 cp wayfinder_paths/config.example.json config.json
 
 # Check status / health

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/examples.json

@@ -1,6 +1,9 @@
 {
   "smoke": {
-    "deposit": {},
+    "deposit": {
+      "main_token_amount": 10.0,
+      "gas_token_amount": 0.01
+    },
     "update": {},
     "status": {},
     "withdraw": {}

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/strategy.py

@@ -195,7 +195,6 @@ class HyperlendStableYieldStrategy(Strategy):
         *,
         main_wallet: dict[str, Any] | None = None,
         strategy_wallet: dict[str, Any] | None = None,
-        simulation: bool = False,
         web3_service: Web3Service = None,
         api_key: str | None = None,
     ):
@@ -207,7 +206,6 @@ class HyperlendStableYieldStrategy(Strategy):
             merged_config["strategy_wallet"] = strategy_wallet
 
         self.config = merged_config
-        self.simulation = simulation
         self.balance_adapter = None
         self.tx_adapter = None
         self.token_adapter = None
@@ -238,7 +236,6 @@ class HyperlendStableYieldStrategy(Strategy):
                 token_transaction_service = LocalTokenTxnService(
                     adapter_config,
                     wallet_provider=wallet_provider,
-                    simulation=self.simulation,
                 )
                 web3_service = DefaultWeb3Service(
                     wallet_provider=wallet_provider,
@@ -250,12 +247,9 @@ class HyperlendStableYieldStrategy(Strategy):
             balance = BalanceAdapter(adapter_config, web3_service=web3_service)
             token_adapter = TokenAdapter()
             ledger_adapter = LedgerAdapter()  # here
-            brap_adapter = BRAPAdapter(
-                web3_service=web3_service, simulation=self.simulation
-            )
+            brap_adapter = BRAPAdapter(web3_service=web3_service)
             hyperlend_adapter = HyperlendAdapter(
                 adapter_config,
-                simulation=self.simulation,
                 web3_service=web3_service,
             )
 
@@ -323,11 +317,109 @@ class HyperlendStableYieldStrategy(Strategy):
         self.hys_z: float = self.HYSTERESIS_Z
         self.rotation_tx_cost: float = self.ROTATION_TX_COST
 
-    async def deposit(self) -> StatusTuple:
+    async def deposit(
+        self, main_token_amount: float = 0.0, gas_token_amount: float = 0.0
+    ) -> StatusTuple:
+        if main_token_amount == 0.0 and gas_token_amount == 0.0:
+            return (
+                False,
+                "Either main_token_amount or gas_token_amount must be provided",
+            )
+
+        if main_token_amount > 0:
+            if main_token_amount < self.MIN_USDT0_DEPOSIT_AMOUNT:
+                return (
+                    False,
+                    f"Main token amount {main_token_amount} is below minimum {self.MIN_USDT0_DEPOSIT_AMOUNT}",
+                )
+
+        if gas_token_amount and gas_token_amount > self.GAS_MAXIMUM:
+            return (
+                False,
+                f"Gas token amount exceeds maximum configured gas buffer: {self.GAS_MAXIMUM}",
+            )
+
+        if self.balance_adapter is None:
+            return (
+                False,
+                "Balance adapter not initialized. Strategy initialization may have failed.",
+            )
+
+        (
+            success,
+            main_usdt0_balance,
+        ) = await self.balance_adapter.get_balance(
+            token_id=self.usdt_token_info.get("token_id"),
+            wallet_address=self._get_main_wallet_address(),
+        )
+        if not success:
+            return (
+                False,
+                f"Failed to get main wallet USDT0 balance: {main_usdt0_balance}",
+            )
+
+        (
+            success,
+            main_hype_balance,
+        ) = await self.balance_adapter.get_balance(
+            token_id=self.hype_token_info.get("token_id"),
+            wallet_address=self._get_main_wallet_address(),
+        )
+        if not success:
+            return (
+                False,
+                f"Failed to get main wallet HYPE balance: {main_hype_balance}",
+            )
+
+        main_usdt0_native = main_usdt0_balance / (
+            10 ** self.usdt_token_info.get("decimals")
+        )
+        main_hype_native = main_hype_balance / (
+            10 ** self.hype_token_info.get("decimals")
+        )
+
+        if main_token_amount > 0:
+            if main_usdt0_native < main_token_amount:
+                return (
+                    False,
+                    f"Main wallet USDT0 balance is less than the deposit amount: {main_usdt0_native} < {main_token_amount}",
+                )
+
+        if gas_token_amount > 0:
+            if main_hype_native < gas_token_amount:
+                return (
+                    False,
+                    f"Main wallet HYPE balance is less than the deposit amount: {main_hype_native} < {gas_token_amount}",
+                )
+
+        if gas_token_amount > 0:
+            (
+                success,
+                msg,
+            ) = await self.balance_adapter.move_from_main_wallet_to_strategy_wallet(
+                self.hype_token_info.get("token_id"),
+                gas_token_amount,
+                strategy_name=self.name,
+            )
+            if not success:
+                return (False, f"HYPE transfer to strategy failed: {msg}")
+
+        if main_token_amount > 0:
+            (
+                success,
+                msg,
+            ) = await self.balance_adapter.move_from_main_wallet_to_strategy_wallet(
+                self.usdt_token_info.get("token_id"),
+                main_token_amount,
+                strategy_name=self.name,
+            )
+            if not success:
+                return (False, f"USDT0 transfer to strategy failed: {msg}")
+
         self._invalidate_assets_snapshot()
         await self._hydrate_position_from_chain()
 
-        return (True, "hydrated positions")
+        return (success, msg)
 
     async def _estimate_redeploy_tokens(self) -> float:
         positions = await self._get_lent_positions()
@@ -1344,26 +1436,12 @@ class HyperlendStableYieldStrategy(Strategy):
                 continue
 
             balance_tokens = float(entry.get("tokens") or 0)
-            if balance_tokens <= 0:
-                continue
-
-            try:
-                (
-                    transfer_success,
-                    _,
-                ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
-                    token_id=token.get("token_id"),
-                    amount=balance_tokens,
-                    strategy_name=self.name,
-                )
-            except Exception:
-                continue
-
-            if transfer_success:
-                actions.append(
-                    f"Transferred {balance_tokens:.4f} {token.get('symbol')} to main wallet"
+            if balance_tokens > 0:
+                logger.warning(
+                    f"Failed to swap {balance_tokens:.4f} {token.get('symbol', 'unknown')} "
+                    f"to {target_token.get('symbol', 'target')} during alignment. "
+                    f"Leaving in strategy wallet for next update cycle."
                 )
-                self._invalidate_assets_snapshot()
 
         kept_tokens = float(balances.get("native", {}).get("tokens") or 0)
 

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/test_strategy.py

@@ -46,20 +46,20 @@ def strategy():
         config=mock_config,
         main_wallet=mock_config["main_wallet"],
         strategy_wallet=mock_config["strategy_wallet"],
-        simulation=True,
     )
 
     if hasattr(s, "balance_adapter") and s.balance_adapter:
         # Mock balances: 1000 USDT0 (with 6 decimals) and 2 HYPE (with 18 decimals)
-        usdt0_balance_mock = AsyncMock(return_value=(True, 1000000000))
-        hype_balance_mock = AsyncMock(return_value=(True, 2000000000000000000))
-
         def get_balance_side_effect(token_id, wallet_address, **kwargs):
-            if token_id == "usdt0-hyperevm" or token_id == "usdt0":
-                return usdt0_balance_mock.return_value
-            elif token_id == "hype-hyperevm" or token_id == "hype":
-                return hype_balance_mock.return_value
-            return (True, 1000000000)
+            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
+                return (True, 1000000000)
+            elif "hype" in token_id_str or token_id_str == "hype":
+                # 2 HYPE with 18 decimals = 2 * 10^18 = 2000000000000000000
+                return (True, 2000000000000000000)
+            # Default: return high balance for any other token
+            return (True, 2000000000000000000)
 
         s.balance_adapter.get_balance = AsyncMock(side_effect=get_balance_side_effect)
 
@@ -101,15 +101,54 @@ def strategy():
         )
 
     if hasattr(s, "balance_adapter") and s.balance_adapter:
+        # Mock the main methods first
         s.balance_adapter.move_from_main_wallet_to_strategy_wallet = AsyncMock(
             return_value=(True, "Transfer successful (simulated)")
         )
         s.balance_adapter.move_from_strategy_wallet_to_main_wallet = AsyncMock(
             return_value=(True, "Transfer successful (simulated)")
         )
-        if hasattr(s.balance_adapter, "wallet_provider"):
-            s.balance_adapter.wallet_provider.broadcast_transaction = AsyncMock(
-                return_value=(True, {"transaction_hash": "0xCAFEBABE"})
+        # Mock internal dependencies unconditionally to prevent MagicMock await errors
+        # These are needed if the real method somehow gets called
+        s.balance_adapter.token_client = AsyncMock()
+        s.balance_adapter.token_client.get_token_details = AsyncMock(
+            return_value={
+                "id": "usdt0-hyperevm",
+                "address": "0x1234",
+                "decimals": 6,
+            }
+        )
+        s.balance_adapter.token_transactions = AsyncMock()
+        s.balance_adapter.token_transactions.build_send = AsyncMock(
+            return_value=(True, {"transaction": "0xMOCK"})
+        )
+        s.balance_adapter.wallet_provider = AsyncMock()
+        s.balance_adapter.wallet_provider.broadcast_transaction = AsyncMock(
+            return_value=(True, {"transaction_hash": "0xCAFEBABE"})
+        )
+        # token_adapter might already be set, so check before overriding
+        if (
+            not hasattr(s.balance_adapter, "token_adapter")
+            or s.balance_adapter.token_adapter is None
+        ):
+            s.balance_adapter.token_adapter = AsyncMock()
+        if hasattr(s.balance_adapter.token_adapter, "get_token_price"):
+            s.balance_adapter.token_adapter.get_token_price = AsyncMock(
+                return_value=(True, {"current_price": 1.0})
+            )
+        # ledger_adapter might already be set, so check before overriding
+        if (
+            not hasattr(s.balance_adapter, "ledger_adapter")
+            or s.balance_adapter.ledger_adapter is None
+        ):
+            s.balance_adapter.ledger_adapter = AsyncMock()
+        if hasattr(s.balance_adapter.ledger_adapter, "record_deposit"):
+            s.balance_adapter.ledger_adapter.record_deposit = AsyncMock(
+                return_value=(True, {})
+            )
+        if hasattr(s.balance_adapter.ledger_adapter, "record_withdrawal"):
+            s.balance_adapter.ledger_adapter.record_withdrawal = AsyncMock(
+                return_value=(True, {})
             )
 
     if hasattr(s, "ledger_adapter") and s.ledger_adapter:
@@ -304,8 +343,8 @@ async def test_canonical_usage(strategy):
     for example_name, example_data in canonical.items():
         if "deposit" in example_data:
             deposit_params = example_data.get("deposit", {})
-            ok, _ = await strategy.deposit(**deposit_params)
-            assert ok, f"Canonical example '{example_name}' deposit failed"
+            ok, msg = await strategy.deposit(**deposit_params)
+            assert ok, f"Canonical example '{example_name}' deposit failed: {msg}"
 
         if "update" in example_data:
             result = await strategy.update()

wayfinder_paths/strategies/stablecoin_yield_strategy/strategy.py

@@ -155,7 +155,6 @@ class StablecoinYieldStrategy(Strategy):
         *,
         main_wallet: dict[str, Any] | None = None,
         strategy_wallet: dict[str, Any] | None = None,
-        simulation: bool = False,
         web3_service=None,
         api_key: str | None = None,
     ):
@@ -167,7 +166,6 @@ class StablecoinYieldStrategy(Strategy):
             merged_config["strategy_wallet"] = strategy_wallet
 
         self.config = merged_config
-        self.simulation = simulation
         self.deposited_amount = 0
         self.current_pool = None
         self.current_apy = 0
@@ -198,7 +196,6 @@ class StablecoinYieldStrategy(Strategy):
                 tx_adapter = LocalTokenTxnService(
                     adapter_config,
                     wallet_provider=wallet_provider,
-                    simulation=self.simulation,
                 )
                 web3_service = DefaultWeb3Service(
                     wallet_provider=wallet_provider, evm_transactions=tx_adapter
@@ -210,9 +207,7 @@ class StablecoinYieldStrategy(Strategy):
             token_adapter = TokenAdapter()
             ledger_adapter = LedgerAdapter()
             pool_adapter = PoolAdapter()
-            brap_adapter = BRAPAdapter(
-                web3_service=web3_service, simulation=self.simulation
-            )
+            brap_adapter = BRAPAdapter(web3_service=web3_service)
 
             self.register_adapters(
                 [