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

wayfinder_paths/core/services/local_evm_txn.py

@@ -4,16 +4,11 @@ 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 web3.middleware import ExtraDataToPOAMiddleware
+from web3.module import Module
 
-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,
@@ -27,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:
@@ -47,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
     """
@@ -60,104 +67,15 @@ 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}")
+        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)
@@ -264,29 +182,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 +217,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 +267,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/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

@@ -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
 
@@ -79,39 +78,17 @@ 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.")
 
 
-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:
@@ -160,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

wayfinder_paths/scripts/create_strategy.py

@@ -62,8 +62,8 @@ def main():
     parser.add_argument(
         "--wallets-file",
         type=Path,
-        default=Path(__file__).parent.parent.parent / "wallets.json",
-        help="Path to wallets.json file",
+        default=Path(__file__).parent.parent.parent / "config.json",
+        help="Path to config.json file",
     )
     parser.add_argument(
         "--override",
@@ -121,9 +121,9 @@ def main():
         print(f"  Updated strategy.py with class name: {class_name}")
 
     # Generate wallet with label matching directory name (strategy identifier)
-    # If wallets.json doesn't exist, create it with a main wallet first
+    # If config.json doesn't exist, create it with a main wallet first
     if not args.wallets_file.exists():
-        print("  Creating new wallets.json with main wallet...")
+        print("  Creating new config.json with main wallet...")
         main_wallet = make_random_wallet()
         main_wallet["label"] = "main"
         write_wallet_to_json(
@@ -133,7 +133,7 @@ def main():
         )
         print(f"  Generated main wallet: {main_wallet['address']}")
 
-    # Generate strategy wallet (will append to existing wallets.json)
+    # Generate strategy wallet (will append to existing config.json)
     wallet = make_random_wallet()
     wallet["label"] = dir_name
     write_wallet_to_json(

wayfinder_paths/scripts/make_wallets.py

@@ -27,7 +27,7 @@ def main():
         "--out-dir",
         type=Path,
         default=Path("."),
-        help="Output directory for wallets.json (and keystore files)",
+        help="Output directory for config.json (and keystore files)",
     )
     parser.add_argument(
         "--keystore-password",
@@ -55,7 +55,7 @@ def main():
     args.out_dir.mkdir(parents=True, exist_ok=True)
 
     # Load existing wallets
-    existing = load_wallets(args.out_dir, "wallets.json")
+    existing = load_wallets(args.out_dir, "config.json")
     has_main = any(w.get("label") in ("main", "default") for w in existing)
 
     rows: list[dict[str, str]] = []
@@ -72,7 +72,7 @@ def main():
             w["label"] = args.label
             rows.append(w)
             print(f"[{index}] {w['address']}  (label: {args.label})")
-            write_wallet_to_json(w, out_dir=args.out_dir, filename="wallets.json")
+            write_wallet_to_json(w, out_dir=args.out_dir, filename="config.json")
             if args.keystore_password:
                 ks = to_keystore_json(w["private_key_hex"], args.keystore_password)
                 ks_path = args.out_dir / f"keystore_{w['address']}.json"
@@ -86,7 +86,7 @@ def main():
                 rows.append(main_w)
                 print(f"[{index}] {main_w['address']}  (main)")
                 write_wallet_to_json(
-                    main_w, out_dir=args.out_dir, filename="wallets.json"
+                    main_w, out_dir=args.out_dir, filename="config.json"
                 )
                 if args.keystore_password:
                     ks = to_keystore_json(
@@ -133,7 +133,7 @@ def main():
                 rows.append(w)
                 print(f"[{index}] {w['address']}  (label: temporary_{next_temp_num})")
 
-            write_wallet_to_json(w, out_dir=args.out_dir, filename="wallets.json")
+            write_wallet_to_json(w, out_dir=args.out_dir, filename="config.json")
             if args.keystore_password:
                 ks = to_keystore_json(w["private_key_hex"], args.keystore_password)
                 ks_path = args.out_dir / f"keystore_{w['address']}.json"

wayfinder_paths/scripts/run_strategy.py

@@ -27,7 +27,7 @@ def _find_wallet(wallets: list[dict[str, Any]], label: str) -> dict[str, Any]:
     for w in wallets:
         if w.get("label") == label:
             return w
-    raise ValueError(f"Wallet label not found in wallets.json: {label}")
+    raise ValueError(f"Wallet label not found in config.json: {label}")
 
 
 def _get_strategy_class(strategy: str):
@@ -58,7 +58,7 @@ def _get_strategy_class(strategy: str):
 async def _run(args: argparse.Namespace) -> int:
     repo_root = Path(__file__).resolve().parents[2]
     wallets_path = (
-        Path(args.wallets).resolve() if args.wallets else repo_root / "wallets.json"
+        Path(args.wallets).resolve() if args.wallets else repo_root / "config.json"
     )
     config_path = (
         Path(args.config).resolve() if args.config else repo_root / "config.json"
@@ -123,7 +123,7 @@ def main() -> int:
         ],
     )
     p.add_argument(
-        "--wallets", default=None, help="Path to wallets.json (default: repo root)"
+        "--wallets", default=None, help="Path to config.json (default: repo root)"
     )
     p.add_argument(
         "--config", default=None, help="Path to config.json (default: repo root)"

wayfinder_paths/strategies/basis_trading_strategy/snapshot_mixin.py

@@ -38,7 +38,7 @@ class BasisSnapshotMixin:
         entry_cost_usd: float,
         exit_cost_usd: float,
     ) -> dict[str, Any]:
-        """Build the `safe[horizon]` entry matching Django output shape."""
+        """Build the `safe[horizon]` entry matching the expected output shape."""
         L = max(1, int(leverage))
 
         depth_checks = depth_checks or {}