wayfinder-paths 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

wayfinder_paths/core/clients/__init__.py

@@ -13,14 +13,10 @@ from wayfinder_paths.core.clients.protocols import (
     HyperlendClientProtocol,
     LedgerClientProtocol,
     PoolClientProtocol,
-    SimulationClientProtocol,
     TokenClientProtocol,
-    TransactionClientProtocol,
     WalletClientProtocol,
 )
-from wayfinder_paths.core.clients.SimulationClient import SimulationClient
 from wayfinder_paths.core.clients.TokenClient import TokenClient
-from wayfinder_paths.core.clients.TransactionClient import TransactionClient
 from wayfinder_paths.core.clients.WalletClient import WalletClient
 from wayfinder_paths.core.clients.WayfinderClient import WayfinderClient
 
@@ -30,19 +26,15 @@ __all__ = [
     "AuthClient",
     "TokenClient",
     "WalletClient",
-    "TransactionClient",
     "LedgerClient",
     "PoolClient",
     "BRAPClient",
-    "SimulationClient",
     "HyperlendClient",
     # Protocols for SDK usage
     "TokenClientProtocol",
     "HyperlendClientProtocol",
     "LedgerClientProtocol",
     "WalletClientProtocol",
-    "TransactionClientProtocol",
     "PoolClientProtocol",
     "BRAPClientProtocol",
-    "SimulationClientProtocol",
 ]

wayfinder_paths/core/clients/protocols.py

@@ -28,12 +28,10 @@ if TYPE_CHECKING:
         LlamaReport,
         PoolList,
     )
-    from wayfinder_paths.core.clients.SimulationClient import SimulationResult
     from wayfinder_paths.core.clients.TokenClient import (
         GasToken,
         TokenDetails,
     )
-    from wayfinder_paths.core.clients.TransactionClient import TransactionPayload
     from wayfinder_paths.core.clients.WalletClient import (
         PoolBalance,
         TokenBalance,
@@ -186,21 +184,6 @@ class WalletClientProtocol(Protocol):
         ...
 
 
-class TransactionClientProtocol(Protocol):
-    """Protocol for transaction operations"""
-
-    async def build_send(
-        self,
-        from_address: str,
-        to_address: str,
-        token_address: str,
-        amount: float,
-        chain_id: int,
-    ) -> TransactionPayload:
-        """Build a send transaction payload for EVM tokens/native transfers"""
-        ...
-
-
 class PoolClientProtocol(Protocol):
     """Protocol for pool-related read operations"""
 
@@ -213,10 +196,6 @@ class PoolClientProtocol(Protocol):
         """Fetch pools by comma-separated pool ids"""
         ...
 
-    async def get_all_pools(self, *, merge_external: bool | None = None) -> PoolList:
-        """Fetch all pools"""
-        ...
-
     async def get_llama_matches(self) -> dict[str, LlamaMatch]:
         """Fetch Llama matches for pools"""
         ...
@@ -246,49 +225,6 @@ class BRAPClientProtocol(Protocol):
         ...
 
 
-class SimulationClientProtocol(Protocol):
-    """Protocol for blockchain transaction simulations"""
-
-    async def simulate_send(
-        self,
-        from_address: str,
-        to_address: str,
-        token_address: str,
-        amount: str,
-        chain_id: int,
-        initial_balances: dict[str, str],
-    ) -> SimulationResult:
-        """Simulate sending native ETH or ERC20 tokens"""
-        ...
-
-    async def simulate_approve(
-        self,
-        from_address: str,
-        to_address: str,
-        token_address: str,
-        amount: str,
-        chain_id: int,
-        initial_balances: dict[str, str],
-        clear_approval_first: bool = False,
-    ) -> SimulationResult:
-        """Simulate ERC20 token approval"""
-        ...
-
-    async def simulate_swap(
-        self,
-        from_token_address: str,
-        to_token_address: str,
-        from_chain_id: int,
-        to_chain_id: int,
-        amount: str,
-        from_address: str,
-        slippage: float,
-        initial_balances: dict[str, str],
-    ) -> SimulationResult:
-        """Simulate token swap operation"""
-        ...
-
-
 class HyperliquidExecutorProtocol(Protocol):
     """Protocol for Hyperliquid order execution operations."""
 

wayfinder_paths/core/config.py

@@ -4,7 +4,6 @@ Separates user-provided configuration from system configuration
 """
 
 import json
-import os
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
@@ -72,12 +71,8 @@ class SystemConfig:
     These are values managed by the Wayfinder system
     """
 
-    # API endpoints (populated from environment or defaults)
-    api_base_url: str = field(
-        default_factory=lambda: os.getenv(
-            "WAYFINDER_API_URL", "https://api.wayfinder.ai"
-        )
-    )
+    # 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
@@ -102,10 +97,7 @@ class SystemConfig:
     def from_dict(cls, data: dict[str, Any]) -> "SystemConfig":
         """Create SystemConfig from dictionary"""
         return cls(
-            api_base_url=data.get(
-                "api_base_url",
-                os.getenv("WAYFINDER_API_URL", "https://api.wayfinder.ai"),
-            ),
+            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),
@@ -113,10 +105,8 @@ class SystemConfig:
             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", os.getenv("WALLETS_PATH", "wallets.json")
-            ),
-            wallet_id=data.get("wallet_id") or os.getenv("WALLET_ID"),
+            wallets_path=data.get("wallets_path", "wallets.json"),
+            wallet_id=data.get("wallet_id"),
         )
 
     def to_dict(self) -> dict[str, Any]:
@@ -386,36 +376,6 @@ class StrategyJobConfig:
         return config
 
 
-def load_config_from_env() -> StrategyJobConfig:
-    """
-    Load configuration from environment variables
-    This is the simplest way for users to provide configuration
-    """
-    user_config = UserConfig(
-        username=os.getenv("WAYFINDER_USERNAME"),
-        password=os.getenv("WAYFINDER_PASSWORD"),
-        refresh_token=os.getenv("WAYFINDER_REFRESH_TOKEN"),
-        main_wallet_address=os.getenv("MAIN_WALLET_ADDRESS"),
-        strategy_wallet_address=os.getenv("STRATEGY_WALLET_ADDRESS"),
-        default_slippage=float(os.getenv("DEFAULT_SLIPPAGE", "0.005")),
-        gas_multiplier=float(os.getenv("GAS_MULTIPLIER", "1.2")),
-    )
-
-    system_config = SystemConfig(
-        api_base_url=os.getenv("WAYFINDER_API_URL", "https://api.wayfinder.ai"),
-        job_id=os.getenv("JOB_ID"),
-        update_interval=int(os.getenv("UPDATE_INTERVAL", "60")),
-        max_retries=int(os.getenv("MAX_RETRIES", "3")),
-        retry_delay=int(os.getenv("RETRY_DELAY", "5")),
-        wallets_path=os.getenv("WALLETS_PATH", "wallets.json"),
-        wallet_id=os.getenv("WALLET_ID"),
-    )
-
-    # No auto-population - wallets must be explicitly set in environment or matched by label
-
-    return StrategyJobConfig(user=user_config, system=system_config)
-
-
 # --- Internal helpers -------------------------------------------------------
 
 

wayfinder_paths/core/engine/StrategyJob.py

@@ -1,5 +1,4 @@
 import asyncio
-import os
 from typing import Any
 
 from loguru import logger
@@ -54,8 +53,6 @@ class StrategyJob:
                 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
 

wayfinder_paths/core/services/base.py

@@ -50,55 +50,6 @@ class EvmTxn(ABC):
     transaction confirmations.
     """
 
-    @abstractmethod
-    async def get_balance(
-        self,
-        address: str,
-        token_address: str | None,
-        chain_id: int,
-    ) -> tuple[bool, Any]:
-        """
-        Get balance for an address.
-
-        Args:
-            address: Address to query balance for
-            token_address: ERC20 token address, or None for native token
-            chain_id: Chain ID
-
-        Returns:
-            Tuple of (success, balance_integer_or_error_message)
-        """
-        pass
-
-    @abstractmethod
-    async def approve_token(
-        self,
-        token_address: str,
-        spender: str,
-        amount: int,
-        from_address: str,
-        chain_id: int,
-        wait_for_receipt: bool = True,
-        timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
-    ) -> tuple[bool, Any]:
-        """
-        Approve a spender to spend tokens on behalf of from_address.
-
-        Args:
-            token_address: ERC20 token contract address
-            spender: Address being approved to spend tokens
-            amount: Amount to approve (in token units, not human-readable)
-            from_address: Address approving the tokens
-            chain_id: Chain ID
-            wait_for_receipt: Whether to wait for the transaction receipt
-            timeout: Receipt timeout in seconds
-
-        Returns:
-            Tuple of (success, transaction_result_dict_or_error_message)
-            Transaction result should include 'tx_hash' and optionally 'receipt'
-        """
-        pass
-
     @abstractmethod
     async def broadcast_transaction(
         self,

wayfinder_paths/core/services/local_evm_txn.py

@@ -4,18 +4,13 @@ from typing import Any
 from eth_account import Account
 from eth_utils import to_checksum_address
 from loguru import logger
-from web3 import AsyncHTTPProvider, AsyncWeb3, Web3
+from web3 import AsyncHTTPProvider, AsyncWeb3
 
 from wayfinder_paths.core.constants import (
     DEFAULT_GAS_ESTIMATE_FALLBACK,
     ONE_GWEI,
-    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,
@@ -79,10 +74,10 @@ class NonceManager:
 
 class LocalEvmTxn(EvmTxn):
     """
-    Local wallet provider using private keys stored in config or environment variables.
+    Local wallet provider using private keys stored in config.json or wallets.json.
 
     This provider implements the current default behavior:
-    - Resolves private keys from config or environment
+    - Resolves private keys from config.json or wallets.json
     - Signs transactions using eth_account
     - Broadcasts transactions via RPC
     """
@@ -107,80 +102,6 @@ class LocalEvmTxn(EvmTxn):
         rpc_url = self._resolve_rpc_url(chain_id)
         return AsyncWeb3(AsyncHTTPProvider(rpc_url))
 
-    async def get_balance(
-        self,
-        address: str,
-        token_address: str | None,
-        chain_id: int,
-    ) -> tuple[bool, Any]:
-        """
-        Get balance for an address (native or ERC20 token).
-        """
-        w3 = self.get_web3(chain_id)
-        try:
-            checksum_addr = to_checksum_address(address)
-
-            if not token_address or token_address.lower() == ZERO_ADDRESS:
-                balance = await w3.eth.get_balance(checksum_addr)
-                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()
-            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]:
-        """
-        Approve a spender to spend tokens on behalf of from_address.
-        """
-        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.encodeABI(
-                fn_name="approve",
-                args=[spender_checksum, amount_int],
-            )
-
-            approve_txn = {
-                "from": from_checksum,
-                "chainId": int(chain_id),
-                "to": token_checksum,
-                "data": transaction_data,
-                "value": 0,
-                "gas": ERC20_APPROVAL_GAS_LIMIT,
-            }
-
-            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}")
-
     async def broadcast_transaction(
         self,
         transaction: dict[str, Any],

wayfinder_paths/core/services/local_token_txn.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
 
+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 +22,12 @@ 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()
+        self.builder = _EvmTransactionBuilder(wallet_provider)
 
     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(
                 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}"
@@ -127,12 +136,20 @@ class LocalTokenTxnService(TokenTxn):
             raise ValueError("Chain ID is required")
         return int(chain_id)
 
+    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)
+
 
 class _EvmTransactionBuilder:
     """Helpers that only build transaction dictionaries for sends and approvals."""
 
-    def __init__(self) -> None:
-        self.transaction_client = TransactionClient()
+    def __init__(self, wallet_provider: EvmTxn) -> None:
+        self.wallet_provider = wallet_provider
 
     async def build_send_transaction(
         self,
@@ -140,22 +157,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,
@@ -173,10 +205,13 @@ class _EvmTransactionBuilder:
         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 +220,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: