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

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/policies/erc20.py

@@ -1,4 +1,4 @@
-from wayfinder_paths.core.utils.evm_helpers import ERC20_ABI
+from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
 
 
 def any_erc20_function(token_address: str) -> dict:

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}")
 
@@ -197,6 +228,10 @@ async def run_strategy(
             result = await strategy_job.execute_strategy("update")
             logger.info(f"Update result: {result}")
 
+        elif action == "exit":
+            result = await strategy_job.execute_strategy("exit")
+            logger.info(f"Exit result: {result}")
+
         elif action == "partial-liquidate":
             usd_value = kwargs.get("amount")
             if not usd_value:
@@ -292,6 +327,7 @@ def main():
             "withdraw",
             "status",
             "update",
+            "exit",
             "policy",
             "script",
             "partial-liquidate",