pmxtjs 2.48.6 → 2.49.0

package/dist/pmxt/client.js

@@ -13,6 +13,18 @@ const server_manager_js_1 = require("./server-manager.js");
 const errors_js_1 = require("./errors.js");
 const constants_js_1 = require("./constants.js");
 const ws_client_js_1 = require("./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.
+const hosted_routing_js_1 = require("./hosted-routing.js");
+const hosted_mappers_js_1 = require("./hosted-mappers.js");
+const hosted_typed_data_js_1 = require("./hosted-typed-data.js");
+const signers_js_1 = require("./signers.js");
+const escrow_js_1 = require("./escrow.js");
+const hosted_errors_js_1 = require("./hosted-errors.js");
 /**
  * Resolve a MarketOutcome shorthand to a plain outcome ID string.
  * Accepts either a raw string ID or a MarketOutcome object.
@@ -139,10 +151,13 @@ 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;
@@ -150,6 +165,12 @@ 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;
     /**
@@ -169,6 +190,8 @@ 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 = (0, constants_js_1.resolvePmxtBaseUrl)({
@@ -178,6 +201,26 @@ 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 signers_js_1.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_routing_js_1.HOSTED_TRADING_VENUES.has(this.exchangeName)) {
+            this.escrow = new escrow_js_1.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
@@ -258,6 +301,25 @@ 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_routing_js_1.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 hosted_errors_js_1.MissingWalletAddress("hosted write requires a signer (pass `signer` or `privateKey`)");
+        }
+        return this.signer;
+    }
     /**
      * Resolve the current sidecar base URL.
      *
@@ -852,6 +914,9 @@ class Exchange {
         }
     }
     async submitOrder(built) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedSubmitOrder(built);
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -878,7 +943,80 @@ class Exchange {
             throw new errors_js_1.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 hosted_errors_js_1.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 hosted_errors_js_1.InvalidSignature(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.
+        (0, hosted_typed_data_js_1.validateTypedData)(typedData, primaryRoute, this.walletAddress);
+        if (buildRequest) {
+            (0, hosted_typed_data_js_1.validateEconomics)(typedData, primaryRoute, buildRequest, payload);
+        }
+        const signature = await signer.signTypedData(typedData);
+        // Layer 3: post-sign recovery + canonical check.
+        (0, hosted_typed_data_js_1.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) {
+                (0, hosted_typed_data_js_1.validateTypedData)(pullTypedData, pullRoute, this.walletAddress);
+            }
+            const pullSig = await signer.signTypedData(pullTypedData);
+            (0, hosted_typed_data_js_1.verifySignature)(pullTypedData, pullSig, signer.address);
+            body["pull_signature"] = pullSig;
+        }
+        const route = hosted_routing_js_1.HOSTED_METHOD_ROUTES.get("submitOrder");
+        const data = await (0, hosted_routing_js_1._tradingRequest)(this, { method: route.method, path: route.path, body });
+        return (0, hosted_mappers_js_1.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 = [];
@@ -905,7 +1043,47 @@ class Exchange {
             throw new errors_js_1.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 hosted_errors_js_1.MissingWalletAddress("hosted cancelOrder requires walletAddress");
+        }
+        const buildRoute = hosted_routing_js_1.HOSTED_METHOD_ROUTES.get("cancelOrderBuild");
+        const buildResp = await (0, hosted_routing_js_1._tradingRequest)(this, {
+            method: buildRoute.method,
+            path: buildRoute.path,
+            body: { order_id: orderId },
+        });
+        const typedData = buildResp["typed_data"];
+        if (!typedData) {
+            throw new hosted_errors_js_1.InvalidSignature(0, "typed_data missing from cancel build response");
+        }
+        (0, hosted_typed_data_js_1.validateTypedData)(typedData, this._hostedCancelTypedDataRoute(false), this.walletAddress);
+        const signature = await signer.signTypedData(typedData);
+        (0, hosted_typed_data_js_1.verifySignature)(typedData, signature, signer.address);
+        const body = {
+            cancel_id: buildResp["cancel_id"],
+            signature,
+        };
+        const pullTypedData = buildResp["pull_typed_data"];
+        if (pullTypedData) {
+            (0, hosted_typed_data_js_1.validateTypedData)(pullTypedData, this._hostedCancelTypedDataRoute(true), this.walletAddress);
+            const pullSig = await signer.signTypedData(pullTypedData);
+            (0, hosted_typed_data_js_1.verifySignature)(pullTypedData, pullSig, signer.address);
+            body["pull_signature"] = pullSig;
+        }
+        const route = hosted_routing_js_1.HOSTED_METHOD_ROUTES.get("cancelOrder");
+        const data = await (0, hosted_routing_js_1._tradingRequest)(this, { method: route.method, path: route.path, body });
+        return (0, hosted_mappers_js_1.orderFromV0)(data);
+    }
     async fetchOrder(orderId) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedFetchOrder(orderId);
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -932,7 +1110,16 @@ class Exchange {
             throw new errors_js_1.PmxtError(`Failed to fetchOrder: ${error}`);
         }
     }
+    async _hostedFetchOrder(orderId) {
+        const route = hosted_routing_js_1.HOSTED_METHOD_ROUTES.get("fetchOrder");
+        const path = (0, hosted_routing_js_1.formatRoutePath)(route, { order_id: orderId });
+        const data = await (0, hosted_routing_js_1._tradingRequest)(this, { method: route.method, path });
+        return (0, hosted_mappers_js_1.orderFromV0)(data);
+    }
     async fetchOpenOrders(marketId) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedFetchOpenOrders(marketId);
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -960,7 +1147,24 @@ class Exchange {
             throw new errors_js_1.PmxtError(`Failed to fetchOpenOrders: ${error}`);
         }
     }
+    async _hostedFetchOpenOrders(marketId) {
+        const address = (0, hosted_routing_js_1.resolveWalletAddress)(this, undefined);
+        const route = hosted_routing_js_1.HOSTED_METHOD_ROUTES.get("fetchOpenOrders");
+        const params = { address };
+        if (marketId !== undefined)
+            params["market_id"] = marketId;
+        const data = await (0, hosted_routing_js_1._tradingRequest)(this, {
+            method: route.method,
+            path: route.path,
+            params,
+        });
+        const items = (Array.isArray(data) ? data : data?.["orders"] ?? []);
+        return items.map(hosted_mappers_js_1.orderFromV0);
+    }
     async fetchMyTrades(params) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedFetchMyTrades(params);
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -988,7 +1192,35 @@ class Exchange {
             throw new errors_js_1.PmxtError(`Failed to fetchMyTrades: ${error}`);
         }
     }
+    async _hostedFetchMyTrades(params) {
+        const address = (0, hosted_routing_js_1.resolveWalletAddress)(this, undefined);
+        const route = hosted_routing_js_1.HOSTED_METHOD_ROUTES.get("fetchMyTrades");
+        const path = (0, hosted_routing_js_1.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 (0, hosted_routing_js_1._tradingRequest)(this, {
+            method: route.method,
+            path,
+            params: Object.keys(q).length ? q : undefined,
+        });
+        const items = (Array.isArray(data) ? data : data?.["trades"] ?? []);
+        return items.map(hosted_mappers_js_1.userTradeFromV0);
+    }
     async fetchClosedOrders(params) {
+        if (this.isHostedTradingMode()) {
+            throw new errors_js_1.NotSupported("Settled orders are modeled as trades — use fetchMyTrades().");
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -1017,6 +1249,9 @@ class Exchange {
         }
     }
     async fetchAllOrders(params) {
+        if (this.isHostedTradingMode()) {
+            throw new errors_js_1.NotSupported("Use fetchOpenOrders() and fetchMyTrades() separately.");
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -1045,6 +1280,9 @@ class Exchange {
         }
     }
     async fetchPositions(address) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedFetchPositions(address);
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -1072,7 +1310,18 @@ class Exchange {
             throw new errors_js_1.PmxtError(`Failed to fetchPositions: ${error}`);
         }
     }
+    async _hostedFetchPositions(address) {
+        const resolvedAddr = (0, hosted_routing_js_1.resolveWalletAddress)(this, address);
+        const route = hosted_routing_js_1.HOSTED_METHOD_ROUTES.get("fetchPositions");
+        const path = (0, hosted_routing_js_1.formatRoutePath)(route, { address: resolvedAddr });
+        const data = await (0, hosted_routing_js_1._tradingRequest)(this, { method: route.method, path });
+        const items = (Array.isArray(data) ? data : data?.["positions"] ?? []);
+        return items.map(hosted_mappers_js_1.positionFromV0);
+    }
     async fetchBalance(address) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedFetchBalance(address);
+        }
         await this.initPromise;
         try {
             const args = [];
@@ -1100,6 +1349,18 @@ class Exchange {
             throw new errors_js_1.PmxtError(`Failed to fetchBalance: ${error}`);
         }
     }
+    async _hostedFetchBalance(address) {
+        const resolvedAddr = (0, hosted_routing_js_1.resolveWalletAddress)(this, address);
+        const route = hosted_routing_js_1.HOSTED_METHOD_ROUTES.get("fetchBalance");
+        const path = (0, hosted_routing_js_1.formatRoutePath)(route, { address: resolvedAddr });
+        const data = await (0, hosted_routing_js_1._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(hosted_mappers_js_1.balanceFromV0);
+        }
+        return [(0, hosted_mappers_js_1.balanceFromV0)(data)];
+    }
     async unwatchOrderBook(outcomeId) {
         await this.initPromise;
         try {
@@ -1772,6 +2033,9 @@ class Exchange {
      * ```
      */
     async buildOrder(params) {
+        if (this.isHostedTradingMode()) {
+            return this._hostedBuildOrder(params);
+        }
         if (this.isHosted) {
             throw new errors_js_1.PmxtError("Trade execution is not available through the hosted API. " +
                 "Use the local PMXT SDK with your venue credentials instead. " +
@@ -1902,6 +2166,106 @@ 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_routing_js_1.HOSTED_METHOD_ROUTES.get("buildOrder");
+        const data = await (0, hosted_routing_js_1._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 errors_js_1.InvalidOrder("cannot specify both 'outcome' and 'marketId'/'outcomeId'");
+            }
+            const outcome = params.outcome;
+            if (!outcome.marketId) {
+                throw new errors_js_1.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 errors_js_1.InvalidOrder("market buy requires denom='usdc'");
+                }
+                resolvedDenom = "usdc";
+            }
+            else if (side === "sell") {
+                if (denom && denom !== "shares") {
+                    throw new errors_js_1.InvalidOrder("market sell requires denom='shares'");
+                }
+                resolvedDenom = "shares";
+            }
+            else {
+                throw new errors_js_1.InvalidOrder(`unknown side: ${side}`);
+            }
+        }
+        else {
+            if (denom && denom !== "shares") {
+                throw new errors_js_1.InvalidOrder("limit orders require denom='shares'");
+            }
+            resolvedDenom = "shares";
+        }
+        if (!(Number(params.amount) > 0)) {
+            throw new errors_js_1.InvalidOrder("amount must be positive");
+        }
+        // to6dec throws InvalidOrder for sub-micro precision.
+        const amount6dec = (0, hosted_mappers_js_1.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
@@ -1916,10 +2280,15 @@ 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 errors_js_1.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.");
@@ -2565,15 +2934,40 @@ exports.Hyperliquid = Hyperliquid;
 /**
  * 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();
  * ```
  */
 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,
+        };
     }
 }
 exports.SuiBets = SuiBets;

package/dist/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/pmxt/constants.js

@@ -6,7 +6,7 @@
  * can be imported from any module without creating import cycles.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ENV = exports.LOCAL_URL = exports.HOSTED_URL = void 0;
+exports.VENUE_ESCROW_ADDRESSES = exports.PREFUNDED_ESCROW_ADDRESSES = exports.ENV = exports.LOCAL_URL = exports.HOSTED_URL = void 0;
 exports.resolvePmxtBaseUrl = resolvePmxtBaseUrl;
 /**
  * The hosted pmxt production endpoint.
@@ -62,3 +62,16 @@ function resolvePmxtBaseUrl(args) {
         return pick(exports.HOSTED_URL);
     return pick(exports.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.
+ */
+exports.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.
+ */
+exports.VENUE_ESCROW_ADDRESSES = new Set();

package/dist/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/pmxt/errors.js

@@ -6,7 +6,7 @@
  * enabling users to catch specific error types.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExchangeNotAvailable = exports.NetworkError = exports.ValidationError = exports.InsufficientFunds = exports.InvalidOrder = exports.RateLimitExceeded = exports.EventNotFound = exports.MarketNotFound = exports.OrderNotFound = exports.NotFoundError = exports.PermissionDenied = exports.AuthenticationError = exports.BadRequest = exports.PmxtError = void 0;
+exports.NotSupported = exports.ExchangeNotAvailable = exports.NetworkError = exports.ValidationError = exports.InsufficientFunds = exports.InvalidOrder = exports.RateLimitExceeded = exports.EventNotFound = exports.MarketNotFound = exports.OrderNotFound = exports.NotFoundError = exports.PermissionDenied = exports.AuthenticationError = exports.BadRequest = exports.PmxtError = void 0;
 exports.fromServerError = fromServerError;
 class PmxtError extends Error {
     code;
@@ -108,6 +108,12 @@ class ExchangeNotAvailable extends PmxtError {
     }
 }
 exports.ExchangeNotAvailable = ExchangeNotAvailable;
+class NotSupported extends PmxtError {
+    constructor(message, exchange) {
+        super(message, "NOT_SUPPORTED", false, exchange);
+    }
+}
+exports.NotSupported = NotSupported;
 // Error code to class mapping
 const ERROR_CODE_MAP = {
     BAD_REQUEST: BadRequest,
@@ -148,3 +154,7 @@ 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/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";
+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>;
+}