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

wayfinder_paths/mcp/utils.py

@@ -0,0 +1,129 @@
+from __future__ import annotations
+
+import hashlib
+import json
+import os
+from decimal import ROUND_DOWN, Decimal, InvalidOperation, getcontext
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+getcontext().prec = 78
+
+
+def ok(result: Any) -> dict[str, Any]:
+    return {"ok": True, "result": result}
+
+
+def err(code: str, message: str, details: Any | None = None) -> dict[str, Any]:
+    return {
+        "ok": False,
+        "error": {"code": str(code), "message": str(message), "details": details},
+    }
+
+
+def repo_root() -> Path:
+    cur = Path(__file__).resolve()
+    for parent in [cur, *cur.parents]:
+        if (parent / "pyproject.toml").exists():
+            return parent
+    return Path.cwd()
+
+
+def read_yaml(path: Path) -> dict[str, Any]:
+    data = yaml.safe_load(path.read_text())
+    return data if isinstance(data, dict) else {}
+
+
+def read_text_excerpt(path: Path, *, max_chars: int = 1200) -> str | None:
+    try:
+        text = path.read_text(encoding="utf-8", errors="replace").strip()
+    except OSError:
+        return None
+    if not text:
+        return None
+    if len(text) <= max_chars:
+        return text
+    return text[: max_chars - 3] + "..."
+
+
+def load_json_file(path: Path) -> Any:
+    try:
+        return json.loads(path.read_text())
+    except Exception:
+        return None
+
+
+def load_config_json() -> dict[str, Any]:
+    cfg_path = os.getenv("WAYFINDER_CONFIG_PATH", "config.json")
+    path = (
+        repo_root() / cfg_path if not Path(cfg_path).is_absolute() else Path(cfg_path)
+    )
+    parsed = load_json_file(path)
+    return parsed if isinstance(parsed, dict) else {}
+
+
+def wallets_path() -> Path:
+    cfg = load_config_json()
+    system = cfg.get("system") if isinstance(cfg.get("system"), dict) else {}
+    candidate = (
+        (system or {}).get("wallets_path")
+        or os.getenv("WALLETS_PATH")
+        or "wallets.json"
+    )
+    p = Path(candidate)
+    if not p.is_absolute():
+        p = repo_root() / p
+    return p
+
+
+def load_wallets() -> list[dict[str, Any]]:
+    cfg = load_config_json()
+    if isinstance(cfg.get("wallets"), list):
+        return [w for w in cfg["wallets"] if isinstance(w, dict)]
+
+    p = wallets_path()
+    if p.exists():
+        parsed = load_json_file(p)
+        if isinstance(parsed, list):
+            return [w for w in parsed if isinstance(w, dict)]
+        if isinstance(parsed, dict) and isinstance(parsed.get("wallets"), list):
+            return [w for w in parsed["wallets"] if isinstance(w, dict)]
+    return []
+
+
+def find_wallet_by_label(label: str) -> dict[str, Any] | None:
+    want = str(label).strip()
+    if not want:
+        return None
+    for w in load_wallets():
+        if str(w.get("label", "")).strip() == want:
+            return w
+    return None
+
+
+def normalize_address(addr: str | None) -> str | None:
+    if not addr:
+        return None
+    a = str(addr).strip()
+    return a if a else None
+
+
+def parse_amount_to_raw(amount: str, decimals: int) -> int:
+    try:
+        d = Decimal(str(amount).strip())
+    except (InvalidOperation, ValueError) as exc:
+        raise ValueError(f"Invalid amount: {amount}") from exc
+    if d <= 0:
+        raise ValueError("Amount must be positive")
+    scale = Decimal(10) ** int(decimals)
+    raw = (d * scale).to_integral_value(rounding=ROUND_DOWN)
+    if raw <= 0:
+        raise ValueError("Amount is too small after decimal scaling")
+    return int(raw)
+
+
+def sha256_json(obj: Any) -> str:
+    payload = json.dumps(obj, sort_keys=True, separators=(",", ":"), ensure_ascii=False)
+    return "sha256:" + hashlib.sha256(payload.encode("utf-8")).hexdigest()

wayfinder_paths/policies/hyperliquid.py

@@ -24,7 +24,7 @@ def any_hyperliquid_user_payload():
                 "field": "chainId",
                 "field_source": "ethereum_typed_data_domain",
                 "operator": "eq",
-                "value": "421614",
+                "value": "42161",
             }
         ],
     }

wayfinder_paths/policies/lifi.py

@@ -0,0 +1,18 @@
+from wayfinder_paths.policies.util import allow_functions
+
+LIFI_ROUTERS: dict[int:str] = {999: "0x0a0758d937d1059c356D4714e57F5df0239bce1A"}
+LIFI_GENERIC = "0x31a9b1835864706Af10103b31Ea2b79bdb995F5F"
+
+
+async def lifi_swap(chain_id):
+    # NOTE: we get the abi from the base contract as it is a generic abi used everywhere
+    # and not all chains have this ABI published
+    return await allow_functions(
+        policy_name="Allow LIFI Swap",
+        abi_chain_id=8453,
+        address=LIFI_ROUTERS[chain_id],
+        function_names=[
+            "swapTokensMultipleV3ERC20ToERC20",
+        ],
+        abi_address_override=LIFI_GENERIC,
+    )

wayfinder_paths/policies/util.py

@@ -2,7 +2,11 @@ from wayfinder_paths.core.utils.evm_helpers import get_abi_filtered
 
 
 async def allow_functions(
-    policy_name: str, abi_chain_id: int, address: str, function_names: list[str]
+    policy_name: str,
+    abi_chain_id: int,
+    address: str,
+    function_names: list[str],
+    abi_address_override=None,
 ):
     # Note: ChainID is just for fetching ABI, doesn't appear in the final policy. Doesn't bind a strict chain.
     return {
@@ -19,7 +23,9 @@ async def allow_functions(
             {
                 "field_source": "ethereum_calldata",
                 "field": "function_name",
-                "abi": await get_abi_filtered(abi_chain_id, address, function_names),
+                "abi": await get_abi_filtered(
+                    abi_chain_id, abi_address_override or address, function_names
+                ),
                 "operator": "in",
                 "value": function_names,
             },

wayfinder_paths/strategies/basis_trading_strategy/strategy.py

@@ -4,6 +4,7 @@ import asyncio
 import math
 import random
 import time
+import traceback
 from collections.abc import Awaitable, Callable
 from datetime import UTC, datetime, timedelta
 from decimal import ROUND_DOWN, ROUND_UP, Decimal, getcontext
@@ -12,12 +13,8 @@ from statistics import fmean
 from typing import Any
 
 from wayfinder_paths.adapters.balance_adapter.adapter import BalanceAdapter
-from wayfinder_paths.adapters.hyperliquid_adapter.adapter import (
-    HYPERLIQUID_BRIDGE_ADDRESS,
-    HyperliquidAdapter,
-)
+from wayfinder_paths.adapters.hyperliquid_adapter.adapter import HyperliquidAdapter
 from wayfinder_paths.adapters.hyperliquid_adapter.executor import (
-    HyperliquidExecutor,
     LocalHyperliquidExecutor,
 )
 from wayfinder_paths.adapters.hyperliquid_adapter.paired_filler import (
@@ -54,6 +51,10 @@ from wayfinder_paths.core.analytics import (
 from wayfinder_paths.core.analytics import (
     z_from_conf as analytics_z_from_conf,
 )
+from wayfinder_paths.core.clients.protocols import (
+    HyperliquidExecutorProtocol as HyperliquidExecutor,
+)
+from wayfinder_paths.core.constants.contracts import HYPERLIQUID_BRIDGE
 from wayfinder_paths.core.strategies.descriptors import (
     Complexity,
     Directionality,
@@ -63,6 +64,11 @@ from wayfinder_paths.core.strategies.descriptors import (
     Volatility,
 )
 from wayfinder_paths.core.strategies.Strategy import StatusDict, StatusTuple, Strategy
+from wayfinder_paths.policies.erc20 import any_erc20_function
+from wayfinder_paths.policies.hyperliquid import (
+    any_hyperliquid_l1_payload,
+    any_hyperliquid_user_payload,
+)
 from wayfinder_paths.strategies.basis_trading_strategy.constants import (
     USDC_ARBITRUM_TOKEN_ID,
 )
@@ -201,7 +207,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             merged_config["strategy_wallet"] = strategy_wallet
         self.config = merged_config
 
-        # Position tracking
         self.current_position: BasisPosition | None = None
         self.deposit_amount: float = 0.0
 
@@ -266,8 +271,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             adapters.append(self.ledger_adapter)
         if self.hyperliquid_adapter is not None:
             adapters.append(self.hyperliquid_adapter)
-        if adapters:
-            self.register_adapters(adapters)
 
     async def setup(self) -> None:
         self.logger.info("Starting BasisTradingStrategy setup")
@@ -332,7 +335,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             )
             return
 
-        # Find matching spot position
         spot_position = None
         spot_balances = spot_state.get("balances", [])
         for bal in spot_balances:
@@ -437,7 +439,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 return (False, f"Failed to transfer ETH for gas: {gas_res}")
             self.logger.info(f"Gas transfer successful: {gas_res}")
 
-        # Real deposit: ensure funds are in the strategy wallet.
         try:
             main_address = self._get_main_wallet_address()
             strategy_address = self._get_strategy_wallet_address()
@@ -481,7 +482,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     f"Strategy wallet already has {strategy_usdc:.2f} USDC, skipping transfer from main"
                 )
 
-            # Accumulate deposit amount for bridging in update()
             self.deposit_amount += main_token_amount
 
             return (
@@ -527,7 +527,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if total_available < 1.0 and self.current_position is None:
             return (False, "No funds to manage. Call deposit() first.")
 
-        # Bridge USDC from strategy wallet to Hyperliquid if needed
         if strategy_usdc > 10.0:
             try:
                 self.logger.info(
@@ -538,7 +537,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     token_id=USDC_ARBITRUM_TOKEN_ID,
                     amount=strategy_usdc,
                     from_wallet=strategy_wallet,
-                    to_address=HYPERLIQUID_BRIDGE_ADDRESS,
+                    to_address=HYPERLIQUID_BRIDGE,
                 )
 
                 if not success:
@@ -547,7 +546,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
                 self.logger.info(f"USDC sent to bridge, tx: {result}")
 
-                # Wait for Hyperliquid to credit the deposit
                 self.logger.info("Waiting for Hyperliquid to credit the deposit...")
 
                 (
@@ -578,7 +576,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             except Exception as e:
                 self.logger.warning(f"Failed to bridge USDC to Hyperliquid: {e}")
 
-        # If no position, find and open one
         if self.current_position is None:
             return await self._find_and_open_position()
 
@@ -702,8 +699,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
         except Exception as e:
             self.logger.error(f"Analysis failed: {e}")
-            import traceback
-
             traceback.print_exc()
             return {
                 "success": False,
@@ -774,7 +769,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             margin_summary = user_state.get("marginSummary", {})
             hl_perp_value = float(margin_summary.get("accountValue", 0))
 
-        # Also check spot USDC balance
         success, spot_state = await self.hyperliquid_adapter.get_spot_user_state(
             address
         )
@@ -798,13 +792,11 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 f"Call exit() to transfer to main wallet.",
             )
 
-        # Close any open position
         if self.current_position is not None:
             close_success, close_msg = await self._close_position()
             if not close_success:
                 return (False, f"Failed to close position: {close_msg}")
 
-        # Step 1: Transfer any spot USDC to perp for withdrawal
         # Wait for spot sale to settle before checking balance
         await asyncio.sleep(5)
 
@@ -850,7 +842,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     break
             break
 
-        # Step 2: Get updated perp balance for withdrawal (with retry)
         # Wait a moment for transfers to settle
         await asyncio.sleep(2)
 
@@ -874,7 +865,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if withdrawable <= 0:
             return (False, "No withdrawable funds available")
 
-        # Step 3: Withdraw from Hyperliquid to Arbitrum (strategy wallet)
         self.logger.info(
             f"Withdrawing ${withdrawable:.2f} from Hyperliquid to Arbitrum"
         )
@@ -888,7 +878,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
         self.logger.info(f"Withdrawal initiated: {withdraw_result}")
 
-        # Step 4: Wait for withdrawal to appear on-chain
         # Hyperliquid withdrawals typically take 5-15 minutes
         self.logger.info("Waiting for withdrawal to appear on-chain...")
 
@@ -915,7 +904,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             f"Withdrawal confirmed: tx={tx_hash}, amount=${withdrawn_amount:.2f}"
         )
 
-        # Step 5: Wait a bit for the USDC to be credited on Arbitrum
         await asyncio.sleep(10)
 
         final_balance = 0.0
@@ -949,7 +937,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
         transferred_items = []
 
-        # Transfer USDC to main wallet
         usdc_ok, usdc_raw = await self.balance_adapter.get_balance(
             token_id=USDC_ARBITRUM_TOKEN_ID,
             wallet_address=strategy_address,
@@ -1045,63 +1032,16 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             gassed_up=True,
         )
 
-    @staticmethod
-    async def policies() -> list[str]:
-        # Placeholder - would include Hyperliquid-specific policies
-        return []
-
     async def ensure_builder_fee_approved(self) -> StatusTuple:
-        if not self.builder_fee:
-            return True, "No builder fee configured"
-
+        if not self.hyperliquid_adapter:
+            return False, "Hyperliquid adapter not configured"
         address = self._get_strategy_wallet_address()
-        builder = self.builder_fee.get("b", "")
-        required_fee = self.builder_fee.get("f", 0)
-
-        if not builder or required_fee <= 0:
-            return True, "Builder fee not required"
-
-        try:
-            success, current_fee = await self.hyperliquid_adapter.get_max_builder_fee(
-                user=address,
-                builder=builder,
-            )
-
-            if not success:
-                self.logger.warning(
-                    "Failed to check builder fee approval, continuing anyway"
-                )
-                return True, "Could not verify builder fee, proceeding"
-
-            self.logger.info(
-                f"Builder fee approval check: current={current_fee}, required={required_fee}"
-            )
-
-            if current_fee >= required_fee:
-                return True, f"Builder fee already approved: {current_fee}"
-
-            # Need to approve
-            max_fee_rate = f"{required_fee / 1000:.3f}%"
-            self.logger.info(
-                f"Approving builder fee: builder={builder}, rate={max_fee_rate}"
-            )
-
-            success, result = await self.hyperliquid_adapter.approve_builder_fee(
-                builder=builder,
-                max_fee_rate=max_fee_rate,
-                address=address,
-            )
-
-            if not success:
-                self.logger.error(f"Builder fee approval failed: {result}")
-                return False, f"Builder fee approval failed: {result}"
-
-            self.logger.info(f"Builder fee approved: {result}")
-            return True, f"Builder fee approved at {max_fee_rate}"
-
-        except Exception as e:
-            self.logger.error(f"Builder fee approval error: {e}")
-            return False, f"Builder fee approval error: {e}"
+        if not address:
+            return False, "No strategy wallet address"
+        return await self.hyperliquid_adapter.ensure_builder_fee_approved(
+            address=address,
+            builder_fee=self.builder_fee,
+        )
 
     # ------------------------------------------------------------------ #
     # Position Management                                                 #
@@ -1218,7 +1158,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             coin = best.get("coin", "unknown")
             safe = best.get("safe", {})
 
-            # Use 7-day horizon sizing by default
             safe_7 = safe.get("7") or {}
             if safe_7.get("spot_usdc", 0) <= 0 or safe_7.get("perp_amount", 0) <= 0:
                 return (True, f"Best opportunity ({coin}) returned zero sizing.")
@@ -1237,19 +1176,16 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 f"expected net APY: {expected_net_apy_pct:.2f}%, target qty: {target_qty}"
             )
 
-            # Execute position using PairedFiller
             address = self._get_strategy_wallet_address()
             order_usd = float(safe_7.get("spot_usdc", 0.0) or 0.0)
             order_usd = float(
                 Decimal(str(order_usd)).quantize(Decimal("0.01"), rounding=ROUND_UP)
             )
 
-            # Step 1: Ensure builder fee is approved
             fee_success, fee_msg = await self.ensure_builder_fee_approved()
             if not fee_success:
                 return (False, f"Builder fee approval failed: {fee_msg}")
 
-            # Step 2: Update leverage for the perp asset
             self.logger.info(f"Setting leverage to {leverage}x for {coin}")
             success, lev_result = await self.hyperliquid_adapter.update_leverage(
                 asset_id=perp_asset_id,
@@ -1261,7 +1197,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 self.logger.warning(f"Failed to set leverage: {lev_result}")
                 # Continue anyway - leverage might already be set
 
-            # Step 3: Ensure USDC is split correctly between spot and perp.
             # Target: spot has order_usd for the spot buy, perp holds the remainder as margin.
             split_ok, split_msg = await self._rebalance_usdc_between_perp_and_spot(
                 target_spot_usdc=order_usd,
@@ -1270,7 +1205,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             if not split_ok:
                 self.logger.warning(f"USDC rebalance failed: {split_msg}")
 
-            # Step 4: Execute paired fill
             filler = PairedFiller(
                 adapter=self.hyperliquid_adapter,
                 address=address,
@@ -1304,7 +1238,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             success, mids = await self.hyperliquid_adapter.get_all_mid_prices()
             entry_price = self._resolve_mid_price(coin, mids) if success else 0.0
 
-            # Step 5: Get liquidation price and place stop-loss
             success, user_state = await self.hyperliquid_adapter.get_user_state(address)
             liquidation_price = None
             if success:
@@ -1473,7 +1406,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
 
         units_to_add = order_usd / price
 
-        # Round to valid decimals for the assets
         spot_valid = self.hyperliquid_adapter.get_valid_order_size(
             pos.spot_asset_id, units_to_add
         )
@@ -1493,7 +1425,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             f"(${order_usd:.2f}) at {leverage}x leverage"
         )
 
-        # Ensure idle USDC is split correctly between spot and perp for this scale-up.
         # Target: spot has order_usd for the spot buy, perp holds the remainder as margin.
         split_ok, split_msg = await self._rebalance_usdc_between_perp_and_spot(
             target_spot_usdc=order_usd,
@@ -1502,7 +1433,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if not split_ok:
             self.logger.warning(f"USDC rebalance failed: {split_msg}")
 
-        # Execute paired fill to add to both legs
         filler = PairedFiller(
             adapter=self.hyperliquid_adapter,
             address=address,
@@ -1585,8 +1515,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 )
             return await self._find_and_open_position()
 
-        # ------------------------------------------------------------------ #
-        # ------------------------------------------------------------------ #
         needs_rebalance, reason = await self._needs_new_position(state, hl_value)
 
         if needs_rebalance:
@@ -1599,31 +1527,22 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     f"Position needs attention but in cooldown: {cooldown_reason}",
                 )
 
-            # Perform rebalance: close and reopen
             self.logger.info(f"Rebalancing position: {reason}")
-
-            # Close existing position
             close_success, close_msg = await self._close_position()
             if not close_success:
                 return (False, f"Rebalance failed - could not close: {close_msg}")
 
-            # Open new position
             return await self._find_and_open_position()
 
-        # ------------------------------------------------------------------ #
-        # ------------------------------------------------------------------ #
         leg_ok, leg_msg = await self._verify_leg_balance(state)
         if not leg_ok:
             self.logger.warning(f"Leg imbalance detected: {leg_msg}")
-            # Try to repair the imbalance
             repair_ok, repair_msg = await self._repair_leg_imbalance(state)
             if repair_ok:
                 actions_taken.append(f"Repaired leg imbalance: {repair_msg}")
             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)
@@ -1642,8 +1561,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             else:
                 actions_taken.append(f"Scale-up failed: {scale_msg}")
 
-        # ------------------------------------------------------------------ #
-        # ------------------------------------------------------------------ #
         sl_ok, sl_msg = await self._ensure_stop_loss_valid(state)
         if not sl_ok:
             actions_taken.append(f"Stop-loss issue: {sl_msg}")
@@ -1915,7 +1832,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             order_coin = order.get("coin", "")
             order_id = order.get("oid")
 
-            # Cancel perp orders for this coin
             if order_coin == pos.coin and order_id:
                 self.logger.info(f"Canceling perp order {order_id} for {pos.coin}")
                 await self.hyperliquid_adapter.cancel_order(
@@ -1924,7 +1840,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                     address=address,
                 )
 
-            # Cancel spot orders for this coin
             if spot_coin and order_coin == spot_coin and order_id:
                 self.logger.info(f"Canceling spot order {order_id} for {spot_coin}")
                 await self.hyperliquid_adapter.cancel_order(
@@ -1940,10 +1855,8 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         pos = self.current_position
         self.logger.info(f"Closing position on {pos.coin}")
 
-        # Cancel all stop-loss and limit orders first
         await self._cancel_all_position_orders()
 
-        # Real execution via PairedFiller - reverse direction to close
         try:
             address = self._get_strategy_wallet_address()
             filler = PairedFiller(
@@ -2011,7 +1924,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if funding_earned > deposited_amount * self.FUNDING_REBALANCE_THRESHOLD:
             return True, f"Funding earned {funding_earned:.2f} exceeds threshold"
 
-        # Check 4: Perp must be SHORT
         perp_size = float(perp_position.get("szi", 0))
         if perp_size >= 0:
             return True, "Perp position is not short"
@@ -2110,7 +2022,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             address
         )
 
-        # Track existing valid orders and orders to cancel
         has_valid_perp_stop = False
         has_valid_spot_limit = False
         orders_to_cancel = []
@@ -2183,7 +2094,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                                 (spot_asset_id, order_id, "spot limit")
                             )
 
-        # Cancel invalid/duplicate orders
         for asset_id, order_id, order_desc in orders_to_cancel:
             self.logger.info(f"Canceling {order_desc} order {order_id}")
             await self.hyperliquid_adapter.cancel_order(
@@ -2192,7 +2102,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 address=address,
             )
 
-        # Place perp stop-loss if not valid one exists
         if not has_valid_perp_stop:
             success, result = await self.hyperliquid_adapter.place_stop_loss(
                 asset_id=perp_asset_id,
@@ -2205,7 +2114,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 return False, f"Failed to place perp stop-loss: {result}"
             self.logger.info(f"Placed perp stop-loss at {stop_loss_price} for {coin}")
 
-        # Place spot limit sell if needed
         if (
             spot_asset_id
             and spot_position_size
@@ -2331,7 +2239,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                         # USDC is 1:1
                         hl_value += total
                     else:
-                        # Look up mid price for non-USDC assets
                         mid_price = self._resolve_mid_price(coin, mid_prices)
                         if mid_price > 0:
                             hl_value += total * mid_price
@@ -2424,7 +2331,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             oi_usd = oi_base * mark_px
             day_ntl_usd = float(ctx.get("dayNtlVlm") or 0.0)
 
-            # Apply liquidity filters
             if oi_usd < oi_floor or day_ntl_usd < day_vlm_floor:
                 continue
 
@@ -2538,14 +2444,12 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 )
                 continue
 
-            # Dedupe and merge
             for record in data:
                 ts = record.get("time", 0)
                 if ts not in seen_times:
                     seen_times.add(ts)
                     all_funding.append(record)
 
-        # Sort by time
         all_funding.sort(key=lambda x: x.get("time", 0))
 
         if not all_funding:
@@ -2585,14 +2489,12 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 )
                 continue
 
-            # Dedupe and merge
             for candle in data:
                 ts = candle.get("t", 0)
                 if ts not in seen_times:
                     seen_times.add(ts)
                     all_candles.append(candle)
 
-        # Sort by time
         all_candles.sort(key=lambda x: x.get("t", 0))
 
         if not all_candles:
@@ -3410,7 +3312,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             if len(pts) > 256:
                 break
         pts.append(float(upper))
-        # Dedupe + sort
         return sorted({float(p) for p in pts if p > 0.0})
 
     async def max_spot_order_usd_for_book(
@@ -3833,3 +3734,11 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if not address:
             raise ValueError("main_wallet address not found")
         return str(address)
+
+    @staticmethod
+    async def policies() -> list[str]:
+        return [
+            any_hyperliquid_l1_payload(),
+            any_hyperliquid_user_payload(),
+            any_erc20_function(HYPERLIQUID_BRIDGE),
+        ]