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

wayfinder_paths/core/services/local_token_txn.py

@@ -1,15 +1,16 @@
 from __future__ import annotations
 
+import asyncio
+from decimal import ROUND_DOWN, Decimal
 from typing import Any
 
 from eth_utils import to_checksum_address
 from loguru import logger
-from web3 import AsyncWeb3
+from web3 import AsyncWeb3, Web3
 
 from wayfinder_paths.core.clients.TokenClient import TokenClient
-from wayfinder_paths.core.clients.TransactionClient import TransactionClient
 from wayfinder_paths.core.constants import ZERO_ADDRESS
-from wayfinder_paths.core.constants.erc20_abi import ERC20_APPROVAL_ABI
+from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI, ERC20_APPROVAL_ABI
 from wayfinder_paths.core.services.base import EvmTxn, TokenTxn
 from wayfinder_paths.core.utils.evm_helpers import resolve_chain_id
 
@@ -22,13 +23,11 @@ class LocalTokenTxnService(TokenTxn):
         config: dict[str, Any] | None,
         *,
         wallet_provider: EvmTxn,
-        simulation: bool = False,
     ) -> None:
-        del config, simulation
+        del config
         self.wallet_provider = wallet_provider
         self.logger = logger.bind(service="DefaultEvmTransactionService")
         self.token_client = TokenClient()
-        self.builder = _EvmTransactionBuilder()
 
     async def build_send(
         self,
@@ -51,14 +50,24 @@ class LocalTokenTxnService(TokenTxn):
             return False, f"Token {token_id} is missing a chain id"
 
         token_address = (token_meta or {}).get("address") or ZERO_ADDRESS
+        is_native = not token_address or token_address.lower() == ZERO_ADDRESS.lower()
+
+        if is_native:
+            amount_wei = self._to_base_units(
+                amount, 18
+            )  # Native tokens use 18 decimals
+        else:
+            decimals = int((token_meta or {}).get("decimals") or 18)
+            amount_wei = self._to_base_units(amount, decimals)
 
         try:
-            tx = await self.builder.build_send_transaction(
+            tx = await self.build_send_transaction(
                 from_address=from_address,
                 to_address=to_address,
                 token_address=token_address,
-                amount=amount,
+                amount=amount_wei,
                 chain_id=int(chain_id),
+                is_native=is_native,
             )
         except Exception as exc:  # noqa: BLE001
             return False, f"Failed to build send transaction: {exc}"
@@ -84,7 +93,7 @@ class LocalTokenTxnService(TokenTxn):
         except (TypeError, ValueError) as exc:
             return False, str(exc)
 
-        approve_tx = self.builder.build_erc20_approval_transaction(
+        approve_tx = self.build_erc20_approval_transaction(
             chain_id=chain_id,
             token_address=token_checksum,
             from_address=from_checksum,
@@ -95,28 +104,53 @@ class LocalTokenTxnService(TokenTxn):
         return True, approve_tx
 
     async def read_erc20_allowance(
-        self, chain: Any, token_address: str, from_address: str, spender_address: str
+        self,
+        chain: Any,
+        token_address: str,
+        from_address: str,
+        spender_address: str,
+        max_retries: int = 3,
     ) -> dict[str, Any]:
         try:
             chain_id = self._chain_id(chain)
         except (TypeError, ValueError) as exc:
             return {"error": str(exc), "allowance": 0}
 
-        w3 = self.get_web3(chain_id)
-        try:
-            contract = w3.eth.contract(
-                address=to_checksum_address(token_address), abi=ERC20_APPROVAL_ABI
-            )
-            allowance = await contract.functions.allowance(
-                to_checksum_address(from_address),
-                to_checksum_address(spender_address),
-            ).call()
-            return (True, {"allowance": int(allowance)})
-        except Exception as exc:  # noqa: BLE001
-            self.logger.error(f"Failed to read allowance: {exc}")
-            return {"error": f"Allowance query failed: {exc}", "allowance": 0}
-        finally:
-            await self._close_web3(w3)
+        last_error = None
+        for attempt in range(max_retries):
+            w3 = self.wallet_provider.get_web3(chain_id)
+            try:
+                contract = w3.eth.contract(
+                    address=to_checksum_address(token_address), abi=ERC20_APPROVAL_ABI
+                )
+                allowance = await contract.functions.allowance(
+                    to_checksum_address(from_address),
+                    to_checksum_address(spender_address),
+                ).call()
+                return {"allowance": int(allowance)}
+            except Exception as exc:  # noqa: BLE001
+                last_error = exc
+                error_str = str(exc)
+                if "429" in error_str or "Too Many Requests" in error_str:
+                    if attempt < max_retries - 1:
+                        wait_time = 3.0 * (2**attempt)  # 3, 6, 12 seconds
+                        self.logger.warning(
+                            f"Rate limited reading allowance, retrying in {wait_time}s..."
+                        )
+                        await asyncio.sleep(wait_time)
+                        continue
+                self.logger.error(f"Failed to read allowance: {exc}")
+                return {"error": f"Allowance query failed: {exc}", "allowance": 0}
+            finally:
+                await self.wallet_provider._close_web3(w3)
+
+        self.logger.error(
+            f"Failed to read allowance after {max_retries} retries: {last_error}"
+        )
+        return {
+            "error": f"Allowance query failed after retries: {last_error}",
+            "allowance": 0,
+        }
 
     def _chain_id(self, chain: Any) -> int:
         if isinstance(chain, dict):
@@ -127,12 +161,13 @@ class LocalTokenTxnService(TokenTxn):
             raise ValueError("Chain ID is required")
         return int(chain_id)
 
-
-class _EvmTransactionBuilder:
-    """Helpers that only build transaction dictionaries for sends and approvals."""
-
-    def __init__(self) -> None:
-        self.transaction_client = TransactionClient()
+    def _to_base_units(self, amount: float, decimals: int) -> int:
+        """Convert human-readable amount to base units (wei for native, token units for ERC20)."""
+        scale = Decimal(10) ** int(decimals)
+        quantized = (Decimal(str(amount)) * scale).to_integral_value(
+            rounding=ROUND_DOWN
+        )
+        return int(quantized)
 
     async def build_send_transaction(
         self,
@@ -140,22 +175,37 @@ class _EvmTransactionBuilder:
         from_address: str,
         to_address: str,
         token_address: str | None,
-        amount: float,
+        amount: int,
         chain_id: int,
+        is_native: bool,
     ) -> dict[str, Any]:
         """Build the transaction dict for sending native or ERC20 tokens."""
-        payload = await self.transaction_client.build_send(
-            from_address=from_address,
-            to_address=to_address,
-            token_address=token_address or "",
-            amount=float(amount),
-            chain_id=int(chain_id),
-        )
-        return self._payload_to_tx(
-            payload=payload,
-            from_address=from_address,
-            is_native=not token_address or token_address.lower() == ZERO_ADDRESS,
-        )
+        from_checksum = to_checksum_address(from_address)
+        to_checksum = to_checksum_address(to_address)
+        chain_id_int = int(chain_id)
+
+        if is_native:
+            return {
+                "chainId": chain_id_int,
+                "from": from_checksum,
+                "to": to_checksum,
+                "value": int(amount),
+            }
+
+        token_checksum = to_checksum_address(token_address or ZERO_ADDRESS)
+        w3_sync = Web3()
+        contract = w3_sync.eth.contract(address=token_checksum, abi=ERC20_ABI)
+        data = contract.functions.transfer(
+            to_checksum, int(amount)
+        )._encode_transaction_data()
+
+        return {
+            "chainId": chain_id_int,
+            "from": from_checksum,
+            "to": token_checksum,
+            "data": data,
+            "value": 0,
+        }
 
     def build_erc20_approval_transaction(
         self,
@@ -168,15 +218,20 @@ class _EvmTransactionBuilder:
         web3: AsyncWeb3,
     ) -> dict[str, Any]:
         """Build an ERC20 approval transaction dict."""
+        del web3  # Use sync Web3 for encoding (AsyncContract doesn't have encodeABI)
         token_checksum = to_checksum_address(token_address)
         spender_checksum = to_checksum_address(spender)
         from_checksum = to_checksum_address(from_address)
         amount_int = int(amount)
 
-        contract = web3.eth.contract(address=token_checksum, abi=ERC20_APPROVAL_ABI)
-        data = contract.encodeABI(
-            fn_name="approve", args=[spender_checksum, amount_int]
-        )
+        # Use synchronous Web3 for encoding (encodeABI doesn't exist in web3.py v7)
+        w3_sync = Web3()
+        contract = w3_sync.eth.contract(address=token_checksum, abi=ERC20_APPROVAL_ABI)
+
+        # In web3.py v7, use _encode_transaction_data to encode without network calls
+        data = contract.functions.approve(
+            spender_checksum, amount_int
+        )._encode_transaction_data()
 
         return {
             "chainId": int(chain_id),
@@ -185,47 +240,3 @@ class _EvmTransactionBuilder:
             "data": data,
             "value": 0,
         }
-
-    def _payload_to_tx(
-        self, payload: dict[str, Any], from_address: str, is_native: bool
-    ) -> dict[str, Any]:
-        data_root = payload.get("data", payload)
-        tx_src = data_root.get("transaction") or data_root
-
-        chain_id = tx_src.get("chainId") or data_root.get("chain_id")
-        if chain_id is None:
-            raise ValueError("Transaction payload missing chainId")
-
-        tx: dict[str, Any] = {"chainId": int(chain_id)}
-        tx["from"] = to_checksum_address(from_address)
-
-        if tx_src.get("to"):
-            tx["to"] = to_checksum_address(tx_src["to"])
-        if tx_src.get("data"):
-            data = tx_src["data"]
-            tx["data"] = data if str(data).startswith("0x") else f"0x{data}"
-
-        val = tx_src.get("value", 0)
-        tx["value"] = self._normalize_value(val) if is_native else 0
-
-        if tx_src.get("gas"):
-            tx["gas"] = int(tx_src["gas"])
-        if tx_src.get("maxFeePerGas"):
-            tx["maxFeePerGas"] = int(tx_src["maxFeePerGas"])
-        if tx_src.get("maxPriorityFeePerGas"):
-            tx["maxPriorityFeePerGas"] = int(tx_src["maxPriorityFeePerGas"])
-        if tx_src.get("gasPrice"):
-            tx["gasPrice"] = int(tx_src["gasPrice"])
-        if tx_src.get("nonce") is not None:
-            tx["nonce"] = int(tx_src["nonce"])
-
-        return tx
-
-    def _normalize_value(self, value: Any) -> int:
-        if isinstance(value, str):
-            if value.startswith("0x"):
-                return int(value, 16)
-            return int(float(value))
-        if isinstance(value, (int, float)):
-            return int(value)
-        return 0

wayfinder_paths/core/services/web3_service.py

@@ -16,7 +16,6 @@ class DefaultWeb3Service(Web3Service):
         *,
         wallet_provider: EvmTxn | None = None,
         evm_transactions: TokenTxn | None = None,
-        simulation: bool = False,
     ) -> None:
         """
         Initialize the service with optional dependency injection.
@@ -33,7 +32,6 @@ class DefaultWeb3Service(Web3Service):
             self._evm_transactions = LocalTokenTxnService(
                 config=cfg,
                 wallet_provider=self._wallet_provider,
-                simulation=simulation,
             )
 
     @property

wayfinder_paths/core/settings.py

@@ -12,14 +12,14 @@ class CoreSettings(BaseSettings):
     """
 
     model_config = SettingsConfigDict(
-        env_file=".env",
-        env_file_encoding="utf-8",
+        # Note: .env file is only used for publishing (REPOSITORY_NAME, PUBLISH_TOKEN)
+        # All other configuration should come from config.json
         case_sensitive=False,
         extra="ignore",  # Ignore extra environment variables (e.g., from Django)
     )
 
     # Core API Configuration
-    API_ENV: str = Field("development", env="API_ENV")
+    API_ENV: str = Field(default="development")
 
     def _compute_default_api_url() -> str:
         """
@@ -44,17 +44,17 @@ class CoreSettings(BaseSettings):
             base = "https://wayfinder.ai/api/v1"
         return base
 
-    WAYFINDER_API_URL: str = Field(_compute_default_api_url(), env="WAYFINDER_API_URL")
+    WAYFINDER_API_URL: str = Field(default_factory=_compute_default_api_url)
 
     # Network Configuration
-    NETWORK: str = Field("testnet", env="NETWORK")  # mainnet, testnet, devnet
+    NETWORK: str = Field(default="testnet")  # mainnet, testnet, devnet
 
     # Logging
-    LOG_LEVEL: str = Field("INFO", env="LOG_LEVEL")
-    LOG_FILE: str = Field("logs/strategy.log", env="LOG_FILE")
+    LOG_LEVEL: str = Field(default="INFO")
+    LOG_FILE: str = Field(default="logs/strategy.log")
 
     # Safety
-    DRY_RUN: bool = Field(False, env="DRY_RUN")
+    DRY_RUN: bool = Field(default=False)
 
 
 # Core settings instance

wayfinder_paths/core/strategies/Strategy.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import os
 import traceback
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable
@@ -57,16 +56,13 @@ class Strategy(ABC):
         *,
         main_wallet: WalletConfig | dict[str, Any] | None = None,
         strategy_wallet: WalletConfig | dict[str, Any] | None = None,
-        simulation: bool = False,
         web3_service: Web3Service | None = None,
         api_key: str | None = None,
     ):
         self.adapters = {}
         self.ledger_adapter = None
         self.logger = logger.bind(strategy=self.__class__.__name__)
-        if api_key:
-            os.environ["WAYFINDER_API_KEY"] = api_key
-
+        # Note: api_key is passed to ClientManager, not set in environment
         self.config = config
 
     async def setup(self) -> None:

wayfinder_paths/core/strategies/descriptors.py

@@ -66,7 +66,7 @@ class StratDescriptor(BaseModel):
 
     # risk indicators
     volatility: Volatility
-    volatility_description_short: str
+    volatility_description: str
     directionality: Directionality
     directionality_description: str
     complexity: Complexity

wayfinder_paths/core/utils/evm_helpers.py

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

wayfinder_paths/core/wallets/README.md

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