wayfinder-paths 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

wayfinder_paths/core/utils/evm_helpers.py

@@ -59,7 +59,7 @@ def resolve_rpc_url(
     explicit_rpc_url: str | None = None,
 ) -> str:
     """
-    Resolve RPC URL from config or environment variables.
+    Resolve RPC URL from config.
 
     Args:
         chain_id: Chain ID to look up RPC URL for
@@ -83,10 +83,7 @@ def resolve_rpc_url(
         by_str = mapping.get(str(chain_id))
         if by_str:
             return str(by_str)
-    env_rpc = os.getenv("RPC_URL")
-    if env_rpc:
-        return env_rpc
-    raise ValueError("RPC URL not provided. Set strategy.rpc_urls or env RPC_URL.")
+    raise ValueError("RPC URL not provided. Set strategy.rpc_urls in config.json.")
 
 
 async def get_next_nonce(
@@ -119,7 +116,7 @@ def resolve_private_key_for_from_address(
     from_address: str, config: dict[str, Any]
 ) -> str | None:
     """
-    Resolve private key for the given address from config or environment.
+    Resolve private key for the given address from config.
 
     Args:
         from_address: Address to resolve private key for
@@ -159,14 +156,12 @@ def resolve_private_key_for_from_address(
         logger.debug("Error resolving addresses from wallet config: %s", e)
 
     if main_addr and from_addr_norm == (main_addr or "").lower():
-        return main_pk or os.getenv("PRIVATE_KEY")
+        return main_pk
     if strategy_addr and from_addr_norm == (strategy_addr or "").lower():
-        return (
-            strategy_pk or os.getenv("PRIVATE_KEY_STRATEGY") or os.getenv("PRIVATE_KEY")
-        )
+        return strategy_pk
 
-    # Fallback to environment variables
-    return os.getenv("PRIVATE_KEY_STRATEGY") or os.getenv("PRIVATE_KEY")
+    # No fallback - private keys must be in config or wallets.json
+    return None
 
 
 async def _get_abi(chain_id: int, address: str) -> str | None:

wayfinder_paths/core/wallets/README.md

@@ -1,6 +1,6 @@
 # Wallet Abstraction Layer
 
-Wayfinder strategies interact with blockchains through a single abstraction: the `EvmTxn` interface defined in `wayfinder_paths/core/services/base.py`. The default implementation (`LocalEvmTxn`) signs transactions with private keys pulled from config/environment variables, while `WalletManager` resolves which provider to use at runtime.
+Wayfinder strategies interact with blockchains through a single abstraction: the `EvmTxn` interface defined in `wayfinder_paths/core/services/base.py`. The default implementation (`LocalEvmTxn`) signs transactions with private keys pulled from config.json or wallets.json, while `WalletManager` resolves which provider to use at runtime.
 
 ## Pieces
 
@@ -46,9 +46,6 @@ class PrivyWallet(EvmTxn):
     async def read_erc20_allowance(self, chain_id: int, token_address: str, owner_address: str, spender_address: str) -> tuple[bool, Any]:
         ...
 
-    async def approve_token(...):
-        ...
-
     async def broadcast_transaction(...):
         ...
 
@@ -76,8 +73,8 @@ web3_service = DefaultWeb3Service(config, wallet_provider=custom_wallet)
 {
   "strategy": {
     "wallet_type": "local",
-    "main_wallet": {"address": "0x...", "wallet_type": "local"},
-    "strategy_wallet": {"address": "0x..."}
+    "main_wallet": { "address": "0x...", "wallet_type": "local" },
+    "strategy_wallet": { "address": "0x..." }
   }
 }
 ```

wayfinder_paths/run_strategy.py

@@ -12,7 +12,7 @@ from pathlib import Path
 
 from loguru import logger
 
-from wayfinder_paths.core.config import StrategyJobConfig, load_config_from_env
+from wayfinder_paths.core.config import StrategyJobConfig
 from wayfinder_paths.core.engine.manifest import load_manifest, validate_manifest
 from wayfinder_paths.core.engine.StrategyJob import StrategyJob
 
@@ -21,7 +21,6 @@ def load_strategy(
     strategy_name: str,
     *,
     strategy_config: dict | None = None,
-    simulation: bool = False,
     api_key: str | None = None,
 ):
     """
@@ -30,7 +29,6 @@ def load_strategy(
     Args:
         strategy_name: Name of the strategy to load (directory name in strategies/)
         strategy_config: Configuration dict for the strategy
-        simulation: Enable simulation mode for testing
         api_key: Optional API key for service account authentication
 
     Returns:
@@ -59,36 +57,45 @@ def load_strategy(
     module = __import__(module_path, fromlist=[class_name])
     strategy_class = getattr(module, class_name)
 
-    return strategy_class(
-        config=strategy_config, simulation=simulation, api_key=api_key
-    )
+    return strategy_class(config=strategy_config, api_key=api_key)
 
 
 def load_config(
     config_path: str | None = None, strategy_name: str | None = None
 ) -> StrategyJobConfig:
     """
-    Load configuration from file or environment
+    Load configuration from config.json file
 
     Args:
-        config_path: Optional path to config file
+        config_path: Path to config file (defaults to "config.json")
         strategy_name: Optional strategy name for per-strategy wallet lookup
 
     Returns:
         StrategyJobConfig instance
+
+    Raises:
+        FileNotFoundError: If config file does not exist
     """
-    if config_path and Path(config_path).exists():
-        logger.info(f"Loading config from {config_path}")
-        with open(config_path) as f:
-            config_data = json.load(f)
-        return StrategyJobConfig.from_dict(config_data, strategy_name=strategy_name)
-    else:
-        logger.info("Loading config from environment variables")
-        config = load_config_from_env()
-        if strategy_name:
-            config.strategy_config["_strategy_name"] = strategy_name
-            config.__post_init__()
-        return config
+    # Default to config.json if not provided
+    if not config_path:
+        config_path = "config.json"
+
+    config_file = Path(config_path)
+    if not config_file.exists():
+        raise FileNotFoundError(
+            f"Config file not found: {config_path}. "
+            "Please create config.json (see wayfinder_paths/config.example.json for template)"
+        )
+
+    logger.info(f"Loading config from {config_path}")
+    with open(config_file) as f:
+        config_data = json.load(f)
+
+    config = StrategyJobConfig.from_dict(config_data, strategy_name=strategy_name)
+    if strategy_name:
+        config.strategy_config["_strategy_name"] = strategy_name
+        config.__post_init__()
+    return config
 
 
 async def run_strategy(
@@ -96,7 +103,6 @@ async def run_strategy(
     config_path: str | None = None,
     action: str = "run",
     manifest_path: str | None = None,
-    simulation: bool = False,
     **kwargs,
 ):
     """
@@ -159,9 +165,7 @@ async def run_strategy(
             module_path, class_name = manifest.entrypoint.rsplit(".", 1)
             module = __import__(module_path, fromlist=[class_name])
             strategy_class = getattr(module, class_name)
-            strategy = strategy_class(
-                config=config.strategy_config, simulation=simulation
-            )
+            strategy = strategy_class(config=config.strategy_config)
             logger.info(
                 f"Loaded strategy from manifest: {strategy_name_for_wallet or 'unnamed'}"
             )
@@ -169,7 +173,6 @@ async def run_strategy(
             strategy = load_strategy(
                 strategy_name,
                 strategy_config=config.strategy_config,
-                simulation=simulation,
             )
             logger.info(f"Loaded strategy: {strategy.name}")
 
@@ -326,7 +329,7 @@ def main():
         help="Path to strategy manifest YAML (alternative to strategy name)",
     )
     parser.add_argument(
-        "--config", help="Path to config file (defaults to environment variables)"
+        "--config", help="Path to config file (defaults to config.json)"
     )
     parser.add_argument(
         "--action",
@@ -372,11 +375,6 @@ def main():
         "--duration", type=int, help="Duration in seconds for script action"
     )
     parser.add_argument("--debug", action="store_true", help="Enable debug logging")
-    parser.add_argument(
-        "--simulation",
-        action="store_true",
-        help="Run in simulation mode (no real transactions)",
-    )
     parser.add_argument(
         "--wallet-id",
         help="Wallet ID for policy rendering (replaces FORMAT_WALLET_ID in policies)",
@@ -401,7 +399,6 @@ def main():
             gas_token_amount=args.gas_token_amount,
             interval=args.interval,
             duration=args.duration,
-            simulation=args.simulation,
             wallet_id=getattr(args, "wallet_id", None),
         )
     )

wayfinder_paths/scripts/make_wallets.py

@@ -15,27 +15,6 @@ def to_keystore_json(private_key_hex: str, password: str):
     return Account.encrypt(private_key_hex, password)
 
 
-def write_env(rows: list[dict[str, str]], out_dir: Path) -> None:
-    with open(out_dir / ".env.example", "w") as f:
-        if rows:
-            label_to_wallet = {r.get("label"): r for r in rows if r.get("label")}
-            main_w = (
-                label_to_wallet.get("main") or label_to_wallet.get("default") or rows[0]
-            )
-            strategy_w = label_to_wallet.get("strategy")
-
-            f.write("RPC_URL=https://rpc.ankr.com/eth\n")
-            # Back-compat defaults
-            f.write(f"PRIVATE_KEY={main_w['private_key_hex']}\n")
-            f.write(f"FROM_ADDRESS={main_w['address']}\n")
-            # Explicit main/strategy variables
-            f.write(f"MAIN_WALLET_ADDRESS={main_w['address']}\n")
-            if strategy_w:
-                f.write(f"STRATEGY_WALLET_ADDRESS={strategy_w['address']}\n")
-                # Optional: expose strategy private key for local dev only
-                f.write(f"PRIVATE_KEY_STRATEGY={strategy_w['private_key_hex']}\n")
-
-
 def main():
     parser = argparse.ArgumentParser(description="Generate local dev wallets")
     parser.add_argument(
@@ -48,7 +27,7 @@ def main():
         "--out-dir",
         type=Path,
         default=Path("."),
-        help="Output directory for wallets.json (and .env/keystore)",
+        help="Output directory for wallets.json (and keystore files)",
     )
     parser.add_argument(
         "--keystore-password",
@@ -161,9 +140,6 @@ def main():
                 ks_path.write_text(json.dumps(ks))
             index += 1
 
-    # Convenience outputs
-    write_env(rows, args.out_dir)
-
 
 if __name__ == "__main__":
     main()

wayfinder_paths/scripts/run_strategy.py

@@ -55,7 +55,6 @@ async def _run(args: argparse.Namespace) -> int:
             "main_wallet": main_wallet,
             "strategy_wallet": strategy_wallet,
         },
-        simulation=args.simulation,
     )
 
     await s.setup()
@@ -101,7 +100,6 @@ def main() -> int:
     )
     p.add_argument("--main-wallet-label", default="main")
     p.add_argument("--strategy-wallet-label", default="basis_trading_strategy")
-    p.add_argument("--simulation", action="store_true")
 
     sub = p.add_subparsers(dest="command", required=True)
 

wayfinder_paths/strategies/basis_trading_strategy/snapshot_mixin.py

@@ -8,7 +8,6 @@ from __future__ import annotations
 
 import asyncio
 import json
-import os
 import time
 from datetime import UTC, datetime
 from decimal import ROUND_DOWN, Decimal
@@ -1007,5 +1006,4 @@ class BasisSnapshotMixin:
         )
         if isinstance(val, str) and val.strip():
             return val.strip()
-        env = os.getenv("BASIS_SNAPSHOT_PATH")
-        return env.strip() if isinstance(env, str) and env.strip() else None
+        return None

wayfinder_paths/strategies/basis_trading_strategy/strategy.py

@@ -208,7 +208,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         *,
         main_wallet: dict[str, Any] | None = None,
         strategy_wallet: dict[str, Any] | None = None,
-        simulation: bool = False,
         web3_service: Web3Service | None = None,
         hyperliquid_executor: HyperliquidExecutor | None = None,
         api_key: str | None = None,
@@ -221,7 +220,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if strategy_wallet:
             merged_config["strategy_wallet"] = strategy_wallet
         self.config = merged_config
-        self.simulation = simulation
 
         # Position tracking
         self.current_position: BasisPosition | None = None
@@ -249,10 +247,10 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             "strategy": self.config,
         }
 
-        # Create Hyperliquid executor if not provided and not in simulation.
+        # Create Hyperliquid executor if not provided.
         # This is only required for placing/canceling orders (not market reads).
         hl_executor = hyperliquid_executor
-        if hl_executor is None and not self.simulation:
+        if hl_executor is None:
             try:
                 hl_executor = LocalHyperliquidExecutor(config=adapter_config)
                 self.logger.info("Created LocalHyperliquidExecutor for real execution")
@@ -267,7 +265,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         try:
             self.hyperliquid_adapter = HyperliquidAdapter(
                 config=adapter_config,
-                simulation=self.simulation,
                 executor=hl_executor,
             )
         except Exception as e:
@@ -280,7 +277,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 tx_adapter = LocalTokenTxnService(
                     adapter_config,
                     wallet_provider=wallet_provider,
-                    simulation=self.simulation,
                 )
                 web3_service = DefaultWeb3Service(
                     wallet_provider=wallet_provider, evm_transactions=tx_adapter
@@ -502,18 +498,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}")
 
-        # Simulation mode - just track the deposit
-        if self.simulation:
-            self.logger.info(
-                f"[SIMULATION] Would send {main_token_amount} USDC to Hyperliquid bridge"
-            )
-            self.deposit_amount = main_token_amount
-            return (
-                True,
-                f"[SIMULATION] Deposited {main_token_amount} USDC. "
-                f"Call update() to analyze and open positions.",
-            )
-
         # Real deposit: ensure funds are in the strategy wallet, then send USDC to bridge.
         try:
             main_address = self._get_main_wallet_address()
@@ -926,11 +910,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
             if not close_success:
                 return (False, f"Failed to close position: {close_msg}")
 
-        if self.simulation:
-            withdrawn = self.deposit_amount
-            self.deposit_amount = 0
-            return (True, f"[SIMULATION] Withdrew {withdrawn} USDC to main wallet")
-
         # Step 1: Transfer any spot USDC to perp for withdrawal
         success, spot_state = await self.hyperliquid_adapter.get_spot_user_state(
             address
@@ -1168,9 +1147,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if not self.builder_fee:
             return True, "No builder fee configured"
 
-        if self.simulation:
-            return True, "[SIMULATION] Builder fee approval skipped"
-
         address = self._get_strategy_wallet_address()
         builder = self.builder_fee.get("b", "")
         required_fee = self.builder_fee.get("f", 0)
@@ -1357,112 +1333,98 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
                 Decimal(str(order_usd)).quantize(Decimal("0.01"), rounding=ROUND_UP)
             )
 
-            if self.simulation:
-                self.logger.info(
-                    f"[SIMULATION] Would open {target_qty} {coin} basis position"
-                )
-                spot_filled = target_qty
-                perp_filled = target_qty
-                spot_notional = order_usd
-                perp_notional = order_usd
-                entry_price = float(best.get("mark_price", 0.0) or 100.0)
-            else:
-                # 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,
-                    leverage=leverage,
-                    is_cross=True,
-                    address=address,
-                )
-                if not success:
-                    self.logger.warning(f"Failed to set leverage: {lev_result}")
-                    # Continue anyway - leverage might already be set
+            # 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 3: Transfer USDC from perp to spot for spot purchase
-                # We need approximately order_usd in spot to buy the asset
-                self.logger.info(
-                    f"Transferring ${order_usd:.2f} from perp to spot for {coin}"
-                )
-                (
-                    success,
-                    transfer_result,
-                ) = await self.hyperliquid_adapter.transfer_perp_to_spot(
-                    amount=order_usd,
-                    address=address,
-                )
-                if not success:
-                    self.logger.warning(
-                        f"Perp to spot transfer failed: {transfer_result}"
-                    )
-                    # May fail if already in spot, continue
+            # 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,
+                leverage=leverage,
+                is_cross=True,
+                address=address,
+            )
+            if not success:
+                self.logger.warning(f"Failed to set leverage: {lev_result}")
+                # Continue anyway - leverage might already be set
 
-                # Step 4: Execute paired fill
-                filler = PairedFiller(
-                    adapter=self.hyperliquid_adapter,
-                    address=address,
-                    cfg=FillConfig(max_slip_bps=35, max_chunk_usd=7500.0),
-                )
+            # Step 3: Transfer USDC from perp to spot for spot purchase
+            # We need approximately order_usd in spot to buy the asset
+            self.logger.info(
+                f"Transferring ${order_usd:.2f} from perp to spot for {coin}"
+            )
+            (
+                success,
+                transfer_result,
+            ) = await self.hyperliquid_adapter.transfer_perp_to_spot(
+                amount=order_usd,
+                address=address,
+            )
+            if not success:
+                self.logger.warning(f"Perp to spot transfer failed: {transfer_result}")
+                # May fail if already in spot, continue
 
-                (
-                    spot_filled,
-                    perp_filled,
-                    spot_notional,
-                    perp_notional,
-                    spot_pointers,
-                    perp_pointers,
-                ) = await filler.fill_pair_units(
-                    coin=coin,
-                    spot_asset_id=spot_asset_id,
-                    perp_asset_id=perp_asset_id,
-                    total_units=target_qty,
-                    direction="long_spot_short_perp",
-                    builder_fee=self.builder_fee,
-                )
+            # Step 4: Execute paired fill
+            filler = PairedFiller(
+                adapter=self.hyperliquid_adapter,
+                address=address,
+                cfg=FillConfig(max_slip_bps=35, max_chunk_usd=7500.0),
+            )
 
-                if spot_filled <= 0 or perp_filled <= 0:
-                    return (False, f"Failed to fill basis position on {coin}")
+            (
+                spot_filled,
+                perp_filled,
+                spot_notional,
+                perp_notional,
+                spot_pointers,
+                perp_pointers,
+            ) = await filler.fill_pair_units(
+                coin=coin,
+                spot_asset_id=spot_asset_id,
+                perp_asset_id=perp_asset_id,
+                total_units=target_qty,
+                direction="long_spot_short_perp",
+                builder_fee=self.builder_fee,
+            )
 
-                self.logger.info(
-                    f"Filled basis position: spot={spot_filled:.6f}, perp={perp_filled:.6f}, "
-                    f"notional=${spot_notional:.2f}/${perp_notional:.2f}"
-                )
+            if spot_filled <= 0 or perp_filled <= 0:
+                return (False, f"Failed to fill basis position on {coin}")
 
-                # Get entry price from current mid
-                success, mids = await self.hyperliquid_adapter.get_all_mid_prices()
-                entry_price = mids.get(coin, 0.0) if success else 0.0
+            self.logger.info(
+                f"Filled basis position: spot={spot_filled:.6f}, perp={perp_filled:.6f}, "
+                f"notional=${spot_notional:.2f}/${perp_notional:.2f}"
+            )
 
-                # 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:
-                    for pos_wrapper in user_state.get("assetPositions", []):
-                        pos = pos_wrapper.get("position", {})
-                        if pos.get("coin") == coin:
-                            liquidation_price = float(pos.get("liquidationPx", 0))
-                            break
+            # Get entry price from current mid
+            success, mids = await self.hyperliquid_adapter.get_all_mid_prices()
+            entry_price = mids.get(coin, 0.0) if success else 0.0
 
-                if liquidation_price and liquidation_price > 0:
-                    sl_success, sl_msg = await self._place_stop_loss_orders(
-                        coin=coin,
-                        perp_asset_id=perp_asset_id,
-                        position_size=perp_filled,
-                        entry_price=entry_price,
-                        liquidation_price=liquidation_price,
-                        spot_asset_id=spot_asset_id,
-                        spot_position_size=spot_filled,
-                    )
-                    if not sl_success:
-                        self.logger.warning(f"Stop-loss placement failed: {sl_msg}")
-                else:
-                    self.logger.warning("Could not get liquidation price for stop-loss")
+            # 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:
+                for pos_wrapper in user_state.get("assetPositions", []):
+                    pos = pos_wrapper.get("position", {})
+                    if pos.get("coin") == coin:
+                        liquidation_price = float(pos.get("liquidationPx", 0))
+                        break
+
+            if liquidation_price and liquidation_price > 0:
+                sl_success, sl_msg = await self._place_stop_loss_orders(
+                    coin=coin,
+                    perp_asset_id=perp_asset_id,
+                    position_size=perp_filled,
+                    entry_price=entry_price,
+                    liquidation_price=liquidation_price,
+                    spot_asset_id=spot_asset_id,
+                    spot_position_size=spot_filled,
+                )
+                if not sl_success:
+                    self.logger.warning(f"Stop-loss placement failed: {sl_msg}")
+            else:
+                self.logger.warning("Could not get liquidation price for stop-loss")
 
             # Create position record
             self.current_position = BasisPosition(
@@ -1836,9 +1798,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if self.current_position is None:
             return True, "No position"
 
-        if self.simulation:
-            return True, "[SIMULATION] Would repair leg imbalance"
-
         pos = self.current_position
         coin = pos.coin
         address = self._get_strategy_wallet_address()
@@ -1930,9 +1889,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         if self.current_position is None:
             return True, "No position"
 
-        if self.simulation:
-            return True, "[SIMULATION] Stop-loss check skipped"
-
         pos = self.current_position
         coin = pos.coin
 
@@ -2026,13 +1982,6 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         pos = self.current_position
         self.logger.info(f"Closing position on {pos.coin}")
 
-        if self.simulation:
-            self.logger.info(
-                f"[SIMULATION] Would close {pos.spot_amount} {pos.coin} basis position"
-            )
-            self.current_position = None
-            return (True, "Position closed (simulation)")
-
         # Cancel all stop-loss and limit orders first
         await self._cancel_all_position_orders()