wayfinder-paths 0.1.14__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
@@ -523,8 +615,7 @@ async def test_atomic_deposit_iteration_swaps_from_eth_when_borrow_surfaces_as_e
         WSTETH_TOKEN_ID: 0,
     }
 
-    async def get_balance_side_effect(*, query: str, wallet_address: str, **_):
-        token_id = query if isinstance(query, str) else (query or {}).get("token_id")
+    async def get_balance_side_effect(*, token_id: str, wallet_address: str, **_):
         return (True, balances.get(token_id, 0))
 
     strategy.balance_adapter.get_balance = AsyncMock(
@@ -570,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,
@@ -588,8 +683,7 @@ async def test_complete_unpaired_weth_borrow_uses_eth_inventory(
         WSTETH_TOKEN_ID: 0,
     }
 
-    async def get_balance_side_effect(*, query: str, wallet_address: str):
-        token_id = query if isinstance(query, str) else (query or {}).get("token_id")
+    async def get_balance_side_effect(*, token_id: str, wallet_address: str):
         return (True, balances.get(token_id, 0))
 
     strategy.balance_adapter.get_balance = AsyncMock(
@@ -606,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()
 
 
@@ -633,10 +730,8 @@ async def test_sweep_token_balances_sweeps_tokens(strategy, mock_adapter_respons
     strategy.min_withdraw_usd = 1.0
 
     # Mock balance returns (has some WETH dust)
-    def balance_side_effect(*, query, wallet_address, **_):
-        token_id = query if isinstance(query, str) else (query or {}).get("token_id")
-        token_id_str = (token_id or "").lower()
-        if "weth" in token_id_str:
+    def balance_side_effect(token_id, wallet_address):
+        if "weth" in token_id.lower():
             return (True, 100 * 10**18)  # 100 WETH
         return (True, 0)
 
@@ -695,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."""
@@ -755,8 +906,7 @@ async def test_partial_liquidate_prefers_wsteth_when_excess(strategy):
     # Wallet balances (raw)
     balances: dict[str, int] = {USDC_TOKEN_ID: 0, WSTETH_TOKEN_ID: 0}
 
-    async def mock_get_balance(*, query: str, wallet_address: str):
-        token_id = query if isinstance(query, str) else (query or {}).get("token_id")
+    async def mock_get_balance(*, token_id: str, wallet_address: str):
         return (True, balances.get(token_id, 0))
 
     strategy.balance_adapter.get_balance = AsyncMock(side_effect=mock_get_balance)
@@ -767,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(
@@ -844,8 +1000,7 @@ async def test_partial_liquidate_uses_usdc_collateral_when_no_wsteth_excess(stra
 
     balances: dict[str, int] = {USDC_TOKEN_ID: 0}
 
-    async def mock_get_balance(*, query: str, wallet_address: str):
-        token_id = query if isinstance(query, str) else (query or {}).get("token_id")
+    async def mock_get_balance(*, token_id: str, wallet_address: str):
         return (True, balances.get(token_id, 0))
 
     strategy.balance_adapter.get_balance = AsyncMock(side_effect=mock_get_balance)
@@ -855,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/strategy.py

@@ -1089,6 +1089,71 @@ class StablecoinYieldStrategy(Strategy):
             f"Successfully withdrew {amount} USDC from strategy: {breakdown_msg}",
         )
 
+    async def exit(self, **kwargs) -> StatusTuple:
+        """Transfer funds from strategy wallet to main wallet."""
+        logger.info("EXIT: Transferring remaining funds to main wallet")
+
+        strategy_address = self._get_strategy_wallet_address()
+        main_address = self._get_main_wallet_address()
+
+        if strategy_address.lower() == main_address.lower():
+            return (True, "Main wallet is strategy wallet, no transfer needed")
+
+        transferred_items = []
+
+        # Transfer USDC to main wallet
+        usdc_ok, usdc_raw = await self.balance_adapter.get_balance(
+            token_id="usd-coin-base",
+            wallet_address=strategy_address,
+        )
+        if usdc_ok and usdc_raw:
+            usdc_balance = float(usdc_raw.get("balance", 0))
+            if usdc_balance > 1.0:
+                logger.info(f"Transferring {usdc_balance:.2f} USDC to main wallet")
+                (
+                    success,
+                    msg,
+                ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
+                    query="usd-coin-base",
+                    amount=usdc_balance,
+                    strategy_name=self.name,
+                    skip_ledger=False,
+                )
+                if success:
+                    transferred_items.append(f"{usdc_balance:.2f} USDC")
+                else:
+                    logger.warning(f"USDC transfer failed: {msg}")
+
+        # Transfer ETH (minus reserve for tx fees) to main wallet
+        eth_ok, eth_raw = await self.balance_adapter.get_balance(
+            token_id="ethereum-base",
+            wallet_address=strategy_address,
+        )
+        if eth_ok and eth_raw:
+            eth_balance = float(eth_raw.get("balance", 0))
+            tx_fee_reserve = 0.0002
+            transferable_eth = eth_balance - tx_fee_reserve
+            if transferable_eth > 0.0001:
+                logger.info(f"Transferring {transferable_eth:.6f} ETH to main wallet")
+                (
+                    success,
+                    msg,
+                ) = await self.balance_adapter.move_from_strategy_wallet_to_main_wallet(
+                    query="ethereum-base",
+                    amount=transferable_eth,
+                    strategy_name=self.name,
+                    skip_ledger=False,
+                )
+                if success:
+                    transferred_items.append(f"{transferable_eth:.6f} ETH")
+                else:
+                    logger.warning(f"ETH transfer failed: {msg}")
+
+        if not transferred_items:
+            return (True, "No funds to transfer to main wallet")
+
+        return (True, f"Transferred to main wallet: {', '.join(transferred_items)}")
+
     async def _get_last_rotation_time(self, wallet_address: str) -> datetime | None:
         success, data = await self.ledger_adapter.get_strategy_latest_transactions(
             wallet_address=self._get_strategy_wallet_address(),

wayfinder_paths/templates/adapter/README.md

@@ -77,7 +77,7 @@ async def test_get_pools():
     ):
         adapter = MyAdapter(config={})
         success, data = await adapter.get_pools(["pool-1"])
-        assert success is True
+        assert success
         assert "pools" in data
 ```
 

{wayfinder_paths-0.1.14.dist-info → wayfinder_paths-0.1.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wayfinder-paths
-Version: 0.1.14
+Version: 0.1.15
 Summary: Wayfinder Path: strategies and adapters
 Author: Wayfinder
 Author-email: dev@wayfinder.ai