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

wayfinder_paths/core/services/base.py

@@ -50,61 +50,6 @@ class EvmTxn(ABC):
     transaction confirmations.
     """
 
-    @abstractmethod
-    async def get_balance(
-        self,
-        address: str,
-        token_address: str | None,
-        chain_id: int,
-        block_identifier: int | str | None = None,
-    ) -> tuple[bool, Any]:
-        """
-        Get balance for an address at a specific block.
-
-        Args:
-            address: Address to query balance for
-            token_address: ERC20 token address, or None for native token
-            chain_id: Chain ID
-            block_identifier: Block to query at. Can be:
-                - int: specific block number (for pinning to tx block)
-                - "safe": OP Stack safe block (data posted to L1)
-                - "finalized": fully finalized block
-                - None/"latest": current head (default, but avoid after txs)
-
-        Returns:
-            Tuple of (success, balance_integer_or_error_message)
-        """
-        pass
-
-    @abstractmethod
-    async def approve_token(
-        self,
-        token_address: str,
-        spender: str,
-        amount: int,
-        from_address: str,
-        chain_id: int,
-        wait_for_receipt: bool = True,
-        timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
-    ) -> tuple[bool, Any]:
-        """
-        Approve a spender to spend tokens on behalf of from_address.
-
-        Args:
-            token_address: ERC20 token contract address
-            spender: Address being approved to spend tokens
-            amount: Amount to approve (in token units, not human-readable)
-            from_address: Address approving the tokens
-            chain_id: Chain ID
-            wait_for_receipt: Whether to wait for the transaction receipt
-            timeout: Receipt timeout in seconds
-
-        Returns:
-            Tuple of (success, transaction_result_dict_or_error_message)
-            Transaction result should include 'tx_hash' and optionally 'receipt'
-        """
-        pass
-
     @abstractmethod
     async def broadcast_transaction(
         self,

wayfinder_paths/core/services/local_evm_txn.py

@@ -4,16 +4,9 @@ from typing import Any
 from eth_account import Account
 from eth_utils import to_checksum_address
 from loguru import logger
-from web3 import AsyncHTTPProvider, AsyncWeb3, Web3
+from web3 import AsyncHTTPProvider, AsyncWeb3
 
-from wayfinder_paths.core.constants import (
-    ZERO_ADDRESS,
-)
 from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
-from wayfinder_paths.core.constants.erc20_abi import (
-    ERC20_APPROVAL_ABI,
-    ERC20_MINIMAL_ABI,
-)
 from wayfinder_paths.core.services.base import EvmTxn
 from wayfinder_paths.core.utils.evm_helpers import (
     resolve_private_key_for_from_address,
@@ -60,105 +53,12 @@ class LocalEvmTxn(EvmTxn):
     def __init__(self, config: dict[str, Any] | None = None):
         self.config = config or {}
         self.logger = logger.bind(provider="LocalWalletProvider")
-        # Cache web3 instances per chain to avoid load balancer inconsistency
-        self._web3_cache: dict[int, AsyncWeb3] = {}
 
     def get_web3(self, chain_id: int) -> AsyncWeb3:
-        # Reuse cached instance to ensure consistent RPC node for reads after writes
-        if chain_id in self._web3_cache:
-            return self._web3_cache[chain_id]
         rpc_url = self._resolve_rpc_url(chain_id)
         w3 = AsyncWeb3(AsyncHTTPProvider(rpc_url))
-        self._web3_cache[chain_id] = w3
         return w3
 
-    async def get_balance(
-        self,
-        address: str,
-        token_address: str | None,
-        chain_id: int,
-        block_identifier: int | str | None = None,
-    ) -> tuple[bool, Any]:
-        """
-        Get balance for an address at a specific block.
-
-        Args:
-            address: Address to query balance for
-            token_address: ERC20 token address, or None for native token
-            chain_id: Chain ID
-            block_identifier: Block to query at. Can be:
-                - int: specific block number (for pinning to tx block)
-                - "safe": OP Stack safe block (data posted to L1)
-                - "finalized": fully finalized block
-                - None/"latest": current head (default, but avoid after txs)
-
-        Returns:
-            Tuple of (success, balance_integer_or_error_message)
-        """
-        w3 = self.get_web3(chain_id)
-        try:
-            checksum_addr = to_checksum_address(address)
-            block_id = block_identifier if block_identifier is not None else "latest"
-
-            if not token_address or token_address.lower() == ZERO_ADDRESS:
-                balance = await w3.eth.get_balance(
-                    checksum_addr, block_identifier=block_id
-                )
-                return (True, int(balance))
-
-            token_checksum = to_checksum_address(token_address)
-            contract = w3.eth.contract(address=token_checksum, abi=ERC20_MINIMAL_ABI)
-            balance = await contract.functions.balanceOf(checksum_addr).call(
-                block_identifier=block_id
-            )
-            return (True, int(balance))
-
-        except Exception as exc:  # noqa: BLE001
-            self.logger.error(f"Failed to get balance: {exc}")
-            return (False, f"Balance query failed: {exc}")
-        finally:
-            await self._close_web3(w3)
-
-    async def approve_token(
-        self,
-        token_address: str,
-        spender: str,
-        amount: int,
-        from_address: str,
-        chain_id: int,
-        wait_for_receipt: bool = True,
-        timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
-    ) -> tuple[bool, Any]:
-        try:
-            token_checksum = to_checksum_address(token_address)
-            spender_checksum = to_checksum_address(spender)
-            from_checksum = to_checksum_address(from_address)
-            amount_int = int(amount)
-
-            w3_sync = Web3()
-            contract = w3_sync.eth.contract(
-                address=token_checksum, abi=ERC20_APPROVAL_ABI
-            )
-            transaction_data = contract.encode_abi(
-                "approve", args=[spender_checksum, amount_int]
-            )
-
-            approve_txn = {
-                "from": from_checksum,
-                "chainId": int(chain_id),
-                "to": token_checksum,
-                "data": transaction_data,
-            }
-
-            return await self.broadcast_transaction(
-                approve_txn,
-                wait_for_receipt=wait_for_receipt,
-                timeout=timeout,
-            )
-        except Exception as exc:  # noqa: BLE001
-            self.logger.error(f"ERC20 approval failed: {exc}")
-            return (False, f"ERC20 approval failed: {exc}")
-
     def _validate_transaction(self, transaction: dict[str, Any]) -> dict[str, Any]:
         tx = dict(transaction)
 
@@ -264,29 +164,29 @@ class LocalEvmTxn(EvmTxn):
         *,
         wait_for_receipt: bool = True,
         timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
-        confirmations: int = 0,
+        confirmations: int = 1,
     ) -> tuple[bool, Any]:
         try:
             chain_id = transaction["chainId"]
             from_address = transaction["from"]
 
-            w3 = self.get_web3(chain_id)
+            web3 = self.get_web3(chain_id)
             try:
                 transaction = self._validate_transaction(transaction)
-                transaction = await self._nonce_transaction(transaction, w3)
-                transaction = await self._gas_limit_transaction(transaction, w3)
+                transaction = await self._nonce_transaction(transaction, web3)
+                transaction = await self._gas_limit_transaction(transaction, web3)
                 transaction = await self._gas_price_transaction(
-                    transaction, chain_id, w3
+                    transaction, chain_id, web3
                 )
 
                 signed_tx = self._sign_transaction(transaction, from_address)
 
-                tx_hash = await w3.eth.send_raw_transaction(signed_tx)
+                tx_hash = await web3.eth.send_raw_transaction(signed_tx)
                 tx_hash_hex = tx_hash.hex()
 
                 result: dict[str, Any] = {"tx_hash": tx_hash_hex}
                 if wait_for_receipt:
-                    receipt = await w3.eth.wait_for_transaction_receipt(
+                    receipt = await web3.eth.wait_for_transaction_receipt(
                         tx_hash, timeout=timeout
                     )
                     result["receipt"] = self._format_receipt(receipt)
@@ -299,32 +199,19 @@ class LocalEvmTxn(EvmTxn):
                             False,
                             f"Transaction reverted (status={receipt_status}): {tx_hash_hex}",
                         )
-                        # Check if transaction reverted (status=0)
-                        # Handle both dict-like and attribute access for web3.py receipts
-                        receipt_status = (
-                            receipt.get("status")
-                            if hasattr(receipt, "get")
-                            else getattr(receipt, "status", None)
-                        )
-                        self.logger.debug(
-                            f"Transaction {tx_hash_hex} receipt status: {receipt_status} (type: {type(receipt_status).__name__})"
-                        )
-                        if receipt_status == 0:
-                            self.logger.error(f"Transaction reverted: {tx_hash_hex}")
-                            return (False, f"Transaction reverted: {tx_hash_hex}")
 
                     # Wait for additional confirmations if requested
                     if confirmations > 0:
                         tx_block = result["receipt"].get("blockNumber")
                         if tx_block:
                             await self._wait_for_confirmations(
-                                w3, tx_block, confirmations
+                                web3, tx_block, confirmations
                             )
 
                 return (True, result)
 
             finally:
-                await self._close_web3(w3)
+                await self._close_web3(web3)
 
         except Exception as exc:  # noqa: BLE001
             self.logger.error(f"Transaction broadcast failed: {exc}")
@@ -362,14 +249,12 @@ class LocalEvmTxn(EvmTxn):
     def _resolve_rpc_url(self, chain_id: int) -> str:
         return resolve_rpc_url(chain_id, self.config or {}, None)
 
-    async def _close_web3(self, w3: AsyncWeb3) -> None:
-        # Don't close cached connections - we want to reuse them for consistency
-        if w3 in self._web3_cache.values():
-            return
+    async def _close_web3(self, web3: AsyncWeb3) -> None:
         try:
-            await w3.provider.session.close()
-        except Exception:  # noqa: BLE001
-            pass
+            if hasattr(web3.provider, "disconnect"):
+                await web3.provider.disconnect()
+        except Exception as e:  # noqa: BLE001
+            self.logger.debug(f"Error disconnecting provider: {e}")
 
     async def _wait_for_confirmations(
         self, w3: AsyncWeb3, tx_block: int, confirmations: int

wayfinder_paths/core/utils/evm_helpers.py

@@ -11,7 +11,6 @@ from pathlib import Path
 from typing import Any
 
 from loguru import logger
-from web3 import AsyncHTTPProvider, AsyncWeb3
 
 from wayfinder_paths.core.constants.base import CHAIN_CODE_TO_ID
 
@@ -86,32 +85,6 @@ def resolve_rpc_url(
     raise ValueError("RPC URL not provided. Set strategy.rpc_urls in config.json.")
 
 
-async def get_next_nonce(
-    from_address: str, rpc_url: str, use_latest: bool = False
-) -> int:
-    """
-    Get the next nonce for the given address.
-
-    Args:
-        from_address: Address to get nonce for
-        rpc_url: RPC URL to connect to
-        use_latest: If True, use 'latest' block instead of 'pending'
-
-    Returns:
-        Next nonce as integer
-    """
-    w3 = AsyncWeb3(AsyncHTTPProvider(rpc_url))
-    try:
-        if use_latest:
-            return await w3.eth.get_transaction_count(from_address, "latest")
-        return await w3.eth.get_transaction_count(from_address)
-    finally:
-        try:
-            await w3.provider.session.close()
-        except Exception:
-            pass
-
-
 def resolve_private_key_for_from_address(
     from_address: str, config: dict[str, Any]
 ) -> str | None:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wayfinder-paths
-Version: 0.1.10
+Version: 0.1.11
 Summary: Wayfinder Path: strategies and adapters
 Author: Wayfinder
 Author-email: dev@wayfinder.ai
@@ -48,7 +48,7 @@ just create-wallets
 # Or manually: poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
 
 # To test a specific strategy
-just just create-wallet stablecoin_yield_strategy
+just create-wallet stablecoin_yield_strategy
 
 # Copy and configure
 cp wayfinder_paths/config.example.json config.json
@@ -374,11 +374,11 @@ class MyStrategy(Strategy):
 
 The following strategies are available and can be run using the CLI:
 
-| Strategy | Description | Chain |
-|----------|-------------|-------|
-| `basis_trading_strategy` | Delta-neutral basis trading | - |
-| `hyperlend_stable_yield_strategy` | Stable yield on HyperLend | HyperEVM |
-| `moonwell_wsteth_loop_strategy` | Leveraged wstETH yield loop | Base |
+| Strategy                          | Description                 | Chain    |
+| --------------------------------- | --------------------------- | -------- |
+| `basis_trading_strategy`          | Delta-neutral basis trading | -        |
+| `hyperlend_stable_yield_strategy` | Stable yield on HyperLend   | HyperEVM |
+| `moonwell_wsteth_loop_strategy`   | Leveraged wstETH yield loop | Base     |
 
 #### Running Strategies
 

{wayfinder_paths-0.1.10.dist-info → wayfinder_paths-0.1.11.dist-info}/RECORD

@@ -1,4 +1,3 @@
-wayfinder_paths/CONFIG_GUIDE.md,sha256=p8eT2FC_dp4bBdezwGmQYLiefLNze-I6lY__UXv07zQ,12975
 wayfinder_paths/__init__.py,sha256=YgOg-PRPT3ROh0zg6hgQyQE-YFkFGw6TM77zDvB4_sE,427
 wayfinder_paths/abis/generic/erc20.json,sha256=geyzVzdTNt3u1XHKxi4seszP_GIWIzPTl0FYgiftRnM,9336
 wayfinder_paths/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -41,7 +40,6 @@ wayfinder_paths/adapters/token_adapter/__init__.py,sha256=nEmxrvffEygn3iKH3cZTNL
 wayfinder_paths/adapters/token_adapter/adapter.py,sha256=JEb7A8wJYHxENFhJ6upAgnQAbPZeVfYi6OGs1hiHxnA,3432
 wayfinder_paths/adapters/token_adapter/examples.json,sha256=RW-3xazj4wbTPl-AVrzduRH1NCXx8m7-06bRMOUJ-lc,3626
 wayfinder_paths/adapters/token_adapter/test_adapter.py,sha256=oEhV5OooRh1oGnaTTMKtdU9oqvHBKR25KgL6-ZB6Mzo,4304
-wayfinder_paths/config.example.json,sha256=gDvS7W-cbaNe2IV7Q72di_PYpCDKODojELaXdd77Gx4,605
 wayfinder_paths/conftest.py,sha256=pqDNijXn9_zmbAdkt_2a18UQLjtsDkNTBJVTgC6H2nA,1136
 wayfinder_paths/core/__init__.py,sha256=AJK8oS2dCVuJ2pmSxqXOCvuWacNaVEU3yALEqsD3rog,398
 wayfinder_paths/core/adapters/BaseAdapter.py,sha256=bzc3ER7aKOsmk9cxyoJxGdI54eibbpcMC8nGYJUrsp0,2033
@@ -73,8 +71,8 @@ wayfinder_paths/core/constants/moonwell_abi.py,sha256=ALb-kKdfF9aUtEHR8OlqvA-3zJ
 wayfinder_paths/core/engine/StrategyJob.py,sha256=DqwkPu5JHp00xkDmj7kyUqs9U-VP0k-OBlVipjEzk14,7257
 wayfinder_paths/core/engine/__init__.py,sha256=WZ2KWnmOZnBocYrqdwq6EUHp6lmTyrKyXgHSHyQswnU,108
 wayfinder_paths/core/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-wayfinder_paths/core/services/base.py,sha256=cvfNoS8VXP7ksrZIjk4BYvqtSSueiHphcxny7Qt7VHY,5980
-wayfinder_paths/core/services/local_evm_txn.py,sha256=kzJUOvHWLZ0ygRmYpVnJJTp48E072YpfD8R9IJJIzOM,16522
+wayfinder_paths/core/services/base.py,sha256=94Wvs7Ym7tK9J3k9lEOhSSIC7ptnMJ161dYtF4XTSZ8,4096
+wayfinder_paths/core/services/local_evm_txn.py,sha256=0SJTTIUNx91bm0XzoqPUUfveNMPPYTUFTMHNFyoJ0ao,11968
 wayfinder_paths/core/services/local_token_txn.py,sha256=YQjuHjdyGwVfAZt3FGMkSKoc34bRiJrWRiR5pXJmL9U,8556
 wayfinder_paths/core/services/web3_service.py,sha256=7iR7bfqfUQCQcdfEWVGqy04PZBtZTuzCDpfLt1a-4OI,1485
 wayfinder_paths/core/settings.py,sha256=aJdy2bRcJtufr4TZnu30R2iv---Ru4s6nxKo-j22uKQ,1962
@@ -83,7 +81,7 @@ wayfinder_paths/core/strategies/__init__.py,sha256=2NjvvDw6sIQGUFV4Qo1olXTxUOY3G
 wayfinder_paths/core/strategies/base.py,sha256=-s0qeiGZl5CHTUL2PavGXM7ACkNlaa0c4jeZR_4DuBM,155
 wayfinder_paths/core/strategies/descriptors.py,sha256=9eFf-gPNw1NO1o1eQqGlEgnz237IpAmrmZnIH3JD-ys,1642
 wayfinder_paths/core/utils/__init__.py,sha256=TEylMYHnG37Z3mizSmw28bUm0vyNBFzf0Nc8dB_7l1A,73
-wayfinder_paths/core/utils/evm_helpers.py,sha256=D1NFanIdy7TcBHOFwYHAgnhENChaW34BNarFfauMX38,6230
+wayfinder_paths/core/utils/evm_helpers.py,sha256=jJBOhQfS19xPmrbAnYRai7LG7ixnTHgcNrPKLDeE3tQ,5476
 wayfinder_paths/core/utils/wallets.py,sha256=tGgVxDW2ZvkvJIb6yow1cirrqhQ67_X9IqxZocBEy2k,2438
 wayfinder_paths/core/wallets/README.md,sha256=GdO1RFUG_jZdVH6qeobHlr_c69hEDgLLrgqYCvj_dGs,3701
 wayfinder_paths/core/wallets/WalletManager.py,sha256=sptj0Dya9iM87BDzUktrYM_Mw33xyVJNrRUTVfBjHGw,1870
@@ -136,7 +134,7 @@ wayfinder_paths/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 wayfinder_paths/tests/test_smoke_manifest.py,sha256=kTcIa4qikcspVh2ohQIk0aHUdIvBvcQBfNbm3PNiVvg,1636
 wayfinder_paths/tests/test_test_coverage.py,sha256=9NrZeVmP02D4W7Qc0XjciC05bhvdTCVibYjTGfa_GQk,7893
 wayfinder_paths/tests/test_utils.py,sha256=pxHT0QKFlyJeJo8bFnKXzWcOdi6t8rbJ0JFCBaFCBRQ,2112
-wayfinder_paths-0.1.10.dist-info/LICENSE,sha256=dYKnlkC_xosBAEQNUvB6cHMuhFgcUtN0oBR7E8_aR2Y,1066
-wayfinder_paths-0.1.10.dist-info/METADATA,sha256=Nyi2X5KQqUSKYoXjM7MQl_mnYZ8EIYbZ4t0BPwC-RSY,25656
-wayfinder_paths-0.1.10.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
-wayfinder_paths-0.1.10.dist-info/RECORD,,
+wayfinder_paths-0.1.11.dist-info/LICENSE,sha256=dYKnlkC_xosBAEQNUvB6cHMuhFgcUtN0oBR7E8_aR2Y,1066
+wayfinder_paths-0.1.11.dist-info/METADATA,sha256=GIUfhzTEdw7KphRWf19P5AaCkT1RIKACpjaelJootCc,25763
+wayfinder_paths-0.1.11.dist-info/WHEEL,sha256=FMvqSimYX_P7y0a7UY-_Mc83r5zkBZsCYPm7Lr0Bsq4,88
+wayfinder_paths-0.1.11.dist-info/RECORD,,

wayfinder_paths/CONFIG_GUIDE.md

@@ -1,390 +0,0 @@
-# Configuration Guide
-
-This guide explains how to configure your strategies for local testing.
-
-## Quick Setup
-
-```bash
-# 1. Generate test wallets (required!)
-# Creates a main wallet (or use 'just create-strategy' which auto-creates wallets)
-just create-wallets
-# Or manually: poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
-
-# 2. Create your config file
-cp wayfinder_paths/config.example.json config.json
-
-# 3. Edit config.json with your Wayfinder credentials
-# NEVER commit this file - it contains your credentials!
-```
-
-## Configuration Structure
-
-### config.json Structure
-
-```json
-{
-  "user": {
-    "username": "your_username",      // OPTIONAL: For OAuth authentication
-    "password": "your_password",      // OPTIONAL: For OAuth authentication
-    "refresh_token": null,            // OPTIONAL: Alternative to username/password
-    "api_key": "sk_live_abc123..."    // OPTIONAL: For service account authentication (loaded directly by clients, not stored in UserConfig)
-  },
-  "system": {
-    "api_base_url": "https://wayfinder.ai/api/v1",
-    "api_key": "sk_live_abc123...",   // OPTIONAL: System-level API key (alternative to user.api_key, loaded directly by clients)
-    "wallets_path": "wallets.json"    // Path to your generated wallets.json
-  },
-  "strategy": {
-    "rpc_urls": {                     // RPC endpoints for different chains
-      "1": "https://eth.llamarpc.com",
-      "42161": "https://arb1.arbitrum.io/rpc",
-      "8453": "https://mainnet.base.org",
-      "solana": "https://api.mainnet-beta.solana.com"
-    }
-  }
-}
-```
-
-## User Configuration
-
-**Authentication (choose one method):**
-
-**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 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.
-
-**Option 2: Personal Access (OAuth) - For Development**
-- `user.username` - Your Wayfinder backend username
-- `user.password` - Your Wayfinder backend password
-- OR `user.refresh_token` - Alternative to username/password
-
-**Other Optional fields:**
-- `user.main_wallet_address` - Override auto-loaded main wallet
-- `user.strategy_wallet_address` - Override auto-loaded strategy wallet
-
-**Security Note:** Never commit `config.json` to version control. Add it to `.gitignore`.
-
-## System Configuration
-
-These are managed automatically by Wayfinder:
-- `api_base_url` - Wayfinder backend API endpoint
-- `wallets_path` - Location of generated wallets.json
-- `job_id` - Auto-generated by Wayfinder
-- `job_type` - Set to "strategy"
-
-## Strategy Configuration
-
-### RPC Endpoints
-
-Default RPC URLs are provided for:
-- Ethereum (chain ID: 1)
-- Arbitrum (chain ID: 42161) 
-- Base (chain ID: 8453)
-- Solana
-
-You can override these in `config.json` if needed.
-
-### Strategy-Specific Settings
-
-Individual strategies may have their own configuration parameters. Check the strategy's README for available options.
-
-## Wallet Generation for Testing
-
-Use the built-in script to generate test wallets for local development:
-
-```bash
-# Generate main wallet (recommended for initial setup)
-poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
-
-# Add additional wallets for multi-account testing
-poetry run python wayfinder_paths/scripts/make_wallets.py -n 3
-
-# Create a wallet with a specific label (e.g., for a strategy)
-poetry run python wayfinder_paths/scripts/make_wallets.py --label "my_strategy_name"
-
-# Generate keystore files (for geth/web3 compatibility)
-poetry run python wayfinder_paths/scripts/make_wallets.py -n 1 --keystore-password "your-password"
-```
-
-This creates `wallets.json` in the repository root with:
-- **main** wallet - your main wallet for testing (labeled "main")
-- Additional wallets with labels if specified
-
-**Note:** Generated wallets are for testing only. Wallet addresses are automatically loaded from `wallets.json` when not explicitly set in config. Strategy-specific wallets are automatically created when you use `just create-strategy "Strategy Name"`.
-
-## Per-Strategy Wallets
-
-Each strategy should have its own dedicated wallet for isolation and security. The system automatically looks up wallets by strategy directory name.
-
-### How It Works
-
-When you run a strategy:
-1. The system uses the strategy directory name (e.g., `hyperlend_stable_yield_strategy`) to look up a wallet
-2. It searches `wallets.json` for a wallet with a matching `label`
-3. If found, that wallet is used as the strategy's dedicated wallet
-4. Falls back to `strategy_wallet_address` from config if explicitly provided
-
-### Creating a Strategy with Wallet
-
-The easiest way to create a new strategy with its own wallet:
-
-```bash
-# Create a new strategy with dedicated wallet
-just create-strategy "My Strategy Name"
-
-# This automatically:
-# - Creates the strategy directory
-# - Generates a wallet with label matching the directory name
-# - Updates the strategy files with the correct names
-```
-
-### Wallet Structure
-
-Wallets in `wallets.json` are stored with labels that match strategy directory names:
-
-```json
-[
-  {
-    "address": "0x...",
-    "private_key_hex": "...",
-    "label": "main"
-  },
-  {
-    "address": "0x...",
-    "private_key_hex": "...",
-    "label": "hyperlend_stable_yield_strategy"
-  },
-  {
-    "address": "0x...",
-    "private_key_hex": "...",
-    "label": "my_awesome_strategy"
-  }
-]
-```
-
-### Manual Wallet Creation
-
-If you need to manually create a wallet for an existing strategy:
-
-```bash
-# Generate a wallet
-poetry run python wayfinder_paths/scripts/make_wallets.py -n 1
-
-# Then edit wallets.json to add a label matching your strategy directory name:
-# {
-#   "address": "0x...",
-#   "private_key_hex": "...",
-#   "label": "your_strategy_directory_name"
-# }
-```
-
-### Strategy Access
-
-Strategies access wallets the same way as before:
-
-```python
-# In strategy code
-strategy_address = self.config.get("strategy_wallet").get("address")
-main_address = self.config.get("main_wallet").get("address")
-```
-
-The strategy wallet is automatically populated from the wallet with label matching the strategy directory name.
-
-## Loading Configuration
-
-The configuration is loaded automatically when running strategies via `run_strategy.py`:
-
-```bash
-poetry run python wayfinder_paths/run_strategy.py stablecoin_yield_strategy --config config.json
-```
-
-For programmatic use:
-
-```python
-from pathlib import Path
-from core.config import StrategyJobConfig
-import json
-
-# Load from file
-with open("config.json") as f:
-    config_data = json.load(f)
-
-config = StrategyJobConfig.from_dict(config_data)
-
-# Configuration now has:
-# - config.user.username & password (for Wayfinder backend)
-# - config.system.api_base_url & wallets_path
-# - config.strategy_config (strategy-specific settings)
-```
-
-## Wallet Abstraction
-
-The strategy system supports multiple wallet types through a wallet abstraction layer. By default, adapters use local private keys (self-custodial wallets), but you can inject custom wallet providers for custodial wallets like Privy or Turnkey.
-
-### Default Behavior (Local Wallets)
-
-By default, adapters use `LocalWalletProvider` which resolves private keys from:
-- `wallets.json` (matched by address)
-- Wallet config in `config.json`
-
-No code changes are required - existing strategies continue to work.
-
-### Using Custom Wallet Providers
-
-To use a custodial wallet provider (e.g., Privy, Turnkey), inject it directly into adapters:
-
-```python
-from adapters.evm_transaction_adapter.adapter import EvmTransactionAdapter
-from my_privy_integration import PrivyWalletProvider
-
-# Create your custom wallet provider
-privy_provider = PrivyWalletProvider(privy_api_key, privy_wallet_id)
-
-# Inject it into adapters
-adapter = EvmTransactionAdapter(config, wallet_provider=privy_provider)
-```
-
-See `core/wallets/README.md` for details on implementing custom wallet providers.
-
-## Security Best Practices
-
-1. **Never commit `config.json`** - add it to `.gitignore`
-2. **Never commit `wallets.json`** - contains private keys
-3. **Use test wallets** - the script generates throwaway wallets for testing
-4. **Keep credentials secure** - Wayfinder username/password grant access to backend resources
-5. **Set conservative parameters** for initial testing:
-   - Lower leverage ratios
-   - Higher slippage tolerance
-   - Lower position sizes
-
-## Authentication with Wayfinder Backend
-
-Wayfinder Paths supports **dual authentication** for different use cases:
-
-### 1. Service Account Authentication (API Key)
-
-**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 two ways:
-
-#### Option A: Strategy Constructor (Programmatic)
-```python
-from wayfinder_paths.strategies.stablecoin_yield_strategy.strategy import StablecoinYieldStrategy
-
-strategy = StablecoinYieldStrategy(
-    config={...},
-    api_key="sk_live_abc123..."  # API key is auto-discovered by all clients
-)
-```
-
-#### Option B: config.json
-```json
-{
-  "user": {
-    "api_key": "sk_live_abc123..."
-  },
-  "system": {
-    "api_key": "sk_live_abc123..."  // Alternative: system-level API key
-  }
-}
-```
-
-**Priority Order:** Constructor parameter > `config.json` (user.api_key or system.api_key)
-
-**How It Works:**
-- 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`)
-- 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
-
-### 2. Personal Access Authentication (OAuth)
-
-**Best for:** Standalone SDK users and local development.
-
-The `username` and `password` in your config authenticate with the Wayfinder backend to access:
-- Wallet management
-- Transaction signing services
-- Strategy execution services
-
-```json
-{
-  "user": {
-    "username": "your_username",
-    "password": "your_password",
-    "refresh_token": null  // Optional: use refresh token instead of username/password
-  }
-}
-```
-
-**Fallback Behavior:**
-- If an API key is not found or authentication fails, the system automatically falls back to OAuth
-- OAuth tokens are automatically refreshed when they expire
-
-### Security Best Practices
-
-- **Never commit credentials** to version control - add `config.json` to `.gitignore`
-- **Use API keys for production** - they provide better rate limits and don't require token refresh
-- **Use OAuth for development** - simpler setup for local testing
-- **Rotate credentials regularly** - especially if exposed or compromised
-
-## Configuration in Strategies
-
-Strategies receive configuration automatically through StrategyJob:
-
-```python
-from core.strategies.Strategy import Strategy
-
-class MyStrategy(Strategy):
-    async def setup(self):
-        # Access strategy-specific config
-        target_leverage = self.config.get("target_leverage", 1.0)
-        
-        # Access RPC URLs
-        eth_rpc = self.config.get("rpc_urls", {}).get("1")
-        
-        # Configuration is already loaded from config.json
-```
-
-## Advanced: Custom RPC Endpoints
-
-To use custom RPC endpoints, update the `strategy.rpc_urls` section in `config.json`:
-
-```json
-{
-  "strategy": {
-    "rpc_urls": {
-      "1": "https://your-custom-ethereum-rpc.com",
-      "8453": "https://your-custom-base-rpc.com"
-    }
-  }
-}
-```
-
-## Troubleshooting
-
-**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 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`
-  - Verify your Wayfinder account credentials
-  - Try using `refresh_token` instead if you have one
-- **General:**
-  - The system automatically falls back from API key to OAuth if API key authentication fails
-  - Check logs for specific authentication error messages
-
-**Issue:** "Wallet not found"
-- Run the wallet generation script first
-- Check that `wallets.json` exists in repository root
-- Verify `system.wallets_path` in config points to the correct location
-
-**Issue:** "Invalid config"
-- Ensure `config.json` follows the correct structure
-- Check that all required fields are present

wayfinder_paths/config.example.json

@@ -1,22 +0,0 @@
-{
-    "user": {
-      "username": "your_username",
-      "password": "your_password",
-      "refresh_token": null,
-      "api_key": "sk_live_abc123..."
-    },
-    "system": {
-      "api_base_url": "https://wayfinder.ai/api/v1",
-      "api_key": "sk_live_abc123...",
-      "wallets_path": "wallets.json"
-    },
-    "strategy": {
-      "rpc_urls": {
-        "1": "https://eth.llamarpc.com",
-        "42161": "https://arb1.arbitrum.io/rpc",
-        "8453": "https://mainnet.base.org",
-        "solana": "https://api.mainnet-beta.solana.com",
-        "999": "https://rpc.hyperliquid.xyz/evm"
-      }
-    }
-  }