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

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/test_strategy.py

@@ -217,32 +217,36 @@ async def test_canonical_usage(strategy, mock_adapter_responses):
 @pytest.mark.asyncio
 async def test_status_returns_status_dict(strategy, mock_adapter_responses):
     """Test that _status returns a proper StatusDict."""
+    snap = MagicMock()
+    snap.totals_usd = {}
+    snap.ltv = 0.5
+    snap.debt_usd = 100.0
+    snap.net_equity_usd = 0.0
+
     with patch.object(
-        strategy, "_aggregate_positions", new_callable=AsyncMock
-    ) as mock_pos:
-        mock_pos.return_value = ({}, {})
-        with patch.object(strategy, "compute_ltv", new_callable=AsyncMock) as mock_ltv:
-            mock_ltv.return_value = 0.5
+        strategy, "_accounting_snapshot", new_callable=AsyncMock
+    ) as mock_snap:
+        mock_snap.return_value = (snap, (0.8, 0.8))
+        with patch.object(
+            strategy, "_get_gas_balance", new_callable=AsyncMock
+        ) as mock_gas:
+            mock_gas.return_value = 100000000000000000  # 0.1 ETH
             with patch.object(
-                strategy, "_get_gas_balance", new_callable=AsyncMock
-            ) as mock_gas:
-                mock_gas.return_value = 100000000000000000  # 0.1 ETH
+                strategy, "get_peg_diff", new_callable=AsyncMock
+            ) as mock_peg:
+                mock_peg.return_value = 0.001
                 with patch.object(
-                    strategy, "get_peg_diff", new_callable=AsyncMock
-                ) as mock_peg:
-                    mock_peg.return_value = 0.001
-                    with patch.object(
-                        strategy, "quote", new_callable=AsyncMock
-                    ) as mock_quote:
-                        mock_quote.return_value = {"apy": 0.1, "data": {}}
+                    strategy, "quote", new_callable=AsyncMock
+                ) as mock_quote:
+                    mock_quote.return_value = {"apy": 0.1, "data": {}}
 
-                        status = await strategy._status()
+                    status = await strategy._status()
 
-                        assert "portfolio_value" in status
-                        assert "net_deposit" in status
-                        assert "strategy_status" in status
-                        assert "gas_available" in status
-                        assert "gassed_up" in status
+                    assert "portfolio_value" in status
+                    assert "net_deposit" in status
+                    assert "strategy_status" in status
+                    assert "gas_available" in status
+                    assert "gassed_up" in status
 
 
 @pytest.mark.asyncio
@@ -417,93 +421,181 @@ async def test_swap_with_retries_aborts_on_unknown_outcome(
 
 
 @pytest.mark.asyncio
-async def test_balance_weth_debt_no_action_when_balanced(
-    strategy, mock_adapter_responses
-):
-    """Test that _balance_weth_debt does nothing when debt is balanced."""
-    # Mock wstETH position: 2 ETH worth
-    strategy.moonwell_adapter.get_pos = AsyncMock(
-        side_effect=[
-            (True, {"underlying_balance": 2 * 10**18, "borrow_balance": 0}),  # wstETH
-            (
-                True,
-                {"underlying_balance": 0, "borrow_balance": 1 * 10**18},
-            ),  # WETH debt
-        ]
-    )
-
-    # Mock prices: wstETH = $2000, WETH = $2000 (so 2 wstETH > 1 WETH debt)
-    strategy.token_adapter.get_token_price = AsyncMock(
-        return_value=(True, {"current_price": 2000.0})
-    )
-
-    success, msg = await strategy._balance_weth_debt()
+async def test_post_run_guard_no_action_when_delta_ok(strategy, mock_adapter_responses):
+    """Post-run guard should do nothing when delta is within tolerance."""
+    snap = MagicMock()
+    snap.wallet_wsteth = 0
+    snap.usdc_supplied = 0
+    snap.wsteth_supplied = 0
+    snap.weth_debt = 5 * 10**18
+    snap.debt_usd = 100.0
+    snap.hf = 1.3
+    snap.capacity_usd = 1000.0
+    snap.totals_usd = {
+        f"Base_{M_WSTETH}": 96.0,
+        f"Base_{M_USDC}": 0.0,
+        f"Base_{WETH}": -100.0,
+    }
 
-    assert success is True
-    assert "balanced" in msg.lower()
+    with patch.object(strategy, "_get_gas_balance", new_callable=AsyncMock) as mock_gas:
+        mock_gas.return_value = int(0.01 * 10**18)
+        with patch.object(
+            strategy, "_get_collateral_factors", new_callable=AsyncMock
+        ) as mock_cf:
+            mock_cf.return_value = (0.8, 0.8)
+            with patch.object(
+                strategy, "_accounting_snapshot", new_callable=AsyncMock
+            ) as mock_snap:
+                mock_snap.return_value = (snap, (0.8, 0.8))
+                with patch.object(
+                    strategy, "_ensure_markets_for_state", new_callable=AsyncMock
+                ) as mock_markets:
+                    mock_markets.return_value = (True, "ok")
+                    with patch.object(
+                        strategy,
+                        "_reconcile_wallet_into_position",
+                        new_callable=AsyncMock,
+                    ) as mock_reconcile:
+                        with patch.object(
+                            strategy,
+                            "_settle_weth_debt_to_target_usd",
+                            new_callable=AsyncMock,
+                        ) as mock_settle:
+                            ok, msg = await strategy._post_run_guard(mode="operate")
+                            assert ok is True
+                            assert "delta ok" in msg.lower()
+                            assert not mock_reconcile.called
+                            assert not mock_settle.called
 
 
 @pytest.mark.asyncio
-async def test_balance_weth_debt_rebalances_when_excess_debt(
+async def test_post_run_guard_restores_delta_via_reconcile(
     strategy, mock_adapter_responses
 ):
-    """Test that _balance_weth_debt attempts to rebalance when debt exceeds collateral."""
-    # Mock positions: wstETH value < WETH debt
-    strategy.moonwell_adapter.get_pos = AsyncMock(
-        side_effect=[
-            (True, {"underlying_balance": 1 * 10**18}),  # 1 wstETH
-            (True, {"borrow_balance": 2 * 10**18}),  # 2 WETH debt (excess)
-        ]
-    )
-
-    # Mock prices
-    strategy.token_adapter.get_token_price = AsyncMock(
-        return_value=(True, {"current_price": 2000.0})
-    )
-
-    # Mock wallet balances (has WETH to repay)
-    strategy.balance_adapter.get_balance = AsyncMock(
-        side_effect=[
-            (True, 1 * 10**18),  # WETH balance
-            (True, 0),  # ETH balance
-        ]
-    )
-
-    strategy.MIN_GAS = 0.005
-
-    success, msg = await strategy._balance_weth_debt()
-
-    # Should have attempted repayment
-    strategy.moonwell_adapter.repay.assert_called()
+    """Post-run guard should attempt wallet reconcile in operate mode when net short."""
+    snap1 = MagicMock()
+    snap1.wallet_wsteth = 0
+    snap1.usdc_supplied = 0
+    snap1.wsteth_supplied = 0
+    snap1.weth_debt = 5 * 10**18
+    snap1.debt_usd = 100.0
+    snap1.hf = 1.3
+    snap1.capacity_usd = 1000.0
+    snap1.totals_usd = {f"Base_{M_WSTETH}": 0.0, f"Base_{WETH}": -100.0}
+
+    snap2 = MagicMock()
+    snap2.wallet_wsteth = 0
+    snap2.usdc_supplied = 0
+    snap2.wsteth_supplied = 0
+    snap2.weth_debt = 5 * 10**18
+    snap2.debt_usd = 100.0
+    snap2.hf = 1.3
+    snap2.capacity_usd = 1000.0
+    snap2.totals_usd = {f"Base_{M_WSTETH}": 98.0, f"Base_{WETH}": -100.0}
+
+    with patch.object(strategy, "_get_gas_balance", new_callable=AsyncMock) as mock_gas:
+        mock_gas.return_value = int(0.01 * 10**18)
+        with patch.object(
+            strategy, "_get_collateral_factors", new_callable=AsyncMock
+        ) as mock_cf:
+            mock_cf.return_value = (0.8, 0.8)
+            with patch.object(
+                strategy, "_accounting_snapshot", new_callable=AsyncMock
+            ) as mock_snap:
+                mock_snap.side_effect = [(snap1, (0.8, 0.8)), (snap2, (0.8, 0.8))]
+                with patch.object(
+                    strategy, "_ensure_markets_for_state", new_callable=AsyncMock
+                ) as mock_markets:
+                    mock_markets.return_value = (True, "ok")
+                    with patch.object(
+                        strategy,
+                        "_reconcile_wallet_into_position",
+                        new_callable=AsyncMock,
+                    ) as mock_reconcile:
+                        mock_reconcile.return_value = (True, "ok")
+                        with patch.object(
+                            strategy,
+                            "_settle_weth_debt_to_target_usd",
+                            new_callable=AsyncMock,
+                        ) as mock_settle:
+                            ok, msg = await strategy._post_run_guard(mode="operate")
+                            assert ok is True
+                            assert "restored by reconcile" in msg.lower()
+                            assert mock_reconcile.called
+                            assert not mock_settle.called
 
 
 @pytest.mark.asyncio
-async def test_balance_weth_debt_rebalances_when_no_wsteth_position(
+async def test_post_run_guard_delevers_to_delta_when_reconcile_insufficient(
     strategy, mock_adapter_responses
 ):
-    """Test that _balance_weth_debt still rebalances when wstETH position fetch fails."""
-    strategy.moonwell_adapter.get_pos = AsyncMock(
-        side_effect=[
-            (False, "rpc error"),  # wstETH (treat as 0)
-            (True, {"borrow_balance": 2 * 10**18}),  # WETH debt
-        ]
-    )
-
-    strategy.token_adapter.get_token_price = AsyncMock(
-        return_value=(True, {"current_price": 2000.0})
-    )
-
-    strategy.balance_adapter.get_balance = AsyncMock(
-        side_effect=[
-            (True, 2 * 10**18),  # WETH balance (enough to repay)
-        ]
-    )
-
-    success, msg = await strategy._balance_weth_debt()
-
-    assert success is True
-    assert "balanced" in msg.lower()
-    strategy.moonwell_adapter.repay.assert_called()
+    """Post-run guard should delever debt when still net short after reconcile."""
+    snap1 = MagicMock()
+    snap1.wallet_wsteth = 0
+    snap1.usdc_supplied = 0
+    snap1.wsteth_supplied = 0
+    snap1.weth_debt = 5 * 10**18
+    snap1.debt_usd = 100.0
+    snap1.hf = 1.3
+    snap1.capacity_usd = 1000.0
+    snap1.totals_usd = {f"Base_{M_WSTETH}": 0.0, f"Base_{WETH}": -100.0}
+
+    snap2 = MagicMock()
+    snap2.wallet_wsteth = 0
+    snap2.usdc_supplied = 0
+    snap2.wsteth_supplied = 0
+    snap2.weth_debt = 5 * 10**18
+    snap2.debt_usd = 100.0
+    snap2.hf = 1.3
+    snap2.capacity_usd = 1000.0
+    snap2.totals_usd = {f"Base_{M_WSTETH}": 0.0, f"Base_{WETH}": -100.0}
+
+    snap3 = MagicMock()
+    snap3.wallet_wsteth = 0
+    snap3.usdc_supplied = 0
+    snap3.wsteth_supplied = 0
+    snap3.weth_debt = int(0.005 * 10**18)  # small debt
+    snap3.debt_usd = 12.0
+    snap3.hf = 1.3
+    snap3.capacity_usd = 1000.0
+    # mismatch = debt_usd - wsteth_coll_usd = 12 - 15 = -3 (within DELTA_TOL_USD of 5)
+    snap3.totals_usd = {f"Base_{M_WSTETH}": 15.0, f"Base_{WETH}": -12.0}
+
+    with patch.object(strategy, "_get_gas_balance", new_callable=AsyncMock) as mock_gas:
+        mock_gas.return_value = int(0.01 * 10**18)
+        with patch.object(
+            strategy, "_get_collateral_factors", new_callable=AsyncMock
+        ) as mock_cf:
+            mock_cf.return_value = (0.8, 0.8)
+            with patch.object(
+                strategy, "_accounting_snapshot", new_callable=AsyncMock
+            ) as mock_snap:
+                mock_snap.side_effect = [
+                    (snap1, (0.8, 0.8)),
+                    (snap2, (0.8, 0.8)),
+                    (snap3, (0.8, 0.8)),
+                ]
+                with patch.object(
+                    strategy, "_ensure_markets_for_state", new_callable=AsyncMock
+                ) as mock_markets:
+                    mock_markets.return_value = (True, "ok")
+                    with patch.object(
+                        strategy,
+                        "_reconcile_wallet_into_position",
+                        new_callable=AsyncMock,
+                    ) as mock_reconcile:
+                        mock_reconcile.return_value = (True, "ok")
+                        with patch.object(
+                            strategy,
+                            "_settle_weth_debt_to_target_usd",
+                            new_callable=AsyncMock,
+                        ) as mock_settle:
+                            mock_settle.return_value = (True, "ok")
+                            ok, msg = await strategy._post_run_guard(mode="operate")
+                            assert ok is True
+                            assert "delta ok" in msg.lower()
+                            assert mock_reconcile.called
+                            assert mock_settle.called
 
 
 @pytest.mark.asyncio
@@ -569,17 +661,21 @@ async def test_atomic_deposit_iteration_swaps_from_eth_when_borrow_surfaces_as_e
 
 
 @pytest.mark.asyncio
-async def test_complete_unpaired_weth_borrow_uses_eth_inventory(
+async def test_reconcile_wallet_into_position_uses_eth_inventory(
     strategy, mock_adapter_responses
 ):
     """If debt exists but wstETH collateral is missing, use wallet ETH to complete the loop."""
-    # wstETH pos is empty; WETH debt exists
-    strategy.moonwell_adapter.get_pos = AsyncMock(
-        side_effect=[
-            (True, {"underlying_balance": 0}),  # mwstETH
-            (True, {"borrow_balance": 5 * 10**18}),  # mWETH debt
-        ]
-    )
+
+    async def get_pos_side_effect(*, mtoken: str):
+        if mtoken == M_USDC:
+            return (True, {"underlying_balance": 0, "borrow_balance": 0})
+        if mtoken == M_WSTETH:
+            return (True, {"underlying_balance": 0, "borrow_balance": 0})
+        if mtoken == M_WETH:
+            return (True, {"underlying_balance": 0, "borrow_balance": 5 * 10**18})
+        return (True, {})
+
+    strategy.moonwell_adapter.get_pos = AsyncMock(side_effect=get_pos_side_effect)
 
     balances: dict[str, int] = {
         ETH_TOKEN_ID: 10 * 10**18,
@@ -604,10 +700,13 @@ async def test_complete_unpaired_weth_borrow_uses_eth_inventory(
 
     strategy._swap_with_retries = AsyncMock(side_effect=swap_side_effect)
 
-    success, msg = await strategy._complete_unpaired_weth_borrow()
+    success, msg = await strategy._reconcile_wallet_into_position(
+        collateral_factors=(0.8, 0.8),
+        max_batch_usd=100000.0,
+    )
 
     assert success is True
-    assert "completed unpaired borrow" in msg.lower()
+    assert strategy._swap_with_retries.called
     strategy.moonwell_adapter.lend.assert_called()
 
 
@@ -691,6 +790,62 @@ def test_min_leverage_gain_constant_exists(strategy):
     assert strategy._MIN_LEVERAGE_GAIN_BPS == 50e-4  # 50 bps
 
 
+@pytest.mark.asyncio
+async def test_update_runs_post_run_guard(strategy, mock_adapter_responses):
+    with patch.object(strategy, "_update_impl", new_callable=AsyncMock) as mock_impl:
+        with patch.object(
+            strategy, "_post_run_guard", new_callable=AsyncMock
+        ) as mock_guard:
+            mock_impl.return_value = (True, "ok")
+            mock_guard.return_value = (True, "guard ok")
+
+            ok, msg = await strategy.update()
+
+            assert ok is True
+            assert "finalizer:" in msg
+            mock_guard.assert_awaited()
+            assert mock_guard.call_args.kwargs.get("mode") == "operate"
+
+
+@pytest.mark.asyncio
+async def test_update_fails_if_post_run_guard_fails(strategy, mock_adapter_responses):
+    with patch.object(strategy, "_update_impl", new_callable=AsyncMock) as mock_impl:
+        with patch.object(
+            strategy, "_post_run_guard", new_callable=AsyncMock
+        ) as mock_guard:
+            mock_impl.return_value = (True, "ok")
+            mock_guard.return_value = (False, "guard failed")
+
+            ok, msg = await strategy.update()
+
+            assert ok is False
+            assert "finalizer failed" in msg.lower()
+
+
+@pytest.mark.asyncio
+async def test_withdraw_runs_post_run_guard_only_on_failure(
+    strategy, mock_adapter_responses
+):
+    with patch.object(strategy, "_withdraw_impl", new_callable=AsyncMock) as mock_impl:
+        with patch.object(
+            strategy, "_post_run_guard", new_callable=AsyncMock
+        ) as mock_guard:
+            mock_impl.return_value = (True, "ok")
+            mock_guard.return_value = (True, "guard ok")
+
+            ok, _ = await strategy.withdraw()
+
+            assert ok is True
+            mock_guard.assert_not_awaited()
+
+            mock_impl.return_value = (False, "failed")
+            ok, msg = await strategy.withdraw()
+            assert ok is False
+            assert "finalizer:" in msg
+            mock_guard.assert_awaited()
+            assert mock_guard.call_args.kwargs.get("mode") == "exit"
+
+
 @pytest.mark.asyncio
 async def test_leverage_calc_handles_high_cf_w(strategy, mock_adapter_responses):
     """Test that leverage calculation handles high collateral factors safely."""
@@ -762,7 +917,13 @@ async def test_partial_liquidate_prefers_wsteth_when_excess(strategy):
         f"Base_{M_USDC}": 1000.0,
         f"Base_{WETH}": -200.0,
     }
-    strategy._aggregate_positions = AsyncMock(return_value=({}, totals_usd))
+    snap = MagicMock()
+    snap.totals_usd = totals_usd
+    snap.debt_usd = 200.0
+    snap.wsteth_price = 2000.0
+    snap.wsteth_dec = 18
+
+    strategy._accounting_snapshot = AsyncMock(return_value=(snap, (0.8, 0.8)))
 
     # Collateral factors
     strategy.moonwell_adapter.get_collateral_factor = AsyncMock(
@@ -849,7 +1010,13 @@ async def test_partial_liquidate_uses_usdc_collateral_when_no_wsteth_excess(stra
         f"Base_{M_USDC}": 500.0,
         f"Base_{WETH}": -200.0,
     }
-    strategy._aggregate_positions = AsyncMock(return_value=({}, totals_usd))
+    snap = MagicMock()
+    snap.totals_usd = totals_usd
+    snap.debt_usd = 200.0
+    snap.usdc_price = 1.0
+    snap.usdc_dec = 6
+
+    strategy._accounting_snapshot = AsyncMock(return_value=(snap, (0.8, 0.8)))
 
     strategy.moonwell_adapter.get_collateral_factor = AsyncMock(
         return_value=(True, 0.8)

wayfinder_paths/strategies/stablecoin_yield_strategy/README.md

@@ -62,7 +62,7 @@ Transactions are scoped to the strategy wallet and Enso Router approval/swap cal
 ### Withdraw
 
 - Requires a prior deposit (the strategy tracks `self.DEPOSIT_USDC`).
-- Reads the pool balance via `BalanceAdapter.get_pool_balance`, unwinds via BRAP swaps back to USDC, and moves USDC from the strategy wallet to the main wallet via `BalanceAdapter.move_from_strategy_wallet_to_main_wallet`.
+- Reads the pool balance via `BalanceAdapter.get_balance` (with pool address and chain_id), unwinds via BRAP swaps back to USDC, and moves USDC from the strategy wallet to the main wallet via `BalanceAdapter.move_from_strategy_wallet_to_main_wallet`.
 - Updates the ledger and clears cached pool state.
 
 ## Running locally