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

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:

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..." }
   }
 }
 ```

wayfinder_paths/run_strategy.py

@@ -12,7 +12,7 @@ from pathlib import Path
 
 from loguru import logger
 
-from wayfinder_paths.core.config import StrategyJobConfig, load_config_from_env
+from wayfinder_paths.core.config import StrategyJobConfig
 from wayfinder_paths.core.engine.manifest import load_manifest, validate_manifest
 from wayfinder_paths.core.engine.StrategyJob import StrategyJob
 
@@ -21,7 +21,6 @@ def load_strategy(
     strategy_name: str,
     *,
     strategy_config: dict | None = None,
-    simulation: bool = False,
     api_key: str | None = None,
 ):
     """
@@ -30,7 +29,6 @@ def load_strategy(
     Args:
         strategy_name: Name of the strategy to load (directory name in strategies/)
         strategy_config: Configuration dict for the strategy
-        simulation: Enable simulation mode for testing
         api_key: Optional API key for service account authentication
 
     Returns:
@@ -59,36 +57,45 @@ def load_strategy(
     module = __import__(module_path, fromlist=[class_name])
     strategy_class = getattr(module, class_name)
 
-    return strategy_class(
-        config=strategy_config, simulation=simulation, api_key=api_key
-    )
+    return strategy_class(config=strategy_config, api_key=api_key)
 
 
 def load_config(
     config_path: str | None = None, strategy_name: str | None = None
 ) -> StrategyJobConfig:
     """
-    Load configuration from file or environment
+    Load configuration from config.json file
 
     Args:
-        config_path: Optional path to config file
+        config_path: Path to config file (defaults to "config.json")
         strategy_name: Optional strategy name for per-strategy wallet lookup
 
     Returns:
         StrategyJobConfig instance
+
+    Raises:
+        FileNotFoundError: If config file does not exist
     """
-    if config_path and Path(config_path).exists():
-        logger.info(f"Loading config from {config_path}")
-        with open(config_path) as f:
-            config_data = json.load(f)
-        return StrategyJobConfig.from_dict(config_data, strategy_name=strategy_name)
-    else:
-        logger.info("Loading config from environment variables")
-        config = load_config_from_env()
-        if strategy_name:
-            config.strategy_config["_strategy_name"] = strategy_name
-            config.__post_init__()
-        return config
+    # Default to config.json if not provided
+    if not config_path:
+        config_path = "config.json"
+
+    config_file = Path(config_path)
+    if not config_file.exists():
+        raise FileNotFoundError(
+            f"Config file not found: {config_path}. "
+            "Please create config.json (see wayfinder_paths/config.example.json for template)"
+        )
+
+    logger.info(f"Loading config from {config_path}")
+    with open(config_file) as f:
+        config_data = json.load(f)
+
+    config = StrategyJobConfig.from_dict(config_data, strategy_name=strategy_name)
+    if strategy_name:
+        config.strategy_config["_strategy_name"] = strategy_name
+        config.__post_init__()
+    return config
 
 
 async def run_strategy(
@@ -96,7 +103,6 @@ async def run_strategy(
     config_path: str | None = None,
     action: str = "run",
     manifest_path: str | None = None,
-    simulation: bool = False,
     **kwargs,
 ):
     """
@@ -159,9 +165,7 @@ async def run_strategy(
             module_path, class_name = manifest.entrypoint.rsplit(".", 1)
             module = __import__(module_path, fromlist=[class_name])
             strategy_class = getattr(module, class_name)
-            strategy = strategy_class(
-                config=config.strategy_config, simulation=simulation
-            )
+            strategy = strategy_class(config=config.strategy_config)
             logger.info(
                 f"Loaded strategy from manifest: {strategy_name_for_wallet or 'unnamed'}"
             )
@@ -169,7 +173,6 @@ async def run_strategy(
             strategy = load_strategy(
                 strategy_name,
                 strategy_config=config.strategy_config,
-                simulation=simulation,
             )
             logger.info(f"Loaded strategy: {strategy.name}")
 
@@ -326,7 +329,7 @@ def main():
         help="Path to strategy manifest YAML (alternative to strategy name)",
     )
     parser.add_argument(
-        "--config", help="Path to config file (defaults to environment variables)"
+        "--config", help="Path to config file (defaults to config.json)"
     )
     parser.add_argument(
         "--action",
@@ -372,11 +375,6 @@ def main():
         "--duration", type=int, help="Duration in seconds for script action"
     )
     parser.add_argument("--debug", action="store_true", help="Enable debug logging")
-    parser.add_argument(
-        "--simulation",
-        action="store_true",
-        help="Run in simulation mode (no real transactions)",
-    )
     parser.add_argument(
         "--wallet-id",
         help="Wallet ID for policy rendering (replaces FORMAT_WALLET_ID in policies)",
@@ -401,7 +399,6 @@ def main():
             gas_token_amount=args.gas_token_amount,
             interval=args.interval,
             duration=args.duration,
-            simulation=args.simulation,
             wallet_id=getattr(args, "wallet_id", None),
         )
     )

wayfinder_paths/scripts/make_wallets.py

@@ -15,27 +15,6 @@ def to_keystore_json(private_key_hex: str, password: str):
     return Account.encrypt(private_key_hex, password)
 
 
-def write_env(rows: list[dict[str, str]], out_dir: Path) -> None:
-    with open(out_dir / ".env.example", "w") as f:
-        if rows:
-            label_to_wallet = {r.get("label"): r for r in rows if r.get("label")}
-            main_w = (
-                label_to_wallet.get("main") or label_to_wallet.get("default") or rows[0]
-            )
-            strategy_w = label_to_wallet.get("strategy")
-
-            f.write("RPC_URL=https://rpc.ankr.com/eth\n")
-            # Back-compat defaults
-            f.write(f"PRIVATE_KEY={main_w['private_key_hex']}\n")
-            f.write(f"FROM_ADDRESS={main_w['address']}\n")
-            # Explicit main/strategy variables
-            f.write(f"MAIN_WALLET_ADDRESS={main_w['address']}\n")
-            if strategy_w:
-                f.write(f"STRATEGY_WALLET_ADDRESS={strategy_w['address']}\n")
-                # Optional: expose strategy private key for local dev only
-                f.write(f"PRIVATE_KEY_STRATEGY={strategy_w['private_key_hex']}\n")
-
-
 def main():
     parser = argparse.ArgumentParser(description="Generate local dev wallets")
     parser.add_argument(
@@ -48,7 +27,7 @@ def main():
         "--out-dir",
         type=Path,
         default=Path("."),
-        help="Output directory for wallets.json (and .env/keystore)",
+        help="Output directory for wallets.json (and keystore files)",
     )
     parser.add_argument(
         "--keystore-password",
@@ -161,9 +140,6 @@ def main():
                 ks_path.write_text(json.dumps(ks))
             index += 1
 
-    # Convenience outputs
-    write_env(rows, args.out_dir)
-
 
 if __name__ == "__main__":
     main()

wayfinder_paths/scripts/run_strategy.py

@@ -55,7 +55,6 @@ async def _run(args: argparse.Namespace) -> int:
             "main_wallet": main_wallet,
             "strategy_wallet": strategy_wallet,
         },
-        simulation=args.simulation,
     )
 
     await s.setup()
@@ -101,7 +100,6 @@ def main() -> int:
     )
     p.add_argument("--main-wallet-label", default="main")
     p.add_argument("--strategy-wallet-label", default="basis_trading_strategy")
-    p.add_argument("--simulation", action="store_true")
 
     sub = p.add_subparsers(dest="command", required=True)
 

wayfinder_paths/strategies/basis_trading_strategy/snapshot_mixin.py

@@ -8,7 +8,6 @@ from __future__ import annotations
 
 import asyncio
 import json
-import os
 import time
 from datetime import UTC, datetime
 from decimal import ROUND_DOWN, Decimal
@@ -1007,5 +1006,4 @@ class BasisSnapshotMixin:
         )
         if isinstance(val, str) and val.strip():
             return val.strip()
-        env = os.getenv("BASIS_SNAPSHOT_PATH")
-        return env.strip() if isinstance(env, str) and env.strip() else None
+        return None