wayfinder-paths 0.1.30__py3-none-any.whl → 0.1.31__py3-none-any.whl

wayfinder_paths/strategies/basis_trading_strategy/strategy.py

@@ -515,11 +515,14 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     f"Found ${strategy_usdc:.2f} USDC in strategy wallet, bridging to Hyperliquid"
                 )
 
+                # Convert USDC to raw units (6 decimals)
+                usdc_raw = int(strategy_usdc * 1e6)
                 success, result = await self.balance_adapter.send_to_address(
                     token_id=USDC_ARBITRUM_TOKEN_ID,
-                    amount=strategy_usdc,
+                    amount=usdc_raw,
                     from_wallet=strategy_wallet,
                     to_address=HYPERLIQUID_BRIDGE,
+                    signing_callback=self.strategy_wallet_signing_callback,
                 )
 
                 if not success:
@@ -559,7 +562,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 self.logger.warning(f"Failed to bridge USDC to Hyperliquid: {e}")
 
         if self.current_position is None:
-            return await self._find_and_open_position()
+            return await self._find_and_open_position(rotation_reason="initial_open")
 
         # Monitor existing position (handles idle capital, leg balance, stop-loss)
         return await self._monitor_position()
@@ -1029,7 +1032,9 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
     # Position Management                                                 #
     # ------------------------------------------------------------------ #
 
-    async def _find_and_open_position(self) -> StatusTuple:
+    async def _find_and_open_position(
+        self, *, rotation_reason: str | None = None
+    ) -> StatusTuple:
         self.logger.info("Analyzing basis trading opportunities...")
 
         try:
@@ -1255,6 +1260,19 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 entry_timestamp=int(time.time() * 1000),
             )
 
+            try:
+                await self._record_rotation(
+                    coin=coin,
+                    spot_asset_id=int(spot_asset_id),
+                    perp_asset_id=int(perp_asset_id),
+                    spot_units=float(spot_filled),
+                    perp_units=float(perp_filled),
+                    leverage=int(leverage),
+                    reason=rotation_reason,
+                )
+            except Exception as exc:  # noqa: BLE001
+                self.logger.debug(f"Failed to record rotation: {exc}")
+
             return (
                 True,
                 f"Opened basis position on {coin}: {spot_filled:.4f} units at {leverage}x, expected net APY: {expected_net_apy_pct:.1f}%",
@@ -1268,6 +1286,128 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
     # Position Scaling                                                    #
     # ------------------------------------------------------------------ #
 
+    async def _unused_usd_now(
+        self,
+        state: dict[str, Any],
+        *,
+        mid_prices: dict[str, Any] | None = None,
+    ) -> tuple[float, float]:
+        """Estimate deployable idle USDC without mistaking perp PnL for new cash.
+
+        `marginSummary.withdrawable` can increase just because the perp leg moves in our favor
+        (unrealized PnL), which frees margin but does not represent a fresh cash deposit.
+        This helper estimates idle capital by comparing current bankroll to what's allocated
+        to the delta-neutral position.
+
+        Returns:
+        - unused_usd: estimated deployable idle USDC.
+        - bankroll_now: estimated bankroll backing the position (perp equity + spot value + spot USDC).
+        """
+        if self.current_position is None:
+            return 0.0, 0.0
+
+        coin = self.current_position.coin
+
+        perp_position = self._get_perp_position(state)
+        if perp_position is None:
+            return 0.0, 0.0
+
+        if mid_prices is None:
+            success, mids = await self.hyperliquid_adapter.get_all_mid_prices()
+            if not success:
+                return 0.0, 0.0
+            mid_prices = mids
+
+        current_price = float(self._resolve_mid_price(coin, mid_prices) or 0.0)
+        if current_price <= 0:
+            return 0.0, 0.0
+
+        # Spot side: only track the strategy coin + USDC. (Other balances are ignored for safety.)
+        address = self._get_strategy_wallet_address()
+        spot_units = 0.0
+        spot_usdc = 0.0
+        success, spot_state = await self.hyperliquid_adapter.get_spot_user_state(
+            address
+        )
+        if success:
+            for bal in spot_state.get("balances", []):
+                bal_coin = str(bal.get("coin", ""))
+                try:
+                    total = float(bal.get("total", 0) or 0.0)
+                except (TypeError, ValueError):
+                    continue
+
+                if bal_coin == "USDC":
+                    spot_usdc = total
+                elif self._coins_match(bal_coin, coin):
+                    spot_units = abs(total)
+
+        spot_value = spot_units * current_price
+
+        # Perp side (account value includes margin + unrealized PnL + funding).
+        margin_summary = state.get("marginSummary") or {}
+        try:
+            perp_equity = float(margin_summary.get("accountValue", 0) or 0.0)
+        except (TypeError, ValueError):
+            perp_equity = 0.0
+
+        bankroll_now = perp_equity + spot_value + spot_usdc
+
+        # Position sizing inputs.
+        try:
+            perp_units = abs(float(perp_position.get("szi", 0) or 0.0))
+        except (TypeError, ValueError):
+            perp_units = 0.0
+
+        if perp_units <= 0 or spot_units <= 0:
+            return 0.0, bankroll_now
+
+        entry_px_raw = perp_position.get("entryPx") or self.current_position.entry_price
+        try:
+            perp_entry_price = float(entry_px_raw or 0.0)
+        except (TypeError, ValueError):
+            perp_entry_price = 0.0
+
+        if perp_entry_price <= 0:
+            return 0.0, bankroll_now
+
+        leverage = float(
+            self.current_position.leverage or self.DEFAULT_MAX_LEVERAGE or 1
+        )
+        lev_raw = perp_position.get("leverage")
+        if isinstance(lev_raw, dict):
+            try:
+                leverage = float(lev_raw.get("value") or leverage)
+            except (TypeError, ValueError):
+                pass
+        elif lev_raw is not None:
+            try:
+                leverage = float(lev_raw)
+            except (TypeError, ValueError):
+                pass
+        if leverage <= 0:
+            leverage = 1.0
+
+        funding_since_open = 0.0
+        cum_funding = perp_position.get("cumFunding") or {}
+        if isinstance(cum_funding, dict):
+            try:
+                funding_since_open = abs(float(cum_funding.get("sinceOpen", 0) or 0.0))
+            except (TypeError, ValueError):
+                funding_since_open = 0.0
+
+        # Margin+PnL contribution of the perp leg for a short at leverage L.
+        current_perp_contrib = (
+            perp_entry_price * (1.0 + 1.0 / leverage) - current_price
+        ) * perp_units
+        # Conservative guard: don't let extreme loss create fake "unused" capital.
+        current_perp_contrib = max(0.0, current_perp_contrib)
+
+        allocated_now = current_perp_contrib + spot_value + funding_since_open
+        unused_usd = max(0.0, bankroll_now - allocated_now)
+
+        return unused_usd, bankroll_now
+
     async def _get_undeployed_capital(self) -> tuple[float, float]:
         address = self._get_strategy_wallet_address()
 
@@ -1495,7 +1635,9 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     False,
                     f"Emergency rebalance failed - could not close: {close_msg}",
                 )
-            return await self._find_and_open_position()
+            return await self._find_and_open_position(
+                rotation_reason="near_liquidation"
+            )
 
         needs_rebalance, reason = await self._needs_new_position(state, hl_value)
 
@@ -1514,7 +1656,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             if not close_success:
                 return (False, f"Rebalance failed - could not close: {close_msg}")
 
-            return await self._find_and_open_position()
+            return await self._find_and_open_position(rotation_reason=str(reason))
 
         leg_ok, leg_msg = await self._verify_leg_balance(state)
         if not leg_ok:
@@ -1525,15 +1667,14 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             else:
                 actions_taken.append(f"Leg imbalance repair failed: {repair_msg}")
 
-        perp_margin, spot_usdc = await self._get_undeployed_capital()
-        total_idle = perp_margin + spot_usdc
-        min_deploy = max(self.MIN_UNUSED_USD, self.UNUSED_REL_EPS * self.deposit_amount)
+        unused_usd, bankroll_now = await self._unused_usd_now(state)
+        min_deploy = max(self.MIN_UNUSED_USD, self.UNUSED_REL_EPS * bankroll_now)
 
-        if total_idle > min_deploy:
+        if unused_usd > min_deploy:
             self.logger.info(
-                f"Found ${total_idle:.2f} idle capital, scaling up position"
+                f"Found ${unused_usd:.2f} deployable idle USDC, scaling up position"
             )
-            scale_ok, scale_msg = await self._scale_up_position(total_idle)
+            scale_ok, scale_msg = await self._scale_up_position(unused_usd)
             if scale_ok:
                 actions_taken.append(f"Scaled up: {scale_msg}")
                 # Refresh state after scale-up so stop-loss uses new position size/liq price
@@ -1550,16 +1691,23 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             actions_taken.append(sl_msg)
 
         position_age_hours = (time.time() * 1000 - pos.entry_timestamp) / (1000 * 3600)
+        rotation_hint = ""
+        try:
+            rotation_hint = await self._rotation_cooldown_hint()
+        except Exception as exc:  # noqa: BLE001
+            self.logger.debug(f"Could not compute rotation cooldown hint: {exc}")
 
         if actions_taken:
+            suffix = f". Rotation: {rotation_hint}" if rotation_hint else ""
             return (
                 True,
-                f"Position on {coin} monitored, age: {position_age_hours:.1f}h. Actions: {'; '.join(actions_taken)}",
+                f"Position on {coin} monitored, age: {position_age_hours:.1f}h. Actions: {'; '.join(actions_taken)}{suffix}",
             )
 
+        suffix = f". Rotation: {rotation_hint}" if rotation_hint else ""
         return (
             True,
-            f"Position on {coin} healthy, age: {position_age_hours:.1f}h",
+            f"Position on {coin} healthy, age: {position_age_hours:.1f}h{suffix}",
         )
 
     async def _is_near_liquidation(self, state: dict[str, Any]) -> tuple[bool, str]:
@@ -2128,6 +2276,44 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
     # Rotation Cooldown                                                   #
     # ------------------------------------------------------------------ #
 
+    async def _record_rotation(
+        self,
+        *,
+        coin: str,
+        spot_asset_id: int,
+        perp_asset_id: int,
+        spot_units: float,
+        perp_units: float,
+        leverage: int,
+        reason: str | None = None,
+    ) -> None:
+        """Write a rotation marker to the local ledger so cooldown survives restarts."""
+        if not self.ledger_adapter:
+            return
+
+        wallet_address = self._get_strategy_wallet_address()
+        op_data: dict[str, Any] = {
+            "type": "BASIS_ROTATION",
+            "coin": str(coin),
+            "spot_asset_id": int(spot_asset_id),
+            "perp_asset_id": int(perp_asset_id),
+            "spot_units": float(spot_units),
+            "perp_units": float(perp_units),
+            "leverage": int(leverage),
+        }
+        if reason:
+            op_data["reason"] = str(reason)
+
+        try:
+            await self.ledger_adapter.ledger_client.add_strategy_operation(
+                wallet_address=wallet_address,
+                operation_data=op_data,
+                usd_value="0",
+                strategy_name=self.name or "basis_trading_strategy",
+            )
+        except Exception as exc:  # noqa: BLE001
+            self.logger.debug(f"Failed to write BASIS_ROTATION to ledger: {exc}")
+
     async def _get_last_rotation_time(self) -> datetime | None:
         wallet_address = self._get_strategy_wallet_address()
 
@@ -2145,16 +2331,20 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 else []
             )
             for txn in tx_list:
-                op_data = txn.get("op_data", {})
-                if (
-                    op_data.get("type") == "HYPE_SPOT"
-                    and op_data.get("buy_or_sell") == "buy"
-                ):
-                    created_str = txn.get("created")
-                    if created_str:
-                        return datetime.fromisoformat(
-                            str(created_str).replace("Z", "+00:00")
-                        )
+                op_data = txn.get("op_data") or {}
+                op_type = str(
+                    txn.get("operation")
+                    or (op_data.get("type") if isinstance(op_data, dict) else "")
+                    or ""
+                )
+                if op_type != "BASIS_ROTATION":
+                    continue
+
+                created_str = txn.get("created") or txn.get("timestamp")
+                if created_str:
+                    return datetime.fromisoformat(
+                        str(created_str).replace("Z", "+00:00")
+                    )
 
             return None
         except Exception as e:
@@ -2174,14 +2364,45 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if last_rotation.tzinfo is None:
             last_rotation = last_rotation.replace(tzinfo=UTC)
 
-        elapsed = now - last_rotation
         cooldown = timedelta(days=self.ROTATION_MIN_INTERVAL_DAYS)
 
-        if elapsed >= cooldown:
+        unlock_at = last_rotation + cooldown
+        remaining = unlock_at - now
+
+        if remaining <= timedelta(0):
             return True, "Cooldown passed"
 
-        remaining = cooldown - elapsed
-        return False, f"Rotation cooldown: {remaining.days} days remaining"
+        days = remaining.days
+        hours = remaining.seconds // 3600
+        unlock_str = unlock_at.strftime("%Y-%m-%d %H:%M UTC")
+        return (
+            False,
+            f"Rotation cooldown: {days}d {hours}h remaining (unlocks {unlock_str})",
+        )
+
+    async def _rotation_cooldown_hint(self) -> str:
+        """Human-readable rotation cooldown status for update() output."""
+        if self.current_position is None:
+            return ""
+
+        last_rotation = await self._get_last_rotation_time()
+        if last_rotation is None:
+            return "unlocked (cooldown inactive; no rotation recorded)"
+
+        now = datetime.now(UTC)
+        if last_rotation.tzinfo is None:
+            last_rotation = last_rotation.replace(tzinfo=UTC)
+
+        cooldown = timedelta(days=self.ROTATION_MIN_INTERVAL_DAYS)
+        unlock_at = last_rotation + cooldown
+        remaining = unlock_at - now
+        if remaining <= timedelta(0):
+            return "unlocked (cooldown passed)"
+
+        days = remaining.days
+        hours = remaining.seconds // 3600
+        unlock_str = unlock_at.strftime("%Y-%m-%d %H:%M UTC")
+        return f"{days}d {hours}h remaining (unlocks {unlock_str})"
 
     # ------------------------------------------------------------------ #
     # Live Portfolio Value                                                #

wayfinder_paths/strategies/basis_trading_strategy/test_strategy.py

@@ -429,35 +429,34 @@ class TestBasisTradingStrategy:
             coin="ETH",
             spot_asset_id=10000,
             perp_asset_id=1,
-            spot_amount=1.0,
-            perp_amount=1.0,
+            spot_amount=0.03,
+            perp_amount=0.03,
             entry_price=2000.0,
             leverage=2,
             entry_timestamp=1700000000000,
             funding_collected=0.0,
         )
 
-        # Mock user state with perp position and idle capital
-        # totalNtlPos represents position notional value, set high to avoid rebalance trigger
-        # unused_usd = accountValue - totalNtlPos = 120 - 112 = 8
-        # threshold for rebalance = epsilon * 2 = max(5, 0.02 * 100) * 2 = 10
-        # 8 < 10 so no rebalance
-        # total_idle = withdrawable (12) + spot_usdc (8) = 20 > min_deploy (5) so will scale up
-        # order_usd = 20 * (2/3) = 13.33 > MIN_NOTIONAL_USD (10)
+        # Make sure there's deployable idle USDC without relying on marginSummary.withdrawable.
+        # With 2x leverage and ~0.03 ETH:
+        # - spot value ≈ 0.03 * 2000 = 60
+        # - perp contrib ≈ (2000*(1+1/2) - 2000) * 0.03 = 30
+        # - bankroll ≈ 30 + 60 + 20 = 110
+        # - allocated ≈ 30 + 60 = 90
+        # - unused ≈ 20 (deployable USDC) -> scale up
         mock_hyperliquid_adapter.get_user_state = AsyncMock(
             return_value=(
                 True,
                 {
                     "marginSummary": {
-                        "accountValue": "120",
+                        "accountValue": "30",
                         "withdrawable": "12",
-                        "totalNtlPos": "112",
                     },
                     "assetPositions": [
                         {
                             "position": {
                                 "coin": "ETH",
-                                "szi": "-1.0",
+                                "szi": "-0.03",
                                 "leverage": {"value": "2"},
                                 "liquidationPx": "2500",
                                 "entryPx": "2000",
@@ -467,14 +466,14 @@ class TestBasisTradingStrategy:
                 },
             )
         )
-        # Include ETH spot balance for leg balance check, plus USDC for idle capital
+        # Include ETH spot balance for leg balance check, plus USDC to deploy.
         mock_hyperliquid_adapter.get_spot_user_state = AsyncMock(
             return_value=(
                 True,
                 {
                     "balances": [
-                        {"coin": "ETH", "total": "1.0"},
-                        {"coin": "USDC", "total": "8"},
+                        {"coin": "ETH", "total": "0.03"},
+                        {"coin": "USDC", "total": "20"},
                     ]
                 },
             )
@@ -516,6 +515,117 @@ class TestBasisTradingStrategy:
             assert mock_filler.fill_pair_units.called
             assert success
 
+    @pytest.mark.asyncio
+    async def test_update_does_not_scale_on_perp_pnl_margin_release(
+        self, strategy, mock_hyperliquid_adapter
+    ):
+        """A favorable perp move can increase withdrawable margin; it should not trigger scale-up."""
+        strategy.deposit_amount = 100.0
+        strategy.current_position = BasisPosition(
+            coin="ETH",
+            spot_asset_id=10000,
+            perp_asset_id=1,
+            spot_amount=0.03,
+            perp_amount=0.03,
+            entry_price=2000.0,
+            leverage=2,
+            entry_timestamp=1700000000000,
+            funding_collected=0.0,
+        )
+
+        # Price down benefits the short perp; withdrawable may rise, but unused cash is ~0.
+        mock_hyperliquid_adapter.get_all_mid_prices = AsyncMock(
+            return_value=(True, {"ETH": 1800.0, "BTC": 50000.0})
+        )
+        mock_hyperliquid_adapter.get_user_state = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "marginSummary": {
+                        "accountValue": "36",
+                        "withdrawable": "12",
+                    },
+                    "assetPositions": [
+                        {
+                            "position": {
+                                "coin": "ETH",
+                                "szi": "-0.03",
+                                "leverage": {"value": "2"},
+                                "liquidationPx": "2500",
+                                "entryPx": "2000",
+                            }
+                        }
+                    ],
+                },
+            )
+        )
+        mock_hyperliquid_adapter.get_spot_user_state = AsyncMock(
+            return_value=(True, {"balances": [{"coin": "ETH", "total": "0.03"}]})
+        )
+
+        strategy._scale_up_position = AsyncMock(return_value=(True, "scaled"))
+
+        success, _ = await strategy.update()
+        assert success
+        strategy._scale_up_position.assert_not_awaited()
+
+    @pytest.mark.asyncio
+    async def test_update_includes_rotation_cooldown_hint(
+        self, strategy, mock_hyperliquid_adapter
+    ):
+        strategy.deposit_amount = 100.0
+        strategy.current_position = BasisPosition(
+            coin="ETH",
+            spot_asset_id=10000,
+            perp_asset_id=1,
+            spot_amount=0.03,
+            perp_amount=0.03,
+            entry_price=2000.0,
+            leverage=2,
+            entry_timestamp=1700000000000,
+            funding_collected=0.0,
+        )
+
+        mock_hyperliquid_adapter.get_user_state = AsyncMock(
+            return_value=(
+                True,
+                {
+                    "marginSummary": {
+                        "accountValue": "0",
+                        "withdrawable": "0",
+                    },
+                    "assetPositions": [
+                        {
+                            "position": {
+                                "coin": "ETH",
+                                "szi": "-0.03",
+                                "leverage": {"value": "2"},
+                                "liquidationPx": "2500",
+                                "entryPx": "2000",
+                            }
+                        }
+                    ],
+                },
+            )
+        )
+        mock_hyperliquid_adapter.get_spot_user_state = AsyncMock(
+            return_value=(True, {"balances": [{"coin": "ETH", "total": "0.03"}]})
+        )
+
+        strategy._needs_new_position = AsyncMock(
+            return_value=(False, "Position healthy")
+        )
+        strategy._verify_leg_balance = AsyncMock(return_value=(True, "ok"))
+        strategy._unused_usd_now = AsyncMock(return_value=(0.0, 100.0))
+        strategy._ensure_stop_loss_valid = AsyncMock(
+            return_value=(True, "Stop-loss ok")
+        )
+        strategy._rotation_cooldown_hint = AsyncMock(return_value="3d 4h remaining")
+
+        success, msg = await strategy.update()
+        assert success
+        assert "Rotation: 3d 4h remaining" in msg
+
     @pytest.mark.asyncio
     async def test_ensure_builder_fee_approved_already_approved(
         self, mock_hyperliquid_adapter, ledger_adapter

wayfinder_paths/strategies/hyperlend_stable_yield_strategy/manifest.yaml

@@ -0,0 +1,29 @@
+schema_version: "0.1"
+entrypoint: "wayfinder_paths.strategies.hyperlend_stable_yield_strategy.strategy.HyperlendStableYieldStrategy"
+permissions:
+  policy: |
+    (wallet.id == 'FORMAT_WALLET_ID') AND (
+      # Allow HyperLend supply and withdraw
+      (action.type == 'hyperlend_supply') OR
+      (action.type == 'hyperlend_withdraw') OR
+      # Allow WHYPE wrap/unwrap
+      (action.type == 'whype_deposit') OR
+      (action.type == 'whype_withdraw') OR
+      # Allow swaps via supported routers (Enso, LiFi, PRJX)
+      (action.type == 'swap' AND action.chain_id == 999) OR
+      # Allow ERC20 approvals for routers
+      (action.type == 'erc20_approve') OR
+      # Allow withdrawals to main wallet
+      (action.type == 'erc20_transfer' AND action.to == main_wallet.address)
+    )
+adapters:
+  - name: "BALANCE"
+    capabilities: ["wallet_read", "wallet_transfer"]
+  - name: "LEDGER"
+    capabilities: ["ledger.read", "ledger.write", "strategy.transactions"]
+  - name: "TOKEN"
+    capabilities: ["token.read"]
+  - name: "HYPERLEND"
+    capabilities: ["market.read", "supply", "withdraw", "rates"]
+  - name: "BRAP"
+    capabilities: ["swap.quote", "swap.execute"]

wayfinder_paths/strategies/moonwell_wsteth_loop_strategy/manifest.yaml

@@ -0,0 +1,33 @@
+schema_version: "0.1"
+entrypoint: "wayfinder_paths.strategies.moonwell_wsteth_loop_strategy.strategy.MoonwellWstethLoopStrategy"
+permissions:
+  policy: |
+    (wallet.id == 'FORMAT_WALLET_ID') AND (
+      # Allow Moonwell lending operations
+      (action.type == 'moonwell_mint') OR
+      (action.type == 'moonwell_redeem') OR
+      (action.type == 'moonwell_borrow') OR
+      (action.type == 'moonwell_repay') OR
+      (action.type == 'moonwell_enter_markets') OR
+      (action.type == 'moonwell_claim_rewards') OR
+      # Allow WETH wrap/unwrap
+      (action.type == 'weth_deposit') OR
+      (action.type == 'weth_withdraw') OR
+      # Allow swaps via Enso router
+      (action.type == 'swap' AND action.chain_id == 8453) OR
+      # Allow ERC20 approvals
+      (action.type == 'erc20_approve') OR
+      # Allow withdrawals to main wallet
+      (action.type == 'erc20_transfer' AND action.to == main_wallet.address)
+    )
+adapters:
+  - name: "BALANCE"
+    capabilities: ["wallet_read", "wallet_transfer"]
+  - name: "LEDGER"
+    capabilities: ["ledger.read", "ledger.write", "strategy.transactions"]
+  - name: "TOKEN"
+    capabilities: ["token.read"]
+  - name: "MOONWELL"
+    capabilities: ["market.read", "supply", "withdraw", "borrow", "repay", "collateral"]
+  - name: "BRAP"
+    capabilities: ["swap.quote", "swap.execute"]

wayfinder_paths/strategies/stablecoin_yield_strategy/manifest.yaml

@@ -0,0 +1,23 @@
+schema_version: "0.1"
+entrypoint: "wayfinder_paths.strategies.stablecoin_yield_strategy.strategy.StablecoinYieldStrategy"
+permissions:
+  policy: |
+    (wallet.id == 'FORMAT_WALLET_ID') AND (
+      # Allow swaps via Enso router on Base
+      (action.type == 'swap' AND action.chain_id == 8453) OR
+      # Allow ERC20 approvals for routers
+      (action.type == 'erc20_approve') OR
+      # Allow withdrawals to main wallet
+      (action.type == 'erc20_transfer' AND action.to == main_wallet.address)
+    )
+adapters:
+  - name: "BALANCE"
+    capabilities: ["wallet_read", "wallet_transfer"]
+  - name: "LEDGER"
+    capabilities: ["ledger.read", "ledger.write", "strategy.transactions"]
+  - name: "TOKEN"
+    capabilities: ["token.read"]
+  - name: "POOL"
+    capabilities: ["pool.read", "pool.search"]
+  - name: "BRAP"
+    capabilities: ["swap.quote", "swap.execute"]