wayfinder-paths 0.1.23__py3-none-any.whl → 0.1.25__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/strategies/boros_hype_strategy/test_strategy.py

@@ -0,0 +1,202 @@
+"""Tests for BorosHypeStrategy."""
+
+import importlib.util
+import sys
+from pathlib import Path
+from unittest.mock import AsyncMock
+
+# Ensure wayfinder-paths is on path for tests.test_utils import
+_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:
+    sys.path.remove(_wayfinder_path_str)
+    sys.path.insert(0, _wayfinder_path_str)
+
+import pytest  # noqa: E402
+
+try:
+    from tests.test_utils import get_canonical_examples, load_strategy_examples
+except ImportError:
+    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)
+    spec.loader.exec_module(test_utils)
+    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 = BorosHypeStrategy(
+        config=mock_config,
+        main_wallet=mock_config["main_wallet"],
+        strategy_wallet=mock_config["strategy_wallet"],
+        simulation=True,
+    )
+
+    # 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
+
+
+@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
+
+    deposit_params = smoke_data.get("deposit", {})
+    ok, msg = await strategy.deposit(**deposit_params)
+    assert isinstance(ok, bool)
+    assert isinstance(msg, str)
+
+    # 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", {}))
+    assert isinstance(ok, bool)
+
+
+@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)
+
+    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"
+
+        if "update" in example_data:
+            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:
+            st = await strategy.status()
+            assert isinstance(st, dict), (
+                f"Canonical example '{example_name}' status failed"
+            )
+
+
+@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():
+        if isinstance(example_data, dict) and "expect" in example_data:
+            expect = example_data.get("expect", {})
+
+            if "deposit" in example_data:
+                deposit_params = example_data.get("deposit", {})
+                ok, _ = await strategy.deposit(**deposit_params)
+
+                if expect.get("success") is False:
+                    assert ok is False, (
+                        f"Expected {example_name} deposit to fail but it succeeded"
+                    )
+                elif expect.get("success") is True:
+                    assert ok is True, (
+                        f"Expected {example_name} deposit to succeed but it failed"
+                    )
+
+
+@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