wayfinder-paths 0.1.15__py3-none-any.whl → 0.1.16__py3-none-any.whl

wayfinder_paths/core/config.py

@@ -5,13 +5,6 @@ from typing import Any
 
 from loguru import logger
 
-from wayfinder_paths.core.constants.base import (
-    ADAPTER_BALANCE,
-    ADAPTER_BRAP,
-    ADAPTER_HYPERLIQUID,
-    ADAPTER_MOONWELL,
-)
-
 
 def _load_config_file() -> dict[str, Any]:
     path = Path("config.json")
@@ -25,6 +18,14 @@ def _load_config_file() -> dict[str, Any]:
 
 
 CONFIG = _load_config_file()
+SUPPORTED_CHAINS = [
+    1,
+    8453,
+    56,
+    42161,
+    137,
+    999,
+]
 
 
 @dataclass
@@ -193,46 +194,6 @@ class StrategyJobConfig:
             strategy_config=strategy_config,
         )
 
-    def get_adapter_config(self, adapter_name: str) -> dict[str, Any]:
-        config = {
-            "api_base_url": self.system.api_base_url,
-        }
-
-        if adapter_name in [
-            ADAPTER_BALANCE,
-            ADAPTER_BRAP,
-            ADAPTER_MOONWELL,
-            ADAPTER_HYPERLIQUID,
-        ]:
-            strategy_wallet = self.strategy_config.get("strategy_wallet")
-            main_wallet = self.strategy_config.get("main_wallet")
-            config["strategy_wallet"] = (
-                {"address": strategy_wallet["address"]}
-                if strategy_wallet
-                and isinstance(strategy_wallet, dict)
-                and strategy_wallet.get("address")
-                else {}
-            )
-            config["main_wallet"] = (
-                {"address": main_wallet["address"]}
-                if main_wallet
-                and isinstance(main_wallet, dict)
-                and main_wallet.get("address")
-                else {}
-            )
-            config["user_wallet"] = (
-                config.get("strategy_wallet") or config.get("main_wallet") or {}
-            )
-
-        if adapter_name == ADAPTER_BRAP:
-            config["default_slippage"] = self.user.default_slippage
-            config["gas_multiplier"] = self.user.gas_multiplier
-
-        if adapter_name in self.strategy_config.get("adapters", {}):
-            config.update(self.strategy_config["adapters"][adapter_name])
-
-        return config
-
 
 def get_api_base_url() -> str:
     system = CONFIG.get("system", {}) if isinstance(CONFIG, dict) else {}

wayfinder_paths/core/constants/base.py

@@ -29,7 +29,6 @@ DEFAULT_SLIPPAGE = 0.005
 # Base L2 (and some RPC providers) can occasionally take >2 minutes to index/return receipts,
 # even if the transaction is eventually mined. A longer timeout reduces false negatives that
 # can lead to unsafe retry behavior (nonce gaps, duplicate swaps, etc.).
-DEFAULT_TRANSACTION_TIMEOUT = 300  # Transaction receipt wait timeout
 DEFAULT_HTTP_TIMEOUT = 30.0  # HTTP client timeout
 
 # Adapter type identifiers

wayfinder_paths/core/constants/erc20_abi.py

@@ -8,8 +8,8 @@ ERC20_ABI = [
     {
         "constant": True,
         "inputs": [
-            {"name": "_owner", "type": "address"},
-            {"name": "_spender", "type": "address"},
+            {"name": "owner", "type": "address"},
+            {"name": "spender", "type": "address"},
         ],
         "name": "allowance",
         "outputs": [{"name": "", "type": "uint256"}],
@@ -18,8 +18,8 @@ ERC20_ABI = [
     {
         "constant": False,
         "inputs": [
-            {"name": "_spender", "type": "address"},
-            {"name": "_value", "type": "uint256"},
+            {"name": "spender", "type": "address"},
+            {"name": "value", "type": "uint256"},
         ],
         "name": "approve",
         "outputs": [{"name": "", "type": "bool"}],
@@ -63,8 +63,8 @@ ERC20_ABI = [
     {
         "constant": False,
         "inputs": [
-            {"name": "_to", "type": "address"},
-            {"name": "_value", "type": "uint256"},
+            {"name": "to", "type": "address"},
+            {"name": "value", "type": "uint256"},
         ],
         "name": "transfer",
         "outputs": [{"name": "", "type": "bool"}],
@@ -73,9 +73,9 @@ ERC20_ABI = [
     {
         "constant": False,
         "inputs": [
-            {"name": "_from", "type": "address"},
-            {"name": "_to", "type": "address"},
-            {"name": "_value", "type": "uint256"},
+            {"name": "from", "type": "address"},
+            {"name": "to", "type": "address"},
+            {"name": "value", "type": "uint256"},
         ],
         "name": "transferFrom",
         "outputs": [{"name": "", "type": "bool"}],
@@ -87,8 +87,8 @@ ERC20_APPROVAL_ABI = [
     {
         "constant": True,
         "inputs": [
-            {"name": "_owner", "type": "address"},
-            {"name": "_spender", "type": "address"},
+            {"name": "owner", "type": "address"},
+            {"name": "spender", "type": "address"},
         ],
         "name": "allowance",
         "outputs": [{"name": "", "type": "uint256"}],
@@ -97,8 +97,8 @@ ERC20_APPROVAL_ABI = [
     {
         "constant": False,
         "inputs": [
-            {"name": "_spender", "type": "address"},
-            {"name": "_value", "type": "uint256"},
+            {"name": "spender", "type": "address"},
+            {"name": "value", "type": "uint256"},
         ],
         "name": "approve",
         "outputs": [{"name": "", "type": "bool"}],

wayfinder_paths/core/strategies/Strategy.py

@@ -8,7 +8,6 @@ from typing import Any, TypedDict
 from loguru import logger
 
 from wayfinder_paths.core.clients.TokenClient import TokenDetails
-from wayfinder_paths.core.services.base import Web3Service
 from wayfinder_paths.core.strategies.descriptors import StratDescriptor
 
 
@@ -56,12 +55,17 @@ 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,
+        main_wallet_signing_callback: Callable[[dict], Awaitable[str]] | None = None,
+        strategy_wallet_signing_callback: Callable[[dict], Awaitable[str]]
+        | None = None,
     ):
         self.adapters = {}
         self.ledger_adapter = None
         self.logger = logger.bind(strategy=self.__class__.__name__)
         self.config = config
+        self.main_wallet_signing_callback = main_wallet_signing_callback
+        self.strategy_wallet_signing_callback = strategy_wallet_signing_callback
 
     async def setup(self) -> None:
         """Initialize strategy-specific setup after construction"""

wayfinder_paths/core/utils/erc20_service.py

@@ -0,0 +1,100 @@
+from web3 import AsyncWeb3
+
+from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
+from wayfinder_paths.core.utils.web3 import web3_from_chain_id
+
+NATIVE_CURRENCY_ADDRESSES: set = {
+    "0x0000000000000000000000000000000000000000",
+    "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+    # TODO: This is not a proper SOL address, this short form is for LIFI only, fix this after fixing lifi
+    "11111111111111111111111111111111",
+    "0x0000000000000000000000000000000000001010",
+}
+
+
+async def get_token_balance(
+    token_address: str, chain_id: int, wallet_address: str
+) -> int:
+    async with web3_from_chain_id(chain_id) as web3:
+        checksum_wallet = AsyncWeb3.to_checksum_address(wallet_address)
+        if not token_address or token_address.lower() in NATIVE_CURRENCY_ADDRESSES:
+            balance = await web3.eth.get_balance(checksum_wallet)
+            return int(balance)
+
+        checksum_token = AsyncWeb3.to_checksum_address(token_address)
+        contract = web3.eth.contract(address=checksum_token, abi=ERC20_ABI)
+        balance = await contract.functions.balanceOf(checksum_wallet).call(
+            block_identifier="pending"
+        )
+        return int(balance)
+
+
+async def get_token_allowance(
+    token_address: str, chain_id: int, owner_address: str, spender_address: str
+):
+    async with web3_from_chain_id(chain_id) as web3:
+        contract = web3.eth.contract(
+            address=web3.to_checksum_address(token_address), abi=ERC20_ABI
+        )
+        return await contract.functions.allowance(
+            web3.to_checksum_address(owner_address),
+            web3.to_checksum_address(spender_address),
+        ).call(block_identifier="pending")
+
+
+async def build_approve_transaction(
+    from_address: str,
+    chain_id: int,
+    token_address: str,
+    spender_address: str,
+    amount: int,
+) -> dict:
+    """Build an ERC20 approve transaction."""
+    async with web3_from_chain_id(chain_id) as web3:
+        contract = web3.eth.contract(
+            address=web3.to_checksum_address(token_address), abi=ERC20_ABI
+        )
+        data = contract.encode_abi(
+            "approve",
+            [
+                web3.to_checksum_address(spender_address),
+                amount,
+            ],
+        )
+        return {
+            "to": web3.to_checksum_address(token_address),
+            "from": web3.to_checksum_address(from_address),
+            "data": data,
+            "chainId": chain_id,
+        }
+
+
+async def build_send_transaction(
+    from_address: str,
+    to_address: str,
+    token_address: str | None,
+    chain_id: int,
+    amount: int,
+) -> dict:
+    async with web3_from_chain_id(chain_id) as web3:
+        from_checksum = web3.to_checksum_address(from_address)
+        to_checksum = web3.to_checksum_address(to_address)
+
+        if not token_address or token_address.lower() in NATIVE_CURRENCY_ADDRESSES:
+            return {
+                "to": to_checksum,
+                "from": from_checksum,
+                "value": amount,
+                "chainId": chain_id,
+            }
+
+        token_checksum = web3.to_checksum_address(token_address)
+        contract = web3.eth.contract(address=token_checksum, abi=ERC20_ABI)
+        data = contract.encode_abi("transfer", [to_checksum, amount])
+
+        return {
+            "to": token_checksum,
+            "from": from_checksum,
+            "data": data,
+            "chainId": chain_id,
+        }

wayfinder_paths/core/utils/evm_helpers.py

@@ -2,7 +2,7 @@
 EVM helper utilities for common blockchain operations.
 
 This module provides reusable functions for EVM-related operations that are shared
-across multiple adapters, extracted from evm_transaction_adapter.
+across multiple adapters.
 """
 
 import json

wayfinder_paths/core/utils/transaction.py

@@ -0,0 +1,191 @@
+import asyncio
+from collections.abc import Callable
+
+from loguru import logger
+from web3 import AsyncWeb3
+
+from wayfinder_paths.core.utils.web3 import (
+    get_transaction_chain_id,
+    web3_from_chain_id,
+    web3s_from_chain_id,
+)
+
+PRE_EIP_1559_CHAIN_IDS: set = {56, 42161}
+
+SUGGESTED_PRIORITY_FEE_MULTIPLIER = 1.5
+SUGGESTED_GAS_PRICE_MULTIPLIER = 1.5
+
+
+def _get_transaction_from_address(transaction: dict) -> str:
+    if "from" not in transaction:
+        raise ValueError("Transaction does not contain from address")
+    return AsyncWeb3.to_checksum_address(transaction["from"])
+
+
+async def nonce_transaction(transaction: dict):
+    transaction = transaction.copy()
+
+    from_address = _get_transaction_from_address(transaction)
+
+    async def _get_nonce(web3: AsyncWeb3, from_address: str) -> int:
+        return await web3.eth.get_transaction_count(from_address)
+
+    async with web3s_from_chain_id(get_transaction_chain_id(transaction)) as web3s:
+        nonces = await asyncio.gather(
+            *[_get_nonce(web3, from_address) for web3 in web3s]
+        )
+
+        nonce = max(nonces)
+        transaction["nonce"] = nonce
+
+    return transaction
+
+
+async def gas_price_transaction(
+    transaction: dict,
+    gas_price_multiplier: float = SUGGESTED_GAS_PRICE_MULTIPLIER,
+    priority_fee_multiplier: float = SUGGESTED_PRIORITY_FEE_MULTIPLIER,
+):
+    transaction = transaction.copy()
+
+    async def _get_gas_price(web3: AsyncWeb3) -> int:
+        return await web3.eth.gas_price
+
+    async def _get_base_fee(web3: AsyncWeb3) -> int:
+        latest_block = await web3.eth.get_block("latest")
+        return latest_block.baseFeePerGas
+
+    async def _get_priority_fee(web3: AsyncWeb3) -> int:
+        lookback_blocks = 10
+        percentile = 80
+        fee_history = await web3.eth.fee_history(
+            lookback_blocks, "latest", [percentile]
+        )
+        historical_priority_fees = [i[0] for i in fee_history.reward]
+        return sum(historical_priority_fees) // len(historical_priority_fees)
+
+    chain_id = get_transaction_chain_id(transaction)
+    async with web3s_from_chain_id(chain_id) as web3s:
+        if chain_id in PRE_EIP_1559_CHAIN_IDS:
+            gas_prices = await asyncio.gather(*[_get_gas_price(web3) for web3 in web3s])
+            gas_price = max(gas_prices)
+
+            transaction["gasPrice"] = int(gas_price * gas_price_multiplier)
+        elif chain_id == 999:
+            # HyperEVM big blocks fetch base gas price from a different RPC method. Priority fee = 0 is # grandfathered in from Django, not sure what's right here.
+            big_block_gas_prices = await asyncio.gather(
+                *[web3.hype.big_block_gas_price() for web3 in web3s]
+            )
+            big_block_gas_price = max(big_block_gas_prices)
+
+            transaction["maxFeePerGas"] = int(
+                big_block_gas_price * priority_fee_multiplier
+            )
+            transaction["maxPriorityFeePerGas"] = 0
+        else:
+            base_fees = await asyncio.gather(*[_get_base_fee(web3) for web3 in web3s])
+            priority_fees = await asyncio.gather(
+                *[_get_priority_fee(web3) for web3 in web3s]
+            )
+
+            base_fee = max(base_fees)
+            priority_fee = max(priority_fees)
+
+            # The next block can grow base fee by up to 12.5%, we give a flew blocks of landing room. log_1.125(2) ~ 6 blocks of landing room. GPT says this is also what Metamask does.
+            max_base_fee_growth_multiplier = 2
+            transaction["maxFeePerGas"] = int(
+                base_fee * max_base_fee_growth_multiplier
+                + priority_fee * priority_fee_multiplier
+            )
+            transaction["maxPriorityFeePerGas"] = int(
+                priority_fee * priority_fee_multiplier
+            )
+
+    return transaction
+
+
+async def gas_limit_transaction(transaction: dict):
+    transaction = transaction.copy()
+
+    # prevents RPCs from taking this as a serious limit
+    transaction.pop("gas", None)
+
+    async def _estimate_gas(web3: AsyncWeb3, transaction: dict) -> int:
+        try:
+            return await web3.eth.estimate_gas(transaction, block_identifier="pending")
+        except Exception as e:
+            logger.info(
+                f"Failed to estimate gas using {web3.provider.endpoint_uri}. Error: {e}"
+            )
+            return 0
+
+    async with web3s_from_chain_id(get_transaction_chain_id(transaction)) as web3s:
+        gas_limits = await asyncio.gather(
+            *[_estimate_gas(web3, transaction) for web3 in web3s]
+        )
+
+        gas_limit = max(gas_limits)
+        if gas_limit == 0:
+            logger.error("Gas estimation failed on all RPCs")
+            raise Exception("Gas estimation failed on all RPCs")
+        transaction["gas"] = gas_limit
+
+    return transaction
+
+
+async def broadcast_transaction(chain_id, signed_transaction: bytes) -> str:
+    async with web3_from_chain_id(chain_id) as web3:
+        tx_hash = await web3.eth.send_raw_transaction(signed_transaction)
+        return tx_hash.hex()
+
+
+async def wait_for_transaction_receipt(
+    chain_id: int,
+    txn_hash: str,
+    poll_interval: float = 0.1,
+    timeout: int = 300,
+    confirmations: int = 3,
+) -> dict:
+    async def _wait_for_receipt(web3: AsyncWeb3, tx_hash: str) -> dict:
+        return await web3.eth.wait_for_transaction_receipt(
+            tx_hash, poll_latency=poll_interval, timeout=timeout
+        )
+
+    async def _get_block_number(web3: AsyncWeb3) -> int:
+        return await web3.eth.block_number
+
+    async with web3s_from_chain_id(chain_id) as web3s:
+        tasks = [
+            asyncio.create_task(_wait_for_receipt(web3, txn_hash)) for web3 in web3s
+        ]
+        done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
+        for task in pending:
+            task.cancel()
+        receipt = done.pop().result()
+
+        target_block = receipt["blockNumber"] + confirmations - 1
+        while (
+            max(await asyncio.gather(*[_get_block_number(w) for w in web3s]))
+            < target_block
+        ):
+            await asyncio.sleep(poll_interval)
+        return receipt
+
+
+async def send_transaction(
+    transaction: dict, sign_callback: Callable, wait_for_receipt=True
+) -> str:
+    logger.info(f"Broadcasting transaction {transaction.get('to', 'unknown')[:10]}...")
+    chain_id = get_transaction_chain_id(transaction)
+    transaction = await gas_limit_transaction(transaction)
+    transaction = await nonce_transaction(transaction)
+    transaction = await gas_price_transaction(transaction)
+    signed_transaction = await sign_callback(transaction)
+    txn_hash = await broadcast_transaction(chain_id, signed_transaction)
+    logger.info(f"Transaction broadcasted: {txn_hash}")
+    if wait_for_receipt:
+        await wait_for_transaction_receipt(chain_id, txn_hash)
+    return txn_hash
+
+
+# TODO: HypeEVM Big Blocks: Setting and detecting

wayfinder_paths/core/utils/web3.py

@@ -0,0 +1,66 @@
+from contextlib import asynccontextmanager
+
+from web3 import AsyncHTTPProvider, AsyncWeb3
+from web3.middleware import ExtraDataToPOAMiddleware
+from web3.module import Module
+
+from wayfinder_paths.core.config import CONFIG
+
+POA_MIDDLEWARE_CHAIN_IDS: set = {56, 137, 43114}
+
+
+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)
+
+
+def _get_rpcs_for_chain_id(chain_id: int) -> list:
+    rpcs = CONFIG.get("strategy", {}).get("rpc_urls", {}).get(str(chain_id))
+    if rpcs is None:
+        raise ValueError(f"No RPCs configured for chain ID {chain_id}")
+    return rpcs
+
+
+def _get_web3(rpc: str, chain_id: int) -> AsyncWeb3:
+    web3 = AsyncWeb3(AsyncHTTPProvider(rpc))
+    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 get_transaction_chain_id(transaction: dict) -> int:
+    if "chainId" not in transaction:
+        raise ValueError("Transaction does not contain chainId")
+    return int(transaction["chainId"])
+
+
+def get_web3s_from_chain_id(chain_id: int) -> list[AsyncWeb3]:
+    rpcs = _get_rpcs_for_chain_id(chain_id)
+    return [_get_web3(rpc, chain_id) for rpc in rpcs]
+
+
+@asynccontextmanager
+async def web3s_from_chain_id(chain_id: int):
+    web3s = get_web3s_from_chain_id(chain_id)
+    try:
+        yield web3s
+    finally:
+        for web3 in web3s:
+            await web3.provider.disconnect()
+
+
+@asynccontextmanager
+async def web3_from_chain_id(chain_id: int):
+    web3s = get_web3s_from_chain_id(chain_id)
+    try:
+        yield web3s[0]
+    finally:
+        await web3s[0].provider.disconnect()

wayfinder_paths/run_strategy.py

@@ -14,19 +14,21 @@ from loguru import logger
 
 from wayfinder_paths.core.config import StrategyJobConfig
 from wayfinder_paths.core.engine.StrategyJob import StrategyJob
+from wayfinder_paths.core.utils.evm_helpers import resolve_private_key_for_from_address
+from wayfinder_paths.core.utils.web3 import get_transaction_chain_id, web3_from_chain_id
 
 
 def load_strategy(
     strategy_name: str,
     *,
-    strategy_config: dict | None = None,
+    config: StrategyJobConfig,
 ):
     """
     Dynamically load a strategy by name
 
     Args:
         strategy_name: Name of the strategy to load (directory name in strategies/)
-        strategy_config: Configuration dict for the strategy
+        config: StrategyJobConfig instance containing user and strategy configuration
 
     Returns:
         Strategy instance
@@ -68,7 +70,34 @@ def load_strategy(
     if strategy_class is None:
         raise ValueError(f"No Strategy class found in {module_path}")
 
-    return strategy_class(config=strategy_config)
+    # Get wallet addresses from strategy_config (enriched from wallets array in config.json)
+    main_wallet = config.strategy_config.get("main_wallet") or {}
+    strategy_wallet = config.strategy_config.get("strategy_wallet") or {}
+    main_wallet_address = main_wallet.get("address")
+    strategy_wallet_address = strategy_wallet.get("address")
+
+    async def main_wallet_signing_callback(transaction):
+        private_key = resolve_private_key_for_from_address(
+            main_wallet_address, config.strategy_config
+        )
+        async with web3_from_chain_id(get_transaction_chain_id(transaction)) as web3:
+            signed = web3.eth.account.sign_transaction(transaction, private_key)
+            return signed.raw_transaction.hex()
+
+    async def strategy_wallet_signing_callback(transaction):
+        private_key = resolve_private_key_for_from_address(
+            strategy_wallet_address,
+            config.strategy_config,
+        )
+        async with web3_from_chain_id(get_transaction_chain_id(transaction)) as web3:
+            signed = web3.eth.account.sign_transaction(transaction, private_key)
+            return signed.raw_transaction.hex()
+
+    return strategy_class(
+        config=config.strategy_config,
+        main_wallet_signing_callback=main_wallet_signing_callback,
+        strategy_wallet_signing_callback=strategy_wallet_signing_callback,
+    )
 
 
 def load_config(
@@ -133,10 +162,12 @@ 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)
+        main_wallet_cfg = config.strategy_config.get("main_wallet") or {}
+        strategy_wallet_cfg = config.strategy_config.get("strategy_wallet") or {}
         logger.debug(
             "Loaded config: wallets(main={} strategy={})",
-            config.user.main_wallet_address or "none",
-            config.user.strategy_wallet_address or "none",
+            main_wallet_cfg.get("address") or "none",
+            strategy_wallet_cfg.get("address") or "none",
         )
 
         # Validate required configuration
@@ -145,7 +176,7 @@ async def run_strategy(
         # Load strategy with the enriched config
         strategy = load_strategy(
             strategy_name,
-            strategy_config=config.strategy_config,
+            config=config,
         )
         logger.info(f"Loaded strategy: {strategy.name}")