wayfinder-paths 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

wayfinder_paths/CONFIG_GUIDE.md

@@ -52,7 +52,6 @@ cp wayfinder_paths/config.example.json config.json
 **Option 1: Service Account (API Key) - Recommended for Production**
 - `user.api_key` - Your Wayfinder API key for service account authentication (loaded directly by clients from config.json)
 - OR `system.api_key` - System-level API key (alternative location, loaded directly by clients)
-- OR set `WAYFINDER_API_KEY` environment variable
 - OR pass `api_key` parameter to strategy constructor
 
 **Note:** API keys in `config.json` are loaded directly by `WayfinderClient` via `_load_config_credentials()`, not through the `UserConfig` or `SystemConfig` dataclasses. This is intentional to allow flexible credential loading.
@@ -139,7 +138,7 @@ just create-strategy "My Strategy Name"
 # This automatically:
 # - Creates the strategy directory
 # - Generates a wallet with label matching the directory name
-# - Updates the manifest with the correct name and entrypoint
+# - Updates the strategy files with the correct names
 ```
 
 ### Wallet Structure
@@ -229,7 +228,6 @@ The strategy system supports multiple wallet types through a wallet abstraction
 
 By default, adapters use `LocalWalletProvider` which resolves private keys from:
 - `wallets.json` (matched by address)
-- Environment variables (`PRIVATE_KEY`, `PRIVATE_KEY_STRATEGY`)
 - Wallet config in `config.json`
 
 No code changes are required - existing strategies continue to work.
@@ -270,7 +268,7 @@ Wayfinder Paths supports **dual authentication** for different use cases:
 
 **Best for:** Backend services, automated systems, and production deployments with higher rate limits.
 
-API keys provide service account authentication and are automatically discovered by all clients. You can provide an API key in three ways:
+API keys provide service account authentication and are automatically discovered by all clients. You can provide an API key in two ways:
 
 #### Option A: Strategy Constructor (Programmatic)
 ```python
@@ -278,16 +276,11 @@ from wayfinder_paths.strategies.stablecoin_yield_strategy.strategy import Stable
 
 strategy = StablecoinYieldStrategy(
     config={...},
-    api_key="sk_live_abc123..."  # Sets WAYFINDER_API_KEY env var automatically
+    api_key="sk_live_abc123..."  # API key is auto-discovered by all clients
 )
 ```
 
-#### Option B: Environment Variable
-```bash
-export WAYFINDER_API_KEY="sk_live_abc123..."
-```
-
-#### Option C: config.json
+#### Option B: config.json
 ```json
 {
   "user": {
@@ -299,14 +292,12 @@ export WAYFINDER_API_KEY="sk_live_abc123..."
 }
 ```
 
-**Priority Order:** Constructor parameter > `config.json` (user.api_key or system.api_key) > `WAYFINDER_API_KEY` environment variable
+**Priority Order:** Constructor parameter > `config.json` (user.api_key or system.api_key)
 
 **How It Works:**
-- When a strategy receives an `api_key`, it sets `os.environ["WAYFINDER_API_KEY"]`
 - All clients created by adapters automatically discover the API key from:
   - Constructor parameter (if passed)
   - `config.json` (via `WayfinderClient._load_config_credentials()` which reads `user.api_key` or `system.api_key`)
-  - `WAYFINDER_API_KEY` environment variable
 - API keys are included in **all** API requests (including public endpoints) for rate limiting
 - No need to pass API keys explicitly to adapters or clients—they auto-discover it
 - **Note:** API keys in `config.json` are loaded directly by clients, not stored in the `UserConfig` or `SystemConfig` dataclasses
@@ -379,7 +370,7 @@ To use custom RPC endpoints, update the `strategy.rpc_urls` section in `config.j
 **Issue:** "Authentication failed"
 - **If using API key:**
   - Verify API key is correct and not expired
-  - Check that API key is set in one of: constructor parameter, `config.json` (user.api_key or system.api_key), or `WAYFINDER_API_KEY` env var
+  - Check that API key is set in one of: constructor parameter or `config.json` (user.api_key or system.api_key)
   - Ensure API key has proper permissions for the operations you're performing
 - **If using OAuth:**
   - Check that `username` and `password` are correct in `config.json`

wayfinder_paths/adapters/balance_adapter/README.md

@@ -3,12 +3,11 @@
 Adapter that exposes wallet, token, and pool balances backed by `WalletClient`/`TokenClient` and now orchestrates transfers between the configured main/strategy wallets (with ledger bookkeeping).
 
 - Entrypoint: `adapters.balance_adapter.adapter.BalanceAdapter`
-- Manifest: `manifest.yaml`
 - Tests: `test_adapter.py`
 
 ## Capabilities
 
-The adapter declares both `wallet_read` and `wallet_transfer` capabilities in its manifest. Transfers are executed by leveraging the shared `DefaultWeb3Service.token_transactions` helper, but ledger recording + wallet selection now live inside the adapter.
+The adapter provides both wallet read and wallet transfer capabilities. Transfers are executed by leveraging the shared `DefaultWeb3Service.token_transactions` helper, but ledger recording + wallet selection now live inside the adapter.
 
 ## Construction
 

wayfinder_paths/adapters/balance_adapter/adapter.py

@@ -170,7 +170,7 @@ class BalanceAdapter(BaseAdapter):
                 token_amount=str(amount),
                 usd_value=usd_value,
                 data={
-                    "token_id": token_info.get("id"),
+                    "token_id": token_info.get("token_id"),
                     "amount": str(amount),
                     "usd_value": usd_value,
                 },
@@ -180,7 +180,7 @@ class BalanceAdapter(BaseAdapter):
                 self.logger.warning(
                     "Ledger entry failed",
                     wallet=wallet_address,
-                    token_id=token_info.get("id"),
+                    token_id=token_info.get("token_id"),
                     amount=amount,
                     error=response,
                 )
@@ -188,13 +188,13 @@ class BalanceAdapter(BaseAdapter):
             self.logger.warning(
                 f"Ledger entry raised: {exc}",
                 wallet=wallet_address,
-                token_id=token_info.get("id"),
+                token_id=token_info.get("token_id"),
             )
 
     async def _token_amount_usd(
         self, token_info: dict[str, Any], amount: float
     ) -> float:
-        token_id = token_info.get("id")
+        token_id = token_info.get("token_id")
         if not token_id:
             return 0.0
         success, price_data = await self.token_adapter.get_token_price(token_id)

wayfinder_paths/adapters/brap_adapter/README.md

@@ -17,7 +17,7 @@ The adapter uses the BRAPClient which automatically handles authentication and A
 
 The BRAPClient will automatically:
 - Use the WAYFINDER_API_URL from settings
-- Handle authentication via environment variables or config.json
+- Handle authentication via config.json
 - Manage token refresh and retry logic
 
 ## Usage

wayfinder_paths/adapters/brap_adapter/adapter.py

@@ -10,12 +10,8 @@ from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
 from wayfinder_paths.core.adapters.models import SWAP
 from wayfinder_paths.core.clients.BRAPClient import BRAPClient, BRAPQuote
 from wayfinder_paths.core.clients.LedgerClient import TransactionRecord
-from wayfinder_paths.core.clients.SimulationClient import (
-    SimulationClient,
-    SimulationResult,
-)
 from wayfinder_paths.core.clients.TokenClient import TokenClient
-from wayfinder_paths.core.constants import DEFAULT_SLIPPAGE
+from wayfinder_paths.core.constants import DEFAULT_SLIPPAGE, ZERO_ADDRESS
 from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
 from wayfinder_paths.core.services.base import Web3Service
 from wayfinder_paths.core.settings import settings
@@ -45,7 +41,6 @@ class BRAPAdapter(BaseAdapter):
         config: dict[str, Any] | None = None,
         *,
         web3_service: Web3Service,
-        simulation: bool = False,
     ):
         super().__init__("brap_adapter", config)
         self.brap_client = BRAPClient()
@@ -55,8 +50,6 @@ class BRAPAdapter(BaseAdapter):
         self.web3_service = web3_service
         self.wallet_provider = web3_service.evm_transactions
         self.token_transactions = web3_service.token_transactions
-        self.simulation = simulation
-        self.simulation_client = SimulationClient() if simulation else None
 
     async def get_swap_quote(
         self,
@@ -115,6 +108,7 @@ class BRAPAdapter(BaseAdapter):
         amount: str,
         slippage: float | None = None,
         wayfinder_fee: float | None = None,
+        preferred_providers: list[str] | None = None,
     ) -> tuple[bool, dict[str, Any] | str]:
         """
         Get the best available quote for a swap operation.
@@ -129,6 +123,8 @@ class BRAPAdapter(BaseAdapter):
             amount: Amount to swap (in smallest units)
             slippage: Maximum slippage tolerance (optional)
             wayfinder_fee: Wayfinder fee (optional)
+            preferred_providers: List of provider names in order of preference (optional).
+                                 If provided, selects first matching provider instead of "best".
 
         Returns:
             Tuple of (success, data) where data is best quote or error message
@@ -146,8 +142,27 @@ class BRAPAdapter(BaseAdapter):
                 wayfinder_fee=wayfinder_fee,
             )
 
-            # Extract best quote from response
-            best_quote = data["best_route"]
+            quotes_container = data.get("quotes", {})
+            # BRAP returns quotes in "all_quotes" not "quotes"
+            all_quotes = quotes_container.get("all_quotes", []) or quotes_container.get(
+                "quotes", []
+            )
+
+            # If preferred providers specified, select by provider preference
+            if preferred_providers and all_quotes:
+                selected_quote = self._select_quote_by_provider(
+                    all_quotes, preferred_providers
+                )
+                if selected_quote:
+                    return (True, selected_quote)
+                # Fall through to best_quote if no preferred provider found
+
+            # Extract best quote from response - check nested quotes first, then top level
+            best_quote = (
+                quotes_container.get("best_quote")
+                or data.get("best_quote")
+                or data.get("best_route")
+            )
 
             if not best_quote:
                 return (False, "No quotes available")
@@ -157,6 +172,58 @@ class BRAPAdapter(BaseAdapter):
             self.logger.error(f"Error getting best quote: {e}")
             return (False, str(e))
 
+    def _select_quote_by_provider(
+        self,
+        quotes: list[dict[str, Any]],
+        preferred_providers: list[str],
+    ) -> dict[str, Any] | None:
+        """
+        Select a quote from the list based on provider preference order.
+
+        Args:
+            quotes: List of quote objects from BRAP API
+            preferred_providers: List of provider names in order of preference (case-insensitive)
+
+        Returns:
+            The first matching quote, or None if no preferred provider found
+        """
+        # Normalize preferred providers to lowercase for case-insensitive matching
+        preferred_lower = [p.lower() for p in preferred_providers]
+
+        # Build a map of provider name -> quotes
+        provider_quotes: dict[str, list[dict[str, Any]]] = {}
+        for quote in quotes:
+            # Provider name might be in different fields depending on BRAP response structure
+            provider = (
+                quote.get("provider")
+                or quote.get("provider_name")
+                or quote.get("source")
+                or quote.get("protocol")
+                or ""
+            ).lower()
+            if provider:
+                if provider not in provider_quotes:
+                    provider_quotes[provider] = []
+                provider_quotes[provider].append(quote)
+
+        # Select first matching provider in preference order
+        for pref in preferred_lower:
+            if pref in provider_quotes:
+                # Return the quote with highest output for this provider
+                provider_list = provider_quotes[pref]
+                best_for_provider = max(
+                    provider_list, key=lambda q: int(q.get("output_amount", 0) or 0)
+                )
+                self.logger.info(f"Selected quote from preferred provider: {pref}")
+                return best_for_provider
+
+        # Log available providers for debugging
+        available = list(provider_quotes.keys())
+        self.logger.warning(
+            f"No preferred provider found. Wanted: {preferred_providers}, Available: {available}"
+        )
+        return None
+
     async def calculate_swap_fees(
         self,
         from_token_address: str,
@@ -255,7 +322,7 @@ class BRAPAdapter(BaseAdapter):
             )
 
             quotes = data.get("quotes", {})
-            all_quotes = quotes.get("quotes", [])
+            all_quotes = quotes.get("all_quotes", []) or quotes.get("quotes", [])
             best_quote = quotes.get("best_quote")
 
             if not all_quotes:
@@ -298,9 +365,20 @@ class BRAPAdapter(BaseAdapter):
         amount: str,
         slippage: float = DEFAULT_SLIPPAGE,
         strategy_name: str | None = None,
+        preferred_providers: list[str] | None = None,
     ) -> tuple[bool, Any]:
         """
         Execute a swap by looking up token metadata via token IDs.
+
+        Args:
+            from_token_id: Source token ID
+            to_token_id: Destination token ID
+            from_address: Wallet address
+            amount: Amount to swap (in smallest units)
+            slippage: Maximum slippage tolerance
+            strategy_name: Strategy name for ledger recording
+            preferred_providers: List of provider names in order of preference (e.g., ["enso", "aerodrome"]).
+                                 If provided, selects first matching provider instead of "best".
         """
         from_token = await self.token_client.get_token_details(from_token_id)
         if not from_token:
@@ -318,6 +396,7 @@ class BRAPAdapter(BaseAdapter):
             to_address=from_address,
             amount=amount,
             slippage=slippage,
+            preferred_providers=preferred_providers,
         )
         if not success:
             return (False, best_quote)
@@ -356,7 +435,14 @@ class BRAPAdapter(BaseAdapter):
             or quote.get("inputAmount")
             or transaction.get("value")
         )
-        if from_token.get("address") and spender and approve_amount:
+        token_address = from_token.get("address")
+        token_address_l = str(token_address or "").lower()
+        is_native = token_address_l in {
+            "",
+            ZERO_ADDRESS.lower(),
+            "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+        }
+        if token_address and (not is_native) and spender and approve_amount:
             approve_success, approve_response = await self._handle_token_approval(
                 chain=chain,
                 token_address=from_token.get("address"),
@@ -367,26 +453,39 @@ class BRAPAdapter(BaseAdapter):
             if not approve_success:
                 return (False, approve_response)
 
-        if self.simulation:
-            simulation = await self._simulate_swap(
-                from_token, to_token, from_address, chain_id, quote
-            )
-            return (True, {"quote": quote, "simulation": simulation})
-
         broadcast_success, broadcast_response = await self._broadcast_transaction(
             transaction
         )
+        self.logger.info(
+            f"Swap broadcast result: success={broadcast_success}, "
+            f"response={broadcast_response}"
+        )
         if not broadcast_success:
             return (False, broadcast_response)
 
-        ledger_record = await self._record_swap_operation(
-            from_token=from_token,
-            to_token=to_token,
-            wallet_address=from_address,
-            quote=quote,
-            broadcast_response=broadcast_response,
-            strategy_name=strategy_name,
-        )
+        # Record the swap operation in ledger - but don't let ledger errors fail the swap
+        # since the on-chain transaction already succeeded
+        try:
+            ledger_record = await self._record_swap_operation(
+                from_token=from_token,
+                to_token=to_token,
+                wallet_address=from_address,
+                quote=quote,
+                broadcast_response=broadcast_response,
+                strategy_name=strategy_name,
+            )
+        except Exception as e:
+            self.logger.warning(
+                f"Ledger recording failed (swap succeeded on-chain): {e}"
+            )
+            # Return the quote with output amount so caller can proceed
+            ledger_record = {
+                "to_amount": quote.get("output_amount"),
+                "from_amount": quote.get("input_amount"),
+                "tx_hash": broadcast_response.get("tx_hash")
+                if isinstance(broadcast_response, dict)
+                else None,
+            }
         return (True, ledger_record)
 
     async def get_bridge_quote(
@@ -594,10 +693,10 @@ class BRAPAdapter(BaseAdapter):
         )
         if not build_success:
             return False, approve_tx
-        return await self._broadcast_transaction(approve_tx)
+        return await self._broadcast_transaction(approve_tx, confirmations=2)
 
     async def _broadcast_transaction(
-        self, transaction: dict[str, Any]
+        self, transaction: dict[str, Any], confirmations: int = 0
     ) -> tuple[bool, Any]:
         if getattr(settings, "DRY_RUN", False):
             return True, {"dry_run": True, "transaction": transaction}
@@ -605,6 +704,7 @@ class BRAPAdapter(BaseAdapter):
             transaction,
             wait_for_receipt=True,
             timeout=DEFAULT_TRANSACTION_TIMEOUT,
+            confirmations=confirmations,
         )
 
     async def _record_swap_operation(
@@ -631,16 +731,19 @@ class BRAPAdapter(BaseAdapter):
         response = broadcast_response if isinstance(broadcast_response, dict) else {}
         operation_data = SWAP(
             adapter=self.adapter_type,
-            from_token_id=from_token.get("id"),
-            to_token_id=to_token.get("id"),
-            from_amount=quote.get("input_amount"),
-            to_amount=quote.get("output_amount"),
+            from_token_id=str(from_token.get("id")),
+            to_token_id=str(to_token.get("id")),
+            from_amount=str(quote.get("input_amount")),
+            to_amount=str(quote.get("output_amount")),
             from_amount_usd=from_amount_usd or 0,
             to_amount_usd=to_amount_usd or 0,
-            transaction_hash=response.get("transaction_hash"),
-            transaction_chain_id=from_token.get("chain_id"),
+            transaction_hash=response.get("tx_hash")
+            or response.get("transaction_hash"),
+            transaction_chain_id=from_token.get("chain_id")
+            or (from_token.get("chain") or {}).get("id"),
             transaction_status=response.get("transaction_status"),
-            transaction_receipt=response.get("transaction_receipt"),
+            # Don't pass raw receipt - it contains HexBytes that can't be JSON serialized
+            transaction_receipt=None,
         )
 
         try:
@@ -666,7 +769,7 @@ class BRAPAdapter(BaseAdapter):
         if raw_amount is None:
             return None
         success, price_data = await self.token_adapter.get_token_price(
-            token_info.get("id")
+            token_info.get("token_id")
         )
         if not success or not price_data:
             return None
@@ -677,44 +780,6 @@ class BRAPAdapter(BaseAdapter):
             / 10 ** int(decimals)
         )
 
-    async def _simulate_swap(
-        self,
-        from_token: dict[str, Any],
-        to_token: dict[str, Any],
-        from_address: str,
-        chain_id: int,
-        quote: dict[str, Any],
-    ) -> SimulationResult:
-        client = await self._get_simulation_client()
-        initial_balances = {"native": "5000000000000000000"}
-        if from_token.get("address"):
-            initial_balances[from_token.get("address")] = "1000000000000000000000000"
-
-        slippage = quote.get("slippage") or quote.get("slippage_percent")
-        if isinstance(slippage, str):
-            try:
-                slippage = float(slippage)
-            except ValueError:
-                slippage = DEFAULT_SLIPPAGE
-        slippage = slippage or DEFAULT_SLIPPAGE
-
-        amount = quote.get("input_amount") or quote.get("inputAmount") or "0"
-        return await client.simulate_swap(
-            from_token_address=from_token.get("address"),
-            to_token_address=to_token.get("address"),
-            from_chain_id=chain_id,
-            to_chain_id=chain_id,
-            amount=str(amount),
-            from_address=from_address,
-            slippage=float(slippage),
-            initial_balances=initial_balances,
-        )
-
-    async def _get_simulation_client(self) -> SimulationClient:
-        if not self.simulation_client:
-            self.simulation_client = SimulationClient()
-        return self.simulation_client
-
     def _chain_id(self, chain: Any) -> int:
         if isinstance(chain, dict):
             chain_id = chain.get("id") or chain.get("chain_id")

wayfinder_paths/adapters/hyperlend_adapter/adapter.py

@@ -12,7 +12,6 @@ from wayfinder_paths.core.clients.HyperlendClient import (
     MarketEntry,
     StableMarket,
 )
-from wayfinder_paths.core.clients.SimulationClient import SimulationClient
 from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
 from wayfinder_paths.core.constants.hyperlend_abi import (
     POOL_ABI,
@@ -37,16 +36,12 @@ class HyperlendAdapter(BaseAdapter):
         self,
         config: dict[str, Any],
         web3_service: Web3Service,
-        simulation: bool = False,
     ) -> None:
         super().__init__("hyperlend_adapter", config)
         cfg = config or {}
         adapter_cfg = cfg.get("hyperlend_adapter") or {}
 
         self.hyperlend_client = HyperlendClient()
-        self.simulation = simulation
-        self.simulation_client = SimulationClient() if simulation else None
-
         self.web3 = web3_service
         self.token_txn_service = web3_service.token_transactions
 
@@ -237,8 +232,6 @@ class HyperlendAdapter(BaseAdapter):
         return await self._broadcast_transaction(approve_tx)
 
     async def _execute(self, tx: dict[str, Any]) -> tuple[bool, Any]:
-        if self.simulation:
-            return True, {"simulation": tx}
         return await self.web3.broadcast_transaction(
             tx, wait_for_receipt=True, timeout=DEFAULT_TRANSACTION_TIMEOUT
         )

wayfinder_paths/adapters/hyperliquid_adapter/adapter.py

@@ -74,7 +74,6 @@ class HyperliquidAdapter(BaseAdapter):
         self,
         config: dict[str, Any] | None = None,
         *,
-        simulation: bool = False,
         executor: HyperliquidExecutor | None = None,
     ) -> None:
         super().__init__("hyperliquid_adapter", config)
@@ -85,7 +84,6 @@ class HyperliquidAdapter(BaseAdapter):
                 "Install with: poetry add hyperliquid"
             )
 
-        self.simulation = simulation
         self._cache = SimpleCache()
         self._executor = executor
 
@@ -481,13 +479,6 @@ class HyperliquidAdapter(BaseAdapter):
         Returns:
             (success, response_data or error_message)
         """
-        if self.simulation:
-            self.logger.info(
-                f"[SIMULATION] place_market_order: asset={asset_id}, "
-                f"is_buy={is_buy}, size={size}, address={address}"
-            )
-            return True, {"simulation": True, "status": "ok"}
-
         if not self._executor:
             raise NotImplementedError(
                 "No Hyperliquid executor configured. "
@@ -525,12 +516,6 @@ class HyperliquidAdapter(BaseAdapter):
         Returns:
             (success, response_data or error_message)
         """
-        if self.simulation:
-            self.logger.info(
-                f"[SIMULATION] cancel_order: asset={asset_id}, oid={order_id}"
-            )
-            return True, {"simulation": True, "status": "ok"}
-
         if not self._executor:
             raise NotImplementedError(
                 "No Hyperliquid executor configured. "
@@ -565,12 +550,6 @@ class HyperliquidAdapter(BaseAdapter):
         Returns:
             (success, response_data or error_message)
         """
-        if self.simulation:
-            self.logger.info(
-                f"[SIMULATION] update_leverage: asset={asset_id}, leverage={leverage}"
-            )
-            return True, {"simulation": True, "status": "ok"}
-
         if not self._executor:
             raise NotImplementedError("No Hyperliquid executor configured.")
 
@@ -590,10 +569,6 @@ class HyperliquidAdapter(BaseAdapter):
         address: str,
     ) -> tuple[bool, dict[str, Any]]:
         """Transfer USDC from spot to perp balance."""
-        if self.simulation:
-            self.logger.info(f"[SIMULATION] transfer_spot_to_perp: {amount} USDC")
-            return True, {"simulation": True, "status": "ok"}
-
         if not self._executor:
             raise NotImplementedError("No Hyperliquid executor configured.")
 
@@ -611,10 +586,6 @@ class HyperliquidAdapter(BaseAdapter):
         address: str,
     ) -> tuple[bool, dict[str, Any]]:
         """Transfer USDC from perp to spot balance."""
-        if self.simulation:
-            self.logger.info(f"[SIMULATION] transfer_perp_to_spot: {amount} USDC")
-            return True, {"simulation": True, "status": "ok"}
-
         if not self._executor:
             raise NotImplementedError("No Hyperliquid executor configured.")
 
@@ -647,13 +618,6 @@ class HyperliquidAdapter(BaseAdapter):
         Returns:
             (success, response_data or error_message)
         """
-        if self.simulation:
-            self.logger.info(
-                f"[SIMULATION] place_stop_loss: asset={asset_id}, "
-                f"trigger={trigger_price}, size={size}"
-            )
-            return True, {"simulation": True, "status": "ok"}
-
         if not self._executor:
             raise NotImplementedError("No Hyperliquid executor configured.")
 
@@ -758,10 +722,6 @@ class HyperliquidAdapter(BaseAdapter):
 
         Note: This is an L1 withdrawal handled by the Hyperliquid executor (signing required).
         """
-        if self.simulation:
-            self.logger.info(f"[SIMULATION] withdraw: {amount} USDC")
-            return True, {"simulation": True, "status": "ok"}
-
         if not self._executor:
             raise NotImplementedError("No Hyperliquid executor configured.")
 
@@ -856,13 +816,6 @@ class HyperliquidAdapter(BaseAdapter):
         Returns:
             (success, response_data or error_message)
         """
-        if self.simulation:
-            self.logger.info(
-                f"[SIMULATION] approve_builder_fee: builder={builder}, "
-                f"rate={max_fee_rate}, address={address}"
-            )
-            return True, {"simulation": True, "status": "ok"}
-
         if not self._executor:
             raise NotImplementedError("No Hyperliquid executor configured.")
 
@@ -903,13 +856,6 @@ class HyperliquidAdapter(BaseAdapter):
         Returns:
             (success, response_data or error_message)
         """
-        if self.simulation:
-            self.logger.info(
-                f"[SIMULATION] place_limit_order: asset={asset_id}, "
-                f"is_buy={is_buy}, price={price}, size={size}"
-            )
-            return True, {"simulation": True, "status": "ok"}
-
         if not self._executor:
             raise NotImplementedError("No Hyperliquid executor configured.")
 

wayfinder_paths/adapters/hyperliquid_adapter/test_adapter_live.py

@@ -17,7 +17,7 @@ from wayfinder_paths.adapters.hyperliquid_adapter.adapter import HyperliquidAdap
 @pytest.fixture
 def live_adapter():
     """Create adapter connected to real Hyperliquid API."""
-    return HyperliquidAdapter(config={}, simulation=True)
+    return HyperliquidAdapter(config={})
 
 
 class TestSpotAssetIDs:

wayfinder_paths/adapters/ledger_adapter/README.md

@@ -17,7 +17,7 @@ The adapter uses the LedgerClient which automatically handles authentication and
 
 The LedgerClient will automatically:
 - Use the WAYFINDER_API_URL from settings
-- Handle authentication via environment variables or config.json
+- Handle authentication via config.json
 - Manage token refresh and retry logic
 
 ## Usage