wayfinder-paths 0.1.23__py3-none-any.whl → 0.1.25__py3-none-any.whl

wayfinder_paths/adapters/boros_adapter/test_adapter.py

@@ -0,0 +1,460 @@
+"""Tests for BorosAdapter."""
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from wayfinder_paths.adapters.boros_adapter.adapter import (
+    BorosAdapter,
+    BorosLimitOrder,
+    BorosMarketQuote,
+)
+
+
+class TestBorosAdapter:
+    """Test cases for BorosAdapter."""
+
+    @pytest.fixture
+    def mock_boros_client(self):
+        """Mock BorosClient for testing."""
+        mock_client = AsyncMock()
+        return mock_client
+
+    @pytest.fixture
+    def adapter(self, mock_boros_client):
+        """Create a BorosAdapter instance with mocked client for testing."""
+        mock_config = {
+            "strategy_wallet": {
+                "address": "0x1234567890123456789012345678901234567890"
+            },
+            "boros_adapter": {},
+        }
+        with patch(
+            "wayfinder_paths.adapters.boros_adapter.adapter.BorosClient",
+            return_value=mock_boros_client,
+        ):
+            adapter = BorosAdapter(
+                config=mock_config,
+                simulation=True,
+            )
+            adapter.boros_client = mock_boros_client
+            return adapter
+
+    def test_adapter_type(self, adapter):
+        """Test adapter has correct type."""
+        assert adapter.adapter_type == "BOROS"
+
+    @pytest.mark.asyncio
+    async def test_connect_success(self, adapter, mock_boros_client):
+        """Test successful connection."""
+        mock_boros_client.list_markets = AsyncMock(
+            return_value=[{"marketId": 1, "symbol": "HYPE-USD"}]
+        )
+
+        result = await adapter.connect()
+        assert result is True
+
+    @pytest.mark.asyncio
+    async def test_connect_failure(self, adapter, mock_boros_client):
+        """Test connection failure."""
+        mock_boros_client.list_markets = AsyncMock(side_effect=Exception("API Error"))
+
+        result = await adapter.connect()
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_list_markets_success(self, adapter, mock_boros_client):
+        """Test successful market listing."""
+        mock_response = [
+            {"marketId": 1, "symbol": "HYPE-USD", "underlying": "HYPE"},
+            {"marketId": 2, "symbol": "BTC-USD", "underlying": "BTC"},
+        ]
+        mock_boros_client.list_markets = AsyncMock(return_value=mock_response)
+
+        success, markets = await adapter.list_markets()
+
+        assert success is True
+        assert len(markets) == 2
+        assert markets[0]["marketId"] == 1
+
+    @pytest.mark.asyncio
+    async def test_list_markets_failure(self, adapter, mock_boros_client):
+        """Test market listing failure."""
+        mock_boros_client.list_markets = AsyncMock(side_effect=Exception("API Error"))
+
+        success, data = await adapter.list_markets()
+
+        assert success is False
+        assert "API Error" in str(data)
+
+    @pytest.mark.asyncio
+    async def test_get_market_success(self, adapter, mock_boros_client):
+        """Test successful single market fetch."""
+        mock_response = {
+            "marketId": 18,
+            "symbol": "HYPERLIQUID-HYPE-USD",
+            "underlying": "HYPE",
+        }
+        mock_boros_client.get_market = AsyncMock(return_value=mock_response)
+
+        success, market = await adapter.get_market(18)
+
+        assert success is True
+        assert market["marketId"] == 18
+
+    @pytest.mark.asyncio
+    async def test_get_orderbook_success(self, adapter, mock_boros_client):
+        """Test successful orderbook fetch."""
+        mock_response = {
+            "long": {"ia": [100, 105, 110], "sz": [1000, 2000, 3000]},
+            "short": {"ia": [115, 120, 125], "sz": [1500, 2500, 3500]},
+        }
+        mock_boros_client.get_order_book = AsyncMock(return_value=mock_response)
+
+        success, book = await adapter.get_orderbook(18)
+
+        assert success is True
+        assert "long" in book
+        assert "short" in book
+
+    @pytest.mark.asyncio
+    async def test_quote_market_success(self, adapter, mock_boros_client):
+        """Test successful market quote."""
+        mock_market = {
+            "marketId": 18,
+            "address": "0xabcd",
+            "symbol": "HYPERLIQUID-HYPE-USD",
+            "underlying": "HYPE",
+            "imData": {"tickStep": 1, "maturity": 1735689600},
+            "tokenId": 3,
+        }
+        mock_orderbook = {
+            "long": {"ia": [100, 105]},
+            "short": {"ia": [115, 120]},
+        }
+        mock_boros_client.get_order_book = AsyncMock(return_value=mock_orderbook)
+
+        success, quote = await adapter.quote_market(mock_market)
+
+        assert success is True
+        assert isinstance(quote, BorosMarketQuote)
+        assert quote.market_id == 18
+        assert quote.best_bid_apr == 0.105  # max(long) * tick_size
+        assert quote.best_ask_apr == 0.115  # min(short) * tick_size
+
+    @pytest.mark.asyncio
+    async def test_quote_markets_for_underlying_success(
+        self, adapter, mock_boros_client
+    ):
+        """Test quoting markets for underlying."""
+        mock_markets = [
+            {
+                "marketId": 18,
+                "symbol": "HYPERLIQUID-HYPE-USD-30D",
+                "underlying": "HYPE",
+                "imData": {"maturity": 1735689600},
+            },
+            {
+                "marketId": 19,
+                "symbol": "HYPERLIQUID-HYPE-USD-60D",
+                "underlying": "HYPE",
+                "imData": {"maturity": 1738368000},
+            },
+            {
+                "marketId": 20,
+                "symbol": "BTC-USD-30D",
+                "underlying": "BTC",
+                "imData": {"maturity": 1735689600},
+            },
+        ]
+        mock_boros_client.list_markets = AsyncMock(return_value=mock_markets)
+        mock_boros_client.get_order_book = AsyncMock(
+            return_value={"long": {"ia": [100]}, "short": {"ia": [110]}}
+        )
+
+        success, quotes = await adapter.quote_markets_for_underlying("HYPE")
+
+        assert success is True
+        assert len(quotes) == 2  # Only HYPE markets
+        assert all(q.underlying == "HYPE" for q in quotes)
+
+    @pytest.mark.asyncio
+    async def test_get_collaterals_success(self, adapter, mock_boros_client):
+        """Test collateral fetch."""
+        mock_response = {
+            "collaterals": [
+                {
+                    "tokenId": 3,
+                    "crossPosition": {"netBalance": "100000000000000000000"},
+                    "isolatedPositions": [],
+                }
+            ]
+        }
+        mock_boros_client.get_collaterals = AsyncMock(return_value=mock_response)
+
+        success, data = await adapter.get_collaterals()
+
+        assert success is True
+        assert "collaterals" in data
+
+    @pytest.mark.asyncio
+    async def test_get_account_balances_success(self, adapter, mock_boros_client):
+        """Test account balance fetch."""
+        mock_response = {
+            "collaterals": [
+                {
+                    "tokenId": 3,
+                    "crossPosition": {"availableBalance": "100000000000000000000"},
+                    "isolatedPositions": [{"availableBalance": "50000000000000000000"}],
+                }
+            ]
+        }
+        mock_boros_client.get_collaterals = AsyncMock(return_value=mock_response)
+
+        success, balances = await adapter.get_account_balances(token_id=3)
+
+        assert success is True
+        assert balances["cross"] == 100.0
+        assert balances["isolated"] == 50.0
+        assert balances["total"] == 150.0
+
+    @pytest.mark.asyncio
+    async def test_get_active_positions_success(self, adapter, mock_boros_client):
+        """Test active positions fetch."""
+        mock_response = {
+            "collaterals": [
+                {
+                    "tokenId": 3,
+                    "crossPosition": {
+                        "marketPositions": [
+                            {
+                                "marketId": 18,
+                                "side": 1,
+                                "sizeWei": "1000000000000000000",
+                            }
+                        ]
+                    },
+                    "isolatedPositions": [],
+                }
+            ]
+        }
+        mock_boros_client.get_collaterals = AsyncMock(return_value=mock_response)
+
+        success, positions = await adapter.get_active_positions(market_id=18)
+
+        assert success is True
+        assert len(positions) == 1
+        assert positions[0]["marketId"] == 18
+        assert positions[0]["size"] == 1.0
+
+    @pytest.mark.asyncio
+    async def test_get_open_limit_orders_success(self, adapter, mock_boros_client):
+        """Test open orders fetch."""
+        mock_response = [
+            {
+                "orderId": "order-123",
+                "marketId": 18,
+                "side": 1,
+                "size": "1000000000000000000",
+                "filledSize": "500000000000000000",
+                "limitTick": 100,
+                "tickStep": 1,
+                "status": "open",
+            }
+        ]
+        mock_boros_client.get_open_orders = AsyncMock(return_value=mock_response)
+
+        success, orders = await adapter.get_open_limit_orders()
+
+        assert success is True
+        assert len(orders) == 1
+        assert isinstance(orders[0], BorosLimitOrder)
+        assert orders[0].order_id == "order-123"
+        assert orders[0].size == 1.0
+        assert orders[0].filled_size == 0.5
+        assert orders[0].remaining_size == 0.5
+
+    @pytest.mark.asyncio
+    async def test_get_full_user_state_success(self, adapter, mock_boros_client):
+        market_acc = "0x" + ("0" * 58) + "000012"  # 0x12 == 18
+        mock_boros_client.get_collaterals = AsyncMock(
+            return_value={
+                "collaterals": [
+                    {
+                        "tokenId": 3,
+                        "crossPosition": {
+                            "availableBalance": "1000000000000000000",
+                            "marketPositions": [
+                                {
+                                    "marketId": 18,
+                                    "side": 1,
+                                    "notionalSize": "1000000000000000000",
+                                    "pnl": {
+                                        "unrealisedPnl": "0",
+                                        "rateSettlementPnl": "0",
+                                    },
+                                }
+                            ],
+                        },
+                        "isolatedPositions": [
+                            {
+                                "availableBalance": "2000000000000000000",
+                                "marketAcc": market_acc,
+                                "marketPositions": [
+                                    {
+                                        "marketId": 18,
+                                        "side": 0,
+                                        "notionalSize": "2000000000000000000",
+                                        "pnl": {
+                                            "unrealisedPnl": "0",
+                                            "rateSettlementPnl": "0",
+                                        },
+                                    }
+                                ],
+                            }
+                        ],
+                        "withdrawal": {
+                            "lastWithdrawalRequestTime": 0,
+                            "lastWithdrawalAmount": 0,
+                        },
+                    }
+                ]
+            }
+        )
+        mock_boros_client.get_open_orders = AsyncMock(
+            return_value=[
+                {
+                    "orderId": "order-1",
+                    "marketId": 18,
+                    "side": 1,
+                    "size": "1000000000000000000",
+                    "filledSize": "0",
+                    "limitTick": 100,
+                    "tickStep": 1,
+                    "status": "open",
+                }
+            ]
+        )
+
+        ok, state = await adapter.get_full_user_state(include_withdrawal_status=False)
+        assert ok is True
+        assert state["protocol"] == "boros"
+        assert state["chainId"] == adapter.chain_id
+        assert "collaterals" in state
+        assert state["balances"]["total"] == 3.0
+        assert len(state["positions"]) == 2
+        assert len(state["openOrders"]) == 1
+
+    @pytest.mark.asyncio
+    async def test_deposit_to_cross_margin_simulation(self, adapter):
+        """Test deposit in simulation mode."""
+        success, result = await adapter.deposit_to_cross_margin(
+            collateral_address="0xabcd",
+            amount_wei=1000000,  # 1 USDT
+            token_id=3,
+            market_id=18,
+        )
+
+        assert success is True
+        assert result["status"] == "simulated"
+
+    @pytest.mark.asyncio
+    async def test_withdraw_collateral_simulation(self, adapter):
+        """Test withdraw in simulation mode."""
+        success, result = await adapter.withdraw_collateral(
+            token_id=3,
+            amount_wei=1000000000000000000,
+        )
+
+        assert success is True
+        assert result["status"] == "simulated"
+
+    @pytest.mark.asyncio
+    async def test_place_rate_order_simulation(self, adapter):
+        """Test place order in simulation mode."""
+        success, result = await adapter.place_rate_order(
+            market_id=18,
+            token_id=3,
+            size_yu_wei=1000000000000000000,
+            side="short",
+            limit_tick=100,
+        )
+
+        assert success is True
+        assert result["status"] == "simulated"
+
+    @pytest.mark.asyncio
+    async def test_close_positions_market_simulation(self, adapter, mock_boros_client):
+        """Test close position in simulation mode."""
+        mock_response = {
+            "collaterals": [
+                {
+                    "tokenId": 3,
+                    "crossPosition": {
+                        "marketPositions": [
+                            {
+                                "marketId": 18,
+                                "side": 1,
+                                "sizeWei": "1000000000000000000",
+                            }
+                        ]
+                    },
+                    "isolatedPositions": [],
+                }
+            ]
+        }
+        mock_boros_client.get_collaterals = AsyncMock(return_value=mock_response)
+
+        success, result = await adapter.close_positions_market(market_id=18)
+
+        assert success is True
+        assert result["status"] == "simulated"
+
+    @pytest.mark.asyncio
+    async def test_cancel_orders_simulation(self, adapter):
+        """Test cancel orders in simulation mode."""
+        success, result = await adapter.cancel_orders(
+            market_id=18,
+            cancel_all=True,
+        )
+
+        assert success is True
+        assert result["status"] == "simulated"
+
+    def test_tick_from_rate(self):
+        """Test APR to tick conversion."""
+        # 10% APR with tick_step=1
+        tick = BorosAdapter.tick_from_rate(0.10, tick_step=1, round_down=False)
+        assert tick > 0
+
+        # Verify roundtrip
+        rate_back = BorosAdapter.rate_from_tick(tick, tick_step=1)
+        assert abs(rate_back - 0.10) < 0.001
+
+    def test_rate_from_tick(self):
+        """Test tick to APR conversion."""
+        rate = BorosAdapter.rate_from_tick(954, tick_step=1)
+        assert rate > 0
+        assert rate < 1  # Should be a decimal
+
+        # Negative tick
+        rate_neg = BorosAdapter.rate_from_tick(-954, tick_step=1)
+        assert rate_neg < 0
+
+    def test_normalize_apr(self):
+        """Test APR normalization."""
+        # Already decimal
+        assert BorosAdapter.normalize_apr(0.10) == 0.10
+
+        # Percent (values between 1 and 1000)
+        assert BorosAdapter.normalize_apr(10.0) == 0.10
+
+        # BPS (values > 1000)
+        assert BorosAdapter.normalize_apr(1100) == 0.11  # 1100 bps = 11%
+
+        # 1e18 scaled
+        result = BorosAdapter.normalize_apr(100000000000000000)
+        assert abs(result - 0.10) < 0.001
+
+        # None
+        assert BorosAdapter.normalize_apr(None) is None

wayfinder_paths/adapters/boros_adapter/test_golden.py

@@ -0,0 +1,156 @@
+"""Golden tests for BorosAdapter parsing/quoting behavior.
+
+These are meant to be stable regression tests during refactors (types/utils split).
+"""
+
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from wayfinder_paths.adapters.boros_adapter.adapter import BorosAdapter
+
+
+@pytest.fixture
+def mock_boros_client():
+    return AsyncMock()
+
+
+@pytest.fixture
+def adapter(mock_boros_client):
+    mock_config = {
+        "strategy_wallet": {"address": "0x1234567890123456789012345678901234567890"},
+        "boros_adapter": {},
+    }
+    with patch(
+        "wayfinder_paths.adapters.boros_adapter.adapter.BorosClient",
+        return_value=mock_boros_client,
+    ):
+        a = BorosAdapter(config=mock_config, simulation=True)
+        a.boros_client = mock_boros_client
+        return a
+
+
+@pytest.mark.asyncio
+async def test_quote_markets_for_underlying_golden(adapter, mock_boros_client):
+    # Make tenor_days deterministic (quote_market uses current wall-clock time).
+    adapter._time_to_maturity_days = lambda maturity_ts: (maturity_ts or 0) / 1000.0  # type: ignore[method-assign]
+
+    mock_markets = [
+        {
+            "marketId": 2,
+            "address": "0x2222",
+            "tokenId": 3,
+            "imData": {
+                "symbol": "HYPERLIQUID-HYPE-USD",
+                "underlying": "HYPE",
+                "maturity": 2000,
+                "tickStep": 7,
+                "collateral": "0xUSDT",
+            },
+        },
+        {
+            "marketId": 1,
+            "address": "0x1111",
+            "tokenId": 3,
+            "imData": {
+                "symbol": "HYPERLIQUID-HYPE-USD",
+                "underlying": "HYPE",
+                "maturity": 1000,
+                "tickStep": 5,
+                "collateral": "0xUSDT",
+            },
+        },
+        # Same underlying but wrong platform should be filtered out when platform is set.
+        {
+            "marketId": 3,
+            "address": "0x3333",
+            "tokenId": 3,
+            "imData": {
+                "symbol": "OTHER-HYPE-USD",
+                "underlying": "HYPE",
+                "maturity": 1500,
+                "tickStep": 1,
+                "collateral": "0xUSDT",
+            },
+            "metadata": {"platformName": "OTHER"},
+            "platform": {"name": "OTHER"},
+        },
+    ]
+
+    async def _get_order_book(market_id: int, tick_size: float = 0.001):
+        if market_id == 1:
+            return {"long": {"ia": [100, 110]}, "short": {"ia": [120, 130]}}
+        if market_id == 2:
+            return {"long": {"ia": [200]}, "short": {"ia": [250]}}
+        return {"long": {"ia": [1]}, "short": {"ia": [2]}}
+
+    mock_boros_client.list_markets = AsyncMock(return_value=mock_markets)
+    mock_boros_client.get_order_book = AsyncMock(side_effect=_get_order_book)
+
+    ok, quotes = await adapter.quote_markets_for_underlying(
+        "HYPE", platform="hyperliquid", tick_size=0.001
+    )
+    assert ok is True
+
+    # Only the two Hyperliquid-tagged markets should remain.
+    assert [q.market_id for q in quotes] == [1, 2]
+
+    q1 = quotes[0]
+    assert q1.underlying == "HYPE"
+    assert q1.symbol == "HYPERLIQUID-HYPE-USD"
+    assert q1.maturity_ts == 1000
+    assert q1.tenor_days == 1.0
+    assert q1.tick_step == 5
+    assert q1.best_bid_apr == 0.11
+    assert q1.best_ask_apr == 0.12
+    assert q1.mid_apr == pytest.approx(0.115)
+
+    q2 = quotes[1]
+    assert q2.maturity_ts == 2000
+    assert q2.tenor_days == 2.0
+    assert q2.tick_step == 7
+    assert q2.best_bid_apr == 0.2
+    assert q2.best_ask_apr == 0.25
+    assert q2.mid_apr == pytest.approx(0.225)
+
+
+@pytest.mark.asyncio
+async def test_get_account_balances_isolated_market_id_golden(
+    adapter, mock_boros_client
+):
+    # marketAcc parsing: last 6 hex chars represent the market id (3 bytes).
+    market_acc = "0x" + ("0" * 58) + "000012"  # 0x12 == 18
+
+    mock_boros_client.get_collaterals = AsyncMock(
+        return_value={
+            "collaterals": [
+                {
+                    "tokenId": 3,
+                    "crossPosition": {"availableBalance": "100000000000000000000"},
+                    "isolatedPositions": [
+                        {
+                            "availableBalance": "50000000000000000000",
+                            "marketAcc": market_acc,
+                        }
+                    ],
+                }
+            ]
+        }
+    )
+
+    ok, balances = await adapter.get_account_balances(token_id=3)
+    assert ok is True
+    assert balances["cross"] == 100.0
+    assert balances["isolated"] == 50.0
+    assert balances["total"] == 150.0
+    assert balances["isolated_market_id"] == 18
+    assert balances["isolated_positions"] == [
+        {
+            "market_id": 18,
+            "balance": 50.0,
+            "balance_wei": 50000000000000000000,
+            "marketAcc": market_acc,
+        }
+    ]

wayfinder_paths/adapters/boros_adapter/types.py

@@ -0,0 +1,70 @@
+"""Types for BorosAdapter (dataclasses)."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any
+
+
+@dataclass
+class BorosMarketQuote:
+    """Quote data for a Boros market."""
+
+    market_id: int
+    market_address: str
+    symbol: str
+    underlying: str
+    tenor_days: float
+    maturity_ts: int
+    collateral_address: str
+    collateral_token_id: int | None
+    tick_step: int | None
+    mid_apr: float | None
+    best_bid_apr: float | None
+    best_ask_apr: float | None
+
+
+@dataclass
+class BorosTenorQuote:
+    """Tenor curve data for a Boros market."""
+
+    market_id: int
+    address: str
+    symbol: str
+    underlying_symbol: str
+    maturity: int
+    tenor_days: float
+    mid_apr: float | None
+    mark_apr: float | None
+    floating_apr: float | None
+    long_yield_apr: float | None
+    volume_24h: float | None
+    notional_oi: float | None
+
+
+@dataclass
+class BorosLimitOrder:
+    """Represents an open limit order on Boros."""
+
+    order_id: str
+    market_id: int
+    side: str  # "long" or "short"
+    size: float  # Size in YU
+    limit_tick: int  # APR in bps
+    limit_apr: float  # APR as decimal (e.g., 0.05 = 5%)
+    filled_size: float
+    remaining_size: float
+    status: str  # "open", "partially_filled", etc.
+    created_at: datetime | None = None
+    raw: dict[str, Any] | None = field(default=None, repr=False)
+
+
+@dataclass
+class MarginHealth:
+    """Margin health metrics for a Boros account."""
+
+    margin_ratio: float
+    maint_margin: float
+    net_balance: float
+    positions: list[dict[str, Any]]