wayfinder-paths 0.1.29__py3-none-any.whl → 0.1.30__py3-none-any.whl

wayfinder_paths/core/constants/hype_oft_abi.py

@@ -0,0 +1,151 @@
+"""LayerZero OFT ABI subset used for bridging native HYPE from HyperEVM."""
+
+HYPE_OFT_ABI = [
+    {
+        "inputs": [
+            {
+                "components": [
+                    {"internalType": "uint32", "name": "dstEid", "type": "uint32"},
+                    {"internalType": "bytes32", "name": "to", "type": "bytes32"},
+                    {"internalType": "uint256", "name": "amountLD", "type": "uint256"},
+                    {
+                        "internalType": "uint256",
+                        "name": "minAmountLD",
+                        "type": "uint256",
+                    },
+                    {
+                        "internalType": "bytes",
+                        "name": "extraOptions",
+                        "type": "bytes",
+                    },
+                    {"internalType": "bytes", "name": "composeMsg", "type": "bytes"},
+                    {"internalType": "bytes", "name": "oftCmd", "type": "bytes"},
+                ],
+                "internalType": "struct SendParam",
+                "name": "_sendParam",
+                "type": "tuple",
+            },
+            {"internalType": "bool", "name": "_payInLzToken", "type": "bool"},
+        ],
+        "name": "quoteSend",
+        "outputs": [
+            {
+                "components": [
+                    {"internalType": "uint256", "name": "nativeFee", "type": "uint256"},
+                    {
+                        "internalType": "uint256",
+                        "name": "lzTokenFee",
+                        "type": "uint256",
+                    },
+                ],
+                "internalType": "struct MessagingFee",
+                "name": "",
+                "type": "tuple",
+            }
+        ],
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "inputs": [
+            {
+                "components": [
+                    {"internalType": "uint32", "name": "dstEid", "type": "uint32"},
+                    {"internalType": "bytes32", "name": "to", "type": "bytes32"},
+                    {"internalType": "uint256", "name": "amountLD", "type": "uint256"},
+                    {
+                        "internalType": "uint256",
+                        "name": "minAmountLD",
+                        "type": "uint256",
+                    },
+                    {
+                        "internalType": "bytes",
+                        "name": "extraOptions",
+                        "type": "bytes",
+                    },
+                    {"internalType": "bytes", "name": "composeMsg", "type": "bytes"},
+                    {"internalType": "bytes", "name": "oftCmd", "type": "bytes"},
+                ],
+                "internalType": "struct SendParam",
+                "name": "_sendParam",
+                "type": "tuple",
+            },
+            {
+                "components": [
+                    {"internalType": "uint256", "name": "nativeFee", "type": "uint256"},
+                    {
+                        "internalType": "uint256",
+                        "name": "lzTokenFee",
+                        "type": "uint256",
+                    },
+                ],
+                "internalType": "struct MessagingFee",
+                "name": "_fee",
+                "type": "tuple",
+            },
+            {"internalType": "address", "name": "_refundAddress", "type": "address"},
+        ],
+        "name": "send",
+        "outputs": [
+            {
+                "components": [
+                    {"internalType": "bytes32", "name": "guid", "type": "bytes32"},
+                    {"internalType": "uint64", "name": "nonce", "type": "uint64"},
+                    {
+                        "components": [
+                            {
+                                "internalType": "uint256",
+                                "name": "nativeFee",
+                                "type": "uint256",
+                            },
+                            {
+                                "internalType": "uint256",
+                                "name": "lzTokenFee",
+                                "type": "uint256",
+                            },
+                        ],
+                        "internalType": "struct MessagingFee",
+                        "name": "fee",
+                        "type": "tuple",
+                    },
+                ],
+                "internalType": "struct MessagingReceipt",
+                "name": "",
+                "type": "tuple",
+            },
+            {
+                "components": [
+                    {
+                        "internalType": "uint256",
+                        "name": "amountSentLD",
+                        "type": "uint256",
+                    },
+                    {
+                        "internalType": "uint256",
+                        "name": "amountReceivedLD",
+                        "type": "uint256",
+                    },
+                ],
+                "internalType": "struct OFTReceipt",
+                "name": "",
+                "type": "tuple",
+            },
+        ],
+        "stateMutability": "payable",
+        "type": "function",
+    },
+    {
+        "inputs": [],
+        "name": "sharedDecimals",
+        "outputs": [{"internalType": "uint8", "name": "", "type": "uint8"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "inputs": [],
+        "name": "decimalConversionRate",
+        "outputs": [{"internalType": "uint256", "name": "", "type": "uint256"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
+]

wayfinder_paths/core/strategies/Strategy.py

@@ -8,7 +8,6 @@ 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):
@@ -52,7 +51,7 @@ class Strategy(ABC):
         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,
+        strategy_sign_typed_data: Callable[[dict], Awaitable[str]] | None = None,
     ):
         self.ledger_adapter = None
         self.logger = logger.bind(strategy=self.__class__.__name__)

wayfinder_paths/mcp/tools/quotes.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
-import re
 from typing import Any
 
 from wayfinder_paths.core.clients.BRAPClient import BRAPClient
 from wayfinder_paths.core.clients.TokenClient import TokenClient
-from wayfinder_paths.core.constants.chains import CHAIN_CODE_TO_ID
+from wayfinder_paths.mcp.tools.execute import (
+    _resolve_token_meta,
+    _select_token_chain,
+)
 from wayfinder_paths.mcp.utils import (
     err,
     find_wallet_by_label,
@@ -15,129 +17,6 @@ from wayfinder_paths.mcp.utils import (
 )
 
 
-def _chain_id(token: dict[str, Any]) -> int | None:
-    # Token payloads often include a database/internal `id` field; do not treat that as a chain id.
-    if token.get("chain_id") is not None:
-        try:
-            return int(token.get("chain_id"))
-        except (TypeError, ValueError):
-            return None
-
-    chain = token.get("chain") or {}
-    if not isinstance(chain, dict):
-        return None
-
-    for key in ("chain_id", "chainId", "id"):
-        if chain.get(key) is None:
-            continue
-        try:
-            return int(chain.get(key))
-        except (TypeError, ValueError):
-            return None
-
-    return None
-
-
-_SIMPLE_CHAIN_SUFFIX_RE = re.compile(r"^[a-z0-9]+\s+[a-z0-9-]+$", re.IGNORECASE)
-_ASSET_CHAIN_SPLIT_RE = re.compile(
-    r"^(?P<asset>[a-z0-9]+)[- _](?P<chain>[a-z0-9-]+)$", re.IGNORECASE
-)
-
-
-def _normalize_token_query(query: str) -> str:
-    q = " ".join(str(query).strip().split())
-    if not q or "-" in q or "_" in q:
-        return q
-    if not _SIMPLE_CHAIN_SUFFIX_RE.match(q):
-        return q
-    asset, chain_code = q.rsplit(" ", 1)
-    if chain_code.lower() in CHAIN_CODE_TO_ID:
-        return f"{asset}-{chain_code}"
-    return q
-
-
-def _is_eth_like_token(meta: dict[str, Any]) -> bool:
-    asset_id = str(meta.get("asset_id") or "").lower()
-    symbol = str(meta.get("symbol") or "").lower()
-    return asset_id == "ethereum" or symbol == "eth"
-
-
-def _split_asset_chain(query: str) -> tuple[str, str] | None:
-    q = str(query).strip()
-    if not q:
-        return None
-    m = _ASSET_CHAIN_SPLIT_RE.match(q)
-    if not m:
-        return None
-    return m.group("asset").lower(), m.group("chain").lower()
-
-
-async def _resolve_token_meta(
-    token_client: TokenClient,
-    *,
-    query: str,
-) -> tuple[str, dict[str, Any]]:
-    q = _normalize_token_query(query)
-    split = _split_asset_chain(q)
-    if split:
-        asset, chain_code = split
-        if asset in {"eth", "ethereum"}:
-            try:
-                gas_meta = await token_client.get_gas_token(chain_code)
-                if isinstance(gas_meta, dict) and _is_eth_like_token(gas_meta):
-                    return q, gas_meta
-            except Exception:
-                pass
-    meta = await token_client.get_token_details(q)
-    return q, meta
-
-
-def _infer_chain_code_from_query(query: str, meta: dict[str, Any]) -> str | None:
-    q = str(query).strip().lower()
-    if not q:
-        return None
-
-    candidates: set[str] = {str(k).lower() for k in CHAIN_CODE_TO_ID.keys()}
-    addrs = meta.get("addresses") or {}
-    if isinstance(addrs, dict):
-        candidates.update(str(k).lower() for k in addrs.keys())
-
-    best: str | None = None
-    for code in candidates:
-        if q.endswith(f"-{code}"):
-            if best is None or len(code) > len(best):
-                best = code
-    return best
-
-
-def _address_for_chain(meta: dict[str, Any], chain_code: str) -> str | None:
-    addrs = meta.get("addresses") or {}
-    if not isinstance(addrs, dict):
-        return None
-    for key, val in addrs.items():
-        if str(key).lower() == chain_code and val:
-            return str(val)
-    return None
-
-
-def _select_token_chain(
-    meta: dict[str, Any], *, query: str
-) -> tuple[int | None, str | None]:
-    chain_id = _chain_id(meta)
-    token_address = meta.get("address")
-
-    desired_chain = _infer_chain_code_from_query(query, meta)
-    if desired_chain:
-        addr = _address_for_chain(meta, desired_chain)
-        if addr:
-            token_address = addr
-        if desired_chain in CHAIN_CODE_TO_ID:
-            chain_id = CHAIN_CODE_TO_ID[desired_chain]
-
-    token_address_out = str(token_address).strip() if token_address else None
-    return chain_id, token_address_out
-
-
 def _slippage_float(slippage_bps: int) -> float:
     return max(0.0, float(int(slippage_bps)) / 10_000.0)
 

wayfinder_paths/strategies/basis_trading_strategy/strategy.py

@@ -58,7 +58,6 @@ from wayfinder_paths.core.strategies.descriptors import (
     Volatility,
 )
 from wayfinder_paths.core.strategies.Strategy import StatusDict, StatusTuple, Strategy
-from wayfinder_paths.core.types import HyperliquidSignCallback
 from wayfinder_paths.policies.erc20 import any_erc20_function
 from wayfinder_paths.policies.hyperliquid import (
     any_hyperliquid_l1_payload,
@@ -182,7 +181,7 @@ class BasisTradingStrategy(BasisSnapshotMixin, Strategy):
         *,
         main_wallet: dict[str, Any] | None = None,
         strategy_wallet: dict[str, Any] | None = None,
-        strategy_sign_typed_data: HyperliquidSignCallback | None = None,
+        strategy_sign_typed_data: Callable[[dict], Awaitable[str]] | None = None,
         main_wallet_signing_callback: Callable[[dict], Awaitable[str]] | None = None,
         strategy_wallet_signing_callback: Callable[[dict], Awaitable[str]]
         | None = None,

wayfinder_paths/strategies/boros_hype_strategy/boros_ops_mixin.py

@@ -11,22 +11,18 @@ from datetime import datetime
 from typing import Any
 
 from loguru import logger
-from web3 import AsyncWeb3
 
 from wayfinder_paths.core.utils.transaction import encode_call, send_transaction
-from wayfinder_paths.core.utils.web3 import web3_from_chain_id
 
 from .constants import (
     BOROS_HYPE_MARKET_ID,
     BOROS_HYPE_TOKEN_ID,
     BOROS_MIN_DEPOSIT_HYPE,
     HYPE_NATIVE,
-    HYPE_OFT_ABI,
     HYPE_OFT_ADDRESS,
     HYPEREVM_CHAIN_ID,
     KHYPE_LST,
     LOOPED_HYPE,
-    LZ_EID_ARBITRUM,
     MIN_HYPE_GAS,
     USDC_ARB,
     USDT_ARB,
@@ -37,11 +33,6 @@ from .constants import (
 from .types import Inventory
 
 
-def _pad_address_bytes32(address: str) -> bytes:
-    checksum = AsyncWeb3.to_checksum_address(address)
-    return bytes.fromhex(checksum[2:]).rjust(32, b"\x00")
-
-
 class BorosHypeBorosOpsMixin:
     async def _fund_boros(
         self, params: dict[str, Any], inventory: Inventory
@@ -267,84 +258,21 @@ class BorosHypeBorosOpsMixin:
         bridge_amount_wei = min(target_wei, max_value_wei)
         if bridge_amount_wei <= 0:
             return True, "Boros funding: nothing to bridge"
-
-        to_bytes32 = _pad_address_bytes32(wallet_address)
-
-        async with web3_from_chain_id(HYPEREVM_CHAIN_ID) 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()
-            )  # OFT sharedDecimals rounding
-            if conversion_rate > 0:
-                bridge_amount_wei = (
-                    bridge_amount_wei // conversion_rate
-                ) * conversion_rate
-            if bridge_amount_wei <= 0:
-                return True, "Boros funding: amount too small after OFT rounding"
-
-            # Quote fee, then clamp amount to fit balance (amount + fee) while
-            # still leaving MIN_HYPE_GAS behind for future gas.
-            send_params = (
-                int(LZ_EID_ARBITRUM),
-                to_bytes32,
-                int(bridge_amount_wei),
-                0,
-                b"",
-                b"",
-                b"",
-            )
-            fee = await contract.functions.quoteSend(send_params, False).call()
-            native_fee = int(fee[0])
-            lz_token_fee = int(fee[1])
-
-            max_send_amount_wei = max(0, max_value_wei - native_fee)
-            if conversion_rate > 0:
-                max_send_amount_wei = (
-                    max_send_amount_wei // conversion_rate
-                ) * conversion_rate
-            if bridge_amount_wei > max_send_amount_wei:
-                bridge_amount_wei = max_send_amount_wei
-                if bridge_amount_wei <= 0:
-                    return False, "Insufficient HyperEVM HYPE to cover OFT bridge fee"
-
-                send_params = (
-                    int(LZ_EID_ARBITRUM),
-                    to_bytes32,
-                    int(bridge_amount_wei),
-                    0,
-                    b"",
-                    b"",
-                    b"",
-                )
-                fee = await contract.functions.quoteSend(send_params, False).call()
-                native_fee = int(fee[0])
-                lz_token_fee = int(fee[1])
-
-            total_value_wei = int(bridge_amount_wei) + int(native_fee)
-            if total_value_wei > max_value_wei:
-                return False, "Insufficient HyperEVM HYPE to bridge after fee quote"
-
-        tx = await encode_call(
-            target=HYPE_OFT_ADDRESS,
-            abi=HYPE_OFT_ABI,
-            fn_name="send",
-            args=[
-                send_params,
-                (int(native_fee), int(lz_token_fee)),
-                AsyncWeb3.to_checksum_address(wallet_address),
-            ],
-            from_address=wallet_address,
-            chain_id=HYPEREVM_CHAIN_ID,
-            value=total_value_wei,
+        (
+            ok_bridge,
+            bridge_res,
+        ) = await self.boros_adapter.bridge_hype_oft_hyperevm_to_arbitrum(
+            amount_wei=int(bridge_amount_wei),
+            max_value_wei=int(max_value_wei),
+            to_address=str(wallet_address),
+            from_address=str(wallet_address),
         )
+        if not ok_bridge:
+            return False, f"OFT bridge failed: {bridge_res}"
 
-        tx_hash = await send_transaction(tx, self._sign_callback, wait_for_receipt=True)
-
-        bridged_hype = float(bridge_amount_wei) / 1e18
+        tx_hash = str(bridge_res.get("tx_hash") or "")
+        bridged_wei = int(bridge_res.get("amount_wei") or 0)
+        bridged_hype = float(bridged_wei) / 1e18
         bridged_usd = bridged_hype * hype_price
 
         # Track in-flight amount so planner doesn't double-fund while the bridge settles.
@@ -360,7 +288,7 @@ class BorosHypeBorosOpsMixin:
 
         return True, (
             f"Bridging {bridged_hype:.6f} HYPE (≈${bridged_usd:.2f}) HyperEVM→Arbitrum via OFT; "
-            f"tx={tx_hash} (LayerZero: https://layerzeroscan.com/tx/{tx_hash}). "
+            f"tx={tx_hash} (LayerZero: {bridge_res.get('layerzeroscan')}). "
             "Once bridged HYPE lands on Arbitrum, the next tick will deposit it to Boros."
         )
 
@@ -431,41 +359,15 @@ class BorosHypeBorosOpsMixin:
                 f"({depositable_hype:.6f} HYPE)",
             )
 
-        # 0) Move any isolated collateral to cross margin (cleanup).
-        # Boros markets expire, so we need to get the actual market ID from isolated positions.
+        # 0) Cleanup: sweep any isolated collateral back to cross margin.
         try:
-            ok_bal, balances = await self.boros_adapter.get_account_balances(
+            ok_sweep, sweep_res = await self.boros_adapter.sweep_isolated_to_cross(
                 token_id=int(token_id)
             )
-            if ok_bal and isinstance(balances, dict):
-                isolated_positions = balances.get("isolated_positions", [])
-                logger.debug(
-                    f"Boros position check: isolated={balances.get('isolated', 0):.6f}, "
-                    f"cross={balances.get('cross', 0):.6f}, "
-                    f"total={balances.get('total', 0):.6f}, "
-                    f"isolated_positions={isolated_positions}"
-                )
-                for iso_pos in isolated_positions:
-                    iso_market_id = iso_pos.get("market_id")
-                    iso_balance = float(iso_pos.get("balance", 0) or 0.0)
-                    if iso_market_id and iso_balance > 0.001:
-                        iso_wei = int(iso_balance * 1e18)  # Boros cash units
-                        logger.info(
-                            f"Moving {iso_balance:.6f} collateral from isolated market {iso_market_id} to cross"
-                        )
-                        ok_xfer, res_xfer = await self.boros_adapter.cash_transfer(
-                            market_id=int(iso_market_id),
-                            amount_wei=iso_wei,
-                            is_deposit=False,  # isolated -> cross
-                        )
-                        if ok_xfer:
-                            await asyncio.sleep(2)
-                        else:
-                            logger.warning(
-                                f"Failed Boros isolated->cross transfer for market {iso_market_id}: {res_xfer}"
-                            )
+            if not ok_sweep:
+                logger.warning(f"Failed Boros isolated->cross sweep: {sweep_res}")
         except Exception as exc:  # noqa: BLE001
-            logger.warning(f"Failed Boros isolated->cross transfer: {exc}")
+            logger.warning(f"Failed Boros isolated->cross sweep: {exc}")
 
         # 1) Best-effort: if any OFT HYPE is sitting idle on Arbitrum, deposit it to cross margin.
         if inventory.hype_oft_arb_balance > 0.0:
@@ -491,104 +393,58 @@ class BorosHypeBorosOpsMixin:
             except Exception as exc:  # noqa: BLE001
                 logger.warning(f"Failed to deposit OFT HYPE to Boros: {exc}")
 
-        # Deposits can land as isolated cash for the given market_id; ensure we
-        # sweep isolated -> cross again before attempting to trade.
-        try:
-            ok_bal, balances = await self.boros_adapter.get_account_balances(
-                token_id=int(token_id)
-            )
-            if ok_bal and isinstance(balances, dict):
-                isolated_positions = balances.get("isolated_positions", [])
-                for iso_pos in isolated_positions:
-                    iso_market_id = iso_pos.get("market_id")
-                    iso_balance = float(iso_pos.get("balance", 0) or 0.0)
-                    if iso_market_id and iso_balance > 0.001:
-                        iso_wei = int(iso_balance * 1e18)  # Boros cash units
-                        logger.info(
-                            f"Moving {iso_balance:.6f} collateral from isolated market {iso_market_id} to cross"
-                        )
-                        ok_xfer, res_xfer = await self.boros_adapter.cash_transfer(
-                            market_id=int(iso_market_id),
-                            amount_wei=iso_wei,
-                            is_deposit=False,  # isolated -> cross
-                        )
-                        if ok_xfer:
-                            await asyncio.sleep(2)
-                        else:
-                            logger.warning(
-                                f"Failed Boros isolated->cross transfer for market {iso_market_id}: {res_xfer}"
-                            )
-        except Exception as exc:  # noqa: BLE001
-            logger.warning(
-                f"Failed Boros isolated->cross transfer after deposit: {exc}"
-            )
-
         # 2) Rollover: close positions in other markets (best effort).
         try:
-            for mid in inventory.boros_position_market_ids or []:
-                try:
-                    mid_int = int(mid)
-                except (TypeError, ValueError):
-                    continue
-                if mid_int <= 0 or mid_int == int(market_id):
-                    continue
-                try:
-                    await self.boros_adapter.close_positions_market(
-                        mid_int, token_id=int(token_id)
-                    )
-                    await asyncio.sleep(2)
-                except Exception as exc:  # noqa: BLE001
-                    logger.warning(f"Failed to close Boros market {mid_int}: {exc}")
+            ok_roll, roll_res = await self.boros_adapter.close_positions_except(
+                keep_market_id=int(market_id),
+                token_id=int(token_id),
+                market_ids=inventory.boros_position_market_ids or [],
+                best_effort=True,
+            )
+            if not ok_roll:
+                logger.warning(f"Failed Boros rollover close: {roll_res}")
         except Exception as exc:  # noqa: BLE001
             logger.warning(f"Failed Boros rollover close: {exc}")
 
-        success, positions = await self.boros_adapter.get_active_positions(
-            market_id=int(market_id)
+        yu_to_usd = (
+            float(inventory.hype_price_usd or 0.0)
+            if int(token_id) == BOROS_HYPE_TOKEN_ID
+            else 1.0
         )
-        if not success:
-            return False, "Failed to get Boros positions"
-
-        if positions:
-            pos = positions[0]
-            current_size_yu = abs(float(pos.get("size", 0) or 0.0))
-        else:
-            current_size_yu = 0.0
-
-        diff_yu = float(target_size_yu) - float(current_size_yu)
-        diff_usd_equiv = abs(diff_yu) * float(inventory.hype_price_usd or 0.0)
-        if diff_usd_equiv < self._planner_config.boros_resize_min_excess_usd:
-            return True, f"Boros position already at target ({current_size_yu:.4f} YU)"
-
-        size_yu_wei = int(abs(diff_yu) * 1e18)  # Boros YU wei
-
-        if diff_yu > 0:
-            # Open/increase SHORT side (receive fixed)
-            ok_open, open_res = await self.boros_adapter.place_rate_order(
-                market_id=int(market_id),
-                token_id=int(token_id),
-                size_yu_wei=size_yu_wei,
-                side="short",
-                tif="IOC",
+        ok_set, set_res = await self.boros_adapter.ensure_position_size_yu(
+            market_id=int(market_id),
+            token_id=int(token_id),
+            target_size_yu=float(target_size_yu),
+            tif="IOC",
+            min_resize_excess_usd=float(
+                self._planner_config.boros_resize_min_excess_usd
+            ),
+            yu_to_usd=float(yu_to_usd),
+        )
+        if not ok_set:
+            return False, f"Failed to ensure Boros position: {set_res}"
+
+        action = str(set_res.get("action") or "unknown")
+        diff_yu = float(set_res.get("diff_yu") or 0.0)
+        if action == "no_op":
+            return (
+                True,
+                f"Boros position already at target ({set_res.get('current_size_yu', 0.0):.4f} YU)",
             )
-            if not ok_open:
-                return False, f"Failed to open Boros position: {open_res}"
+        if action == "increase_short":
             return (
                 True,
                 f"Boros position increased by {diff_yu:.4f} YU on market {market_id}",
             )
-
-        # Close/decrease position
-        ok_close, close_res = await self.boros_adapter.close_positions_market(
-            market_id=int(market_id),
-            token_id=int(token_id),
-            size_yu_wei=size_yu_wei,
-        )
-        if not ok_close:
-            return False, f"Failed to close Boros position: {close_res}"
+        if action == "decrease":
+            return (
+                True,
+                f"Boros position decreased by {abs(diff_yu):.4f} YU on market {market_id}",
+            )
 
         return (
             True,
-            f"Boros position decreased by {abs(diff_yu):.4f} YU on market {market_id}",
+            f"Boros position adjusted ({action}) on market {market_id}: Δ={diff_yu:.4f} YU",
         )
 
     async def _complete_pending_withdrawal(