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

wayfinder_paths/strategies/basis_trading_strategy/test_strategy.py

@@ -282,8 +282,25 @@ class TestBasisTradingStrategy:
                 assert success is False, "Expected deposit to fail"
 
     @pytest.mark.asyncio
-    async def test_update_without_deposit(self, strategy):
+    async def test_update_without_deposit(self, strategy, mock_hyperliquid_adapter):
         """Test update fails without deposit."""
+        strategy.deposit_amount = 0.0
+
+        # No USDC in perp withdrawable or spot.
+        mock_hyperliquid_adapter.get_user_state = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "marginSummary": {"accountValue": "0"},
+                    "withdrawable": "0",
+                    "assetPositions": [],
+                },
+            )
+        )
+        mock_hyperliquid_adapter.get_spot_user_state = AsyncMock(
+            return_value=(True, {"balances": []})
+        )
+
         success, msg = await strategy.update()
         assert success is False
         assert "No deposit" in msg
@@ -347,15 +364,6 @@ class TestBasisTradingStrategy:
         z = strategy._z_from_conf(0.99)
         assert 2.5 < z < 2.6  # ~2.576 for 99% two-sided confidence
 
-    def test_calculate_funding_stats(self, strategy):
-        """Test funding statistics calculation."""
-        hourly_funding = [0.0001, 0.0002, -0.0001, 0.0003, 0.0001]
-        stats = strategy._calculate_funding_stats(hourly_funding)
-
-        assert stats["points"] == 5
-        assert stats["mean_hourly"] > 0
-        assert stats["neg_hour_fraction"] == 0.2  # 1/5 negative
-
     @pytest.mark.asyncio
     async def test_build_batch_snapshot_and_filter(self, strategy):
         snap = await strategy.build_batch_snapshot(
@@ -521,7 +529,7 @@ class TestBasisTradingStrategy:
             )
         )
         mock_hyperliquid_adapter.get_valid_order_size = MagicMock(
-            side_effect=lambda aid, sz: sz
+            side_effect=lambda _aid, sz: sz
         )
         mock_hyperliquid_adapter.transfer_perp_to_spot = AsyncMock(
             return_value=(True, "ok")
@@ -763,3 +771,212 @@ class TestBasisTradingStrategy:
 
         # deposit_amount should now be set from detected balance
         assert strategy.deposit_amount == 50.0
+
+    @pytest.mark.asyncio
+    async def test_update_spot_usdc_only_rebalances_before_open(
+        self, strategy, mock_hyperliquid_adapter
+    ):
+        """
+        If funds are mostly in spot USDC (e.g., after liquidation), update() should:
+          - detect deposit from spot+perp USDC
+          - transfer spot->perp to reach the target split before opening.
+        """
+        strategy.deposit_amount = 0.0
+        strategy.current_position = None
+
+        # Perp account has $0 withdrawable, spot has $100 USDC
+        mock_hyperliquid_adapter.get_user_state = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "marginSummary": {"accountValue": "0"},
+                    "withdrawable": "0",
+                    "assetPositions": [],
+                },
+            )
+        )
+        mock_hyperliquid_adapter.get_spot_user_state = AsyncMock(
+            return_value=(
+                True,
+                {"balances": [{"coin": "USDC", "total": "100"}]},
+            )
+        )
+
+        # Avoid running the full solver; return a deterministic best trade.
+        strategy.find_best_trade_with_backtest = AsyncMock(
+            return_value={
+                "coin": "ETH",
+                "spot_asset_id": 10000,
+                "perp_asset_id": 1,
+                "net_apy": 0.1,
+                "best_L": 2,
+                "safe": {
+                    "7": {
+                        "safe_leverage": 2,
+                        "spot_usdc": 66.67,
+                        "spot_amount": 0.033335,
+                        "perp_amount": 0.033335,
+                    }
+                },
+            }
+        )
+
+        # Mock the paired filler to avoid actual execution
+        with patch(
+            "wayfinder_paths.strategies.basis_trading_strategy.strategy.PairedFiller"
+        ) as mock_filler_class:
+            mock_filler = MagicMock()
+            mock_filler.fill_pair_units = AsyncMock(
+                return_value=(0.5, 0.5, 1000.0, 1000.0, [], [])
+            )
+            mock_filler_class.return_value = mock_filler
+
+            success, _ = await strategy.update()
+            assert success is True
+
+        # Target spot was $66.67, so we should transfer $33.33 spot->perp.
+        mock_hyperliquid_adapter.transfer_spot_to_perp.assert_called_once()
+        _, kwargs = mock_hyperliquid_adapter.transfer_spot_to_perp.call_args
+        assert kwargs["address"] == "0x5678"
+        assert abs(kwargs["amount"] - 33.33) < 1e-6
+
+        # Should not attempt perp->spot when spot already has sufficient USDC.
+        mock_hyperliquid_adapter.transfer_perp_to_spot.assert_not_called()
+
+        assert strategy.deposit_amount == 100.0
+
+    @pytest.mark.asyncio
+    async def test_update_near_liquidation_closes_and_redeploys(
+        self, strategy, mock_hyperliquid_adapter
+    ):
+        """Near-liquidation should trigger an emergency close+redeploy (bypasses cooldown)."""
+        from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
+            BasisPosition,
+        )
+
+        strategy.deposit_amount = 100.0
+        strategy.current_position = BasisPosition(
+            coin="HYPE",
+            spot_asset_id=10107,
+            perp_asset_id=7,
+            spot_amount=1.0,
+            perp_amount=1.0,
+            entry_price=100.0,
+            leverage=2,
+            entry_timestamp=1700000000000,
+            funding_collected=0.0,
+        )
+
+        # Price is exactly 75% of the way from entry -> liquidation:
+        # (175 - 100) / (200 - 100) = 0.75
+        mock_hyperliquid_adapter.get_all_mid_prices = AsyncMock(
+            return_value=(True, {"HYPE": 175.0})
+        )
+        mock_hyperliquid_adapter.get_user_state = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "marginSummary": {
+                        "accountValue": "100",
+                        "withdrawable": "0",
+                        "totalNtlPos": "100",
+                    },
+                    "assetPositions": [
+                        {
+                            "position": {
+                                "coin": "HYPE",
+                                "szi": "-1.0",
+                                "entryPx": "100",
+                                "liquidationPx": "200",
+                            }
+                        }
+                    ],
+                },
+            )
+        )
+        mock_hyperliquid_adapter.get_spot_user_state = AsyncMock(
+            return_value=(
+                True,
+                {"balances": [{"coin": "HYPE", "total": "1.0"}]},
+            )
+        )
+
+        # Ensure cooldown would block a normal rebalance, but emergency should bypass it.
+        strategy._is_rotation_allowed = AsyncMock(return_value=(False, "cooldown"))
+        strategy._close_position = AsyncMock(return_value=(True, "closed"))
+        strategy._find_and_open_position = AsyncMock(return_value=(True, "redeployed"))
+
+        success, msg = await strategy.update()
+        assert success is True
+        assert msg == "redeployed"
+        strategy._close_position.assert_awaited_once()
+        strategy._find_and_open_position.assert_awaited_once()
+        strategy._is_rotation_allowed.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_net_deposit_handles_float_return(self, strategy):
+        """Test that strategy correctly handles float from get_strategy_net_deposit.
+
+        The ledger adapter returns (success, float) not (success, dict).
+        This test ensures the strategy doesn't try to call .get() on the float,
+        which would raise "'float' object has no attribute 'get'".
+        """
+        # Mock ledger adapter to return a float (not a dict)
+        strategy.ledger_adapter.get_strategy_net_deposit = AsyncMock(
+            return_value=(True, 1500.0)
+        )
+
+        # Call status() which internally uses get_strategy_net_deposit
+        status = await strategy.status()
+
+        # Verify net_deposit is correctly set from the float
+        assert status["net_deposit"] == 1500.0
+
+    @pytest.mark.asyncio
+    async def test_setup_handles_float_net_deposit(
+        self, mock_hyperliquid_adapter, ledger_adapter
+    ):
+        """Test that setup() correctly handles float from get_strategy_net_deposit.
+
+        This catches if code is changed to expect a dict with .get('net_deposit').
+        """
+        with patch(
+            "wayfinder_paths.strategies.basis_trading_strategy.strategy.HyperliquidAdapter",
+            return_value=mock_hyperliquid_adapter,
+        ):
+            with patch(
+                "wayfinder_paths.strategies.basis_trading_strategy.strategy.BalanceAdapter"
+            ):
+                with patch(
+                    "wayfinder_paths.strategies.basis_trading_strategy.strategy.TokenAdapter"
+                ):
+                    with patch(
+                        "wayfinder_paths.strategies.basis_trading_strategy.strategy.LedgerAdapter",
+                        return_value=ledger_adapter,
+                    ):
+                        with patch(
+                            "wayfinder_paths.strategies.basis_trading_strategy.strategy.WalletManager"
+                        ):
+                            from wayfinder_paths.strategies.basis_trading_strategy.strategy import (
+                                BasisTradingStrategy,
+                            )
+
+                            s = BasisTradingStrategy(
+                                config={
+                                    "main_wallet": {"address": "0x1234"},
+                                    "strategy_wallet": {"address": "0x5678"},
+                                },
+                            )
+                            s.hyperliquid_adapter = mock_hyperliquid_adapter
+                            s.ledger_adapter = ledger_adapter
+
+                            # Mock get_strategy_net_deposit to return float (not dict)
+                            s.ledger_adapter.get_strategy_net_deposit = AsyncMock(
+                                return_value=(True, 2500.0)
+                            )
+
+                            # Run setup - should not raise AttributeError
+                            await s.setup()
+
+                            # Verify deposit_amount was set from the float
+                            assert s.deposit_amount == 2500.0

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/README.md

@@ -66,7 +66,7 @@ Allocates USDT0 on HyperEVM across HyperLend stablecoin markets. The strategy:
 # Install dependencies
 poetry install
 
-# Generate main wallet (writes wallets.json)
+# Generate main wallet (writes config.json)
 # Creates a main wallet (or use 'just create-strategy' which auto-creates wallets)
 poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
 
@@ -82,4 +82,4 @@ poetry run python wayfinder_paths/run_strategy.py hyperlend_stable_yield_strateg
 poetry run python wayfinder_paths/run_strategy.py hyperlend_stable_yield_strategy --action withdraw --config $(pwd)/config.json
 ```
 
-Wallet addresses/labels are auto-resolved from `wallets.json`. Set `NETWORK=testnet` in your config to run the orchestration without touching live HyperEVM endpoints.
+Wallet addresses/labels are auto-resolved from `config.json`. Set `NETWORK=testnet` in your config to run the orchestration without touching live HyperEVM endpoints.

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/strategy.py

@@ -104,6 +104,7 @@ class HyperlendStableYieldStrategy(Strategy):
             f"rotation band (dwell={HYSTERESIS_DWELL_HOURS}h, z={HYSTERESIS_Z:.2f}) to avoid churn while still "
             "short-circuiting when yield gaps are extreme."
         ),
+        risk_description="Protocol risk is always present when engaging with DeFi strategies, this includes underlying DeFi protocols and Wayfinder itself. Additional risk includes rate volatility between sampling windows, swap slippage on HYPE ⇄ stable legs, HyperLend protocol risk, and rotation gas costs eroding yield if APY edges are thin. Strategy requires a small HYPE balance for gas on HyperEVM.",
         gas_token_symbol="HYPE",
         gas_token_id="hyperliquid-hyperevm",
         deposit_token_id="usdt0-hyperevm",

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/README.md

@@ -86,7 +86,7 @@ The position is **delta-neutral**: WETH debt offsets wstETH collateral, so PnL i
 # Install dependencies
 poetry install
 
-# Generate wallets (writes wallets.json)
+# Generate wallets (writes config.json)
 poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
 
 # Copy config and edit credentials

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/strategy.py

@@ -81,7 +81,8 @@ class MoonwellWstethLoopStrategy(Strategy):
     summary = "Loop wstETH on Moonwell for amplified staking yields."
 
     # Strategy parameters
-    MIN_GAS = 0.002  # Minimum Base ETH (in ETH) required for gas fees (Base L2)
+    # Minimum Base ETH (in ETH) required for gas fees (Base L2)
+    MIN_GAS = 0.002
     MAINTENANCE_GAS = MIN_GAS / 10
     # When wrapping ETH to WETH for swaps/repayment, avoid draining gas below this floor.
     # We can dip below MIN_GAS temporarily, but should not wipe the wallet.
@@ -110,6 +111,7 @@ class MoonwellWstethLoopStrategy(Strategy):
         description="Leveraged wstETH carry: loops USDC → borrow WETH → swap wstETH → lend. "
         "Depeg-aware sizing with safety factor. ETH-neutral: WETH debt vs wstETH collateral.",
         summary="Leveraged wstETH carry on Base with depeg-aware sizing.",
+        risk_description=f"Protocol risk is always present when engaging with DeFi strategies, this includes underlying DeFi protocols and Wayfinder itself. Additional risks include weth/wsteth depegging (this strategy tracks the peg and is robust up to {int(MAX_DEPEG * 100)}% depeg). The rate spread between weth borrow and wsteth lend may also turn negative. This will likely only be temporary and is very rare. If this persists manual withdraw may be needed.",
         gas_token_symbol="ETH",
         gas_token_id=ETH_TOKEN_ID,
         deposit_token_id=USDC_TOKEN_ID,
@@ -532,11 +534,9 @@ class MoonwellWstethLoopStrategy(Strategy):
             return 0
 
         try:
-            evm = getattr(self.web3_service, "evm_transactions", None)
-            if evm is None:
-                return 0
-            ok, bal = await evm.get_balance(
-                wallet_address, token_address, BASE_CHAIN_ID, block_identifier
+            ok, bal = await self.balance_adapter.get_balance(
+                token_id=token_id,
+                wallet_address=wallet_address,
             )
             return int(bal) if ok else 0
         except Exception as exc:
@@ -1340,7 +1340,8 @@ class MoonwellWstethLoopStrategy(Strategy):
         for mtoken in mtoken_list:
             pos = await self.moonwell_adapter.get_pos(mtoken=mtoken)
             positions.append(pos)
-            await asyncio.sleep(2.0)  # 2s delay between positions for public RPC
+            # 2s delay between positions for public RPC
+            await asyncio.sleep(2.0)
 
         # Token data can be fetched in parallel (uses cache, minimal RPC)
         token_data = await asyncio.gather(

wayfinder_paths/strategies/stablecoin_yield_strategy/README.md

@@ -71,7 +71,7 @@ Transactions are scoped to the strategy wallet and Enso Router approval/swap cal
 # Install dependencies
 poetry install
 
-# Generate main wallet (writes wallets.json)
+# Generate main wallet (writes config.json)
 # Creates a main wallet (or use 'just create-strategy' which auto-creates wallets)
 poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
 
@@ -86,4 +86,4 @@ poetry run python wayfinder_paths/run_strategy.py stablecoin_yield_strategy --ac
 poetry run python wayfinder_paths/run_strategy.py stablecoin_yield_strategy --action update --config $(pwd)/config.json
 ```
 
-Wallet addresses are auto-populated from `wallets.json` when you run `wayfinder_paths/scripts/make_wallets.py`. Set `NETWORK=testnet` in `config.json` to dry-run operations against mocked services.
+Wallet addresses are auto-populated from `config.json` when you run `wayfinder_paths/scripts/make_wallets.py`. Set `NETWORK=testnet` in `config.json` to dry-run operations against mocked services.

wayfinder_paths/strategies/stablecoin_yield_strategy/strategy.py

@@ -65,6 +65,7 @@ class StablecoinYieldStrategy(Strategy):
             f"Continuously optimizes positions for maximum stable yield while avoiding impermanent loss. "
             f"Min: {MIN_AMOUNT_USDC} USDC + ETH gas. Filters for ${MIN_TVL:,}+ TVL protocols."
         ),
+        risk_description=f"Protocol risk is always present when engaging with DeFi strategies, this includes underlying DeFi protocols and Wayfinder itself. Additional risks include temporary yield fluctuations, gas costs during rebalancing, and potential brief capital lock-up during protocol transitions. Strategy filters for protocols with a minimum TVL of ${MIN_TVL:,} to ensure low-risk exposure.",
         gas_token_symbol="ETH",
         gas_token_id="ethereum-base",
         deposit_token_id="usd-coin-base",
@@ -303,8 +304,8 @@ class StablecoinYieldStrategy(Strategy):
             success, deposit_data = await self.ledger_adapter.get_strategy_net_deposit(
                 wallet_address=strategy_address,
             )
-            if success:
-                self.DEPOSIT_USDC = deposit_data.get("net_deposit", 0)
+            if success and deposit_data is not None:
+                self.DEPOSIT_USDC = float(deposit_data)
                 logger.info(f"Strategy net deposit: {self.DEPOSIT_USDC} USDC")
             else:
                 logger.error(f"Failed to fetch strategy net deposit: {deposit_data}")
@@ -427,30 +428,29 @@ class StablecoinYieldStrategy(Strategy):
                 self._track_token(token_info.get("token_id"))
 
             success, reports = await self.pool_adapter.get_pools_by_ids(
-                pool_ids=[self.current_pool.get("token_id")],
-                merge_external=False,
+                pool_ids=[self.current_pool.get("token_id")]
             )
             if success and reports.get("pools"):
                 self.current_pool_data = reports.get("pools", [])[0]
 
-        identifiers = []
+        pool_ids = []
         pool_id = self.current_pool.get("token_id", None)
         if isinstance(pool_id, str):
-            identifiers.append(pool_id)
+            pool_ids.append(pool_id)
 
         pool_address = self.current_pool.get("address", None)
         pool_chain = self.current_pool.get("chain", None)
         chain_code = ((pool_chain or {}).get("code")) or None
         if isinstance(pool_address, str) and isinstance(chain_code, str):
-            identifiers.append(f"{chain_code.lower()}_{pool_address.lower()}")
+            pool_ids.append(f"{chain_code.lower()}_{pool_address.lower()}")
 
         llama_report = None
-        if identifiers:
-            success, llama_reports = await self.pool_adapter.get_llama_reports(
-                identifiers=identifiers
+        if pool_ids:
+            success, llama_reports = await self.pool_adapter.get_pools_by_ids(
+                pool_ids=pool_ids
             )
             if success:
-                for identifier in identifiers:
+                for identifier in pool_ids:
                     if not isinstance(identifier, str):
                         continue
                     report = llama_reports.get(identifier.lower(), None)
@@ -464,12 +464,12 @@ class StablecoinYieldStrategy(Strategy):
                 "llama_report": llama_report,
             }
 
-        if llama_report and llama_report.get("llama_combined_apy_pct") is not None:
+        if llama_report and llama_report.get("combined_apy_pct") is not None:
             self.current_combined_apy_pct = (
-                llama_report.get("llama_combined_apy_pct", 0) / 100
+                llama_report.get("combined_apy_pct", 0) / 100
             )
-        elif llama_report and llama_report.get("llama_apy_pct") is not None:
-            self.current_combined_apy_pct = llama_report.get("llama_apy_pct", 0) / 100
+        elif llama_report and llama_report.get("apy") is not None:
+            self.current_combined_apy_pct = llama_report.get("apy", 0) / 100
         elif self.current_pool_data:
             self.current_combined_apy_pct = self.current_pool_data.get("apy", 0)
 
@@ -525,8 +525,8 @@ class StablecoinYieldStrategy(Strategy):
             self.current_pool_balance = inferred_balance
             if inferred_entry:
                 self.current_pool_data = inferred_entry
-                llama_combined = inferred_entry.get("llama_combined_apy_pct")
-                llama_apy = inferred_entry.get("llama_apy_pct")
+                llama_combined = inferred_entry.get("combined_apy_pct")
+                llama_apy = inferred_entry.get("apy")
                 if llama_combined is not None:
                     self.current_combined_apy_pct = float(llama_combined) / 100
                 elif llama_apy is not None:
@@ -1209,7 +1209,7 @@ class StablecoinYieldStrategy(Strategy):
             self.current_combined_apy_pct = self.current_pool_data.get("apy", 0)
         else:
             self.current_combined_apy_pct = (
-                target_pool_data.get("llama_combined_apy_pct", 0) / 100
+                target_pool_data.get("combined_apy_pct", 0) / 100
                 if target_pool_data
                 else 0
             )
@@ -1440,21 +1440,21 @@ class StablecoinYieldStrategy(Strategy):
         return results
 
     async def _find_best_pool(self) -> tuple[bool, dict[str, Any]]:
-        success, llama_data = await self.pool_adapter.get_llama_matches()
+        success, llama_data = await self.pool_adapter.get_pools()
         if not success:
             return False, {"message": f"Failed to fetch Llama data: {llama_data}"}
 
         llama_pools = [
             pool
             for pool in llama_data.get("matches", [])
-            if pool.get("llama_stablecoin")
-            and pool.get("llama_il_risk") == "no"
-            and pool.get("llama_tvl_usd") > self.MIN_TVL
-            and pool.get("llama_apy_pct") > self.DUST_APY
+            if pool.get("stablecoin")
+            and pool.get("ilRisk") == "no"
+            and pool.get("tvlUsd") > self.MIN_TVL
+            and pool.get("combined_apy_pct") > self.DUST_APY
             and pool.get("network", "").lower() in self.SUPPORTED_NETWORK_CODES
         ]
         llama_pools = sorted(
-            llama_pools, key=lambda pool: pool.get("llama_apy_pct"), reverse=True
+            llama_pools, key=lambda pool: pool.get("combined_apy_pct"), reverse=True
         )
         if not llama_pools:
             return False, {"message": "No suitable pools found."}
@@ -1515,7 +1515,7 @@ class StablecoinYieldStrategy(Strategy):
             return None
 
         try:
-            combined_apy_pct = pool_data.get("llama_combined_apy_pct") / 100
+            combined_apy_pct = pool_data.get("combined_apy_pct") / 100
             success, quotes = await self.brap_adapter.get_swap_quote(
                 from_token_address=current_token.get("address"),
                 to_token_address=token.get("address"),

wayfinder_paths/strategies/stablecoin_yield_strategy/test_strategy.py

@@ -121,9 +121,8 @@ def strategy():
             )
 
     if hasattr(s, "ledger_adapter") and s.ledger_adapter:
-        s.ledger_adapter.get_strategy_net_deposit = AsyncMock(
-            return_value=(True, {"net_deposit": 0})
-        )
+        # NOTE: The real LedgerClient returns float, not dict!
+        s.ledger_adapter.get_strategy_net_deposit = AsyncMock(return_value=(True, 0.0))
         s.ledger_adapter.get_strategy_transactions = AsyncMock(
             return_value=(True, {"transactions": []})
         )
@@ -135,21 +134,21 @@ def strategy():
                 {"pools": [{"id": "test-pool-base", "apy": 15.0, "symbol": "POOL"}]},
             )
         )
-        s.pool_adapter.get_llama_matches = AsyncMock(
+        s.pool_adapter.get_pools = AsyncMock(
             return_value=(
                 True,
                 {
                     "matches": [
                         {
-                            "llama_stablecoin": True,
-                            "llama_il_risk": "no",
-                            "llama_tvl_usd": 2000000,
-                            "llama_apy_pct": 5.0,
+                            "stablecoin": True,
+                            "ilRisk": "no",
+                            "tvlUsd": 2000000,
+                            "apy": 5.0,
                             "network": "base",
                             "address": "0x1234567890123456789012345678901234567890",
                             "token_id": "test-pool-base",
                             "pool_id": "test-pool-base",
-                            "llama_combined_apy_pct": 15.0,
+                            "combined_apy_pct": 15.0,
                         }
                     ]
                 },
@@ -541,3 +540,23 @@ async def test_partial_liquidate_uses_tracked_tokens(strategy):
     # Verify success
     assert ok
     assert "liquidation completed" in msg.lower()
+
+
+@pytest.mark.asyncio
+async def test_setup_handles_float_net_deposit(strategy):
+    """Test that setup() correctly handles float from get_strategy_net_deposit.
+
+    The ledger adapter returns (success, float) not (success, dict).
+    This test ensures the strategy doesn't try to call .get() on the float,
+    which would raise "'float' object has no attribute 'get'".
+    """
+    # Mock get_strategy_net_deposit to return float (not dict)
+    strategy.ledger_adapter.get_strategy_net_deposit = AsyncMock(
+        return_value=(True, 1500.0)
+    )
+
+    # Run setup - should not raise AttributeError
+    await strategy.setup()
+
+    # Verify DEPOSIT_USDC was set from the float
+    assert strategy.DEPOSIT_USDC == 1500.0

wayfinder_paths/templates/adapter/README.md

@@ -46,7 +46,7 @@ class MyAdapter(BaseAdapter):
         """Example capability that proxies PoolClient."""
         try:
             data = await self.pool_client.get_pools_by_ids(
-                pool_ids=",".join(pool_ids), merge_external=True
+                pool_ids=pool_ids
             )
             return (True, data)
         except Exception as exc:  # noqa: BLE001

{wayfinder_paths-0.1.11.dist-info → wayfinder_paths-0.1.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wayfinder-paths
-Version: 0.1.11
+Version: 0.1.13
 Summary: Wayfinder Path: strategies and adapters
 Author: Wayfinder
 Author-email: dev@wayfinder.ai
@@ -15,8 +15,6 @@ Requires-Dist: loguru (>=0.7.3,<0.8.0)
 Requires-Dist: numpy (>=1.26.0,<2.0.0)
 Requires-Dist: pandas (>=2.2.0,<3.0.0)
 Requires-Dist: pydantic (>=2.11.9,<3.0.0)
-Requires-Dist: pydantic-settings (>=2.7.0,<3.0.0)
-Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
 Requires-Dist: pyyaml (>=6.0.1,<7.0.0)
 Requires-Dist: web3 (>=7.13.0,<8.0.0)
 Description-Content-Type: text/markdown
@@ -43,7 +41,7 @@ curl -sSL https://install.python-poetry.org | python3 -
 poetry install
 
 # ⚠️ Generate test wallets FIRST (required!)
-# This creates wallets.json with a main wallet for local testing
+# This creates config.json with a main wallet for local testing
 just create-wallets
 # Or manually: poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
 
@@ -92,8 +90,7 @@ wayfinder_paths/
 │   ├── config.example.json       # Example configuration
 │   ├── scripts/                  # Utility scripts
 │   └── run_strategy.py           # Strategy runner script
-├── config.json                   # Your local config (created by you)
-├── wallets.json                  # Generated dev wallets
+├── config.json                   # Your local config with credentials and wallets
 ├── pyproject.toml                # Poetry configuration
 └── README.md                     # This file
 ```
@@ -302,7 +299,7 @@ class MyAdapter(BaseAdapter):
 
     async def get_pools(self, pool_ids: list[str]):
         data = await self.pool_client.get_pools_by_ids(
-            pool_ids=",".join(pool_ids), merge_external=True
+            pool_ids=",".join(pool_ids)
         )
         return (True, data)
 ```
@@ -491,7 +488,7 @@ poetry run python wayfinder_paths/run_strategy.py stablecoin_yield_strategy --de
 
 ### Wallet Generation for Testing
 
-**Before running any strategies, generate test wallets.** This creates `wallets.json` in the repository root with throwaway wallets for local testing:
+**Before running any strategies, generate test wallets.** This creates `config.json` in the repository root with throwaway wallets for local testing:
 
 ```bash
 # Essential: Create main wallet for testing
@@ -501,8 +498,8 @@ just create-wallets
 
 This creates:
 
-- `main` wallet - your main wallet for testing (labeled "main" in wallets.json)
-- `wallets.json` - wallet addresses and private keys for local testing
+- `main` wallet - your main wallet for testing (labeled "main" in config.json)
+- `config.json` - wallet addresses and private keys for local testing
 
 **Note:** Strategy-specific wallets are automatically created when you use `just create-strategy "Strategy Name"`. For manual creation, use `just create-wallet "strategy_name"` or `poetry run python wayfinder_paths/scripts/make_wallets.py --label "strategy_name"`.
 
@@ -538,9 +535,9 @@ cp wayfinder_paths/config.example.json config.json
 #   - user.username: Your Wayfinder username
 #   - user.password: Your Wayfinder password
 #   - OR user.refresh_token: Your refresh token
-#   - system.wallets_path: Path to wallets.json (default: "wallets.json")
+#   - system.wallets_path: Path to config.json (default: "config.json")
 #
-# Wallet addresses are auto-loaded from wallets.json by default.
+# Wallet addresses are auto-loaded from config.json by default.
 # Then run with:
 poetry run python wayfinder_paths/run_strategy.py stablecoin_yield_strategy --config config.json
 ```