pmxtjs 2.48.6 → 2.49.0

package/dist/esm/pmxt/server-manager.d.ts

@@ -36,6 +36,10 @@ export declare class ServerManager {
      * Check if the server is running.
      */
     isServerRunning(): Promise<boolean>;
+    /**
+     * Backwards-compatible alias for `isServerRunning()`.
+     */
+    isServerAlive(): Promise<boolean>;
     /**
      * Wait for the server to be ready.
      * Requires a lock file to be present to avoid falsely matching an unrelated

package/dist/esm/pmxt/server-manager.js

@@ -98,6 +98,12 @@ export class ServerManager {
             return false;
         }
     }
+    /**
+     * Backwards-compatible alias for `isServerRunning()`.
+     */
+    async isServerAlive() {
+        return this.isServerRunning();
+    }
     /**
      * Wait for the server to be ready.
      * Requires a lock file to be present to avoid falsely matching an unrelated

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

@@ -0,0 +1,57 @@
+/**
+ * Signer helpers for hosted PMXT trading.
+ *
+ * `ethers` is an optional peer dependency — read-only SDK users do not need it
+ * installed. Hosted-mode signing imports it lazily via `require()` and throws
+ * a clear install hint when it's missing.
+ *
+ * Mirrors `sdks/python/pmxt/signers.py`.
+ */
+/**
+ * EIP-712 typed data payload as accepted by ethers v6 / Web3 wallets.
+ * `EIP712Domain` is allowed inside `types` (and is the standard) but ethers
+ * strips it before signing — see {@link EthersSigner.signTypedData}.
+ */
+export interface TypedData {
+    types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>;
+    primaryType: string;
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: string;
+    };
+    message: Record<string, unknown>;
+}
+/**
+ * Pluggable signer abstraction. Implement this to integrate hardware wallets
+ * or remote signing services. {@link EthersSigner} is the built-in
+ * private-key implementation.
+ */
+export interface Signer {
+    readonly address: string;
+    signTypedData(typedData: TypedData): Promise<string>;
+}
+/**
+ * Built-in signer backed by an ethers `Wallet`.
+ *
+ * `ethers` is imported lazily — a clear, install-hint-bearing error is thrown
+ * if the peer dependency is missing.
+ */
+export declare class EthersSigner implements Signer {
+    private readonly _wallet;
+    readonly address: string;
+    constructor(privateKey: string);
+    signTypedData(typedData: TypedData): Promise<string>;
+}
+/**
+ * Convenience factory: build a {@link Signer} from a raw private key.
+ *
+ * Currently always returns an {@link EthersSigner}. Async for forward
+ * compatibility with key-loaders that may need to await (e.g. keystore
+ * decryption).
+ */
+export declare function signerFromPrivateKey(privateKey: string): Promise<Signer>;

package/dist/esm/pmxt/signers.js

@@ -0,0 +1,50 @@
+/**
+ * Signer helpers for hosted PMXT trading.
+ *
+ * `ethers` is an optional peer dependency — read-only SDK users do not need it
+ * installed. Hosted-mode signing imports it lazily via `require()` and throws
+ * a clear install hint when it's missing.
+ *
+ * Mirrors `sdks/python/pmxt/signers.py`.
+ */
+const ETHERS_INSTALL_HINT = "hosted trading requires the optional 'ethers' peer dependency. Install with: npm install ethers";
+/**
+ * Built-in signer backed by an ethers `Wallet`.
+ *
+ * `ethers` is imported lazily — a clear, install-hint-bearing error is thrown
+ * if the peer dependency is missing.
+ */
+export class EthersSigner {
+    _wallet; // ethers.Wallet
+    address;
+    constructor(privateKey) {
+        let ethers;
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            ethers = require("ethers");
+        }
+        catch {
+            throw new Error(ETHERS_INSTALL_HINT);
+        }
+        this._wallet = new ethers.Wallet(privateKey);
+        this.address = this._wallet.address;
+    }
+    async signTypedData(typedData) {
+        // ethers expects `types` WITHOUT the EIP712Domain entry — it derives
+        // the domain hash from the `domain` argument.
+        const types = { ...typedData.types };
+        delete types["EIP712Domain"];
+        const sig = await this._wallet.signTypedData(typedData.domain, types, typedData.message);
+        return sig.startsWith("0x") ? sig : "0x" + sig;
+    }
+}
+/**
+ * Convenience factory: build a {@link Signer} from a raw private key.
+ *
+ * Currently always returns an {@link EthersSigner}. Async for forward
+ * compatibility with key-loaders that may need to await (e.g. keystore
+ * decryption).
+ */
+export async function signerFromPrivateKey(privateKey) {
+    return new EthersSigner(privateKey);
+}

package/dist/esm/pmxt/ws-client.js

@@ -7,6 +7,7 @@
  * does not support the /ws endpoint.
  */
 import { PmxtError } from "./errors.js";
+import { logger } from "./logger.js";
 const MAX_QUEUED_MESSAGES_PER_SUBSCRIPTION = 100_000;
 /**
  * Multiplexed WebSocket client for the pmxt sidecar.
@@ -117,7 +118,7 @@ export class SidecarWsClient {
                 }
                 catch (err) {
                     // Dispatch bug -- log and continue; don't kill the connection.
-                    console.error('[SidecarWsClient] dispatch error:', err);
+                    logger.error('[SidecarWsClient] dispatch error:', { err });
                 }
             };
         });

package/dist/generated/src/models/OrderLevel.d.ts

@@ -27,6 +27,12 @@ export interface OrderLevel {
      * @memberof OrderLevel
      */
     size: number;
+    /**
+     *
+     * @type {number}
+     * @memberof OrderLevel
+     */
+    orderCount?: number;
 }
 /**
  * Check if a given object implements the OrderLevel interface.

package/dist/generated/src/models/OrderLevel.js

@@ -38,6 +38,7 @@ function OrderLevelFromJSONTyped(json, ignoreDiscriminator) {
     return {
         'price': json['price'],
         'size': json['size'],
+        'orderCount': json['orderCount'] == null ? undefined : json['orderCount'],
     };
 }
 function OrderLevelToJSON(json) {
@@ -50,5 +51,6 @@ function OrderLevelToJSONTyped(value, ignoreDiscriminator = false) {
     return {
         'price': value['price'],
         'size': value['size'],
+        'orderCount': value['orderCount'],
     };
 }

package/dist/index.d.ts

@@ -33,6 +33,7 @@ export { MarketList } from "./pmxt/models.js";
 export type { UnifiedSeries } from "./pmxt/models.js";
 export type * from "./pmxt/models.js";
 export * from "./pmxt/errors.js";
+export * from "./pmxt/hosted-errors.js";
 declare function stopServer(): Promise<void>;
 declare function restartServer(): Promise<void>;
 /**
@@ -77,6 +78,7 @@ declare const pmxt: {
     ValidationError: typeof errors.ValidationError;
     NetworkError: typeof errors.NetworkError;
     ExchangeNotAvailable: typeof errors.ExchangeNotAvailable;
+    NotSupported: typeof errors.NotSupported;
     MarketList: typeof models.MarketList;
     Exchange: typeof Exchange;
     Polymarket: typeof Polymarket;

package/dist/index.js

@@ -93,6 +93,7 @@ Object.defineProperty(exports, "resolvePmxtBaseUrl", { enumerable: true, get: fu
 var models_js_1 = require("./pmxt/models.js");
 Object.defineProperty(exports, "MarketList", { enumerable: true, get: function () { return models_js_1.MarketList; } });
 __exportStar(require("./pmxt/errors.js"), exports);
+__exportStar(require("./pmxt/hosted-errors.js"), exports);
 const defaultManager = new server_manager_js_1.ServerManager();
 // Flat aliases for the namespaced server commands. Kept as permanent,
 // fully-supported shorthand — `pmxt.server.stop()` and `pmxt.stopServer()`

package/dist/pmxt/client.d.ts

@@ -7,6 +7,8 @@
 import { Configuration, DefaultApi, ExchangeCredentials } from "../generated/src/index.js";
 import { Balance, BuiltOrder, CreateOrderParams, EventFetchParams, EventFilterCriteria, EventFilterFunction, ExecutionPriceResult, FetchOrderBookParams, MarketFetchParams, MarketFilterCriteria, MarketFilterFunction, MarketOutcome, MyTradesParams, Order, OrderBook, OrderHistoryParams, PaginatedMarketsResult, Position, SeriesFetchParams, PriceCandle, SubscribedAddressSnapshot, SubscriptionOption, Trade, UnifiedEvent, UnifiedMarket, UnifiedSeries, UserTrade, FirehoseEvent } from "./models.js";
 import { ServerManager } from "./server-manager.js";
+import type { Signer } from "./signers.js";
+import { Escrow } from "./escrow.js";
 /**
  * Base exchange client options.
  */
@@ -49,6 +51,18 @@ export interface ExchangeOptions {
     proxyAddress?: string;
     /** Optional signature type (0=EOA, 1=Proxy) */
     signatureType?: number;
+    /**
+     * EVM wallet address used for hosted reads/writes. Required for hosted
+     * endpoints that operate on a wallet (balances, positions, trades, open
+     * orders). When omitted, hosted reads raise {@link MissingWalletAddress}.
+     */
+    walletAddress?: string;
+    /**
+     * External signer used for hosted writes. When `privateKey` is supplied
+     * without `signer` in hosted mode, an internal {@link EthersSigner} is
+     * built from it lazily.
+     */
+    signer?: Signer;
 }
 /**
  * Base class for prediction market exchanges.
@@ -58,10 +72,10 @@ export interface ExchangeOptions {
  */
 export declare abstract class Exchange {
     private static readonly OBDATA_WATCH_ALL_SOURCES;
-    protected exchangeName: string;
+    exchangeName: string;
+    pmxtApiKey?: string;
     protected apiKey?: string;
     protected privateKey?: string;
-    protected pmxtApiKey?: string;
     protected proxyAddress?: string;
     protected signatureType?: number;
     protected api: DefaultApi;
@@ -69,6 +83,12 @@ export declare abstract class Exchange {
     protected serverManager: ServerManager;
     protected initPromise: Promise<void>;
     protected isHosted: boolean;
+    /** Wallet address used for hosted endpoints that operate on a wallet. */
+    walletAddress?: string;
+    /** External signer used for hosted writes. */
+    signer?: Signer;
+    /** Escrow namespace — populated in hosted mode for trading-allowlisted venues. */
+    escrow?: Escrow;
     private _hostedAccount?;
     private _accountDiscoveryPromise?;
     /**
@@ -87,6 +107,18 @@ export declare abstract class Exchange {
     protected handleResponse(response: any): any;
     protected getCredentials(): ExchangeCredentials | undefined;
     protected getAuthHeaders(): Record<string, string>;
+    /**
+     * 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.
+     */
+    protected isHostedTradingMode(): boolean;
+    /**
+     * 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).
+     */
+    protected requireHostedSigner(): Signer;
     /**
      * Resolve the current sidecar base URL.
      *
@@ -184,14 +216,37 @@ export declare abstract class Exchange {
     fetchOrderBook(outcomeId: string | MarketOutcome, limit?: number, params?: FetchOrderBookParams): Promise<OrderBook | OrderBook[]>;
     fetchOrderBooks(outcomeIds: (string | MarketOutcome)[]): Promise<Record<string, OrderBook>>;
     submitOrder(built: BuiltOrder): Promise<Order>;
+    /**
+     * 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`.
+     */
+    private _hostedSubmitOrder;
+    /**
+     * 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.
+     */
+    private _hostedTypedDataRoute;
+    private _hostedCancelTypedDataRoute;
     cancelOrder(orderId: string): Promise<Order>;
+    /**
+     * Hosted-mode cancelOrder: build the cancel typed_data on the server,
+     * validate + sign (dual-sign for Opinion cross-chain), then submit.
+     */
+    private _hostedCancelOrder;
     fetchOrder(orderId: string): Promise<Order>;
+    private _hostedFetchOrder;
     fetchOpenOrders(marketId?: string): Promise<Order[]>;
+    private _hostedFetchOpenOrders;
     fetchMyTrades(params?: MyTradesParams): Promise<UserTrade[]>;
+    private _hostedFetchMyTrades;
     fetchClosedOrders(params?: OrderHistoryParams): Promise<Order[]>;
     fetchAllOrders(params?: OrderHistoryParams): Promise<Order[]>;
     fetchPositions(address?: string): Promise<Position[]>;
+    private _hostedFetchPositions;
     fetchBalance(address?: string): Promise<Balance[]>;
+    private _hostedFetchBalance;
     unwatchOrderBook(outcomeId: string | MarketOutcome): Promise<void>;
     unwatchAddress(address: string): Promise<void>;
     close(): Promise<void>;
@@ -388,6 +443,23 @@ export declare abstract class Exchange {
     }): Promise<BuiltOrder>;
     private _discoverHostedAccount;
     private _executeSorOrder;
+    /**
+     * 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.
+     */
+    private _hostedBuildOrder;
+    /**
+     * Hosted-mode createOrder: build → sign → submit single-call wrapper.
+     */
+    private _hostedCreateOrder;
+    /**
+     * 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}).
+     */
+    private _hostedBuildOrderBody;
     /**
      * @example
      * ```typescript
@@ -401,7 +473,9 @@ export declare abstract class Exchange {
      * });
      * ```
      */
-    createOrder(params: any): Promise<Order>;
+    createOrder(params: CreateOrderParams & {
+        outcome?: MarketOutcome;
+    }): Promise<Order>;
     /**
      * Calculate the average execution price for a given amount by walking the order book.
      * Uses the sidecar server for calculation to ensure consistency.
@@ -721,17 +795,44 @@ export declare class GeminiTitan extends Exchange {
 export declare class Hyperliquid extends Exchange {
     constructor(options?: ExchangeOptions);
 }
+/**
+ * Options for the SuiBets exchange client.
+ */
+export interface SuiBetsOptions extends ExchangeOptions {
+    /**
+     * Sui wallet address (0x + 64 hex chars).
+     * Required for fetchPositions(). Can also be set via the
+     * SUIBETS_WALLET_ADDRESS environment variable on the sidecar.
+     */
+    walletAddress?: string;
+}
 /**
  * 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 declare class SuiBets extends Exchange {
-    constructor(options?: ExchangeOptions);
+    private readonly _walletAddress?;
+    constructor(options?: SuiBetsOptions);
+    /**
+     * 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.
+     */
+    protected getCredentials(): ExchangeCredentials | undefined;
 }
 /**
  * Mock exchange client.