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

wayfinder_paths/core/config.py

@@ -1,8 +1,3 @@
-"""
-Core Configuration System
-Separates user-provided configuration from system configuration
-"""
-
 import json
 from dataclasses import dataclass, field
 from pathlib import Path
@@ -18,143 +13,51 @@ from wayfinder_paths.core.constants.base import (
 )
 
 
+def _load_config_file() -> dict[str, Any]:
+    path = Path("config.json")
+    if not path.exists():
+        return {}
+    try:
+        return json.loads(path.read_text())
+    except Exception as e:
+        logger.warning(f"Failed to read config file at config.json: {e}")
+        return {}
+
+
+CONFIG = _load_config_file()
+
+
 @dataclass
 class UserConfig:
-    """
-    User-provided configuration
-    These are values that users MUST provide to run strategies
-    """
-
-    # Credential-based auth (JWT)
     username: str | None = None
     password: str | None = None
     refresh_token: str | None = None
-
-    # Wallet configuration
-    main_wallet_address: str | None = None  # User's main wallet address
-    strategy_wallet_address: str | None = None  # Dedicated strategy wallet address
-
-    # Optional user preferences
-    default_slippage: float = 0.005  # Default slippage tolerance (0.5%)
-    gas_multiplier: float = 1.2  # Gas limit multiplier for safety
-
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "UserConfig":
-        """Create UserConfig from dictionary"""
-        return cls(
-            username=data.get("username"),
-            password=data.get("password"),
-            refresh_token=data.get("refresh_token"),
-            main_wallet_address=data.get("main_wallet_address"),
-            strategy_wallet_address=data.get("strategy_wallet_address"),
-            default_slippage=data.get("default_slippage", 0.005),
-            gas_multiplier=data.get("gas_multiplier", 1.2),
-        )
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary"""
-        return {
-            "username": self.username,
-            "password": self.password,
-            "refresh_token": self.refresh_token,
-            "main_wallet_address": self.main_wallet_address,
-            "strategy_wallet_address": self.strategy_wallet_address,
-            "default_slippage": self.default_slippage,
-            "gas_multiplier": self.gas_multiplier,
-        }
+    main_wallet_address: str | None = None
+    strategy_wallet_address: str | None = None
+    default_slippage: float = 0.005
+    gas_multiplier: float = 1.2
 
 
 @dataclass
 class SystemConfig:
-    """
-    System-level configuration
-    These are values managed by the Wayfinder system
-    """
-
-    # API endpoints (populated from config.json or defaults)
     api_base_url: str = field(default="https://api.wayfinder.ai")
-
-    # Job configuration
     job_id: str | None = None
     job_type: str = "strategy"
-
-    # Execution settings
-    update_interval: int = 60  # Default update interval in seconds
-    max_retries: int = 3  # Maximum retries for failed operations
-    retry_delay: int = 5  # Delay between retries in seconds
-
-    # System paths
+    update_interval: int = 60
+    max_retries: int = 3
+    retry_delay: int = 5
     log_path: str | None = None
     data_path: str | None = None
-
-    # Local wallets.json path used to auto-populate wallet addresses when not provided
-    wallets_path: str | None = "wallets.json"
-
-    # Optional wallet_id for policy rendering
     wallet_id: str | None = None
 
-    @classmethod
-    def from_dict(cls, data: dict[str, Any]) -> "SystemConfig":
-        """Create SystemConfig from dictionary"""
-        return cls(
-            api_base_url=data.get("api_base_url", "https://api.wayfinder.ai"),
-            job_id=data.get("job_id"),
-            job_type=data.get("job_type", "strategy"),
-            update_interval=data.get("update_interval", 60),
-            max_retries=data.get("max_retries", 3),
-            retry_delay=data.get("retry_delay", 5),
-            log_path=data.get("log_path"),
-            data_path=data.get("data_path"),
-            wallets_path=data.get("wallets_path", "wallets.json"),
-            wallet_id=data.get("wallet_id"),
-        )
-
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary"""
-        return {
-            "api_base_url": self.api_base_url,
-            "job_id": self.job_id,
-            "job_type": self.job_type,
-            "update_interval": self.update_interval,
-            "max_retries": self.max_retries,
-            "retry_delay": self.retry_delay,
-            "log_path": self.log_path,
-            "data_path": self.data_path,
-            "wallets_path": self.wallets_path,
-            "wallet_id": self.wallet_id,
-        }
-
 
 @dataclass
 class StrategyJobConfig:
-    """
-    Complete configuration for a strategy job
-    Combines user and system configurations
-    """
-
     user: UserConfig
     system: SystemConfig
-    strategy_config: dict[str, Any] = field(
-        default_factory=dict
-    )  # Strategy-specific configuration
+    strategy_config: dict[str, Any] = field(default_factory=dict)
 
     def __post_init__(self) -> None:
-        """
-        Enrich strategy_config with wallet addresses and private keys from wallets.json.
-
-        This method automatically loads wallet information from wallets.json to populate
-        main_wallet and strategy_wallet addresses in strategy_config. Only uses wallets
-        with exact label matches (no fallbacks).
-
-        Wallet enrichment is conditional and can be skipped:
-        - Skipped if wallet_type is explicitly set to a non-"local" value
-        - Only performed if wallet_type is None, "local", or not specified
-        - Allows custom wallet providers (Privy/Turnkey) to opt out of file-based enrichment
-
-        Note:
-            This method never raises exceptions - all errors are logged but do not
-            prevent config construction failures.
-        """
         try:
             if not isinstance(self.strategy_config, dict):
                 self.strategy_config = {}
@@ -169,21 +72,11 @@ class StrategyJobConfig:
             if wallet_type in (None, "local"):
                 self._enrich_wallet_private_keys(by_addr)
         except Exception as e:
-            # Defensive: never allow config construction to fail on enrichment
             logger.warning(
                 f"Failed to enrich strategy config with wallet information: {e}"
             )
 
     def _get_wallet_type(self) -> str | None:
-        """
-        Determine the wallet type from strategy config.
-
-        Checks strategy_config, main_wallet, and strategy_wallet for wallet_type.
-        Returns the first wallet_type found, or None if not specified.
-
-        Returns:
-            Wallet type string or None if not specified.
-        """
         wallet_type = self.strategy_config.get("wallet_type")
         if wallet_type:
             return wallet_type
@@ -205,26 +98,16 @@ class StrategyJobConfig:
     def _load_wallets_from_file(
         self,
     ) -> tuple[dict[str, dict[str, Any]], dict[str, dict[str, Any]]]:
-        """
-        Load wallets from wallets.json file and index by label and address.
-
-        Returns:
-            Tuple of (by_label, by_addr) dictionaries:
-            - by_label: Maps wallet label to wallet entry
-            - by_addr: Maps wallet address (lowercase) to wallet entry
-        """
-        entries = _read_wallets_file(self.system.wallets_path)
+        entries = _read_wallets_from_config()
         by_label: dict[str, dict[str, Any]] = {}
         by_addr: dict[str, dict[str, Any]] = {}
 
         if entries and isinstance(entries, list):
             for e in entries:
                 if isinstance(e, dict):
-                    # Index by label
                     label = e.get("label")
                     if isinstance(label, str):
                         by_label[label] = e
-                    # Index by address
                     addr = e.get("address")
                     if isinstance(addr, str):
                         by_addr[addr.lower()] = e
@@ -232,16 +115,6 @@ class StrategyJobConfig:
         return by_label, by_addr
 
     def _enrich_wallet_addresses(self, by_label: dict[str, dict[str, Any]]) -> None:
-        """
-        Enrich strategy_config with wallet addresses from wallets.json.
-
-        Loads main_wallet and strategy_wallet addresses by exact label match.
-        Only sets addresses if they are not already present in strategy_config.
-
-        Args:
-            by_label: Dictionary mapping wallet labels to wallet entries.
-        """
-        # Load main wallet by exact label match only
         if "main_wallet" not in self.strategy_config:
             main_wallet = by_label.get("main")
             if main_wallet:
@@ -249,33 +122,21 @@ class StrategyJobConfig:
                     "address": main_wallet["address"]
                 }
 
-        # Load strategy wallet by strategy name label match only
         strategy_name = self.strategy_config.get("_strategy_name")
         if strategy_name and isinstance(strategy_name, str):
             strategy_wallet = by_label.get(strategy_name)
             if strategy_wallet:
-                # Use strategy-specific wallet as strategy_wallet
                 if "strategy_wallet" not in self.strategy_config:
                     self.strategy_config["strategy_wallet"] = {
                         "address": strategy_wallet["address"]
                     }
                 elif isinstance(self.strategy_config.get("strategy_wallet"), dict):
-                    # Ensure address is set if not already
                     if not self.strategy_config["strategy_wallet"].get("address"):
                         self.strategy_config["strategy_wallet"]["address"] = (
                             strategy_wallet["address"]
                         )
 
     def _enrich_wallet_private_keys(self, by_addr: dict[str, dict[str, Any]]) -> None:
-        """
-        Enrich wallet configs with private keys from wallets.json.
-
-        Only enriches private keys if using local wallet type (or defaulting to local).
-        This ensures custom wallet providers don't get private keys from files.
-
-        Args:
-            by_addr: Dictionary mapping wallet addresses (lowercase) to wallet entries.
-        """
         try:
             for key in ("main_wallet", "strategy_wallet"):
                 wallet_obj = self.strategy_config.get(key)
@@ -292,24 +153,38 @@ class StrategyJobConfig:
                             wallet_obj["private_key_hex"] = pk
         except Exception as e:
             logger.warning(
-                f"Failed to enrich wallet private keys from wallets.json: {e}"
+                f"Failed to enrich wallet private keys from config.json: {e}"
             )
 
     @classmethod
     def from_dict(
         cls, data: dict[str, Any], strategy_name: str | None = None
     ) -> "StrategyJobConfig":
-        """Create StrategyJobConfig from dictionary
-
-        Args:
-            data: Configuration dictionary
-            strategy_name: Optional strategy name for per-strategy wallet lookup
-        """
-        user_cfg = UserConfig.from_dict(data.get("user", {}))
-        sys_cfg = SystemConfig.from_dict(data.get("system", {}))
-        # No auto-population - wallets must be explicitly set in config or matched by label
+        user_data = data.get("user", {})
+        user_cfg = UserConfig(
+            username=user_data.get("username"),
+            password=user_data.get("password"),
+            refresh_token=user_data.get("refresh_token"),
+            main_wallet_address=user_data.get("main_wallet_address"),
+            strategy_wallet_address=user_data.get("strategy_wallet_address"),
+            default_slippage=user_data.get("default_slippage", 0.005),
+            gas_multiplier=user_data.get("gas_multiplier", 1.2),
+        )
+
+        system_data = data.get("system", {})
+        sys_cfg = SystemConfig(
+            api_base_url=system_data.get("api_base_url", "https://api.wayfinder.ai"),
+            job_id=system_data.get("job_id"),
+            job_type=system_data.get("job_type", "strategy"),
+            update_interval=system_data.get("update_interval", 60),
+            max_retries=system_data.get("max_retries", 3),
+            retry_delay=system_data.get("retry_delay", 5),
+            log_path=system_data.get("log_path"),
+            data_path=system_data.get("data_path"),
+            wallet_id=system_data.get("wallet_id"),
+        )
+
         strategy_config = data.get("strategy", {})
-        # Store strategy name in config for wallet lookup
         if strategy_name:
             strategy_config["_strategy_name"] = strategy_name
         return cls(
@@ -318,25 +193,11 @@ class StrategyJobConfig:
             strategy_config=strategy_config,
         )
 
-    def to_dict(self) -> dict[str, Any]:
-        """Convert to dictionary"""
-        return {
-            "user": self.user.to_dict(),
-            "system": self.system.to_dict(),
-            "strategy": self.strategy_config,
-        }
-
     def get_adapter_config(self, adapter_name: str) -> dict[str, Any]:
-        """
-        Get configuration for a specific adapter
-        Combines relevant user and system settings
-        """
         config = {
             "api_base_url": self.system.api_base_url,
         }
 
-        # Add wallet configuration if needed
-        # Only use wallets from strategy_config (matched by label) - no fallbacks
         if adapter_name in [
             ADAPTER_BALANCE,
             ADAPTER_BRAP,
@@ -359,60 +220,35 @@ class StrategyJobConfig:
                 and main_wallet.get("address")
                 else {}
             )
-            # user_wallet uses strategy_wallet if available, otherwise main_wallet
             config["user_wallet"] = (
                 config.get("strategy_wallet") or config.get("main_wallet") or {}
             )
 
-        # Add specific settings
         if adapter_name == ADAPTER_BRAP:
             config["default_slippage"] = self.user.default_slippage
             config["gas_multiplier"] = self.user.gas_multiplier
 
-        # Add any strategy-specific adapter config
         if adapter_name in self.strategy_config.get("adapters", {}):
             config.update(self.strategy_config["adapters"][adapter_name])
 
         return config
 
 
-# --- Internal helpers -------------------------------------------------------
-
-
-def _read_wallets_file(wallets_path: str | None) -> list[dict[str, Any]]:
-    """
-    Read wallet entries from a JSON file.
+def get_api_base_url() -> str:
+    system = CONFIG.get("system", {}) if isinstance(CONFIG, dict) else {}
+    api_url = system.get("api_base_url")
+    if api_url and isinstance(api_url, str):
+        return api_url.strip()
+    return "https://wayfinder.ai/api/v1"
 
-    Args:
-        wallets_path: Path to the wallets.json file. If None or empty, returns empty list.
 
-    Returns:
-        List of wallet dictionaries. Each wallet dict should contain:
-        - label: Wallet label (str)
-        - address: Wallet address (str)
-        - private_key or private_key_hex: Private key (str, optional)
-
-        Returns empty list if file doesn't exist, is invalid JSON, or contains
-        non-list data.
-
-    Note:
-        All errors are logged but do not raise exceptions. This allows the
-        config system to continue functioning even if wallets.json is missing
-        or malformed.
-    """
-    if not wallets_path:
-        return []
-    path = Path(wallets_path)
-    if not path.exists():
-        return []
+def _read_wallets_from_config() -> list[dict[str, Any]]:
     try:
-        data = json.loads(path.read_text())
-        if isinstance(data, list):
-            return data
-        return []
-    except (FileNotFoundError, json.JSONDecodeError, OSError) as e:
-        logger.warning(f"Failed to read wallets file at {wallets_path}: {e}")
+        wallets = CONFIG.get("wallets", [])
+        if isinstance(wallets, list):
+            return wallets
+        logger.warning("Wallets section in config.json is not a list")
         return []
     except Exception as e:
-        logger.warning(f"Unexpected error reading wallets file at {wallets_path}: {e}")
+        logger.warning(f"Failed to read wallets from config.json: {e}")
         return []

wayfinder_paths/core/services/local_evm_txn.py

@@ -5,6 +5,8 @@ from eth_account import Account
 from eth_utils import to_checksum_address
 from loguru import logger
 from web3 import AsyncHTTPProvider, AsyncWeb3
+from web3.middleware import ExtraDataToPOAMiddleware
+from web3.module import Module
 
 from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
 from wayfinder_paths.core.services.base import EvmTxn
@@ -20,6 +22,7 @@ GAS_LIMIT_BUFFER_MULTIPLIER = 1.5
 
 # Chains that don't support EIP-1559 (London) and need legacy gas pricing
 PRE_LONDON_GAS_CHAIN_IDS: set[int] = {56, 42161}
+POA_MIDDLEWARE_CHAIN_IDS: set = {56, 137, 43114}
 
 
 def _looks_like_revert_error(error: Any) -> bool:
@@ -40,12 +43,23 @@ def _looks_like_revert_error(error: Any) -> bool:
     )
 
 
+class HyperModule(Module):
+    def __init__(self, w3):
+        super().__init__(w3)
+
+    async def big_block_gas_price(self):
+        big_block_gas_price = await self.w3.manager.coro_request(
+            "eth_bigBlockGasPrice", []
+        )
+        return int(big_block_gas_price, 16)
+
+
 class LocalEvmTxn(EvmTxn):
     """
-    Local wallet provider using private keys stored in config.json or wallets.json.
+    Local wallet provider using private keys stored in config.json or config.json.
 
     This provider implements the current default behavior:
-    - Resolves private keys from config.json or wallets.json
+    - Resolves private keys from config.json or config.json
     - Signs transactions using eth_account
     - Broadcasts transactions via RPC
     """
@@ -56,8 +70,12 @@ class LocalEvmTxn(EvmTxn):
 
     def get_web3(self, chain_id: int) -> AsyncWeb3:
         rpc_url = self._resolve_rpc_url(chain_id)
-        w3 = AsyncWeb3(AsyncHTTPProvider(rpc_url))
-        return w3
+        web3 = AsyncWeb3(AsyncHTTPProvider(rpc_url))
+        if chain_id in POA_MIDDLEWARE_CHAIN_IDS:
+            web3.middleware_onion.inject(ExtraDataToPOAMiddleware, layer=0)
+        if chain_id == 999:
+            web3.attach_modules({"hype": (HyperModule)})
+        return web3
 
     def _validate_transaction(self, transaction: dict[str, Any]) -> dict[str, Any]:
         tx = dict(transaction)

wayfinder_paths/core/strategies/Strategy.py

@@ -152,21 +152,21 @@ class Strategy(ABC):
 
     @staticmethod
     async def policies() -> list[str]:
-        """Return policy strings for this strategy (Django-compatible)."""
+        """Return policy strings for this strategy."""
         raise NotImplementedError
 
     @abstractmethod
     async def _status(self) -> StatusDict:
         """
         Return status payload. Subclasses should implement this.
-        Should include Django-compatible keys (portfolio_value, net_deposit, strategy_status).
+        Should include keys (portfolio_value, net_deposit, strategy_status).
         Backward-compatible keys (active_amount, total_earned) may also be included.
         """
         pass
 
     async def status(self) -> StatusDict:
         """
-        Wrapper to compute and return strategy status. In Django, this also snapshots.
+        Wrapper to compute and return strategy status and record a snapshot.
         Here we simply delegate to _status for compatibility.
         """
 

wayfinder_paths/core/strategies/descriptors.py

@@ -46,12 +46,19 @@ DEFAULT_TOKEN_REWARDS = [
     },
 ]
 
+DEFAULT_FEE_DESCRIPTION = """Wayfinder deducts a 10% performance fee on profits generated by this vault. Fees are collected from the assets in the vault.
+
+If fees remain unpaid, Wayfinder may pause automated management of this vault."""
+
 
 class StratDescriptor(BaseModel):
     description: str
 
     summary: str
 
+    risk_description: str
+    fee_description: str = DEFAULT_FEE_DESCRIPTION
+
     gas_token_symbol: str
     gas_token_id: str
     deposit_token_id: str

wayfinder_paths/core/utils/evm_helpers.py

@@ -78,9 +78,13 @@ def resolve_rpc_url(
     if chain_id is not None and isinstance(mapping, dict):
         by_int = mapping.get(chain_id)
         if by_int:
+            if isinstance(by_int, list):
+                return str(by_int[0])
             return str(by_int)
         by_str = mapping.get(str(chain_id))
         if by_str:
+            if isinstance(by_str, list):
+                return str(by_str[0])
             return str(by_str)
     raise ValueError("RPC URL not provided. Set strategy.rpc_urls in config.json.")
 
@@ -133,7 +137,7 @@ def resolve_private_key_for_from_address(
     if strategy_addr and from_addr_norm == (strategy_addr or "").lower():
         return strategy_pk
 
-    # No fallback - private keys must be in config or wallets.json
+    # No fallback - private keys must be in config or config.json
     return None
 
 

wayfinder_paths/core/utils/wallets.py

@@ -6,11 +6,7 @@ from eth_account import Account
 
 
 def make_random_wallet() -> dict[str, str]:
-    """Generate a new random wallet.
-
-    Returns a mapping with keys: "address" and "private_key_hex" (0x-prefixed).
-    """
-    acct = Account.create()  # uses os.urandom
+    acct = Account.create()
     return {
         "address": acct.address,
         "private_key_hex": acct.key.hex(),
@@ -22,33 +18,31 @@ def _load_existing_wallets(file_path: Path) -> list[dict[str, Any]]:
         return []
     try:
         parsed = json.loads(file_path.read_text())
-        if isinstance(parsed, list):
-            return parsed
         if isinstance(parsed, dict):
             wallets = parsed.get("wallets")
             if isinstance(wallets, list):
                 return wallets
         return []
     except Exception:
-        # If the file is malformed, start fresh rather than raising.
         return []
 
 
 def _save_wallets(file_path: Path, wallets: list[dict[str, Any]]) -> None:
-    # Ensure stable ordering by address for readability
+    config = {}
+    if file_path.exists():
+        try:
+            config = json.loads(file_path.read_text())
+        except Exception:
+            pass
+
     sorted_wallets = sorted(wallets, key=lambda w: w.get("address", ""))
-    file_path.write_text(json.dumps(sorted_wallets, indent=2))
+    config["wallets"] = sorted_wallets
+    file_path.write_text(json.dumps(config, indent=2))
 
 
 def write_wallet_to_json(
-    wallet: dict[str, str], out_dir: str | Path = ".", filename: str = "wallets.json"
+    wallet: dict[str, str], out_dir: str | Path = ".", filename: str = "config.json"
 ) -> Path:
-    """Create or update a wallets.json with the provided wallet.
-
-    - Ensures the output directory exists.
-    - Merges with existing entries keyed by address (updates if present, appends otherwise).
-    - Writes a pretty-printed JSON list of wallet objects.
-    """
     out_dir_path = Path(out_dir)
     out_dir_path.mkdir(parents=True, exist_ok=True)
     file_path = out_dir_path / filename
@@ -71,7 +65,6 @@ def write_wallet_to_json(
 
 
 def load_wallets(
-    out_dir: str | Path = ".", filename: str = "wallets.json"
+    out_dir: str | Path = ".", filename: str = "config.json"
 ) -> list[dict[str, Any]]:
-    """Public helper to read wallets.json as a list of wallet dicts."""
     return _load_existing_wallets(Path(out_dir) / filename)

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.json or wallets.json, 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 config.json, while `WalletManager` resolves which provider to use at runtime.
 
 ## Pieces
 

wayfinder_paths/run_strategy.py

@@ -135,14 +135,16 @@ async def run_strategy(
         # Load configuration with strategy name for wallet lookup
         logger.debug(f"Config path provided: {config_path}")
         config = load_config(config_path, strategy_name=strategy_name)
-        logger.debug(
-            "Loaded config: creds=%s wallets(main=%s strategy=%s)",
+        creds = (
             "yes"
             if (config.user.username and config.user.password)
             or config.user.refresh_token
-            else "no",
-            (config.user.main_wallet_address or "none"),
-            (config.user.strategy_wallet_address or "none"),
+            else "no"
+        )
+        main_wallet = config.user.main_wallet_address or "none"
+        strategy_wallet = config.user.strategy_wallet_address or "none"
+        logger.debug(
+            f"Loaded config: creds={creds} wallets(main={main_wallet} strategy={strategy_wallet})"
         )
 
         # Load strategy with the enriched config
@@ -157,13 +159,13 @@ async def run_strategy(
 
         # Setup strategy job
         logger.info("Setting up strategy job...")
-        logger.debug(
-            "Auth mode: %s",
+        auth_mode = (
             "credentials"
             if (config.user.username and config.user.password)
             or config.user.refresh_token
-            else "missing",
+            else "missing"
         )
+        logger.debug(f"Auth mode: {auth_mode}")
         await strategy_job.setup()
 
         # Execute action