wayfinder-paths 0.1.28__tar.gz → 0.1.30__tar.gz

{wayfinder_paths-0.1.28 → wayfinder_paths-0.1.30}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: wayfinder-paths
-Version: 0.1.28
+Version: 0.1.30
 Summary: Wayfinder Path: strategies and adapters
 Author: Wayfinder
 Author-email: dev@wayfinder.ai

{wayfinder_paths-0.1.28 → wayfinder_paths-0.1.30}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "wayfinder-paths"
-version = "0.1.28"
+version = "0.1.30"
 description = "Wayfinder Path: strategies and adapters"
 readme = "README.md"
 authors = ["Wayfinder <dev@wayfinder.ai>"]

{wayfinder_paths-0.1.28 → wayfinder_paths-0.1.30}/wayfinder_paths/adapters/boros_adapter/adapter.py

@@ -5,15 +5,20 @@ import time
 from collections.abc import Callable
 from typing import Any
 
-from eth_abi import encode
+from eth_abi import decode, encode
 from eth_utils import function_signature_to_4byte_selector, to_checksum_address
 from loguru import logger
 
 from wayfinder_paths.core.adapters.BaseAdapter import BaseAdapter
-from wayfinder_paths.core.constants.base import DEFAULT_TRANSACTION_TIMEOUT
-from wayfinder_paths.core.constants.contracts import BOROS_MARKET_HUB, BOROS_ROUTER
+from wayfinder_paths.core.constants.chains import CHAIN_ID_HYPEREVM
+from wayfinder_paths.core.constants.contracts import (
+    BOROS_MARKET_HUB,
+    BOROS_ROUTER,
+    HYPE_OFT_ADDRESS,
+)
+from wayfinder_paths.core.constants.hype_oft_abi import HYPE_OFT_ABI
 from wayfinder_paths.core.utils.tokens import build_approve_transaction
-from wayfinder_paths.core.utils.transaction import send_transaction
+from wayfinder_paths.core.utils.transaction import encode_call, send_transaction
 from wayfinder_paths.core.utils.web3 import web3_from_chain_id
 
 from .client import BorosClient
@@ -115,6 +120,120 @@ class BorosAdapter(BaseAdapter):
         }
     ]
 
+    @staticmethod
+    def _pad_address_bytes32(address: str) -> bytes:
+        checksum = to_checksum_address(address)
+        return bytes.fromhex(checksum[2:]).rjust(32, b"\x00")
+
+    async def get_cash_fee_data(self, *, token_id: int) -> tuple[bool, dict[str, Any]]:
+        """Read MarketHub.getCashFeeData(tokenId) from chain.
+
+        This is useful for guarding Boros actions that require a minimum amount
+        of cross cash (e.g., MMInsufficientMinCash()).
+        """
+        try:
+            selector = function_signature_to_4byte_selector("getCashFeeData(uint16)")
+            params = encode(["uint16"], [int(token_id)])
+            data = "0x" + selector.hex() + params.hex()
+
+            async with web3_from_chain_id(self.chain_id) as web3:
+                raw: bytes = await web3.eth.call(
+                    {
+                        "to": to_checksum_address(BOROS_MARKET_HUB),
+                        "data": data,
+                    }
+                )
+
+            if len(raw) % 32 != 0:
+                return False, {"error": f"Unexpected getCashFeeData() size: {len(raw)}"}
+
+            n_words = len(raw) // 32
+            values = decode(["uint256"] * n_words, raw)
+            if len(values) < 4:
+                return False, {
+                    "error": f"Unexpected getCashFeeData() words: {len(values)}"
+                }
+
+            # Empirically (2026-02-01 on Arbitrum MarketHub), the return is 4 uint256s.
+            # We expose all 4, and provide float conversions for the commonly used ones.
+            scaling_factor_wei = int(values[0])
+            fee_rate_wei = int(values[1])
+            min_cash_cross_wei = int(values[2])
+            min_cash_isolated_wei = int(values[3])
+
+            return True, {
+                "token_id": int(token_id),
+                "scaling_factor_wei": scaling_factor_wei,
+                "fee_rate_wei": fee_rate_wei,
+                "min_cash_cross_wei": min_cash_cross_wei,
+                "min_cash_isolated_wei": min_cash_isolated_wei,
+                "fee_rate": fee_rate_wei / 1e18,
+                "min_cash_cross": min_cash_cross_wei / 1e18,
+                "min_cash_isolated": min_cash_isolated_wei / 1e18,
+            }
+        except Exception as exc:  # noqa: BLE001
+            return False, {"error": str(exc)}
+
+    async def sweep_isolated_to_cross(
+        self,
+        *,
+        token_id: int,
+        market_id: int | None = None,
+    ) -> tuple[bool, dict[str, Any]]:
+        """Sweep isolated cash -> cross cash for a given token (optionally per-market).
+
+        Boros deposits can sometimes show up as isolated cash for the target market;
+        this helper moves that isolated cash back to cross margin using cash_transfer.
+
+        Notes:
+        - Uses `get_account_balances()` (collaterals endpoint) to find isolated cash.
+        - cash_transfer uses 1e18 internal cash units, not token native decimals.
+        - This does NOT touch isolated positions for other markets unless market_id is None.
+        """
+        if self.simulation:
+            return True, {"status": "simulated"}
+
+        ok_bal, balances = await self.get_account_balances(token_id=int(token_id))
+        if not ok_bal or not isinstance(balances, dict):
+            return False, {"error": f"Failed to read Boros balances: {balances}"}
+
+        isolated_positions = balances.get("isolated_positions") or []
+        if not isinstance(isolated_positions, list):
+            isolated_positions = []
+
+        moved: list[dict[str, Any]] = []
+        for iso in isolated_positions:
+            try:
+                iso_market_id = int(iso.get("market_id"))
+                if market_id is not None and iso_market_id != int(market_id):
+                    continue
+                balance_wei = int(iso.get("balance_wei") or 0)
+                if balance_wei <= 0:
+                    continue
+
+                tx_ok, tx_res = await self.cash_transfer(
+                    market_id=iso_market_id,
+                    amount_wei=balance_wei,
+                    is_deposit=False,  # isolated -> cross
+                )
+                moved.append(
+                    {
+                        "market_id": iso_market_id,
+                        "balance_wei": balance_wei,
+                        "ok": tx_ok,
+                        "tx": tx_res,
+                    }
+                )
+                if not tx_ok:
+                    return False, {
+                        "error": f"Failed sweep isolated->cross for market {iso_market_id}",
+                        "moved": moved,
+                    }
+            except Exception as exc:  # noqa: BLE001
+                return False, {"error": f"Failed sweep isolated->cross: {exc}"}
+
+        return True, {"status": "ok", "moved": moved}
+
     @staticmethod
     def _unwrap_tx_payload(payload: dict[str, Any]) -> dict[str, Any]:
         """Best-effort unwrap of API payloads that may nest the tx dict."""
@@ -195,7 +314,6 @@ class BorosAdapter(BaseAdapter):
         self,
         calldata: dict[str, Any],
         *,
-        timeout: int = DEFAULT_TRANSACTION_TIMEOUT,
         max_retries: int = 2,
     ) -> tuple[bool, dict[str, Any]]:
         """Broadcast calldata from Boros API with retry logic.
@@ -292,14 +410,6 @@ class BorosAdapter(BaseAdapter):
             "attempts": max_retries + 1,
         }
 
-    async def connect(self) -> bool:
-        try:
-            markets = await self.boros_client.list_markets(limit=1)
-            return len(markets) > 0
-        except Exception as exc:
-            logger.error(f"BorosAdapter connection failed: {exc}")
-            return False
-
     # ------------------------------------------------------------------ #
     # Tick Math Utilities                                                  #
     # ------------------------------------------------------------------ #
@@ -1015,6 +1125,14 @@ class BorosAdapter(BaseAdapter):
         token_id: int,
         market_id: int,
     ) -> tuple[bool, dict[str, Any]]:
+        """Deposit collateral into Boros cross margin.
+
+        IMPORTANT: amount_wei is in the collateral token's native decimals.
+        Example: USDT has 6 decimals, so 1 USDT = 1_000_000.
+
+        After deposit, Boros may credit the cash as isolated for market_id. This
+        helper sweeps isolated -> cross for that market to match the method name.
+        """
         if self.simulation:
             logger.info(
                 f"[SIMULATION] deposit_to_cross_margin: {amount_wei} wei, "
@@ -1074,7 +1192,24 @@ class BorosAdapter(BaseAdapter):
                     "tx": tx_res,
                 }
 
-            return True, {"status": "ok", "approve": approve_res, "tx": tx_res}
+            sweep_ok, sweep_res = await self.sweep_isolated_to_cross(
+                token_id=int(token_id),
+                market_id=int(market_id),
+            )
+            if not sweep_ok:
+                return False, {
+                    "error": f"Deposit succeeded but isolated->cross sweep failed: {sweep_res}",
+                    "approve": approve_res,
+                    "tx": tx_res,
+                    "sweep": sweep_res,
+                }
+
+            return True, {
+                "status": "ok",
+                "approve": approve_res,
+                "tx": tx_res,
+                "sweep": sweep_res,
+            }
         except Exception as e:
             logger.error(f"Failed to deposit to cross margin: {e}")
             return False, {"error": str(e)}
@@ -1174,6 +1309,302 @@ class BorosAdapter(BaseAdapter):
             logger.error(f"Failed to cash transfer: {e}")
             return False, {"error": str(e)}
 
+    async def bridge_hype_oft_hyperevm_to_arbitrum(
+        self,
+        *,
+        amount_wei: int,
+        max_value_wei: int | None = None,
+        to_address: str | None = None,
+        from_address: str | None = None,
+        dst_eid: int = 30110,
+        min_amount_wei: int = 0,
+    ) -> tuple[bool, dict[str, Any]]:
+        """Bridge native HYPE from HyperEVM -> Arbitrum via LayerZero OFT.
+
+        Notes:
+        - Uses HyperEVM chain id (999) for the transaction.
+        - `amount_wei` is in 1e18 (native HYPE).
+        - The OFT bridge requires `msg.value = amount + nativeFee`.
+        - Amount must be rounded down to `decimalConversionRate()`.
+        - If `max_value_wei` is provided, clamps amount so that (amount + fee) <= max_value_wei.
+        """
+        if amount_wei <= 0:
+            return True, {"status": "no_op", "amount_wei": 0}
+
+        if self.simulation:
+            return True, {
+                "status": "simulated",
+                "amount_wei": int(amount_wei),
+                "dst_eid": int(dst_eid),
+                "to": to_address or self.user_address,
+            }
+
+        if not self.sign_callback:
+            return False, {"error": "sign_callback not configured"}
+
+        sender = from_address or self.user_address
+        recipient = to_address or self.user_address
+        if not sender or not recipient:
+            return False, {"error": "from_address/to_address not configured"}
+
+        try:
+            async with web3_from_chain_id(CHAIN_ID_HYPEREVM) as w3:
+                contract = w3.eth.contract(
+                    address=w3.to_checksum_address(HYPE_OFT_ADDRESS),
+                    abi=HYPE_OFT_ABI,
+                )
+
+                conversion_rate = int(
+                    await contract.functions.decimalConversionRate().call()
+                )
+                if conversion_rate > 0:
+                    amount_wei = (int(amount_wei) // conversion_rate) * conversion_rate
+                else:
+                    amount_wei = int(amount_wei)
+
+                if amount_wei <= 0:
+                    return True, {"status": "no_op", "amount_wei": 0}
+
+                to_bytes32 = self._pad_address_bytes32(recipient)
+
+                def _send_params(amount_ld: int) -> tuple[Any, ...]:
+                    return (
+                        int(dst_eid),
+                        to_bytes32,
+                        int(amount_ld),
+                        int(min_amount_wei),
+                        b"",
+                        b"",
+                        b"",
+                    )
+
+                send_params = _send_params(int(amount_wei))
+                fee = await contract.functions.quoteSend(send_params, False).call()
+                native_fee_wei = int(fee[0])
+                lz_token_fee_wei = int(fee[1])
+
+                if max_value_wei is not None:
+                    max_send_amount_wei = max(0, int(max_value_wei) - native_fee_wei)
+                    if conversion_rate > 0:
+                        max_send_amount_wei = (
+                            max_send_amount_wei // conversion_rate
+                        ) * conversion_rate
+                    if amount_wei > max_send_amount_wei:
+                        amount_wei = int(max_send_amount_wei)
+                        if amount_wei <= 0:
+                            return False, {
+                                "error": "Insufficient balance to cover OFT fee",
+                                "native_fee_wei": native_fee_wei,
+                                "max_value_wei": int(max_value_wei),
+                            }
+                        send_params = _send_params(int(amount_wei))
+                        fee = await contract.functions.quoteSend(
+                            send_params, False
+                        ).call()
+                        native_fee_wei = int(fee[0])
+                        lz_token_fee_wei = int(fee[1])
+
+                total_value_wei = int(amount_wei) + int(native_fee_wei)
+                if max_value_wei is not None and total_value_wei > int(max_value_wei):
+                    return False, {
+                        "error": "Insufficient balance after fee quote",
+                        "amount_wei": int(amount_wei),
+                        "native_fee_wei": int(native_fee_wei),
+                        "total_value_wei": int(total_value_wei),
+                        "max_value_wei": int(max_value_wei),
+                    }
+
+            tx = await encode_call(
+                target=HYPE_OFT_ADDRESS,
+                abi=HYPE_OFT_ABI,
+                fn_name="send",
+                args=[
+                    send_params,
+                    (int(native_fee_wei), int(lz_token_fee_wei)),
+                    to_checksum_address(sender),
+                ],
+                from_address=sender,
+                chain_id=CHAIN_ID_HYPEREVM,
+                value=int(total_value_wei),
+            )
+            tx_hash = await send_transaction(
+                tx, self.sign_callback, wait_for_receipt=True
+            )
+            return True, {
+                "status": "ok",
+                "tx_hash": tx_hash,
+                "amount_wei": int(amount_wei),
+                "native_fee_wei": int(native_fee_wei),
+                "lz_token_fee_wei": int(lz_token_fee_wei),
+                "total_value_wei": int(total_value_wei),
+                "dst_eid": int(dst_eid),
+                "to": recipient,
+                "from": sender,
+                "layerzeroscan": f"https://layerzeroscan.com/tx/{tx_hash}",
+            }
+        except Exception as exc:  # noqa: BLE001
+            return False, {"error": str(exc)}
+
+    async def close_positions_except(
+        self,
+        *,
+        keep_market_id: int,
+        token_id: int = 3,
+        market_ids: list[int] | None = None,
+        best_effort: bool = True,
+    ) -> tuple[bool, dict[str, Any]]:
+        """Close all Boros positions except `keep_market_id` (best-effort by default)."""
+        if self.simulation:
+            return True, {
+                "status": "simulated",
+                "keep_market_id": int(keep_market_id),
+                "markets": market_ids or [],
+            }
+
+        if market_ids is None:
+            ok_pos, positions = await self.get_active_positions()
+            if not ok_pos:
+                return False, {"error": f"Failed to get positions: {positions}"}
+            market_ids = sorted(
+                {
+                    int(p.get("marketId"))
+                    for p in positions
+                    if p.get("marketId") is not None
+                }
+            )
+
+        results: list[dict[str, Any]] = []
+        failures: list[dict[str, Any]] = []
+        for mid in market_ids:
+            if int(mid) == int(keep_market_id):
+                continue
+            ok_close, res_close = await self.close_positions_market(
+                int(mid), token_id=int(token_id)
+            )
+            entry = {"market_id": int(mid), "ok": bool(ok_close), "res": res_close}
+            results.append(entry)
+            if not ok_close:
+                failures.append(entry)
+                if not best_effort:
+                    return False, {
+                        "error": f"Failed to close position for market {mid}",
+                        "results": results,
+                    }
+
+        return True, {"status": "ok", "results": results, "failures": failures}
+
+    async def ensure_position_size_yu(
+        self,
+        *,
+        market_id: int,
+        token_id: int,
+        target_size_yu: float,
+        tif: str = "IOC",
+        min_resize_excess_usd: float | None = None,
+        yu_to_usd: float | None = None,
+    ) -> tuple[bool, dict[str, Any]]:
+        """Ensure the Boros position size (YU) for a market.
+
+        - Uses `place_rate_order(... side="short")` to increase the position.
+        - Uses `close_positions_market(..., size_yu_wei=...)` to decrease it.
+        - If `min_resize_excess_usd` is provided, uses `yu_to_usd` to skip small resizes.
+        """
+        if self.simulation:
+            return True, {
+                "status": "simulated",
+                "market_id": int(market_id),
+                "token_id": int(token_id),
+                "target_size_yu": float(target_size_yu),
+            }
+
+        ok_pos, positions = await self.get_active_positions(market_id=int(market_id))
+        if not ok_pos:
+            return False, {"error": f"Failed to get positions: {positions}"}
+
+        if positions:
+            current_size_yu = abs(float(positions[0].get("size", 0) or 0.0))
+        else:
+            current_size_yu = 0.0
+
+        diff_yu = float(target_size_yu) - float(current_size_yu)
+        diff_abs_yu = abs(diff_yu)
+
+        if min_resize_excess_usd is not None:
+            if yu_to_usd is None or yu_to_usd <= 0:
+                return False, {
+                    "error": "yu_to_usd required when min_resize_excess_usd is set",
+                    "yu_to_usd": yu_to_usd,
+                }
+            diff_usd_equiv = diff_abs_yu * float(yu_to_usd)
+            if diff_usd_equiv < float(min_resize_excess_usd):
+                return True, {
+                    "status": "ok",
+                    "action": "no_op",
+                    "market_id": int(market_id),
+                    "token_id": int(token_id),
+                    "current_size_yu": float(current_size_yu),
+                    "target_size_yu": float(target_size_yu),
+                    "diff_yu": float(diff_yu),
+                }
+
+        if diff_abs_yu < 1e-9:
+            return True, {
+                "status": "ok",
+                "action": "no_op",
+                "market_id": int(market_id),
+                "token_id": int(token_id),
+                "current_size_yu": float(current_size_yu),
+                "target_size_yu": float(target_size_yu),
+                "diff_yu": float(diff_yu),
+            }
+
+        size_yu_wei = int(diff_abs_yu * 1e18)
+
+        if diff_yu > 0:
+            ok_open, res_open = await self.place_rate_order(
+                market_id=int(market_id),
+                token_id=int(token_id),
+                size_yu_wei=int(size_yu_wei),
+                side="short",
+                tif=tif,
+            )
+            if not ok_open:
+                return False, {
+                    "error": f"Failed to open/increase position: {res_open}",
+                    "market_id": int(market_id),
+                }
+            return True, {
+                "status": "ok",
+                "action": "increase_short",
+                "market_id": int(market_id),
+                "token_id": int(token_id),
+                "current_size_yu": float(current_size_yu),
+                "target_size_yu": float(target_size_yu),
+                "diff_yu": float(diff_yu),
+                "tx": res_open,
+            }
+
+        ok_close, res_close = await self.close_positions_market(
+            market_id=int(market_id),
+            token_id=int(token_id),
+            size_yu_wei=int(size_yu_wei),
+        )
+        if not ok_close:
+            return False, {
+                "error": f"Failed to close/decrease position: {res_close}",
+                "market_id": int(market_id),
+            }
+        return True, {
+            "status": "ok",
+            "action": "decrease",
+            "market_id": int(market_id),
+            "token_id": int(token_id),
+            "current_size_yu": float(current_size_yu),
+            "target_size_yu": float(target_size_yu),
+            "diff_yu": float(diff_yu),
+            "tx": res_close,
+        }
+
     async def place_rate_order(
         self,
         *,

{wayfinder_paths-0.1.28 → wayfinder_paths-0.1.30}/wayfinder_paths/adapters/boros_adapter/client.py

@@ -250,10 +250,11 @@ class BorosClient:
 
         Args:
             token_id: Boros token ID (e.g., 3 for USDT).
-            amount_wei: Amount in scaled wei (1e18).
-            market_id: Target market ID.
-            user_address: User wallet address.
-            account_id: Boros account ID (0 = cross margin).
+            amount_wei: Amount in NATIVE token decimals (despite the param name).
+                Example: USDT has 6 decimals, so 1 USDT = 1_000_000.
+        market_id: Target market ID.
+        user_address: User wallet address.
+        account_id: Boros account ID (0 = cross margin).
 
         Returns:
             Calldata dictionary with 'to', 'data', 'value' fields.
@@ -283,7 +284,8 @@ class BorosClient:
 
         Args:
             token_id: Boros token ID.
-            amount_wei: Amount in scaled wei.
+            amount_wei: Amount in NATIVE token decimals (despite the param name).
+                Example: USDT has 6 decimals, so 1 USDT = 1_000_000.
             user_address: User wallet address.
             account_id: Account ID.