tpluspy 0.2.0__tar.gz → 0.2.3__tar.gz

{tpluspy-0.2.0 → tpluspy-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tpluspy
-Version: 0.2.0
+Version: 0.2.3
 Summary: tpluspy: Client utilities for interacting with tplus
 Home-page: https://github.com/tpluslabs/tpluspy
 Author: TPlus Labs

{tpluspy-0.2.0 → tpluspy-0.2.3}/setup.py

@@ -8,7 +8,7 @@ long_description = (here / "README.md").read_text(encoding="utf-8")
 
 setup(
     name="tpluspy",
-    version="0.2.0",
+    version="0.2.3",
     description="""tpluspy: Client utilities for interacting with tplus""",
     long_description=long_description,
     long_description_content_type="text/markdown",

{tpluspy-0.2.0 → tpluspy-0.2.3}/tplus/_cli/_context.py

@@ -6,6 +6,7 @@ from typing import TYPE_CHECKING
 import click
 
 if TYPE_CHECKING:
+    from tplus.client.blockchain import BlockchainClient
     from tplus.client.clearingengine import ClearingEngineClient
     from tplus.client.market_data import MarketDataClient
     from tplus.client.orderbook import OrderBookClient
@@ -26,6 +27,7 @@ class CLIContext(dict):
         self.orderbook_base_url: str | None = None
         self.clearing_base_url: str | None = None
         self.market_data_base_url: str | None = None
+        self.blockchain_base_url: str | None = None
         self.account: str | None = None
         self.ignore_ssl: bool = False
 
@@ -106,6 +108,17 @@ class CLIContext(dict):
             insecure_ssl=self.ignore_ssl,
         )
 
+    def blockchain_client(self) -> "BlockchainClient":
+        if not self.blockchain_base_url:
+            raise click.UsageError(
+                "No blockchain client base URL specified. "
+                "Pass --blockchain-base-url or set TPLUS_BLOCKCHAIN_BASE_URL."
+            )
+
+        from tplus.client.blockchain import BlockchainClient
+
+        return BlockchainClient(base_url=self.blockchain_base_url, insecure_ssl=self.ignore_ssl)
+
     def market_data_client(self) -> "MarketDataClient":
         if not self.market_data_base_url:
             raise click.UsageError(
@@ -164,6 +177,16 @@ def market_data_url_option() -> Callable:
     )
 
 
+def blockchain_url_option() -> Callable:
+    return click.option(
+        "--blockchain-base-url",
+        envvar="TPLUS_BLOCKCHAIN_BASE_URL",
+        help="T+ blockchain client base URL.",
+        callback=_set_on_ctx("blockchain_base_url"),
+        expose_value=False,
+    )
+
+
 def tplus_account_option() -> Callable:
     def callback(ctx: click.Context, _param, value):
         cli_ctx = ctx.ensure_object(CLIContext)

{tpluspy-0.2.0 → tpluspy-0.2.3}/tplus/_cli/debug.py

@@ -2,7 +2,12 @@ import asyncio
 
 import click
 
-from tplus._cli._context import CLIContext, clearing_url_option, pass_cli_context
+from tplus._cli._context import (
+    CLIContext,
+    blockchain_url_option,
+    clearing_url_option,
+    pass_cli_context,
+)
 from tplus.cli_tools import ignore_ssl_option
 
 
@@ -90,6 +95,48 @@ def _set_withdrawal_delay(
     click.echo("Withdrawal delay parameters updated.")
 
 
+@debug.command("sync-vault-events")
+@click.option("--from-block", "from_block", type=int, required=True)
+@click.option("--to-block", "to_block", type=int, required=True)
+@click.option("--address", "address", default=None, help="Contract address to filter on.")
+@click.option(
+    "--event",
+    "events",
+    multiple=True,
+    help="Event topic-0 signature to filter on (repeatable).",
+)
+@click.option(
+    "--operator-secret",
+    "operator_secret",
+    envvar="TPLUS_OPERATOR_SECRET",
+    default=None,
+    help="Hex operator secret. Required by authenticated (threshold) clients.",
+)
+@blockchain_url_option()
+@ignore_ssl_option()
+@pass_cli_context
+def _sync_vault_events(
+    cli_ctx: CLIContext,
+    from_block: int,
+    to_block: int,
+    address: str | None,
+    events: tuple[str, ...],
+    operator_secret: str | None,
+):
+    """Re-ingest a blockchain client's on-chain events in a block range."""
+    client = cli_ctx.blockchain_client()
+    asyncio.run(
+        client.sync_vault_events(
+            from_block,
+            to_block,
+            address=address,
+            events=list(events) or None,
+            operator_secret=operator_secret,
+        )
+    )
+    click.echo(f"Requested re-ingestion of blocks {from_block}-{to_block}.")
+
+
 @debug.command("reset-users")
 @clearing_url_option()
 @ignore_ssl_option()

{tpluspy-0.2.0 → tpluspy-0.2.3}/tplus/_cli/markets.py

@@ -136,9 +136,9 @@ def _klines(
     )
     if output_format == "raw":
         echo_with_pager(
-            [kline.model_dump_json() for kline in klines],
+            [kline.model_dump_json() for kline in klines.items],
             no_pager=no_pager,
         )
         return
 
-    render([kline.model_dump() for kline in klines], output_format, no_pager=no_pager)
+    render([kline.model_dump() for kline in klines.items], output_format, no_pager=no_pager)

{tpluspy-0.2.0 → tpluspy-0.2.3}/tplus/client/__init__.py

@@ -1,3 +1,4 @@
+from .blockchain import BlockchainClient
 from .clearingengine import ClearingEngineClient
 from .market_data import MarketDataClient
 from .oms import AssetRegistryClient
@@ -5,6 +6,7 @@ from .orderbook import OrderBookClient
 from .withdrawal import WithdrawalClient
 
 __all__ = (
+    "BlockchainClient",
     "ClearingEngineClient",
     "MarketDataClient",
     "OrderBookClient",

{tpluspy-0.2.0 → tpluspy-0.2.3}/tplus/client/base.py

@@ -178,10 +178,9 @@ class BaseClient:
         user: "UserType | None" = None,
         request_timeout: float | None = None,
     ) -> dict[str, Any]:
-        relative_url = endpoint if endpoint.startswith("/") else f"/{endpoint}"
         response = await self._send(
             method,
-            relative_url,
+            endpoint,
             json_data=json_data,
             params=params,
             request_timeout=request_timeout,
@@ -201,6 +200,7 @@ class BaseClient:
         headers: dict[str, str] | None = None,
         request_timeout: float | None = None,
     ) -> httpx.Response:
+        relative_url = relative_url if relative_url.startswith("/") else f"/{relative_url}"
         if json_data or params:
             self.logger.debug(
                 f"Request to {method} {relative_url} with payload: {json_data} params: {params}"

tpluspy-0.2.3/tplus/client/blockchain.py

@@ -0,0 +1,50 @@
+import time
+
+from tplus.client.base import BaseClient
+from tplus.utils.operator import load_operator_sk, sign_operator_payload
+
+
+class BlockchainClient(BaseClient):
+    """Admin HTTP client for a blockchain client (threshold / anvil).
+
+    Authenticates with a secp256k1 operator signature rather than Ed25519 user signing.
+    ``base_url`` points at the blockchain client's health-API port.
+    """
+
+    async def sync_vault_events(
+        self,
+        from_block: int,
+        to_block: int,
+        *,
+        address: str | None = None,
+        events: list[str] | None = None,
+        operator_secret: str | None = None,
+        timestamp_ms: int | None = None,
+    ) -> None:
+        """Trigger re-ingestion of on-chain events in ``[from_block, to_block]``.
+
+        Fire-and-forget: the client re-queries logs and replays them over the overlay, so nothing
+        is returned here. Pass ``operator_secret`` for authenticated (threshold) clients; omit it
+        for anvil.
+        """
+        timestamp = int(time.time() * 1000) if timestamp_ms is None else timestamp_ms
+        events_str = ",".join(events) if events else ""
+        payload = f"{from_block}:{to_block}:{timestamp}:{address or ''}:{events_str}".encode()
+
+        signature = ""
+        if operator_secret is not None:
+            signature = sign_operator_payload(payload, load_operator_sk(operator_secret))
+
+        body: dict = {
+            "from_block": from_block,
+            "to_block": to_block,
+            "timestamp": timestamp,
+            "signature": signature,
+        }
+        if address is not None:
+            body["address"] = address
+        if events is not None:
+            body["events"] = events
+
+        # "historical_logs" is the blockchain client's existing route name.
+        await self._post("historical_logs", json_data=body, requires_auth=False)

{tpluspy-0.2.0 → tpluspy-0.2.3}/tplus/client/clearingengine/__init__.py

@@ -5,6 +5,7 @@ from tplus.client.clearingengine.admin import AdminClient
 from tplus.client.clearingengine.admin_settlement import AdminSettlementClient
 from tplus.client.clearingengine.assetregistry import AdminAssetRegistryClient
 from tplus.client.clearingengine.base import BaseClearingEngineClient
+from tplus.client.clearingengine.cross_venue import CrossVenueClient
 from tplus.client.clearingengine.decimal import DecimalClient
 from tplus.client.clearingengine.vault import VaultClient
 
@@ -50,6 +51,13 @@ class ClearingEngineClient(BaseClearingEngineClient):
         """
         return VaultClient.from_client(self)
 
+    @cached_property
+    def cross_venue(self) -> CrossVenueClient:
+        """
+        User-facing cross-venue (Hyperliquid) margin APIs.
+        """
+        return CrossVenueClient.from_client(self)
+
     @cached_property
     def admin(self) -> AdminClient:
         """

{tpluspy-0.2.0 → tpluspy-0.2.3}/tplus/client/clearingengine/admin.py

@@ -1,35 +1,25 @@
-import hashlib
 import time
 from typing import Any
 
-from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.asymmetric import ec
-from cryptography.hazmat.primitives.asymmetric.utils import Prehashed, decode_dss_signature
 
 from tplus.client.clearingengine.base import BaseClearingEngineClient
 from tplus.model.asset_identifier import AssetIdentifier
 from tplus.model.interest_rates import InterestRates
 from tplus.model.types import UserPublicKey
+from tplus.utils.operator import load_operator_sk, sign_operator_payload
 from tplus.utils.user import User
 
 
 class AdminClient(BaseClearingEngineClient):
     @staticmethod
     def _load_operator_sk(operator_secret) -> ec.EllipticCurvePrivateKey:
-        secret_bytes = bytes.fromhex(operator_secret)
-        return ec.derive_private_key(int.from_bytes(secret_bytes, "big"), ec.SECP256K1())
+        return load_operator_sk(operator_secret)
 
     @staticmethod
     def _sign(payload: bytes, sk: ec.EllipticCurvePrivateKey) -> str:
         """SHA256 -> ECDSA sign -> low-S normalize -> compact r||s -> hex."""
-        SECP256K1_ORDER = 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141
-        SECP256K1_HALF_ORDER = SECP256K1_ORDER // 2
-        digest = hashlib.sha256(payload).digest()
-        sig_der = sk.sign(digest, ec.ECDSA(Prehashed(hashes.SHA256())))
-        r, s = decode_dss_signature(sig_der)
-        if s > SECP256K1_HALF_ORDER:
-            s = SECP256K1_ORDER - s
-        return (r.to_bytes(32, "big") + s.to_bytes(32, "big")).hex()
+        return sign_operator_payload(payload, sk)
 
     async def get_verifying_key(self):
         """
@@ -222,6 +212,32 @@ class AdminClient(BaseClearingEngineClient):
 
         await self._post("admin/last-trade-prices/modify", json_data={"prices": prices})
 
+    async def set_impact_prices(
+        self,
+        asset_id: AssetIdentifier,
+        buy_impact: str | None,
+        sell_impact: str | None,
+        decimals: int = 0,
+    ):
+        """Override the buy/sell impact prices for an asset on the CE (debug only).
+
+        The CE applies the override locally and propagates it to the OMS. Pass
+        ``buy_impact=None`` and ``sell_impact=None`` (the default) to clear the
+        override and set the asset's impact price back to ``None``.
+        """
+        prices: dict[str, Any]
+        if buy_impact is None and sell_impact is None:
+            prices = {str(asset_id): None}
+        else:
+            override: dict[str, Any] = {}
+            if buy_impact is not None:
+                override["buy_impact"] = {"price": buy_impact, "decimals": decimals}
+            if sell_impact is not None:
+                override["sell_impact"] = {"price": sell_impact, "decimals": decimals}
+            prices = {str(asset_id): override}
+
+        await self._post("admin/impact-prices/modify", json_data={"prices": prices})
+
     async def set_book_decimals(
         self,
         asset_id: AssetIdentifier,
@@ -243,12 +259,20 @@ class AdminClient(BaseClearingEngineClient):
         is_mm: bool,
         operator_secret: str,
         timestamp_ns: int | None = None,
+        nonce: int | None = None,
     ):
         ts = time.time_ns() if timestamp_ns is None else timestamp_ns
+        request_nonce = time.time_ns() if nonce is None else nonce
 
         sk = AdminClient._load_operator_sk(operator_secret=operator_secret)
         user_pubkey = bytes(user.public_key_vec)
-        payload = ts.to_bytes(8, "big") + user_pubkey + b"\x01"
+        payload = (
+            b"ce.admin.status.modify.v1"
+            + request_nonce.to_bytes(8, "big")
+            + ts.to_bytes(8, "big")
+            + user_pubkey
+            + (b"\x01" if is_mm else b"\x00")
+        )
         sig = AdminClient._sign(payload, sk)
 
         await self._post(
@@ -258,6 +282,7 @@ class AdminClient(BaseClearingEngineClient):
                     "user": user.public_key,
                     "is_mm": is_mm,
                     "timestamp_ns": ts,
+                    "nonce": request_nonce,
                 },
                 "signature": sig,
             },
@@ -275,6 +300,19 @@ class AdminClient(BaseClearingEngineClient):
             json_data={"fee_account": user},
         )
 
+    async def set_avs_backstop_target(
+        self, user: UserPublicKey | None, account_index: int | None = None
+    ):
+        """Configure the AVS backstop target, or clear it (disabling the
+        post-liquidation transfer) when ``user`` is ``None``."""
+        await self._post(
+            "admin/avs-backstop-target/modify",
+            json_data={"user": user, "account_index": account_index},
+        )
+
+    async def clear_avs_backstop_target(self):
+        await self.set_avs_backstop_target(None)
+
     async def reset_users(self):
         await self._post(
             "admin/users/reset",
@@ -287,6 +325,19 @@ class AdminClient(BaseClearingEngineClient):
             json_data={},
         )
 
+    async def expire_xm_venue_locks(self):
+        """Force-expire every cross-venue (Hyperliquid) state-lock now (debug only).
+
+        Simulates the inaccessible-/downtime-timeout cliff: each locked venue
+        balance is zeroed and the (now smaller) credit line is gossiped to the
+        OMS. Lets e2e tests observe the post-timeout solvency drop without
+        waiting the real 7-day ``VENUE_INACCESSIBLE_TIMEOUT_NS``.
+        """
+        await self._post(
+            "admin/xm/expire-locks",
+            json_data={},
+        )
+
 
 def _asset_id_to_index(
     asset_id: int | AssetIdentifier | str,

tpluspy-0.2.3/tplus/client/clearingengine/cross_venue.py

@@ -0,0 +1,36 @@
+import time
+from typing import TYPE_CHECKING
+
+from tplus.client.clearingengine.base import BaseClearingEngineClient
+
+if TYPE_CHECKING:
+    from tplus.utils.user import User
+
+
+class CrossVenueClient(BaseClearingEngineClient):
+    """User-facing cross-venue (e.g. Hyperliquid) margin APIs on the clearing engine."""
+
+    async def get_venue_state(self, user: "User", venue: int) -> dict:
+        """Read the caller's cross-venue ``(user, venue)`` state.
+
+        User-authenticated: the query is signed with ``user``'s key, so a user
+        can only read their own venue state. Returns
+        ``{venue_present, allocation_bps, locked, usd_balance}`` — ``venue_present``
+        flips true once the adapter binding reaches the CE, and ``allocation_bps``
+        is non-zero once the credit line is applied.
+        """
+        ts = time.time_ns()
+        sep = b"\x1f"
+        # Must match `xm_venue_state_signing_payload` in the CE creditline route.
+        payload = (
+            b"xm_venue_state_query_v1"
+            + sep
+            + bytes.fromhex(user.public_key)
+            + sep
+            + venue.to_bytes(8, "big")
+            + sep
+            + ts.to_bytes(8, "big")
+        )
+        signature = user.sk.sign(payload).hex()
+        endpoint = f"xm/venue/{user.public_key}/{venue}?timestamp_ns={ts}&signature={signature}"
+        return await self._get(endpoint, requires_auth=False)

{tpluspy-0.2.0 → tpluspy-0.2.3}/tplus/client/market_data.py

@@ -1,11 +1,15 @@
-"""Read-only client for the `market-data-service` (public market data; no auth)."""
+"""Client for the `market-data-service` (public market data + per-user endpoints)."""
 
 from collections.abc import AsyncIterator
-from typing import Any
+from typing import TYPE_CHECKING, Any
 
 from tplus.client.base import BaseClient
 from tplus.model.asset_identifier import AssetIdentifier
-from tplus.model.klines import KlineUpdate, parse_kline_update
+
+if TYPE_CHECKING:
+    from tplus.client.auth import AuthenticatedClient
+    from tplus.types import UserType
+from tplus.model.klines import KlinesPage, KlineUpdate, parse_kline_update, parse_klines_page
 from tplus.model.orderbook import OrderBook, OrderBookDiff
 from tplus.model.trades import (
     Trade,
@@ -15,6 +19,8 @@ from tplus.model.trades import (
     parse_trades,
 )
 
+DEFAULT_BASE_URL = "http://localhost:8011"
+
 
 def _pagination(page: int | None, limit: int | None) -> dict[str, Any]:
     params: dict[str, Any] = {}
@@ -30,8 +36,33 @@ def _pagination(page: int | None, limit: int | None) -> dict[str, Any]:
 class MarketDataClient(BaseClient):
     """Klines, order-book depth, public trades and 24h tickers (REST + WS streams)."""
 
-    def __init__(self, base_url: str = "http://localhost:8011", **kwargs: Any) -> None:
+    def __init__(
+        self,
+        base_url: str = DEFAULT_BASE_URL,
+        *,
+        auth_client: "AuthenticatedClient | None" = None,
+        **kwargs: Any,
+    ) -> None:
         super().__init__(base_url, **kwargs)
+        # Per-user endpoints borrow the OMS bearer token from this client.
+        self._auth_client = auth_client
+
+    async def _authed_get(
+        self,
+        endpoint: str,
+        *,
+        user: "UserType | None" = None,
+        params: dict[str, Any] | None = None,
+    ) -> Any:
+        """GET an MDS endpoint with the OMS bearer token attached."""
+        if self._auth_client is None:
+            raise ValueError("per-user market-data endpoints require an `auth_client`")
+
+        signer = user if not isinstance(user, str) else None
+        await self._auth_client._ensure_auth(user=signer)
+        headers = self._auth_client._get_auth_headers(user=user)
+        response = await self._send("GET", endpoint, params=params, headers=headers)
+        return self._handle_response(response)
 
     async def get_orderbook_snapshot(self, asset_id: AssetIdentifier) -> OrderBook:
         """Current order-book snapshot for `asset_id`."""
@@ -50,8 +81,8 @@ class MarketDataClient(BaseClient):
         page: int | None = None,
         limit: int | None = None,
         end_timestamp_ns: int | None = None,
-    ) -> list[KlineUpdate]:
-        """K-line (candlestick) data for `asset_id`."""
+    ) -> KlinesPage:
+        """A page of k-line (candlestick) data for `asset_id`, with pagination metadata."""
         params = _pagination(page, limit)
         if end_timestamp_ns:
             params["end_timestamp_ns"] = end_timestamp_ns
@@ -59,10 +90,10 @@ class MarketDataClient(BaseClient):
         response = await self._request(
             "GET", f"/klines/{asset_id}", params=params, requires_auth=False
         )
-        if not isinstance(response, list):
+        if not isinstance(response, dict | list):
             raise ValueError(f"Invalid response from get_klines: {response}")
 
-        return parse_kline_update(response)
+        return parse_klines_page(response)
 
     async def get_ticker(self, asset_id: AssetIdentifier) -> dict[str, Any]:
         """24h ticker for `asset_id`."""