wayfinder-paths 0.1.25__py3-none-any.whl → 0.1.27__py3-none-any.whl

wayfinder_paths/adapters/hyperliquid_adapter/util.py

@@ -0,0 +1,237 @@
+import asyncio
+import time
+from decimal import ROUND_DOWN, Decimal
+from typing import Any
+
+from hyperliquid.info import Info
+from loguru import logger
+
+
+def _get_sigfigs(price):
+    num_str = str(price).strip().lower()
+    if "e" in num_str:
+        mantissa = num_str.split("e")[0]
+        mantissa = mantissa.replace(".", "")
+        mantissa = mantissa.strip("0")
+        return len(mantissa)
+
+    if "." in num_str:
+        int_part, dec_part = num_str.split(".")
+        int_part = int_part.lstrip("0")
+        num_str = int_part + dec_part
+        if dec_part:
+            num_str = num_str.rstrip("0")
+    else:
+        num_str = num_str.rstrip("0")
+    return len(num_str)
+
+
+class Util:
+    def __init__(self, info: Info):
+        self.info: Info = info
+
+    def get_hypecore_spot_assets(self):
+        response = {}
+        spot_meta_attr = self.info.spot_meta
+        spot_meta = spot_meta_attr() if callable(spot_meta_attr) else spot_meta_attr
+        for i in spot_meta["universe"]:
+            base, quote = i["tokens"]
+            base_info = spot_meta["tokens"][base]
+            quote_info = spot_meta["tokens"][quote]
+            name = f"{base_info['name']}/{quote_info['name']}"
+            response[name] = i["index"] + 10000
+        return response
+
+    def get_hypecore_perpetual_assets(self):
+        response = {}
+        for k, v in self.info.coin_to_asset.items():
+            # First 10_000 are default perp ids
+            # Anything over 100_000 are HIP3 perp ids
+            if 0 <= v < 10000 or 100000 <= v:
+                response[k] = v
+
+        return response
+
+    def get_hypecore_asset_id(self, asset_name, is_perp):
+        assets = (
+            self.get_hypecore_spot_assets()
+            if not is_perp
+            else self.get_hypecore_perpetual_assets()
+        )
+        return assets.get(asset_name)
+
+    async def get_hypecore_all_dex_mid_prices(self):
+        return await self.info.all_dex_mid_prices()
+
+    async def get_hypecore_all_dex_meta_universe(self):
+        return await self.info.all_dex_meta_universe()
+
+    def get_size_decimals_for_hypecore_asset(self, asset_id: int):
+        return self.info.asset_to_sz_decimals[asset_id]
+
+    def get_price_decimals_for_hypecore_asset(self, asset_id: int):
+        is_spot = asset_id >= 10_000
+        decimals = (
+            6 if not is_spot else 8
+        ) - self.get_size_decimals_for_hypecore_asset(asset_id)
+        return decimals
+
+    def get_valid_hypecore_order_size(self, asset_id: int, size: float):
+        decimals = self.get_size_decimals_for_hypecore_asset(asset_id)
+        step = Decimal(10) ** -decimals
+        value = Decimal(str(size)).quantize(step, rounding=ROUND_DOWN)
+        return float(value)
+
+    def get_valid_hypecore_price_size(self, asset_id: int, price: float):
+        decimals = self.get_price_decimals_for_hypecore_asset(asset_id)
+        actual_decimals = max(str(price)[::-1].find("."), 0)
+
+        sigfigs = _get_sigfigs(price)
+        if sigfigs > 5 and actual_decimals:
+            price = float(f"{price:.5g}")
+
+        if actual_decimals > decimals:
+            price = max(10**-decimals, round(price, decimals))
+        return price
+
+    def _reformat_perp_user_state(self, perp_user_state: dict) -> dict:
+        asset_positions = perp_user_state.get("assetPositions", [])
+        for pos in asset_positions:
+            position = pos.get("position", {})
+            # Fix funding direction: negative = earned, positive = paid
+            if "cumFunding" in position:
+                old_funding = position.pop("cumFunding")
+                position["cumFundingEarned"] = {
+                    k: str(float(v)) for k, v in old_funding.items()
+                }
+        return perp_user_state
+
+    async def get_hypecore_user(self, address):
+        perp_user_state, spot_user_state, open_orders = await asyncio.gather(
+            self.info.all_dex_user_state(address),
+            self.info.spot_user_state(address),
+            self.info.all_dex_open_orders(address),
+        )
+        formatted_perp_state = self._reformat_perp_user_state(perp_user_state)
+        state = {
+            "perp_user_state": formatted_perp_state,
+            "spot_user_state": spot_user_state,
+            "open_orders": open_orders,
+        }
+        logger.info(state)
+        return state
+
+    def get_perp_margin_amount(self, state):
+        return float(state["perp_user_state"]["marginSummary"]["accountValue"])
+
+    def get_spot_usdc_amount(self, state):
+        for i in state["spot_user_state"]["balances"]:
+            if i["coin"] == "USDC":
+                return float(i["total"])
+        return 0.0
+
+    def get_margin_utilization(self, state):
+        account_value = float(state["perp_user_state"]["marginSummary"]["accountValue"])
+        total_margin_used = float(
+            state["perp_user_state"]["marginSummary"]["totalMarginUsed"]
+        )
+        return total_margin_used / account_value if account_value > 0 else 0.0
+
+    async def get_spot_account_value(
+        self,
+        state,
+        ignore_dust=False,
+        dust_threshold: float = 1.0,
+        mid_prices: dict[str, Any] | None = None,
+    ):
+        if mid_prices is None:
+            mid_prices = await self.get_hypecore_all_dex_mid_prices()
+
+        total_spot = 0.0
+        for i in state["spot_user_state"]["balances"]:
+            asset_name = i["coin"]
+            mid_price = 0.0
+            if asset_name == "USDC":
+                mid_price = 1.0
+            else:
+                asset_id = self.get_hypecore_asset_id(
+                    f"{asset_name}/USDC", is_perp=False
+                )
+                mid_price_id = self.info.asset_to_coin[asset_id]
+                raw_price = mid_prices.get(mid_price_id)
+                mid_price = float(raw_price) if raw_price is not None else 0.0
+            value = mid_price * float(i["total"])
+            if ignore_dust and value < dust_threshold:
+                continue
+            total_spot += value
+        return total_spot
+
+    async def fetch_hypecore_user_fills(self, wallet: str):
+        """Fetch all available trade fills (up to the most-recent 10,000) from HypeCore."""
+        start, end = 0, int(time.time() * 1000)
+        out = []
+        while True:
+            try:
+                batch = await self.info.user_fills_by_time(wallet, start, end, False)
+            except Exception as e:
+                logger.error(f"Failed to fetch fills via node/public/SDK: {e}")
+                break
+            if not batch or len(batch) == 0:
+                break
+            out.extend(batch)
+            start = batch[-1]["time"] + 1
+            if len(batch) < 2000:  # each page ≤ 2000 rows
+                break
+        return out
+
+    async def get_hypecore_position(self, address, asset_name):
+        perp_user_state = await self.info.all_dex_user_state(address)
+        formatted_perp_user_state = self._reformat_perp_user_state(perp_user_state)
+
+        for pos in formatted_perp_user_state.get("assetPositions", []):
+            if pos["position"]["coin"] == asset_name:
+                return pos
+
+        return None
+
+    @classmethod
+    def parse_dollar_value(cls, response: dict) -> Decimal | None:
+        if response.get("status", "") != "ok" or not len(
+            resp := response.get("response", {})
+        ):
+            return None
+
+        if resp.get("type", "") != "order" or not len(data := resp.get("data", {})):
+            return None
+
+        statuses = data.get("statuses", [])
+
+        if not len(statuses):
+            return None
+
+        return sum(
+            [
+                Decimal(status["filled"]["totalSz"])
+                * Decimal(status["filled"]["avgPx"])
+                for status in statuses
+                if "filled" in status
+            ]
+        )
+
+    @staticmethod
+    def _sig_hex_to_hl_signature(sig_hex: str) -> dict[str, Any]:
+        """Convert a 65-byte hex signature into Hyperliquid {r,s,v}."""
+        if not isinstance(sig_hex, str) or not sig_hex.startswith("0x"):
+            raise ValueError("Expected hex signature string starting with 0x")
+        raw = bytes.fromhex(sig_hex[2:])
+        if len(raw) != 65:
+            raise ValueError(f"Expected 65-byte signature, got {len(raw)} bytes")
+
+        r = raw[0:32]
+        s = raw[32:64]
+        v = raw[64]
+        # Normalize v to 27/28 when needed.
+        if v < 27:
+            v += 27
+
+        return {"r": f"0x{r.hex()}", "s": f"0x{s.hex()}", "v": int(v)}

wayfinder_paths/adapters/pendle_adapter/adapter.py

@@ -10,11 +10,9 @@ from eth_utils import to_checksum_address
 
 from wayfinder_paths.adapters.multicall_adapter.adapter import MulticallAdapter
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
-from wayfinder_paths.core.constants.contracts import TOKENS_REQUIRING_APPROVAL_RESET
 from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
 from wayfinder_paths.core.utils.tokens import (
-    build_approve_transaction,
-    get_token_allowance,
+    ensure_allowance,
     get_token_balance,
 )
 from wayfinder_paths.core.utils.transaction import send_transaction
@@ -240,56 +238,6 @@ class PendleAdapter(BaseAdapter):
         txn_hash = await send_transaction(tx, self.strategy_wallet_signing_callback)
         return True, txn_hash
 
-    async def _ensure_allowance(
-        self,
-        *,
-        chain_id: int,
-        token_address: str,
-        owner: str,
-        spender: str,
-        amount: int,
-    ) -> tuple[bool, Any]:
-        token_checksum = to_checksum_address(token_address)
-        owner_checksum = to_checksum_address(owner)
-        spender_checksum = to_checksum_address(spender)
-
-        allowance = await get_token_allowance(
-            token_checksum,
-            chain_id,
-            owner_checksum,
-            spender_checksum,
-        )
-        if allowance >= amount:
-            return True, {"status": "already_approved"}
-
-        if (int(chain_id), token_checksum) in TOKENS_REQUIRING_APPROVAL_RESET:
-            # Some tokens (e.g., USDT) require allowance to be set to 0 before
-            # being increased.
-            if int(allowance) > 0:
-                clear_tx = await build_approve_transaction(
-                    from_address=owner_checksum,
-                    chain_id=chain_id,
-                    token_address=token_checksum,
-                    spender_address=spender_checksum,
-                    amount=0,
-                )
-                try:
-                    await self._send_tx(clear_tx)
-                except Exception as exc:  # noqa: BLE001
-                    return False, {"error": str(exc), "token": token_address}
-
-        approve_tx = await build_approve_transaction(
-            from_address=owner_checksum,
-            chain_id=chain_id,
-            token_address=token_checksum,
-            spender_address=spender_checksum,
-            amount=self.MAX_UINT256,
-        )
-        try:
-            return await self._send_tx(approve_tx)
-        except Exception as exc:
-            return False, {"error": str(exc), "token": token_address}
-
     # ---------------------------
     # Multicall helpers
     # ---------------------------
@@ -1783,12 +1731,21 @@ class PendleAdapter(BaseAdapter):
             amount = approval.get("amount")
             if not token or not amount:
                 continue
-            approved, result = await self._ensure_allowance(
+            if not self.strategy_wallet_signing_callback:
+                return False, {
+                    "error": "strategy_wallet_signing_callback is required",
+                    "stage": "approval",
+                    "details": {
+                        "error": "strategy_wallet_signing_callback is required"
+                    },
+                }
+            approved, result = await ensure_allowance(
                 chain_id=chain_id,
                 token_address=token,
                 owner=sender,
                 spender=spender,
                 amount=int(amount),
+                signing_callback=self.strategy_wallet_signing_callback,
             )
             if not approved:
                 return False, {
@@ -1910,13 +1867,20 @@ class PendleAdapter(BaseAdapter):
             amount = approval.get("amount")
             if not (isinstance(token, str) and token and amount is not None):
                 continue
+            if not self.strategy_wallet_signing_callback:
+                return False, {
+                    "stage": "approval",
+                    "error": "strategy_wallet_signing_callback is required",
+                    "token": token,
+                }
             try:
-                approved, result = await self._ensure_allowance(
+                approved, result = await ensure_allowance(
                     chain_id=chain_id,
                     token_address=token,
                     owner=sender,
                     spender=spender,
                     amount=int(str(amount)),
+                    signing_callback=self.strategy_wallet_signing_callback,
                 )
             except Exception as exc:  # noqa: BLE001
                 return False, {

wayfinder_paths/adapters/pendle_adapter/test_adapter.py

@@ -310,11 +310,10 @@ class TestPendleAdapter:
                 new_callable=AsyncMock,
                 return_value=10_000,
             ),
-            patch.object(
-                adapter,
-                "_ensure_allowance",
+            patch(
+                "wayfinder_paths.adapters.pendle_adapter.adapter.ensure_allowance",
                 new_callable=AsyncMock,
-                return_value=(True, {"status": "already_approved"}),
+                return_value=(True, "0xapprovehash"),
             ),
             patch.object(
                 adapter,
@@ -499,9 +498,9 @@ class TestPendleAdapter:
         # Mock allowance and approval
         with (
             patch(
-                "wayfinder_paths.adapters.pendle_adapter.adapter.get_token_allowance",
+                "wayfinder_paths.adapters.pendle_adapter.adapter.ensure_allowance",
                 new_callable=AsyncMock,
-                return_value=2**256 - 1,  # Already approved
+                return_value=(True, "0xapprovehash"),
             ),
             patch(
                 "wayfinder_paths.adapters.pendle_adapter.adapter.send_transaction",
@@ -569,24 +568,9 @@ class TestPendleAdapter:
 
         with (
             patch(
-                "wayfinder_paths.adapters.pendle_adapter.adapter.get_token_allowance",
-                new_callable=AsyncMock,
-                return_value=0,  # No allowance
-            ),
-            patch(
-                "wayfinder_paths.adapters.pendle_adapter.adapter.build_approve_transaction",
-                new_callable=AsyncMock,
-                return_value={
-                    "to": token_in_addr,
-                    "data": "0x",
-                    "chainId": 42161,
-                    "from": "0x" + "a" * 40,
-                },
-            ),
-            patch(
-                "wayfinder_paths.adapters.pendle_adapter.adapter.send_transaction",
+                "wayfinder_paths.adapters.pendle_adapter.adapter.ensure_allowance",
                 new_callable=AsyncMock,
-                side_effect=Exception("Approval tx failed"),
+                return_value=(False, {"error": "Approval tx failed"}),
             ),
         ):
             success, result = await adapter.execute_swap(
@@ -620,29 +604,13 @@ class TestPendleAdapter:
             }
         )
 
-        with (
-            patch(
-                "wayfinder_paths.adapters.pendle_adapter.adapter.get_token_allowance",
-                new_callable=AsyncMock,
-                return_value=0,  # No allowance, will try to approve
-            ),
-            patch(
-                "wayfinder_paths.adapters.pendle_adapter.adapter.build_approve_transaction",
-                new_callable=AsyncMock,
-                return_value={
-                    "to": token_in_addr,
-                    "data": "0xapprove",
-                    "chainId": 42161,
-                },
-            ),
-        ):
-            success, result = await adapter.execute_swap(
-                chain="arbitrum",
-                market_address="0x" + "d" * 40,
-                token_in=token_in_addr,
-                token_out="0x" + "e" * 40,
-                amount_in="1000000",
-            )
+        success, result = await adapter.execute_swap(
+            chain="arbitrum",
+            market_address="0x" + "d" * 40,
+            token_in=token_in_addr,
+            token_out="0x" + "e" * 40,
+            amount_in="1000000",
+        )
 
         assert success is False
         assert result["stage"] == "approval"

wayfinder_paths/core/clients/BalanceClient.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from wayfinder_paths.core.clients.WayfinderClient import WayfinderClient
+from wayfinder_paths.core.config import get_api_base_url
+
+
+class BalanceClient(WayfinderClient):
+    def __init__(self):
+        super().__init__()
+        self.api_base_url = get_api_base_url()
+
+    async def get_enriched_wallet_balances(
+        self,
+        *,
+        wallet_address: str,
+        exclude_spam_tokens: bool = True,
+    ) -> dict:
+        url = f"{self.api_base_url}/blockchain/balances/enriched/"
+        params = {
+            "address": wallet_address,
+            "exclude_spam_tokens": str(exclude_spam_tokens).lower(),
+        }
+        response = await self._request("GET", url, params=params)
+        return response.json()
+
+    async def get_wallet_activity(
+        self,
+        *,
+        wallet_address: str,
+        limit: int = 20,
+        offset: str | None = None,
+    ) -> dict:
+        url = f"{self.api_base_url}/blockchain/balances/activity/"
+        params: dict[str, str | int] = {"address": wallet_address, "limit": limit}
+        if offset:
+            params["offset"] = offset
+        response = await self._request("GET", url, params=params)
+        return response.json()
+
+    async def get_token_balance(
+        self,
+        *,
+        wallet_address: str,
+        token_id: str,
+        human_readable: bool = True,
+    ) -> dict:
+        url = f"{self.api_base_url}/public/balances/token/"
+        params = {
+            "wallet_address": wallet_address,
+            "token_id": token_id,
+            "human_readable": str(human_readable).lower(),
+        }
+        response = await self._request("GET", url, params=params)
+        return response.json()
+
+    async def get_pool_balance(
+        self,
+        *,
+        pool_address: str,
+        chain_id: int,
+        user_address: str,
+        human_readable: bool = True,
+    ) -> dict:
+        url = f"{self.api_base_url}/public/balances/pool/"
+        params = {
+            "pool_address": pool_address,
+            "chain_id": chain_id,
+            "user_address": user_address,
+            "human_readable": str(human_readable).lower(),
+        }
+        response = await self._request("GET", url, params=params)
+        return response.json()

wayfinder_paths/core/clients/TokenClient.py

@@ -90,7 +90,7 @@ class FuzzyTokenResult(TypedDict):
 class TokenClient(WayfinderClient):
     def __init__(self):
         super().__init__()
-        self.api_base_url = f"{get_api_base_url()}/blockchain/tokens"
+        self.api_base_url = f"{get_api_base_url()}/v1/blockchain/tokens"
 
     async def get_token_details(
         self, query: str, market_data: bool = False, chain_id: int | None = None

wayfinder_paths/core/clients/__init__.py

@@ -1,3 +1,4 @@
+from wayfinder_paths.core.clients.BalanceClient import BalanceClient
 from wayfinder_paths.core.clients.BRAPClient import BRAPClient
 from wayfinder_paths.core.clients.ClientManager import ClientManager
 from wayfinder_paths.core.clients.HyperlendClient import HyperlendClient
@@ -16,6 +17,7 @@ from wayfinder_paths.core.clients.WayfinderClient import WayfinderClient
 __all__ = [
     "WayfinderClient",
     "ClientManager",
+    "BalanceClient",
     "TokenClient",
     "LedgerClient",
     "PoolClient",

wayfinder_paths/core/strategies/Strategy.py

@@ -8,6 +8,7 @@ from loguru import logger
 
 from wayfinder_paths.core.clients.TokenClient import TokenDetails
 from wayfinder_paths.core.strategies.descriptors import StratDescriptor
+from wayfinder_paths.core.types import HyperliquidSignCallback
 
 
 class StatusDict(TypedDict):
@@ -48,18 +49,17 @@ class Strategy(ABC):
         self,
         config: StrategyConfig | dict[str, Any] | None = None,
         *,
-        main_wallet: WalletConfig | dict[str, Any] | None = None,
-        strategy_wallet: WalletConfig | dict[str, Any] | 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,
+        strategy_sign_typed_data: HyperliquidSignCallback | None = None,
     ):
         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
+        self.strategy_sign_typed_data = strategy_sign_typed_data
 
     async def setup(self) -> None:
         pass

wayfinder_paths/core/types.py

@@ -0,0 +1,19 @@
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+# EVM transaction signing callback
+# Used for signing EVM-compatible transactions (mainnet, Base, Arbitrum, etc.)
+# Parameters: transaction dict with to/from/data/value/etc.
+# Returns: signed transaction hex string
+TransactionSigningCallback = Callable[[dict], Awaitable[str]]
+
+# Hyperliquid signing callback
+# Used for signing Hyperliquid actions (orders, transfers, withdrawals, etc.)
+# Parameters:
+#   - action: dict - The action being signed (order, transfer, etc.)
+#   - payload: str - Either JSON string (EIP-712) or keccak hash (local) of typed data
+#   - address: str - The address signing the transaction
+# Returns: signature dict {"r": "0x...", "s": "0x...", "v": 28} or None if declined
+HyperliquidSignCallback = Callable[
+    [dict[str, Any], str, str], Awaitable[dict[str, str] | None]
+]

wayfinder_paths/core/utils/tokens.py

@@ -1,8 +1,10 @@
 from collections.abc import Callable
 from typing import Any
 
+from eth_utils import to_checksum_address
 from web3 import AsyncWeb3
 
+from wayfinder_paths.core.constants.contracts import TOKENS_REQUIRING_APPROVAL_RESET
 from wayfinder_paths.core.constants.erc20_abi import ERC20_ABI
 from wayfinder_paths.core.utils.transaction import send_transaction
 from wayfinder_paths.core.utils.web3 import web3_from_chain_id
@@ -27,7 +29,9 @@ async def get_token_balance(
         checksum_wallet = AsyncWeb3.to_checksum_address(wallet_address)
 
         if is_native_token(token_address):
-            balance = await web3.eth.get_balance(checksum_wallet)
+            balance = await web3.eth.get_balance(
+                checksum_wallet, block_identifier="pending"
+            )
             return int(balance)
         else:
             checksum_token = AsyncWeb3.to_checksum_address(token_address)
@@ -121,6 +125,20 @@ async def ensure_allowance(
     allowance = await get_token_allowance(token_address, chain_id, owner, spender)
     if allowance >= amount:
         return True, {}
+
+    if (
+        int(chain_id),
+        to_checksum_address(token_address),
+    ) in TOKENS_REQUIRING_APPROVAL_RESET:
+        clear_transaction = await build_approve_transaction(
+            from_address=owner,
+            chain_id=chain_id,
+            token_address=token_address,
+            spender_address=spender,
+            amount=0,
+        )
+        await send_transaction(clear_transaction, signing_callback)
+
     approve_tx = await build_approve_transaction(
         from_address=owner,
         chain_id=chain_id,

wayfinder_paths/core/utils/transaction.py

@@ -33,7 +33,9 @@ async def nonce_transaction(transaction: dict):
     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)
+        return await web3.eth.get_transaction_count(
+            from_address, block_identifier="pending"
+        )
 
     async with web3s_from_chain_id(get_transaction_chain_id(transaction)) as web3s:
         nonces = await asyncio.gather(
@@ -218,13 +220,13 @@ async def encode_call(
     value: int = 0,
 ) -> dict[str, Any]:
     async with web3_from_chain_id(chain_id) as web3:
-        contract = web3.eth.contract(address=target, abi=abi)
         try:
-            tx_data = await getattr(contract.functions, fn_name)(
-                *args
-            ).build_transaction({"from": from_address})
-            data = tx_data["data"]
-        except ValueError as exc:
+            contract = web3.eth.contract(
+                address=web3.to_checksum_address(target),
+                abi=abi,
+            )
+            data = contract.encode_abi(fn_name, args)
+        except (ValueError, TypeError) as exc:
             raise ValueError(f"Failed to encode {fn_name}: {exc}") from exc
 
         return {