pmxtjs 2.48.6 → 2.49.1

package/dist/esm/pmxt/client.js

@@ -7,9 +7,21 @@
 import { Configuration, DefaultApi, } from "../generated/src/index.js";
 import { MarketList, } from "./models.js";
 import { ServerManager } from "./server-manager.js";
-import { PmxtError, fromServerError } from "./errors.js";
+import { PmxtError, fromServerError, InvalidOrder, NotSupported } from "./errors.js";
 import { resolvePmxtBaseUrl } from "./constants.js";
 import { SidecarWsClient } from "./ws-client.js";
+// Hosted-mode trading dispatch.
+// These modules are introduced as part of the hosted trading mode rollout.
+// Some of them may be authored by parallel agents; until they all land, the
+// import names below are the conventional ones from the plan. Cross-module
+// "Cannot find module" errors during the parallel landing window resolve
+// once the matching files exist.
+import { HOSTED_TRADING_VENUES, _tradingRequest, resolveWalletAddress, formatRoutePath, HOSTED_METHOD_ROUTES, } from "./hosted-routing.js";
+import { orderFromV0, positionFromV0, balanceFromV0, userTradeFromV0, to6dec, } from "./hosted-mappers.js";
+import { validateTypedData, validateEconomics, verifySignature, } from "./hosted-typed-data.js";
+import { EthersSigner } from "./signers.js";
+import { Escrow } from "./escrow.js";
+import { MissingWalletAddress, InvalidSignature as HostedInvalidSignature, } from "./hosted-errors.js";
 /**
  * Resolve a MarketOutcome shorthand to a plain outcome ID string.
  * Accepts either a raw string ID or a MarketOutcome object.
@@ -136,10 +148,13 @@ export class Exchange {
         "kalshi",
         "opinion",
     ]);
+    // Public so structural interfaces like `HostedClientLike`
+    // (./hosted-routing) can read the venue name and hosted credentials
+    // without violating protected-access on this base class.
     exchangeName;
+    pmxtApiKey;
     apiKey;
     privateKey;
-    pmxtApiKey;
     proxyAddress;
     signatureType;
     api;
@@ -147,6 +162,12 @@ export class Exchange {
     serverManager;
     initPromise;
     isHosted;
+    /** Wallet address used for hosted endpoints that operate on a wallet. */
+    walletAddress;
+    /** External signer used for hosted writes. */
+    signer;
+    /** Escrow namespace — populated in hosted mode for trading-allowlisted venues. */
+    escrow;
     _hostedAccount;
     _accountDiscoveryPromise;
     /**
@@ -166,6 +187,8 @@ export class Exchange {
         this.privateKey = options.privateKey;
         this.proxyAddress = options.proxyAddress;
         this.signatureType = options.signatureType;
+        this.walletAddress = options.walletAddress;
+        this.signer = options.signer;
         // Resolve base URL + hosted API key via the shared precedence
         // rules. See constants.ts for the full resolution table.
         const resolved = resolvePmxtBaseUrl({
@@ -175,6 +198,26 @@ export class Exchange {
         const baseUrl = resolved.baseUrl;
         this.pmxtApiKey = resolved.pmxtApiKey;
         this.isHosted = resolved.isHosted;
+        // Hosted trading bridge: if the caller passed a privateKey but no
+        // explicit signer, lazily wrap it in an EthersSigner so that
+        // `pmxt.Polymarket(pmxtApiKey, privateKey)` just works without the
+        // user touching `signer`. EthersSigner's constructor synchronously
+        // builds an ethers.Wallet, so this remains a synchronous bridge —
+        // the constructor stays sync.
+        if (this.pmxtApiKey && this.privateKey && !this.signer) {
+            try {
+                this.signer = new EthersSigner(this.privateKey);
+            }
+            catch {
+                // ethers not installed — defer the error to the first
+                // hosted write that actually needs the signer. Read-only
+                // hosted callers don't need ethers.
+            }
+        }
+        // Instantiate Escrow namespace for hosted-trading-allowlisted venues.
+        if (this.pmxtApiKey && HOSTED_TRADING_VENUES.has(this.exchangeName)) {
+            this.escrow = new Escrow(this);
+        }
         // auto_start_server defaults: true for local, false for hosted.
         // An explicit value in the options always wins.
         const autoStartServer = options.autoStartServer !== undefined
@@ -255,6 +298,25 @@ export class Exchange {
         }
         return headers;
     }
+    /**
+     * Returns true when this client should dispatch trading methods through
+     * the hosted PMXT trading API (`pmxtApiKey` set AND venue is on the
+     * hosted-trading allowlist). Used to gate every Group A method.
+     */
+    isHostedTradingMode() {
+        return Boolean(this.pmxtApiKey) && HOSTED_TRADING_VENUES.has(this.exchangeName);
+    }
+    /**
+     * Require a configured signer for a hosted write. Returns the signer or
+     * throws {@link MissingWalletAddress} (consistent with the error class
+     * surfaced for missing wallet wiring on hosted writes).
+     */
+    requireHostedSigner() {
+        if (!this.signer) {
+            throw new MissingWalletAddress("hosted write requires a signer (pass `signer` or `privateKey`)");
+        }
+        return this.signer;
+    }
     /**
      * Resolve the current sidecar base URL.
      *
@@ -849,6 +911,9 @@ export class Exchange {
         }
     }
     async submitOrder(built) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedSubmitOrder(built);
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -875,7 +940,80 @@ export class Exchange {
             throw new PmxtError(`Failed to submitOrder: ${error}`);
         }
     }
+    /**
+     * Hosted-mode submitOrder: validate the stored build response, sign the
+     * typed_data (and pull_typed_data for Opinion cross-chain sells), then
+     * POST to `/v0/trade/submit-order`.
+     */
+    async _hostedSubmitOrder(built) {
+        const signer = this.requireHostedSigner();
+        if (!this.walletAddress) {
+            throw new MissingWalletAddress("hosted submitOrder requires walletAddress");
+        }
+        // BuiltOrder is the SDK-side wrapper around the build response —
+        // expect typed_data, optional pull_typed_data, built_order_id, and
+        // the originating build_request to be present.
+        const payload = built;
+        const typedData = payload["typed_data"];
+        if (!typedData) {
+            throw new HostedInvalidSignature(0, "typed_data missing from built order");
+        }
+        const buildRequest = payload["build_request"]
+            ?? payload["params"]?.["build_request"];
+        const side = String(buildRequest?.["side"] ?? "buy");
+        const primaryRoute = this._hostedTypedDataRoute(side, false);
+        // Layer 1: schema, Layer 2: economics.
+        validateTypedData(typedData, primaryRoute, this.walletAddress);
+        if (buildRequest) {
+            validateEconomics(typedData, primaryRoute, buildRequest, payload);
+        }
+        const signature = await signer.signTypedData(typedData);
+        // Layer 3: post-sign recovery + canonical check.
+        verifySignature(typedData, signature, signer.address);
+        const body = {
+            built_order_id: payload["built_order_id"],
+            signature,
+        };
+        const pullTypedData = payload["pull_typed_data"];
+        if (pullTypedData) {
+            const pullRoute = this._hostedTypedDataRoute(side, true);
+            if (pullRoute) {
+                validateTypedData(pullTypedData, pullRoute, this.walletAddress);
+            }
+            const pullSig = await signer.signTypedData(pullTypedData);
+            verifySignature(pullTypedData, pullSig, signer.address);
+            body["pull_signature"] = pullSig;
+        }
+        const route = HOSTED_METHOD_ROUTES.get("submitOrder");
+        const data = await _tradingRequest(this, { method: route.method, path: route.path, body });
+        return orderFromV0(data);
+    }
+    /**
+     * Resolve the per-(venue, side, pull) typed-data schema route used by
+     * `validateTypedData` / `validateEconomics`. Returns undefined for the
+     * pull leg when a venue/side combo doesn't have one.
+     */
+    _hostedTypedDataRoute(side, isPull) {
+        const venue = this.exchangeName;
+        const sideLower = side.toLowerCase();
+        if (venue === "polymarket") {
+            return sideLower === "sell" ? "polymarket_sell" : "polymarket_buy";
+        }
+        // opinion
+        if (sideLower === "buy")
+            return "opinion_buy";
+        // sell — polygon, or BSC pull leg for cross-chain
+        return isPull ? "opinion_sell_bsc_pull" : "opinion_sell_polygon";
+    }
+    _hostedCancelTypedDataRoute(isPull) {
+        if (this.exchangeName === "polymarket")
+            return "cancel_polymarket";
+        return isPull ? "cancel_opinion_bsc_pull" : "cancel_opinion_polygon";
+    }
     async cancelOrder(orderId) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedCancelOrder(orderId);
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -902,7 +1040,47 @@ export class Exchange {
             throw new PmxtError(`Failed to cancelOrder: ${error}`);
         }
     }
+    /**
+     * Hosted-mode cancelOrder: build the cancel typed_data on the server,
+     * validate + sign (dual-sign for Opinion cross-chain), then submit.
+     */
+    async _hostedCancelOrder(orderId) {
+        const signer = this.requireHostedSigner();
+        if (!this.walletAddress) {
+            throw new MissingWalletAddress("hosted cancelOrder requires walletAddress");
+        }
+        const buildRoute = HOSTED_METHOD_ROUTES.get("cancelOrderBuild");
+        const buildResp = await _tradingRequest(this, {
+            method: buildRoute.method,
+            path: buildRoute.path,
+            body: { order_id: orderId },
+        });
+        const typedData = buildResp["typed_data"];
+        if (!typedData) {
+            throw new HostedInvalidSignature(0, "typed_data missing from cancel build response");
+        }
+        validateTypedData(typedData, this._hostedCancelTypedDataRoute(false), this.walletAddress);
+        const signature = await signer.signTypedData(typedData);
+        verifySignature(typedData, signature, signer.address);
+        const body = {
+            cancel_id: buildResp["cancel_id"],
+            signature,
+        };
+        const pullTypedData = buildResp["pull_typed_data"];
+        if (pullTypedData) {
+            validateTypedData(pullTypedData, this._hostedCancelTypedDataRoute(true), this.walletAddress);
+            const pullSig = await signer.signTypedData(pullTypedData);
+            verifySignature(pullTypedData, pullSig, signer.address);
+            body["pull_signature"] = pullSig;
+        }
+        const route = HOSTED_METHOD_ROUTES.get("cancelOrder");
+        const data = await _tradingRequest(this, { method: route.method, path: route.path, body });
+        return orderFromV0(data);
+    }
     async fetchOrder(orderId) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedFetchOrder(orderId);
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -929,7 +1107,16 @@ export class Exchange {
             throw new PmxtError(`Failed to fetchOrder: ${error}`);
         }
     }
+    async _hostedFetchOrder(orderId) {
+        const route = HOSTED_METHOD_ROUTES.get("fetchOrder");
+        const path = formatRoutePath(route, { order_id: orderId });
+        const data = await _tradingRequest(this, { method: route.method, path });
+        return orderFromV0(data);
+    }
     async fetchOpenOrders(marketId) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedFetchOpenOrders(marketId);
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -957,7 +1144,24 @@ export class Exchange {
             throw new PmxtError(`Failed to fetchOpenOrders: ${error}`);
         }
     }
+    async _hostedFetchOpenOrders(marketId) {
+        const address = resolveWalletAddress(this, undefined);
+        const route = HOSTED_METHOD_ROUTES.get("fetchOpenOrders");
+        const params = { address };
+        if (marketId !== undefined)
+            params["market_id"] = marketId;
+        const data = await _tradingRequest(this, {
+            method: route.method,
+            path: route.path,
+            params,
+        });
+        const items = (Array.isArray(data) ? data : data?.["orders"] ?? []);
+        return items.map(orderFromV0);
+    }
     async fetchMyTrades(params) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedFetchMyTrades(params);
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -985,7 +1189,35 @@ export class Exchange {
             throw new PmxtError(`Failed to fetchMyTrades: ${error}`);
         }
     }
+    async _hostedFetchMyTrades(params) {
+        const address = resolveWalletAddress(this, undefined);
+        const route = HOSTED_METHOD_ROUTES.get("fetchMyTrades");
+        const path = formatRoutePath(route, { address });
+        const q = {};
+        if (params?.marketId)
+            q["market_id"] = params.marketId;
+        if (params?.outcomeId)
+            q["outcome_id"] = params.outcomeId;
+        if (params?.limit !== undefined)
+            q["limit"] = String(params.limit);
+        if (params?.cursor)
+            q["cursor"] = params.cursor;
+        if (params?.since)
+            q["since"] = String(params.since.getTime());
+        if (params?.until)
+            q["until"] = String(params.until.getTime());
+        const data = await _tradingRequest(this, {
+            method: route.method,
+            path,
+            params: Object.keys(q).length ? q : undefined,
+        });
+        const items = (Array.isArray(data) ? data : data?.["trades"] ?? []);
+        return items.map(userTradeFromV0);
+    }
     async fetchClosedOrders(params) {
+        if (this.isHostedTradingMode()) {
+            throw new NotSupported("Settled orders are modeled as trades — use fetchMyTrades().");
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -1014,6 +1246,9 @@ export class Exchange {
         }
     }
     async fetchAllOrders(params) {
+        if (this.isHostedTradingMode()) {
+            throw new NotSupported("Use fetchOpenOrders() and fetchMyTrades() separately.");
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -1042,6 +1277,9 @@ export class Exchange {
         }
     }
     async fetchPositions(address) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedFetchPositions(address);
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -1069,7 +1307,18 @@ export class Exchange {
             throw new PmxtError(`Failed to fetchPositions: ${error}`);
         }
     }
+    async _hostedFetchPositions(address) {
+        const resolvedAddr = resolveWalletAddress(this, address);
+        const route = HOSTED_METHOD_ROUTES.get("fetchPositions");
+        const path = formatRoutePath(route, { address: resolvedAddr });
+        const data = await _tradingRequest(this, { method: route.method, path });
+        const items = (Array.isArray(data) ? data : data?.["positions"] ?? []);
+        return items.map(positionFromV0);
+    }
     async fetchBalance(address) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedFetchBalance(address);
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -1097,6 +1346,18 @@ export class Exchange {
             throw new PmxtError(`Failed to fetchBalance: ${error}`);
         }
     }
+    async _hostedFetchBalance(address) {
+        const resolvedAddr = resolveWalletAddress(this, address);
+        const route = HOSTED_METHOD_ROUTES.get("fetchBalance");
+        const path = formatRoutePath(route, { address: resolvedAddr });
+        const data = await _tradingRequest(this, { method: route.method, path });
+        // Hosted balance is a single USDC escrow record; wrap in an array
+        // to match the existing Balance[] return shape.
+        if (Array.isArray(data)) {
+            return data.map(balanceFromV0);
+        }
+        return [balanceFromV0(data)];
+    }
     async unwatchOrderBook(outcomeId) {
         await this.initPromise;
         try {
@@ -1769,6 +2030,9 @@ export class Exchange {
      * ```
      */
     async buildOrder(params) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedBuildOrder(params);
+        }
         if (this.isHosted) {
             throw new PmxtError("Trade execution is not available through the hosted API. " +
                 "Use the local PMXT SDK with your venue credentials instead. " +
@@ -1899,6 +2163,106 @@ export class Exchange {
         }
         return convertOrder(submitData);
     }
+    /**
+     * Hosted-mode buildOrder: validate inputs locally, then POST to the
+     * trading service's `build-order` endpoint and return a BuiltOrder
+     * that carries the original build_request for Layer-2 economic checks
+     * at submit time.
+     */
+    async _hostedBuildOrder(params) {
+        const body = this._hostedBuildOrderBody(params);
+        const route = HOSTED_METHOD_ROUTES.get("buildOrder");
+        const data = await _tradingRequest(this, {
+            method: route.method,
+            path: route.path,
+            body,
+        });
+        // Attach the originating build_request so submit can run economic
+        // validation without an extra catalog round-trip.
+        const built = { ...data, build_request: body };
+        return built;
+    }
+    /**
+     * Hosted-mode createOrder: build → sign → submit single-call wrapper.
+     */
+    async _hostedCreateOrder(params) {
+        const built = await this._hostedBuildOrder(params);
+        return this._hostedSubmitOrder(built);
+    }
+    /**
+     * Construct the hosted build-order request body and validate inputs
+     * locally per the v0 contract (denom/side compatibility, > 6-decimal
+     * precision rejected via {@link to6dec}).
+     */
+    _hostedBuildOrderBody(params) {
+        let marketId = params.marketId;
+        let outcomeId = params.outcomeId;
+        if (params.outcome) {
+            if (marketId !== undefined || outcomeId !== undefined) {
+                throw new InvalidOrder("cannot specify both 'outcome' and 'marketId'/'outcomeId'");
+            }
+            const outcome = params.outcome;
+            if (!outcome.marketId) {
+                throw new InvalidOrder("outcome.marketId is not set; ensure the outcome comes from a fetched market");
+            }
+            marketId = outcome.marketId;
+            outcomeId = outcome.outcomeId;
+        }
+        const side = String(params.side);
+        const orderType = String(params.type ?? "market");
+        const denom = params["denom"];
+        // denom/side compatibility per v0:
+        //   market buy  -> denom='usdc'
+        //   market sell -> denom='shares'
+        //   any limit   -> denom='shares'
+        let resolvedDenom;
+        if (orderType === "market") {
+            if (side === "buy") {
+                if (denom && denom !== "usdc") {
+                    throw new InvalidOrder("market buy requires denom='usdc'");
+                }
+                resolvedDenom = "usdc";
+            }
+            else if (side === "sell") {
+                if (denom && denom !== "shares") {
+                    throw new InvalidOrder("market sell requires denom='shares'");
+                }
+                resolvedDenom = "shares";
+            }
+            else {
+                throw new InvalidOrder(`unknown side: ${side}`);
+            }
+        }
+        else {
+            if (denom && denom !== "shares") {
+                throw new InvalidOrder("limit orders require denom='shares'");
+            }
+            resolvedDenom = "shares";
+        }
+        if (!(Number(params.amount) > 0)) {
+            throw new InvalidOrder("amount must be positive");
+        }
+        // to6dec throws InvalidOrder for sub-micro precision.
+        const amount6dec = to6dec(params.amount).toString();
+        const body = {
+            market_id: marketId,
+            outcome_id: outcomeId,
+            side,
+            order_type: orderType,
+            denom: resolvedDenom,
+            amount: params.amount,
+            amount_6dec: amount6dec,
+        };
+        if (params.price !== undefined)
+            body["price"] = params.price;
+        const extra = params;
+        if (extra["slippage_pct"] !== undefined) {
+            body["slippage_pct"] = extra["slippage_pct"];
+        }
+        if (this.walletAddress)
+            body["user_address"] = this.walletAddress;
+        return body;
+    }
     /**
      * @example
      * ```typescript
@@ -1913,10 +2277,15 @@ export class Exchange {
      * ```
      */
     async createOrder(params) {
+        // SOR escape path (preserved): legacy hosted SOR flow uses a venue-side
+        // SDK to execute the legs, only when a privateKey is present.
+        if (this.isHosted && this.exchangeName === 'sor' && this.privateKey) {
+            return this._executeSorOrder(params);
+        }
+        if (this.isHostedTradingMode()) {
+            return this._hostedCreateOrder(params);
+        }
         if (this.isHosted) {
-            if (this.exchangeName === 'sor' && this.privateKey) {
-                return this._executeSorOrder(params);
-            }
             throw new PmxtError("Trade execution is not available through the hosted API. " +
                 "Use the local PMXT SDK with your venue credentials instead. " +
                 "See https://pmxt.dev/docs/quickstart for setup instructions.");
@@ -2548,15 +2917,40 @@ export class Hyperliquid extends Exchange {
 /**
  * SuiBets exchange client.
  *
+ * SuiBets is a decentralised P2P sports betting exchange on Sui mainnet.
+ * No house edge. 2% platform fee.
+ * Contract: 0xd51fe151bec66a15b086a67c1cfce9b05759ddac1d73fcd3e14324ad202b2e59
+ *
  * @example
  * ```typescript
  * const suibets = new SuiBets();
- * const markets = await suibets.fetchMarkets();
+ * const markets = await suibets.fetchMarkets({ limit: 20 });
+ *
+ * // With wallet for fetchPositions()
+ * const me = new SuiBets({ walletAddress: '0xabc...' });
+ * const positions = await me.fetchPositions();
  * ```
  */
 export class SuiBets extends Exchange {
+    _walletAddress;
     constructor(options = {}) {
         super("suibets", options);
+        this._walletAddress = options.walletAddress;
+    }
+    /**
+     * Includes walletAddress in the credentials sent to the sidecar so
+     * that fetchPositions() can reach the /api/p2p/my endpoint.
+     * Falls back to SUIBETS_WALLET_ADDRESS env var on the sidecar side
+     * when walletAddress is not set here.
+     */
+    getCredentials() {
+        const base = super.getCredentials();
+        if (!this._walletAddress)
+            return base;
+        return {
+            ...(base ?? {}),
+            walletAddress: this._walletAddress,
+        };
     }
 }
 /**

package/dist/esm/pmxt/constants.d.ts

@@ -51,3 +51,14 @@ export declare function resolvePmxtBaseUrl(args: {
     pmxtApiKey?: string;
     isHosted: boolean;
 };
+/**
+ * Lowercase 0x-prefixed escrow addresses that are pre-funded by pmxt for
+ * hosted trading. Orders routed through these addresses use the shared
+ * escrow balance rather than a per-venue deposit.
+ */
+export declare const PREFUNDED_ESCROW_ADDRESSES: ReadonlySet<string>;
+/**
+ * Lowercase 0x-prefixed escrow addresses that the hosted trading API treats
+ * as venue-owned escrows. Currently empty; populated as venues onboard.
+ */
+export declare const VENUE_ESCROW_ADDRESSES: ReadonlySet<string>;

package/dist/esm/pmxt/constants.js

@@ -58,3 +58,16 @@ export function resolvePmxtBaseUrl(args) {
         return pick(HOSTED_URL);
     return pick(LOCAL_URL);
 }
+/**
+ * Lowercase 0x-prefixed escrow addresses that are pre-funded by pmxt for
+ * hosted trading. Orders routed through these addresses use the shared
+ * escrow balance rather than a per-venue deposit.
+ */
+export const PREFUNDED_ESCROW_ADDRESSES = new Set([
+    "0x3ad326f78b1390b9a5dc5f00e7f62f8632de23e2",
+]);
+/**
+ * Lowercase 0x-prefixed escrow addresses that the hosted trading API treats
+ * as venue-owned escrows. Currently empty; populated as venues onboard.
+ */
+export const VENUE_ESCROW_ADDRESSES = new Set();

package/dist/esm/pmxt/errors.d.ts

@@ -51,5 +51,8 @@ export declare class NetworkError extends PmxtError {
 export declare class ExchangeNotAvailable extends PmxtError {
     constructor(message: string, exchange?: string);
 }
+export declare class NotSupported extends PmxtError {
+    constructor(message: string, exchange?: string);
+}
 /** Convert a server error response object into a typed PmxtError. */
 export declare function fromServerError(errorData: unknown): PmxtError;

package/dist/esm/pmxt/errors.js

@@ -90,6 +90,11 @@ export class ExchangeNotAvailable extends PmxtError {
         super(message, "EXCHANGE_NOT_AVAILABLE", true, exchange);
     }
 }
+export class NotSupported extends PmxtError {
+    constructor(message, exchange) {
+        super(message, "NOT_SUPPORTED", false, exchange);
+    }
+}
 // Error code to class mapping
 const ERROR_CODE_MAP = {
     BAD_REQUEST: BadRequest,
@@ -130,3 +135,7 @@ export function fromServerError(errorData) {
     }
     return new PmxtError(message, code, retryable, exchange);
 }
+// Hosted error classes live in ./hosted-errors. Re-exported from index.ts
+// at the package root, NOT here — re-exporting from errors.ts creates a
+// circular dependency (hosted-errors imports PmxtError from errors.ts)
+// that crashes tsx/CJS module loaders even though tsc and ts-jest tolerate it.

package/dist/esm/pmxt/escrow.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Hosted-mode escrow namespace.
+ *
+ * Exposes the `/v0/escrow/*` endpoints of the pmxt hosted trading API as a
+ * small ergonomic helper class. Each method returns the raw upstream JSON
+ * payload as `unknown` — typed mappers can be layered on later without
+ * breaking the wire shape.
+ *
+ * Mirrors `sdks/python/pmxt/escrow.py`.
+ */
+import { HostedClientLike } from "./hosted-routing.js";
+export declare class Escrow {
+    private readonly client;
+    constructor(client: HostedClientLike);
+    /**
+     * Build an unsigned approve transaction for a given ERC-20 `token`. When
+     * `amountWei` is omitted, the server returns an unlimited approval.
+     */
+    approveTx(token: string, amountWei?: bigint): Promise<unknown>;
+    /**
+     * Build an unsigned deposit transaction for `amount` (USDC, 6-decimal
+     * grid). Accepts number, decimal string, or BigInt in micro-units.
+     */
+    depositTx(amount: number | string | bigint): Promise<unknown>;
+    /**
+     * Build an unsigned withdraw transaction. `action` selects the stage of
+     * the withdrawal lifecycle: `request` initiates, `claim` finalizes after
+     * the timelock, `cancel` aborts a pending request.
+     */
+    withdrawTx(action: "request" | "claim" | "cancel", amount?: number | string | bigint): Promise<unknown>;
+    /**
+     * List the user's withdrawal records. `include` is forwarded verbatim and
+     * defaults to `"pending,events"` to match the Python SDK.
+     */
+    withdrawals(opts?: {
+        include?: string;
+        address?: string;
+    }): Promise<unknown>;
+}