wayfinder-paths 0.1.21__tar.gz → 0.1.23__tar.gz

{wayfinder_paths-0.1.21 → wayfinder_paths-0.1.23}/PKG-INFO

@@ -1,17 +1,16 @@
 Metadata-Version: 2.1
 Name: wayfinder-paths
-Version: 0.1.21
+Version: 0.1.23
 Summary: Wayfinder Path: strategies and adapters
 Author: Wayfinder
 Author-email: dev@wayfinder.ai
 Requires-Python: >=3.12,<4.0
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: aiohttp (>=3.13.0,<4.0.0)
 Requires-Dist: eth-account (>=0.13.7,<0.14.0)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
-Requires-Dist: hyperliquid-python-sdk (>=0.21.0,<0.22.0)
+Requires-Dist: hyperliquid-felix
 Requires-Dist: loguru (>=0.7.3,<0.8.0)
 Requires-Dist: numpy (>=1.26.0,<2.0.0)
 Requires-Dist: pandas (>=2.2.0,<3.0.0)
@@ -98,7 +97,7 @@ Strategy Layer       - Trading logic (deposit, update, withdraw, exit)
        ↓
 Adapter Layer        - Protocol integrations (BalanceAdapter, PoolAdapter, etc.)
        ↓
-Client Layer         - API wrappers (TokenClient, WalletClient, PoolClient, etc.)
+Client Layer         - API wrappers (TokenClient, PoolClient, LedgerClient, etc.)
        ↓
 Network              - RPCs, Wayfinder API, external services
 ```

{wayfinder_paths-0.1.21 → wayfinder_paths-0.1.23}/README.md

@@ -76,7 +76,7 @@ Strategy Layer       - Trading logic (deposit, update, withdraw, exit)
        ↓
 Adapter Layer        - Protocol integrations (BalanceAdapter, PoolAdapter, etc.)
        ↓
-Client Layer         - API wrappers (TokenClient, WalletClient, PoolClient, etc.)
+Client Layer         - API wrappers (TokenClient, PoolClient, LedgerClient, etc.)
        ↓
 Network              - RPCs, Wayfinder API, external services
 ```

{wayfinder_paths-0.1.21 → wayfinder_paths-0.1.23}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wayfinder-paths"
-version = "0.1.21"
+version = "0.1.23"
 description = "Wayfinder Path: strategies and adapters"
 readme = "README.md"
 authors = ["Wayfinder <dev@wayfinder.ai>"]
@@ -19,7 +19,7 @@ eth-account = "^0.13.7"
 aiohttp = "^3.13.0"
 numpy = "^1.26.0"
 pandas = "^2.2.0"
-hyperliquid-python-sdk = "^0.21.0"
+hyperliquid-felix = "*"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^8.4.2"

{wayfinder_paths-0.1.21 → wayfinder_paths-0.1.23}/wayfinder_paths/__init__.py

@@ -1,13 +1,10 @@
 __version__ = "0.1.0"
 
-# Re-export commonly used items for convenience
 from wayfinder_paths.core import (
     BaseAdapter,
-    LiquidationResult,
     StatusDict,
     StatusTuple,
     Strategy,
-    StrategyJob,
 )
 
 __all__ = [
@@ -16,5 +13,4 @@ __all__ = [
     "Strategy",
     "StatusDict",
     "StatusTuple",
-    "StrategyJob",
 ]

{wayfinder_paths-0.1.21 → wayfinder_paths-0.1.23}/wayfinder_paths/adapters/balance_adapter/README.md

@@ -93,7 +93,6 @@ config = {
 
 ## Dependencies
 
-- `WalletClient` - For balance queries
 - `TokenClient` - For token metadata
 - `LedgerAdapter` - For transaction recording
 - `TokenAdapter` - For price lookups

wayfinder_paths-0.1.23/wayfinder_paths/adapters/balance_adapter/adapter.py

@@ -0,0 +1,179 @@
+from typing import Any
+
+from wayfinder_paths.adapters.ledger_adapter.adapter import LedgerAdapter
+from wayfinder_paths.adapters.token_adapter.adapter import TokenAdapter
+from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
+from wayfinder_paths.core.clients.TokenClient import TokenClient
+from wayfinder_paths.core.utils.evm_helpers import resolve_chain_id
+from wayfinder_paths.core.utils.tokens import build_send_transaction, get_token_balance
+from wayfinder_paths.core.utils.transaction import send_transaction
+
+
+class BalanceAdapter(BaseAdapter):
+    adapter_type = "BALANCE"
+
+    def __init__(
+        self,
+        config: dict[str, Any],
+        main_wallet_signing_callback=None,
+        strategy_wallet_signing_callback=None,
+    ):
+        super().__init__("balance", config)
+        self.main_wallet_signing_callback = main_wallet_signing_callback
+        self.strategy_wallet_signing_callback = strategy_wallet_signing_callback
+        self.token_client = TokenClient()
+        self.token_adapter = TokenAdapter()
+        self.ledger_adapter = LedgerAdapter()
+
+    async def get_balance(
+        self,
+        *,
+        wallet_address: str,
+        token_id: str | None = None,
+        token_address: str | None = None,
+        chain_id: int | None = None,
+    ) -> tuple[bool, int | str]:
+        try:
+            if token_id and not token_address:
+                token_info = await self.token_client.get_token_details(token_id)
+                token_address = token_info["address"]
+                chain_id = chain_id or resolve_chain_id(token_info)
+            balance = await get_token_balance(token_address, chain_id, wallet_address)
+            return True, balance
+        except Exception as e:
+            return False, str(e)
+
+    async def move_from_main_wallet_to_strategy_wallet(
+        self,
+        token_id: str,
+        amount: float,
+        strategy_name: str = "unknown",
+        skip_ledger: bool = False,
+    ) -> tuple[bool, str]:
+        return await self._move_between_wallets(
+            token_id=token_id,
+            amount=amount,
+            from_wallet=self.config["main_wallet"],
+            to_wallet=self.config["strategy_wallet"],
+            ledger_method=self.ledger_adapter.record_deposit
+            if not skip_ledger
+            else None,
+            ledger_wallet="to",
+            strategy_name=strategy_name,
+        )
+
+    async def move_from_strategy_wallet_to_main_wallet(
+        self,
+        token_id: str,
+        amount: float,
+        strategy_name: str = "unknown",
+        skip_ledger: bool = False,
+    ) -> tuple[bool, str]:
+        return await self._move_between_wallets(
+            token_id=token_id,
+            amount=amount,
+            from_wallet=self.config["strategy_wallet"],
+            to_wallet=self.config["main_wallet"],
+            ledger_method=self.ledger_adapter.record_withdrawal
+            if not skip_ledger
+            else None,
+            ledger_wallet="from",
+            strategy_name=strategy_name,
+        )
+
+    async def send_to_address(
+        self,
+        token_id: str,
+        amount: int,
+        from_wallet: dict[str, Any],
+        to_address: str,
+        signing_callback,
+    ) -> tuple[bool, str]:
+        token_info = await self.token_client.get_token_details(token_id)
+        chain_id = resolve_chain_id(token_info)
+        tx = await build_send_transaction(
+            from_address=from_wallet["address"],
+            to_address=to_address,
+            token_address=token_info["address"],
+            chain_id=chain_id,
+            amount=amount,
+        )
+        tx_hash = await send_transaction(tx, signing_callback)
+        return True, tx_hash
+
+    async def _move_between_wallets(
+        self,
+        *,
+        token_id: str,
+        amount: float,
+        from_wallet: dict[str, Any],
+        to_wallet: dict[str, Any],
+        ledger_method,
+        ledger_wallet: str,
+        strategy_name: str,
+    ) -> tuple[bool, str]:
+        token_info = await self.token_client.get_token_details(token_id)
+        chain_id = resolve_chain_id(token_info)
+        decimals = token_info.get("decimals", 18)
+        raw_amount = int(amount * (10**decimals))
+
+        transaction = await build_send_transaction(
+            from_address=from_wallet["address"],
+            to_address=to_wallet["address"],
+            token_address=token_info["address"],
+            chain_id=chain_id,
+            amount=raw_amount,
+        )
+
+        main_address = self.config.get("main_wallet", {}).get("address", "").lower()
+        callback = (
+            self.main_wallet_signing_callback
+            if from_wallet["address"].lower() == main_address
+            else self.strategy_wallet_signing_callback
+        )
+        tx_hash = await send_transaction(transaction, callback)
+
+        if ledger_method:
+            wallet_for_ledger = (
+                from_wallet["address"]
+                if ledger_wallet == "from"
+                else to_wallet["address"]
+            )
+            await self._record_ledger_entry(
+                ledger_method, wallet_for_ledger, token_info, amount, strategy_name
+            )
+
+        return True, tx_hash
+
+    async def _record_ledger_entry(
+        self,
+        ledger_method,
+        wallet_address: str,
+        token_info: dict[str, Any],
+        amount: float,
+        strategy_name: str,
+    ) -> None:
+        try:
+            chain_id = resolve_chain_id(token_info)
+            token_id = token_info.get("token_id")
+            usd_value = (
+                await self.token_adapter.get_amount_usd(
+                    token_info.get("token_id"), amount, decimals=0
+                )
+                or 0.0
+            )
+            await ledger_method(
+                wallet_address=wallet_address,
+                chain_id=chain_id,
+                token_address=token_info.get("address"),
+                token_amount=str(amount),
+                usd_value=usd_value,
+                data={
+                    "token_id": token_id,
+                    "amount": str(amount),
+                    "usd_value": usd_value,
+                },
+                strategy_name=strategy_name,
+            )
+        except Exception as exc:
+            self.logger.warning(f"Ledger entry failed: {exc}", wallet=wallet_address)

wayfinder_paths-0.1.23/wayfinder_paths/adapters/balance_adapter/test_adapter.py

@@ -0,0 +1,90 @@
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from wayfinder_paths.adapters.balance_adapter.adapter import BalanceAdapter
+
+
+class TestBalanceAdapter:
+    @pytest.fixture
+    def mock_token_client(self):
+        return AsyncMock()
+
+    @pytest.fixture
+    def adapter(self, mock_token_client):
+        with patch(
+            "wayfinder_paths.adapters.balance_adapter.adapter.TokenClient",
+            return_value=mock_token_client,
+        ):
+            return BalanceAdapter(config={})
+
+    @pytest.mark.asyncio
+    async def test_health_check(self, adapter):
+        health = await adapter.health_check()
+        assert isinstance(health, dict)
+        assert health.get("status") in {"healthy", "unhealthy", "error"}
+
+    @pytest.mark.asyncio
+    async def test_connect(self, adapter):
+        ok = await adapter.connect()
+        assert isinstance(ok, bool)
+
+    def test_adapter_type(self, adapter):
+        assert adapter.adapter_type == "BALANCE"
+
+    @pytest.mark.asyncio
+    async def test_get_balance_with_token_id(self, adapter, mock_token_client):
+        mock_token_client.get_token_details = AsyncMock(
+            return_value={
+                "token_id": "usd-coin-base",
+                "address": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+                "chain": {"id": 8453, "code": "base"},
+            }
+        )
+
+        with patch(
+            "wayfinder_paths.adapters.balance_adapter.adapter.get_token_balance",
+            new_callable=AsyncMock,
+            return_value=1000000,
+        ) as mock_get_balance:
+            success, balance = await adapter.get_balance(
+                token_id="usd-coin-base",
+                wallet_address="0xWallet",
+            )
+
+            assert success
+            assert balance == 1000000
+            mock_token_client.get_token_details.assert_called_once_with("usd-coin-base")
+            mock_get_balance.assert_called_once_with(
+                "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", 8453, "0xWallet"
+            )
+
+    @pytest.mark.asyncio
+    async def test_get_balance_with_token_address(self, adapter, mock_token_client):
+        with patch(
+            "wayfinder_paths.adapters.balance_adapter.adapter.get_token_balance",
+            new_callable=AsyncMock,
+            return_value=5000000,
+        ) as mock_get_balance:
+            success, balance = await adapter.get_balance(
+                token_address="0xTokenAddress",
+                wallet_address="0xWallet",
+                chain_id=8453,
+            )
+
+            assert success
+            assert balance == 5000000
+            mock_get_balance.assert_called_once_with("0xTokenAddress", 8453, "0xWallet")
+            mock_token_client.get_token_details.assert_not_called()
+
+    @pytest.mark.asyncio
+    async def test_get_balance_token_not_found(self, adapter, mock_token_client):
+        mock_token_client.get_token_details = AsyncMock(return_value=None)
+
+        success, error = await adapter.get_balance(
+            token_id="invalid-token",
+            wallet_address="0xWallet",
+        )
+
+        assert success is False
+        assert "NoneType" in error or "subscriptable" in error

wayfinder_paths-0.1.23/wayfinder_paths/adapters/brap_adapter/README.md

@@ -0,0 +1,71 @@
+# BRAP Adapter
+
+Adapter for cross-chain swaps and bridges via the BRAP (Bridge/Router/Adapter Protocol).
+
+- **Type**: `BRAP`
+- **Module**: `wayfinder_paths.adapters.brap_adapter.adapter.BRAPAdapter`
+
+## Usage
+
+```python
+from wayfinder_paths.adapters.brap_adapter.adapter import BRAPAdapter
+
+adapter = BRAPAdapter(strategy_wallet_signing_callback=signing_callback)
+```
+
+## Methods
+
+### best_quote
+
+Get the best quote for a swap.
+
+```python
+success, quote = await adapter.best_quote(
+    from_token_address="0x...",
+    to_token_address="0x...",
+    from_chain_id=8453,
+    to_chain_id=1,
+    from_address="0x...",
+    amount="1000000000",
+    preferred_providers=["enso"],  # optional
+)
+if success:
+    print(f"Output: {quote.get('output_amount')}")
+```
+
+### swap_from_token_ids
+
+Execute a swap using token IDs.
+
+```python
+success, result = await adapter.swap_from_token_ids(
+    from_token_id="usd-coin-base",
+    to_token_id="ethereum",
+    from_address="0x...",
+    amount="1000000000",
+    strategy_name="my_strategy",
+    preferred_providers=["enso"],
+)
+if success:
+    print(f"TX: {result.get('tx_hash')}")
+```
+
+### swap_from_quote
+
+Execute a swap from a pre-fetched quote.
+
+```python
+success, result = await adapter.swap_from_quote(
+    from_token=from_token_info,
+    to_token=to_token_info,
+    from_address="0x...",
+    quote=quote,
+    strategy_name="my_strategy",
+)
+```
+
+## Testing
+
+```bash
+poetry run pytest wayfinder_paths/adapters/brap_adapter/ -v
+```