wayfinder-paths 0.1.11__py3-none-any.whl → 0.1.14__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/engine/StrategyJob.py

@@ -1,5 +1,4 @@
 import asyncio
-import os
 from typing import Any
 
 from loguru import logger
@@ -16,7 +15,6 @@ class StrategyJob:
         config: StrategyJobConfig,
         clients: dict[str, Any] | None = None,
         skip_auth: bool = False,
-        api_key: str | None = None,
     ):
         """
         Initialize a StrategyJob.
@@ -26,16 +24,12 @@ class StrategyJob:
             config: Strategy job configuration.
             clients: Optional dict of pre-instantiated clients to inject directly.
             skip_auth: If True, skips authentication (for SDK usage).
-            api_key: Optional API key for service account authentication.
-                If provided, will be passed to ClientManager and strategy.
         """
         self.strategy = strategy
         self.config = config
 
         self.job_id = strategy.name or "unknown"
-        self.clients = ClientManager(
-            clients=clients, skip_auth=skip_auth, api_key=api_key
-        )
+        self.clients = ClientManager(clients=clients, skip_auth=skip_auth)
 
     def _setup_strategy(self):
         """Setup the strategy instance"""
@@ -44,23 +38,6 @@ class StrategyJob:
 
         self.strategy.log = self.log
 
-    def _is_using_api_key(self) -> bool:
-        """Check if API key authentication is being used."""
-        if self.clients._api_key:
-            return True
-
-        if self.clients.auth:
-            try:
-                creds = self.clients.auth._load_config_credentials()
-                if creds.get("api_key"):
-                    return True
-                if os.getenv("WAYFINDER_API_KEY"):
-                    return True
-            except Exception:
-                pass
-
-        return False
-
     async def setup(self):
         """
         Initialize the strategy job and strategy.
@@ -69,38 +46,13 @@ class StrategyJob:
         """
         self._setup_strategy()
 
-        # Ensure auth token is set for API calls
+        # Ensure API key is set for API calls
+        # All clients inherit from WayfinderClient and have _ensure_api_key()
         if not self.clients._skip_auth:
-            is_api_key_auth = self._is_using_api_key()
-
-            if is_api_key_auth:
-                logger.debug("Using API key authentication")
-                if self.clients.auth:
-                    await self.clients.auth._ensure_bearer_token()
-            else:
-                # Try to ensure bearer token is set, authenticate if needed
-                try:
-                    if self.clients.auth:
-                        await self.clients.auth._ensure_bearer_token()
-                except (PermissionError, Exception) as e:
-                    if not isinstance(e, PermissionError):
-                        logger.warning(
-                            f"Authentication failed: {e}, trying OAuth fallback"
-                        )
-                    username = self.config.user.username
-                    password = self.config.user.password
-                    refresh_token = self.config.user.refresh_token
-                    if refresh_token or (username and password):
-                        await self.clients.authenticate(
-                            username=username,
-                            password=password,
-                            refresh_token=refresh_token,
-                        )
-                    else:
-                        raise ValueError(
-                            "Authentication required: provide api_key parameter for service account auth, "
-                            "or username+password/refresh_token in config.json for personal access"
-                        ) from e
+            # Ensure API key on any client (they all share the same method)
+            token_client = self.clients.token
+            if token_client:
+                token_client._ensure_api_key()
 
         existing_cfg = dict(getattr(self.strategy, "config", {}) or {})
         strategy_cfg = dict(self.config.strategy_config or {})

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)
@@ -137,13 +155,13 @@ class LocalEvmTxn(EvmTxn):
             gas_price = await self._get_gas_price(w3)
 
             transaction["gasPrice"] = int(gas_price * SUGGESTED_GAS_PRICE_MULTIPLIER)
-        elif chain_id == 999:
-            big_block_gas_price = await w3.hype.big_block_gas_price()
+        # elif chain_id == 999:
+        #     big_block_gas_price = await w3.hype.big_block_gas_price()
 
-            transaction["maxFeePerGas"] = int(
-                big_block_gas_price * SUGGESTED_PRIORITY_FEE_MULTIPLIER
-            )
-            transaction["maxPriorityFeePerGas"] = 0
+        #     transaction["maxFeePerGas"] = int(
+        #         big_block_gas_price * SUGGESTED_PRIORITY_FEE_MULTIPLIER
+        #     )
+        #     transaction["maxPriorityFeePerGas"] = 0
         else:
             base_fee = await self._get_base_fee(w3)
             priority_fee = await self._get_priority_fee(w3)

wayfinder_paths/core/services/local_token_txn.py

@@ -154,7 +154,7 @@ class LocalTokenTxnService(TokenTxn):
 
     def _chain_id(self, chain: Any) -> int:
         if isinstance(chain, dict):
-            chain_id = chain.get("id") or chain.get("chain_id")
+            chain_id = chain.get("id")
         else:
             chain_id = getattr(chain, "id", None)
         if chain_id is None:

wayfinder_paths/core/strategies/Strategy.py

@@ -57,12 +57,10 @@ class Strategy(ABC):
         main_wallet: WalletConfig | dict[str, Any] | None = None,
         strategy_wallet: WalletConfig | dict[str, Any] | None = None,
         web3_service: Web3Service | None = None,
-        api_key: str | None = None,
     ):
         self.adapters = {}
         self.ledger_adapter = None
         self.logger = logger.bind(strategy=self.__class__.__name__)
-        # Note: api_key is passed to ClientManager, not set in environment
         self.config = config
 
     async def setup(self) -> None:
@@ -152,21 +150,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