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

wayfinder_paths/strategies/boros_hype_strategy/test_planner_golden.py

@@ -0,0 +1,374 @@
+"""Golden tests for the Boros HYPE planner.
+
+These tests lock in the current Observe→Plan behavior so we can safely refactor
+the strategy into smaller modules without changing what it *does*.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from wayfinder_paths.adapters.boros_adapter import BorosMarketQuote
+from wayfinder_paths.strategies.boros_hype_strategy.constants import (
+    BOROS_HYPE_MARKET_ID,
+    BOROS_HYPE_TOKEN_ID,
+    HYPE_OFT_ADDRESS,
+    MIN_HYPE_GAS,
+)
+from wayfinder_paths.strategies.boros_hype_strategy.strategy import build_plan
+from wayfinder_paths.strategies.boros_hype_strategy.types import (
+    AllocationStatus,
+    HedgeConfig,
+    Inventory,
+    PlannerConfig,
+    PlannerRuntime,
+    PlanOp,
+)
+
+
+def _inv(**overrides) -> Inventory:
+    base = {
+        "hype_hyperevm_balance": 0.0,
+        "hype_hyperevm_value_usd": 0.0,
+        "whype_balance": 0.0,
+        "whype_value_usd": 0.0,
+        "khype_balance": 0.0,
+        "khype_value_usd": 0.0,
+        "looped_hype_balance": 0.0,
+        "looped_hype_value_usd": 0.0,
+        "usdc_arb_idle": 0.0,
+        "usdt_arb_idle": 0.0,
+        "eth_arb_balance": 0.0,
+        "hype_oft_arb_balance": 0.0,
+        "hype_oft_arb_value_usd": 0.0,
+        "hl_perp_margin": 0.0,
+        "hl_spot_usdc": 0.0,
+        "hl_spot_hype": 0.0,
+        "hl_spot_hype_value_usd": 0.0,
+        "hl_short_size_hype": 0.0,
+        "hl_short_value_usd": 0.0,
+        "hl_unrealized_pnl": 0.0,
+        "hl_withdrawable_usd": 0.0,
+        "boros_idle_collateral_isolated": 0.0,
+        "boros_idle_collateral_cross": 0.0,
+        "boros_collateral_hype": 0.0,
+        "boros_collateral_usd": 0.0,
+        "boros_pending_withdrawal_hype": 0.0,
+        "boros_pending_withdrawal_usd": 0.0,
+        "boros_committed_collateral_usd": 0.0,
+        "boros_position_size": 0.0,
+        "boros_position_value": 0.0,
+        "khype_to_hype_ratio": 1.0,
+        "looped_hype_to_hype_ratio": 1.0,
+        "hype_price_usd": 25.0,
+        "spot_value_usd": 0.0,
+        "total_hype_exposure": 0.0,
+        "total_value": 0.0,
+        "boros_position_market_ids": None,
+    }
+    base.update(overrides)
+    return Inventory(**base)
+
+
+def _alloc(**overrides) -> AllocationStatus:
+    base = {
+        "spot_value": 0.0,
+        "hl_value": 0.0,
+        "boros_value": 0.0,
+        "idle_value": 0.0,
+        "total_value": 1.0,
+        "spot_pct_actual": 0.0,
+        "hl_pct_actual": 0.0,
+        "boros_pct_actual": 0.0,
+        "spot_deviation": 0.0,
+        "hl_deviation": 0.0,
+        "boros_deviation": 0.0,
+        "spot_needed_usd": 0.0,
+        "hl_needed_usd": 0.0,
+        "boros_needed_usd": 0.0,
+    }
+    base.update(overrides)
+    return AllocationStatus(**base)
+
+
+def _one_hype_quote() -> list[BorosMarketQuote]:
+    return [
+        BorosMarketQuote(
+            market_id=BOROS_HYPE_MARKET_ID,
+            market_address="0x0000000000000000000000000000000000000000",
+            symbol="HYPE-USD",
+            underlying="HYPE",
+            tenor_days=7.0,
+            maturity_ts=1_800_000_000,
+            collateral_address=HYPE_OFT_ADDRESS,
+            collateral_token_id=BOROS_HYPE_TOKEN_ID,
+            tick_step=1,
+            mid_apr=0.10,
+            best_bid_apr=0.095,
+            best_ask_apr=0.105,
+        )
+    ]
+
+
+def test_build_plan_pending_withdrawal_is_noop():
+    inv = _inv(total_value=1000.0, boros_pending_withdrawal_usd=5.0)
+    alloc = _alloc(total_value=1000.0)
+    runtime = PlannerRuntime()
+    hedge_cfg = HedgeConfig(
+        spot_pct=0.60,
+        khype_fraction=0.5,
+        looped_hype_fraction=0.5,
+        hyperliquid_pct=0.35,
+        boros_pct=0.05,
+    )
+    config = PlannerConfig()
+
+    plan = build_plan(
+        inv=inv,
+        alloc=alloc,
+        risk_progress=0.0,
+        hedge_cfg=hedge_cfg,
+        config=config,
+        runtime=runtime,
+        boros_quotes=_one_hype_quote(),
+        pending_withdrawal_completion=False,
+    )
+
+    assert plan.steps == []
+    assert any("pending boros withdrawal" in msg.lower() for msg in plan.messages)
+
+
+def test_build_plan_routes_capital_idle_usdc():
+    total = 1000.0
+    hedge_cfg = HedgeConfig(
+        spot_pct=0.60,
+        khype_fraction=0.5,
+        looped_hype_fraction=0.5,
+        hyperliquid_pct=0.35,
+        boros_pct=0.05,
+    )
+    config = PlannerConfig()
+    runtime = PlannerRuntime()
+
+    inv = _inv(
+        total_value=total,
+        usdc_arb_idle=total,
+        hype_hyperevm_balance=max(0.0, MIN_HYPE_GAS - 0.01),  # force gas step
+    )
+
+    alloc = _alloc(
+        spot_value=0.0,
+        hl_value=0.0,
+        boros_value=0.0,
+        idle_value=total,
+        total_value=total,
+        spot_pct_actual=0.0,
+        hl_pct_actual=0.0,
+        boros_pct_actual=0.0,
+        spot_deviation=-0.60,
+        hl_deviation=-0.35,
+        boros_deviation=-0.05,
+        spot_needed_usd=600.0,
+        hl_needed_usd=350.0,
+        boros_needed_usd=50.0,
+    )
+
+    plan = build_plan(
+        inv=inv,
+        alloc=alloc,
+        risk_progress=0.0,
+        hedge_cfg=hedge_cfg,
+        config=config,
+        runtime=runtime,
+        boros_quotes=_one_hype_quote(),
+        pending_withdrawal_completion=False,
+    )
+
+    ops = [s.op for s in plan.steps]
+    assert ops == [
+        PlanOp.ENSURE_GAS_ON_HYPEREVM,
+        PlanOp.FUND_BOROS,
+        PlanOp.SEND_USDC_TO_HL,
+        PlanOp.BRIDGE_TO_HYPEREVM,
+    ]
+
+    fund_step = plan.steps[1]
+    assert abs(fund_step.params["amount_usd"] - 50.0) < 1e-9  # 5% target
+
+    send_step = plan.steps[2]
+    assert abs(send_step.params["amount_usd"] - 1000.0) < 1e-9  # send all to HL
+
+    bridge_step = plan.steps[3]
+    assert abs(bridge_step.params["amount_usd"] - 600.0) < 1e-9
+    assert abs(bridge_step.params["reserve_hl_margin_usd"] - 350.0) < 1e-9
+
+
+def test_build_plan_sizes_hedge_and_boros_position():
+    total = 1000.0
+    hedge_cfg = HedgeConfig(
+        spot_pct=0.60,
+        khype_fraction=0.5,
+        looped_hype_fraction=0.5,
+        hyperliquid_pct=0.35,
+        boros_pct=0.05,
+    )
+    config = PlannerConfig()
+    runtime = PlannerRuntime()
+
+    inv = _inv(
+        total_value=total,
+        spot_value_usd=600.0,
+        hl_perp_margin=350.0,
+        boros_collateral_usd=50.0,
+        boros_committed_collateral_usd=50.0,
+        usdc_arb_idle=0.0,
+        usdt_arb_idle=0.0,
+        hype_hyperevm_balance=MIN_HYPE_GAS,  # avoid gas + LST swap steps
+        total_hype_exposure=10.0,
+        hl_short_size_hype=0.0,
+        hype_price_usd=24.0,  # avoids .5 rounding in target Boros size
+        boros_position_size=0.0,
+    )
+
+    alloc = _alloc(
+        spot_value=600.0,
+        hl_value=350.0,
+        boros_value=50.0,
+        idle_value=0.0,
+        total_value=total,
+        spot_pct_actual=0.60,
+        hl_pct_actual=0.35,
+        boros_pct_actual=0.05,
+        spot_deviation=0.0,
+        hl_deviation=0.0,
+        boros_deviation=0.0,
+        spot_needed_usd=0.0,
+        hl_needed_usd=0.0,
+        boros_needed_usd=0.0,
+    )
+
+    plan = build_plan(
+        inv=inv,
+        alloc=alloc,
+        risk_progress=0.0,
+        hedge_cfg=hedge_cfg,
+        config=config,
+        runtime=runtime,
+        boros_quotes=_one_hype_quote(),
+        pending_withdrawal_completion=False,
+    )
+
+    ops = [s.op for s in plan.steps]
+    assert ops == [PlanOp.ENSURE_HL_SHORT, PlanOp.ENSURE_BOROS_POSITION]
+
+    hedge_step = plan.steps[0]
+    assert hedge_step.params == {"target_size": 10.0, "current_size": 0.0}
+
+    boros_step = plan.steps[1]
+    assert boros_step.params["market_id"] == BOROS_HYPE_MARKET_ID
+    assert abs(boros_step.params["target_size_usd"] - 240.0) < 1e-9
+
+    # Market selection should persist in runtime (hysteresis)
+    assert runtime.current_boros_market_id == BOROS_HYPE_MARKET_ID
+
+
+def test_build_plan_redeploy_mode_is_single_step():
+    total = 1000.0
+    runtime = PlannerRuntime()
+    hedge_cfg = HedgeConfig(
+        spot_pct=0.60,
+        khype_fraction=0.5,
+        looped_hype_fraction=0.5,
+        hyperliquid_pct=0.35,
+        boros_pct=0.05,
+    )
+    config = PlannerConfig()
+
+    inv = _inv(total_value=total, usdc_arb_idle=total)
+    alloc = _alloc(total_value=total)
+
+    plan = build_plan(
+        inv=inv,
+        alloc=alloc,
+        risk_progress=0.95,  # above full_rebalance_threshold
+        hedge_cfg=hedge_cfg,
+        config=config,
+        runtime=runtime,
+        boros_quotes=_one_hype_quote(),
+        pending_withdrawal_completion=False,
+    )
+
+    assert [s.op for s in plan.steps] == [PlanOp.CLOSE_AND_REDEPLOY]
+
+
+def test_build_plan_trim_mode_adds_partial_trim_first():
+    total = 1000.0
+    runtime = PlannerRuntime()
+    hedge_cfg = HedgeConfig(
+        spot_pct=0.60,
+        khype_fraction=0.5,
+        looped_hype_fraction=0.5,
+        hyperliquid_pct=0.35,
+        boros_pct=0.05,
+    )
+    config = PlannerConfig()
+
+    inv = _inv(
+        total_value=total,
+        spot_value_usd=600.0,
+        hype_price_usd=25.0,
+        hl_short_size_hype=10.0,  # $250 notional short
+        hl_perp_margin=50.0,  # intentionally low margin to force trim
+        hype_hyperevm_balance=MIN_HYPE_GAS,  # avoid gas step
+    )
+    alloc = _alloc(total_value=total)
+
+    plan = build_plan(
+        inv=inv,
+        alloc=alloc,
+        risk_progress=0.80,  # TRIM band
+        hedge_cfg=hedge_cfg,
+        config=config,
+        runtime=runtime,
+        boros_quotes=_one_hype_quote(),
+        pending_withdrawal_completion=False,
+    )
+
+    assert plan.steps, "Expected at least one step in TRIM mode"
+    assert plan.steps[0].op == PlanOp.PARTIAL_TRIM_SPOT
+    assert plan.steps[0].params["trim_pct"] == pytest.approx(0.196875)
+
+
+def test_build_plan_skips_boros_funding_when_collateral_already_committed():
+    total = 1000.0
+    runtime = PlannerRuntime()
+    hedge_cfg = HedgeConfig(
+        spot_pct=0.60,
+        khype_fraction=0.5,
+        looped_hype_fraction=0.5,
+        hyperliquid_pct=0.35,
+        boros_pct=0.05,
+    )
+    config = PlannerConfig()
+
+    inv = _inv(
+        total_value=total,
+        usdc_arb_idle=0.0,
+        usdt_arb_idle=0.0,
+        boros_committed_collateral_usd=60.0,  # already above target
+        hype_hyperevm_balance=MIN_HYPE_GAS,  # avoid gas step
+    )
+    alloc = _alloc(total_value=total)
+
+    plan = build_plan(
+        inv=inv,
+        alloc=alloc,
+        risk_progress=0.0,
+        hedge_cfg=hedge_cfg,
+        config=config,
+        runtime=runtime,
+        boros_quotes=_one_hype_quote(),
+        pending_withdrawal_completion=False,
+    )
+
+    assert all(s.op != PlanOp.FUND_BOROS for s in plan.steps)

wayfinder_paths/{templates/strategy → strategies/boros_hype_strategy}/test_strategy.py

@@ -1,19 +1,16 @@
+"""Tests for BorosHypeStrategy."""
+
+import importlib.util
 import sys
 from pathlib import Path
-
-# TODO: Replace MyStrategy with your actual strategy class name
-from wayfinder_paths.strategies.your_strategy.strategy import (
-    MyStrategy,  # noqa: E402
-)
+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)
 elif sys.path.index(_wayfinder_path_str) > 0:
-    # Move to front to take precedence
     sys.path.remove(_wayfinder_path_str)
     sys.path.insert(0, _wayfinder_path_str)
 
@@ -22,9 +19,6 @@ import pytest  # noqa: E402
 try:
     from tests.test_utils import get_canonical_examples, load_strategy_examples
 except ImportError:
-    # Fallback if path setup didn't work
-    import importlib.util
-
     test_utils_path = Path(_wayfinder_path_dir) / "tests" / "test_utils.py"
     spec = importlib.util.spec_from_file_location("tests.test_utils", test_utils_path)
     test_utils = importlib.util.module_from_spec(spec)
@@ -32,61 +26,35 @@ except ImportError:
     get_canonical_examples = test_utils.get_canonical_examples
     load_strategy_examples = test_utils.load_strategy_examples
 
+from wayfinder_paths.strategies.boros_hype_strategy.strategy import (  # noqa: E402
+    BorosHypeStrategy,
+)
+
 
 @pytest.fixture
 def strategy():
+    """Create a strategy instance for testing with minimal config."""
     mock_config = {
         "main_wallet": {"address": "0x1234567890123456789012345678901234567890"},
         "strategy_wallet": {"address": "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd"},
     }
 
-    s = MyStrategy(
+    s = BorosHypeStrategy(
         config=mock_config,
         main_wallet=mock_config["main_wallet"],
         strategy_wallet=mock_config["strategy_wallet"],
+        simulation=True,
     )
 
-    # TODO: Add mocking for your adapters here if needed
-    # Example for balance_adapter:
-    # if hasattr(s, "balance_adapter") and s.balance_adapter:
-    #     usdc_balance_mock = AsyncMock(return_value=(True, 60000000))
-    #     gas_balance_mock = AsyncMock(return_value=(True, 2000000000000000))
-    #
-    #     def get_balance_side_effect(query, wallet_address, **kwargs):
-    #         token_id = query if isinstance(query, str) else (query or {}).get("token_id")
-    #         if token_id == "usd-coin-base" or token_id == "usd-coin":
-    #         elif token_id == "ethereum-base" or token_id == "ethereum":
-    #
-    #     s.balance_adapter.get_balance = AsyncMock(
-    #         side_effect=get_balance_side_effect
-    #     )
-
-    # Example for token_adapter:
-    # if hasattr(s, "token_adapter") and s.token_adapter:
-    #     default_token = {
-    #         "id": "usd-coin-base",
-    #         "symbol": "USDC",
-    #         "name": "USD Coin",
-    #         "decimals": 6,
-    #         "address": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-    #         "chain": {"code": "base", "id": 8453, "name": "Base"},
-    #     }
-    #     s.token_adapter.get_token = AsyncMock(return_value=(True, default_token))
-    #     s.token_adapter.get_gas_token = AsyncMock(return_value=(True, default_token))
-
-    # Example for transaction adapters:
-    # if hasattr(s, "tx_adapter") and s.tx_adapter:
-    #     s.tx_adapter.move_from_main_wallet_to_strategy_wallet = AsyncMock(
-    #     )
-    #     s.tx_adapter.move_from_strategy_wallet_to_main_wallet = AsyncMock(
-    #     )
-
-    # Example for ledger_adapter:
-    # if hasattr(s, "ledger_adapter") and s.ledger_adapter:
-    #     s.ledger_adapter.get_strategy_net_deposit = AsyncMock(
-    #     )
-    #     s.ledger_adapter.get_strategy_transactions = AsyncMock(
-    #     )
+    # Mock the Boros adapter
+    if hasattr(s, "boros_adapter") and s.boros_adapter:
+        s.boros_adapter.quote_markets_for_underlying = AsyncMock(
+            return_value=(True, [])
+        )
+        s.boros_adapter.get_account_balances = AsyncMock(
+            return_value=(True, {"total": 0.0, "cross": 0.0, "isolated": 0.0})
+        )
+        s.boros_adapter.get_active_positions = AsyncMock(return_value=(True, []))
 
     return s
 
@@ -94,9 +62,12 @@ def strategy():
 @pytest.mark.asyncio
 @pytest.mark.smoke
 async def test_smoke(strategy):
+    """REQUIRED: Basic smoke test - verifies strategy lifecycle."""
     examples = load_strategy_examples(Path(__file__))
     smoke_data = examples["smoke"]
 
+    await strategy.setup()
+
     st = await strategy.status()
     assert isinstance(st, dict)
     assert "portfolio_value" in st or "net_deposit" in st or "strategy_status" in st
@@ -106,7 +77,9 @@ async def test_smoke(strategy):
     assert isinstance(ok, bool)
     assert isinstance(msg, str)
 
-    ok, msg = await strategy.update(**smoke_data.get("update", {}))
+    # update() returns (success, message, rotated) - 3 values
+    update_result = await strategy.update(**smoke_data.get("update", {}))
+    ok = update_result[0]
     assert isinstance(ok, bool)
 
     ok, msg = await strategy.withdraw(**smoke_data.get("withdraw", {}))
@@ -115,6 +88,9 @@ async def test_smoke(strategy):
 
 @pytest.mark.asyncio
 async def test_canonical_usage(strategy):
+    """REQUIRED: Test canonical usage examples from examples.json."""
+    await strategy.setup()
+
     examples = load_strategy_examples(Path(__file__))
     canonical = get_canonical_examples(examples)
 
@@ -125,7 +101,9 @@ async def test_canonical_usage(strategy):
             assert ok, f"Canonical example '{example_name}' deposit failed"
 
         if "update" in example_data:
-            ok, msg = await strategy.update()
+            update_result = await strategy.update()
+            ok = update_result[0]
+            msg = update_result[1] if len(update_result) > 1 else ""
             assert ok, f"Canonical example '{example_name}' update failed: {msg}"
 
         if "status" in example_data:
@@ -137,6 +115,9 @@ async def test_canonical_usage(strategy):
 
 @pytest.mark.asyncio
 async def test_error_cases(strategy):
+    """OPTIONAL: Test error scenarios from examples.json."""
+    await strategy.setup()
+
     examples = load_strategy_examples(Path(__file__))
 
     for example_name, example_data in examples.items():
@@ -156,11 +137,66 @@ async def test_error_cases(strategy):
                         f"Expected {example_name} deposit to succeed but it failed"
                     )
 
-            if "update" in example_data:
-                ok, _ = await strategy.update()
-                if "success" in expect:
-                    expected_success = expect.get("success")
-                    assert ok == expected_success, (
-                        f"Expected {example_name} update to "
-                        f"{'succeed' if expected_success else 'fail'} but got opposite"
-                    )
+
+@pytest.mark.asyncio
+async def test_below_minimum_deposit(strategy):
+    """Test deposit below minimum threshold fails."""
+    await strategy.setup()
+
+    ok, msg = await strategy.deposit(main_token_amount=50.0, gas_token_amount=0.01)
+    assert ok is False
+    assert "minimum" in msg.lower() or "150" in msg
+
+
+@pytest.mark.asyncio
+async def test_opa_loop_structure(strategy):
+    """Test OPA loop components are properly configured."""
+    await strategy.setup()
+
+    # Verify OPA config
+    config = strategy.opa_config
+    assert config.max_iterations_per_tick > 0
+    assert config.max_steps_per_iteration > 0
+    assert config.max_total_steps_per_tick > 0
+
+    # Verify inventory changing ops
+    ops = strategy.get_inventory_changing_ops()
+    assert len(ops) > 0
+
+
+@pytest.mark.asyncio
+async def test_observe_returns_inventory(strategy):
+    """Test observe() returns valid inventory."""
+    await strategy.setup()
+
+    inv = await strategy.observe()
+    assert inv is not None
+    assert hasattr(inv, "hype_hyperevm_balance")
+    assert hasattr(inv, "total_value")
+    assert hasattr(inv, "hype_price_usd")
+
+
+@pytest.mark.asyncio
+async def test_plan_returns_plan(strategy):
+    """Test plan() returns valid plan."""
+    await strategy.setup()
+
+    inv = await strategy.observe()
+    plan = strategy.plan(inv)
+
+    assert plan is not None
+    assert hasattr(plan, "steps")
+    assert hasattr(plan, "desired_state")
+
+
+@pytest.mark.asyncio
+async def test_status_returns_expected_fields(strategy):
+    """Test status() returns expected fields."""
+    await strategy.setup()
+
+    status = await strategy.status()
+
+    assert "portfolio_value" in status
+    assert "strategy_status" in status
+    assert "gas_available" in status
+    assert "gassed_up" in status