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

wayfinder_paths/adapters/pool_adapter/test_adapter.py

@@ -41,7 +41,7 @@ class TestPoolAdapter:
             pool_ids=["pool-123", "pool-456"]
         )
 
-        assert success is True
+        assert success
         assert data == mock_response
         mock_pool_client.get_pools_by_ids.assert_called_once_with(
             pool_ids=["pool-123", "pool-456"]
@@ -66,7 +66,7 @@ class TestPoolAdapter:
 
         success, data = await adapter.get_pools()
 
-        assert success is True
+        assert success
         assert data == mock_response
 
     @pytest.mark.asyncio

wayfinder_paths/adapters/token_adapter/test_adapter.py

@@ -33,7 +33,7 @@ class TestTokenAdapter:
         ):
             success, data = await adapter.get_token("0x1234...")
 
-            assert success is True
+            assert success
             assert data == mock_token_data
 
     @pytest.mark.asyncio
@@ -55,7 +55,7 @@ class TestTokenAdapter:
         ):
             success, data = await adapter.get_token("token-123")
 
-            assert success is True
+            assert success
             assert data == mock_token_data
 
     def test_adapter_type(self, adapter):
@@ -80,7 +80,7 @@ class TestTokenAdapter:
         ):
             success, data = await adapter.get_token_price("test-token")
 
-            assert success is True
+            assert success
             assert data["current_price"] == 1.50
             assert data["symbol"] == "TEST"
             assert data["name"] == "Test Token"
@@ -113,7 +113,7 @@ class TestTokenAdapter:
         ):
             success, data = await adapter.get_gas_token("base")
 
-            assert success is True
+            assert success
             assert data["symbol"] == "ETH"
             assert data["name"] == "Ethereum"
 

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"}],
@@ -83,23 +83,12 @@ ERC20_ABI = [
     },
 ]
 
-# Minimal ABI for specific use cases (e.g., when you only need certain functions)
-ERC20_MINIMAL_ABI = [
-    {
-        "constant": True,
-        "inputs": [{"name": "account", "type": "address"}],
-        "name": "balanceOf",
-        "outputs": [{"name": "", "type": "uint256"}],
-        "type": "function",
-    }
-]
-
 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"}],
@@ -108,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/engine/StrategyJob.py

@@ -62,7 +62,7 @@ class StrategyJob:
         await self.strategy.setup()
 
     async def execute_strategy(self, action: str, **kwargs) -> dict[str, Any]:
-        """Execute a strategy action (deposit, withdraw, update, status, partial_liquidate)"""
+        """Execute a strategy action (deposit, withdraw, update, status, exit, partial_liquidate)"""
         try:
             if action == "deposit":
                 result = await self.strategy.deposit(**kwargs)
@@ -72,6 +72,8 @@ class StrategyJob:
                 result = await self.strategy.update()
             elif action == "status":
                 result = await self.strategy.status()
+            elif action == "exit":
+                result = await self.strategy.exit(**kwargs)
             elif action == "partial_liquidate":
                 usd_value = kwargs.get("usd_value")
                 if usd_value is None:

wayfinder_paths/core/services/test_local_evm_txn.py

@@ -0,0 +1,145 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from wayfinder_paths.core.services.local_evm_txn import BASE_CHAIN_ID, LocalEvmTxn
+
+
+class _FakeTxHash:
+    def __init__(self, value: str):
+        self._value = value
+
+    def hex(self) -> str:
+        return self._value
+
+
+@pytest.mark.asyncio
+async def test_base_defaults_to_two_confirmations():
+    txn = LocalEvmTxn(config={})
+
+    fake_web3 = MagicMock()
+    fake_web3.eth = MagicMock()
+    fake_web3.eth.send_raw_transaction = AsyncMock(return_value=_FakeTxHash("0x1"))
+    fake_web3.eth.wait_for_transaction_receipt = AsyncMock(
+        return_value={
+            "status": 1,
+            "blockNumber": 100,
+            "transactionHash": "0x1",
+            "gasUsed": 21_000,
+            "logs": [],
+        }
+    )
+
+    txn.get_web3 = MagicMock(return_value=fake_web3)
+    txn._validate_transaction = MagicMock(side_effect=lambda tx: tx)
+    txn._nonce_transaction = AsyncMock(side_effect=lambda tx, _w3: tx)
+    txn._gas_limit_transaction = AsyncMock(side_effect=lambda tx, _w3: tx)
+    txn._gas_price_transaction = AsyncMock(side_effect=lambda tx, _chain_id, _w3: tx)
+    txn._sign_transaction = MagicMock(return_value=b"signed")
+    txn._close_web3 = AsyncMock()
+    txn._wait_for_confirmations = AsyncMock()
+
+    ok, result = await txn.broadcast_transaction(
+        {
+            "chainId": BASE_CHAIN_ID,
+            "from": "0x0000000000000000000000000000000000000001",
+            "to": "0x0000000000000000000000000000000000000002",
+            "value": 0,
+        },
+        wait_for_receipt=True,
+        timeout=1,
+    )
+
+    assert ok is True
+    txn._wait_for_confirmations.assert_awaited_once_with(fake_web3, 100, 2)
+    assert result["confirmations"] == 2
+    assert result["confirmed_block_number"] == 102
+
+
+@pytest.mark.asyncio
+async def test_non_base_defaults_to_zero_confirmations():
+    txn = LocalEvmTxn(config={})
+
+    fake_web3 = MagicMock()
+    fake_web3.eth = MagicMock()
+    fake_web3.eth.send_raw_transaction = AsyncMock(return_value=_FakeTxHash("0x1"))
+    fake_web3.eth.wait_for_transaction_receipt = AsyncMock(
+        return_value={
+            "status": 1,
+            "blockNumber": 100,
+            "transactionHash": "0x1",
+            "gasUsed": 21_000,
+            "logs": [],
+        }
+    )
+
+    txn.get_web3 = MagicMock(return_value=fake_web3)
+    txn._validate_transaction = MagicMock(side_effect=lambda tx: tx)
+    txn._nonce_transaction = AsyncMock(side_effect=lambda tx, _w3: tx)
+    txn._gas_limit_transaction = AsyncMock(side_effect=lambda tx, _w3: tx)
+    txn._gas_price_transaction = AsyncMock(side_effect=lambda tx, _chain_id, _w3: tx)
+    txn._sign_transaction = MagicMock(return_value=b"signed")
+    txn._close_web3 = AsyncMock()
+    txn._wait_for_confirmations = AsyncMock()
+
+    ok, result = await txn.broadcast_transaction(
+        {
+            "chainId": 1,
+            "from": "0x0000000000000000000000000000000000000001",
+            "to": "0x0000000000000000000000000000000000000002",
+            "value": 0,
+        },
+        wait_for_receipt=True,
+        timeout=1,
+    )
+
+    assert ok is True
+    txn._wait_for_confirmations.assert_not_awaited()
+    assert result["confirmations"] == 0
+    assert result["confirmed_block_number"] == 100
+
+
+@pytest.mark.asyncio
+async def test_explicit_confirmations_override_defaults():
+    txn = LocalEvmTxn(config={})
+
+    fake_web3 = MagicMock()
+    fake_web3.eth = MagicMock()
+    fake_web3.eth.send_raw_transaction = AsyncMock(return_value=_FakeTxHash("0x1"))
+    fake_web3.eth.wait_for_transaction_receipt = AsyncMock(
+        return_value={
+            "status": 1,
+            "blockNumber": 100,
+            "transactionHash": "0x1",
+            "gasUsed": 21_000,
+            "logs": [],
+        }
+    )
+
+    txn.get_web3 = MagicMock(return_value=fake_web3)
+    txn._validate_transaction = MagicMock(side_effect=lambda tx: tx)
+    txn._nonce_transaction = AsyncMock(side_effect=lambda tx, _w3: tx)
+    txn._gas_limit_transaction = AsyncMock(side_effect=lambda tx, _w3: tx)
+    txn._gas_price_transaction = AsyncMock(side_effect=lambda tx, _chain_id, _w3: tx)
+    txn._sign_transaction = MagicMock(return_value=b"signed")
+    txn._close_web3 = AsyncMock()
+    txn._wait_for_confirmations = AsyncMock()
+
+    ok, result = await txn.broadcast_transaction(
+        {
+            "chainId": BASE_CHAIN_ID,
+            "from": "0x0000000000000000000000000000000000000001",
+            "to": "0x0000000000000000000000000000000000000002",
+            "value": 0,
+        },
+        wait_for_receipt=True,
+        timeout=1,
+        confirmations=0,
+    )
+
+    assert ok is True
+    txn._wait_for_confirmations.assert_not_awaited()
+    assert result["confirmations"] == 0
+    assert result["confirmed_block_number"] == 100

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"""
@@ -143,8 +147,22 @@ class Strategy(ABC):
     @abstractmethod
     async def update(self) -> StatusTuple:
         """
-        Update strategy positions/rebalance
-        Returns: (success: bool, message: str)
+        Deploy funds to protocols (no main wallet access).
+        Called after deposit() has transferred assets to strategy wallet.
+
+        Returns:
+            Tuple of (success: bool, message: str)
+        """
+        pass
+
+    @abstractmethod
+    async def exit(self, **kwargs) -> StatusTuple:
+        """
+        Transfer funds from strategy wallet to main wallet.
+        Called after withdraw() has liquidated all positions.
+
+        Returns:
+            Tuple of (success: bool, message: str)
         """
         pass
 

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,12 +2,11 @@
 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
 import os
-from pathlib import Path
 from typing import Any
 
 from loguru import logger
@@ -170,9 +169,3 @@ async def get_abi_filtered(
         if item.get("type") == "function" and item.get("name") in function_names
     ]
     return filtered_abi
-
-
-with open(Path(__file__).parent.parent.parent.joinpath("abis/generic/erc20.json")) as f:
-    erc20_abi_raw = f.read()
-
-ERC20_ABI = json.loads(erc20_abi_raw)