pmxtjs 2.48.5 → 2.49.0

package/dist/esm/pmxt/escrow.js

@@ -0,0 +1,78 @@
+/**
+ * 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 { _tradingRequest, formatRoutePath, HOSTED_METHOD_ROUTES, resolveWalletAddress, } from "./hosted-routing.js";
+export class Escrow {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Build an unsigned approve transaction for a given ERC-20 `token`. When
+     * `amountWei` is omitted, the server returns an unlimited approval.
+     */
+    async approveTx(token, amountWei) {
+        const route = HOSTED_METHOD_ROUTES.get("escrowApproveTx");
+        return _tradingRequest(this.client, {
+            method: route.method,
+            path: route.path,
+            body: {
+                token,
+                amount_wei: amountWei === undefined ? null : amountWei.toString(),
+            },
+        });
+    }
+    /**
+     * Build an unsigned deposit transaction for `amount` (USDC, 6-decimal
+     * grid). Accepts number, decimal string, or BigInt in micro-units.
+     */
+    async depositTx(amount) {
+        const route = HOSTED_METHOD_ROUTES.get("escrowDepositTx");
+        return _tradingRequest(this.client, {
+            method: route.method,
+            path: route.path,
+            body: {
+                amount: typeof amount === "bigint" ? amount.toString() : amount,
+            },
+        });
+    }
+    /**
+     * 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.
+     */
+    async withdrawTx(action, amount) {
+        const route = HOSTED_METHOD_ROUTES.get("escrowWithdrawTx");
+        const normalizedAmount = amount === undefined
+            ? null
+            : typeof amount === "bigint"
+                ? amount.toString()
+                : amount;
+        return _tradingRequest(this.client, {
+            method: route.method,
+            path: route.path,
+            body: { action, amount: normalizedAmount },
+        });
+    }
+    /**
+     * List the user's withdrawal records. `include` is forwarded verbatim and
+     * defaults to `"pending,events"` to match the Python SDK.
+     */
+    async withdrawals(opts = {}) {
+        const address = resolveWalletAddress(this.client, opts.address);
+        const route = HOSTED_METHOD_ROUTES.get("escrowWithdrawals");
+        const path = formatRoutePath(route, { address });
+        return _tradingRequest(this.client, {
+            method: route.method,
+            path,
+            params: { include: opts.include ?? "pending,events" },
+        });
+    }
+}

package/dist/esm/pmxt/feed-client.d.ts

@@ -59,6 +59,7 @@ export declare class FeedClient {
     private readonly baseUrl;
     private readonly headers;
     constructor(feedName: string, options?: FeedClientOptions);
+    listFeeds(): Promise<string[]>;
     loadMarkets(): Promise<Record<string, Market>>;
     fetchTicker(symbol: string): Promise<Ticker>;
     fetchTickers(symbols?: string[]): Promise<Tickers>;
@@ -72,4 +73,6 @@ export declare class FeedClient {
         order?: 'asc' | 'desc';
     }): Promise<Ticker[]>;
     private get;
+    private getRoot;
+    private request;
 }

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

@@ -22,6 +22,9 @@ export class FeedClient {
             ...(resolved.pmxtApiKey ? { 'Authorization': `Bearer ${resolved.pmxtApiKey}` } : {}),
         };
     }
+    async listFeeds() {
+        return this.getRoot();
+    }
     async loadMarkets() {
         return this.get('loadMarkets', {});
     }
@@ -50,12 +53,18 @@ export class FeedClient {
         return this.get('fetchHistoricalPrices', { symbol, ...opts });
     }
     async get(method, params) {
+        return this.request(`${this.baseUrl}/api/feeds/${this.feedName}/${method}`, params);
+    }
+    async getRoot(params = {}) {
+        return this.request(`${this.baseUrl}/api/feeds/`, params);
+    }
+    async request(url, params) {
         const qs = Object.entries(params)
             .filter(([, v]) => v !== undefined && v !== null)
             .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`)
             .join('&');
-        const url = `${this.baseUrl}/api/feeds/${this.feedName}/${method}${qs ? '?' + qs : ''}`;
-        const response = await fetch(url, {
+        const requestUrl = `${url}${qs ? '?' + qs : ''}`;
+        const response = await fetch(requestUrl, {
             headers: this.headers,
             signal: AbortSignal.timeout(30_000),
         });

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

@@ -0,0 +1,84 @@
+/**
+ * Hosted trading error hierarchy and upstream response mapping.
+ *
+ * Mirrors the Python implementation in `pmxt/_hosted_errors.py`. TypeScript
+ * does not support multiple inheritance, so each hosted error class extends
+ * the semantically-closest legacy parent (e.g. `InsufficientEscrowBalance`
+ * extends `InsufficientFunds`) so existing `instanceof` checks continue to
+ * match. The `static isHostedError = true` flag and the {@link isHostedError}
+ * helper provide a structural alternative for callers that want to detect
+ * hosted-mode failures regardless of the concrete subclass.
+ */
+import { AuthenticationError, ExchangeNotAvailable, InsufficientFunds, InvalidOrder, NotFoundError, PmxtError, ValidationError } from "./errors.js";
+export declare class HostedTradingError extends PmxtError {
+    static readonly isHostedError = true;
+    readonly status: number;
+    readonly detail: string;
+    constructor(status: number, detail: string);
+}
+export declare class InsufficientEscrowBalance extends InsufficientFunds {
+    static readonly isHostedError = true;
+    readonly status: number;
+    readonly detail: string;
+    constructor(status: number, detail: string);
+}
+export declare class OrderSizeTooSmall extends InvalidOrder {
+    static readonly isHostedError = true;
+    readonly status: number;
+    readonly detail: string;
+    constructor(status: number, detail: string);
+}
+export declare class InvalidApiKey extends AuthenticationError {
+    static readonly isHostedError = true;
+    readonly status: number;
+    readonly detail: string;
+    constructor(status: number, detail: string);
+}
+export declare class OutcomeNotFound extends NotFoundError {
+    static readonly isHostedError = true;
+    readonly status: number;
+    readonly detail: string;
+    constructor(status: number, detail: string);
+}
+export declare class CatalogUnavailable extends ExchangeNotAvailable {
+    static readonly isHostedError = true;
+    readonly status: number;
+    readonly detail: string;
+    constructor(status: number, detail: string);
+}
+export declare class BuiltOrderExpired extends InvalidOrder {
+    static readonly isHostedError = true;
+    readonly status: number;
+    readonly detail: string;
+    constructor(status: number, detail: string);
+}
+export declare class InvalidSignature extends AuthenticationError {
+    static readonly isHostedError = true;
+    readonly status: number;
+    readonly detail: string;
+    constructor(status: number, detail: string);
+}
+export declare class NoLiquidity extends InvalidOrder {
+    static readonly isHostedError = true;
+    readonly status: number;
+    readonly detail: string;
+    constructor(status: number, detail: string);
+}
+/**
+ * Local validation failure. Not a hosted-mode upstream error, so does NOT
+ * carry the `isHostedError` flag.
+ */
+export declare class MissingWalletAddress extends ValidationError {
+    constructor(message: string);
+}
+/**
+ * Returns true if `e` is a hosted trading error — either an instance of
+ * {@link HostedTradingError} or any subclass that carries the
+ * `static isHostedError = true` marker.
+ */
+export declare function isHostedError(e: unknown): boolean;
+/**
+ * Read an upstream `Response` and throw the matching hosted trading error.
+ * Always throws — return type is `never`.
+ */
+export declare function raiseFromResponse(response: Response): Promise<never>;

package/dist/esm/pmxt/hosted-errors.js

@@ -0,0 +1,186 @@
+/**
+ * Hosted trading error hierarchy and upstream response mapping.
+ *
+ * Mirrors the Python implementation in `pmxt/_hosted_errors.py`. TypeScript
+ * does not support multiple inheritance, so each hosted error class extends
+ * the semantically-closest legacy parent (e.g. `InsufficientEscrowBalance`
+ * extends `InsufficientFunds`) so existing `instanceof` checks continue to
+ * match. The `static isHostedError = true` flag and the {@link isHostedError}
+ * helper provide a structural alternative for callers that want to detect
+ * hosted-mode failures regardless of the concrete subclass.
+ */
+import { AuthenticationError, ExchangeNotAvailable, InsufficientFunds, InvalidOrder, NotFoundError, PmxtError, ValidationError, } from "./errors.js";
+export class HostedTradingError extends PmxtError {
+    static isHostedError = true;
+    status;
+    detail;
+    constructor(status, detail) {
+        super(detail);
+        this.status = status;
+        this.detail = detail;
+        this.name = this.constructor.name;
+    }
+}
+export class InsufficientEscrowBalance extends InsufficientFunds {
+    static isHostedError = true;
+    status;
+    detail;
+    constructor(status, detail) {
+        super(detail);
+        this.status = status;
+        this.detail = detail;
+        this.name = this.constructor.name;
+    }
+}
+export class OrderSizeTooSmall extends InvalidOrder {
+    static isHostedError = true;
+    status;
+    detail;
+    constructor(status, detail) {
+        super(detail);
+        this.status = status;
+        this.detail = detail;
+        this.name = this.constructor.name;
+    }
+}
+export class InvalidApiKey extends AuthenticationError {
+    static isHostedError = true;
+    status;
+    detail;
+    constructor(status, detail) {
+        super(detail);
+        this.status = status;
+        this.detail = detail;
+        this.name = this.constructor.name;
+    }
+}
+export class OutcomeNotFound extends NotFoundError {
+    static isHostedError = true;
+    status;
+    detail;
+    constructor(status, detail) {
+        super(detail);
+        this.status = status;
+        this.detail = detail;
+        this.name = this.constructor.name;
+    }
+}
+export class CatalogUnavailable extends ExchangeNotAvailable {
+    static isHostedError = true;
+    status;
+    detail;
+    constructor(status, detail) {
+        super(detail);
+        this.status = status;
+        this.detail = detail;
+        this.name = this.constructor.name;
+    }
+}
+export class BuiltOrderExpired extends InvalidOrder {
+    static isHostedError = true;
+    status;
+    detail;
+    constructor(status, detail) {
+        super(detail);
+        this.status = status;
+        this.detail = detail;
+        this.name = this.constructor.name;
+    }
+}
+export class InvalidSignature extends AuthenticationError {
+    static isHostedError = true;
+    status;
+    detail;
+    constructor(status, detail) {
+        super(detail);
+        this.status = status;
+        this.detail = detail;
+        this.name = this.constructor.name;
+    }
+}
+export class NoLiquidity extends InvalidOrder {
+    static isHostedError = true;
+    status;
+    detail;
+    constructor(status, detail) {
+        super(detail);
+        this.status = status;
+        this.detail = detail;
+        this.name = this.constructor.name;
+    }
+}
+/**
+ * Local validation failure. Not a hosted-mode upstream error, so does NOT
+ * carry the `isHostedError` flag.
+ */
+export class MissingWalletAddress extends ValidationError {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+    }
+}
+/**
+ * Returns true if `e` is a hosted trading error — either an instance of
+ * {@link HostedTradingError} or any subclass that carries the
+ * `static isHostedError = true` marker.
+ */
+export function isHostedError(e) {
+    if (e instanceof HostedTradingError)
+        return true;
+    const ctor = e?.constructor;
+    return ctor != null && ctor.isHostedError === true;
+}
+/**
+ * Read an upstream `Response` and throw the matching hosted trading error.
+ * Always throws — return type is `never`.
+ */
+export async function raiseFromResponse(response) {
+    const status = response.status;
+    let detail = "";
+    try {
+        const body = await response.json();
+        if (body != null && typeof body === "object") {
+            const record = body;
+            const candidate = (typeof record.detail === "string" ? record.detail : undefined) ||
+                (typeof record.message === "string" ? record.message : undefined) ||
+                (typeof record.error === "string" ? record.error : undefined);
+            detail = candidate || JSON.stringify(body);
+        }
+        else {
+            detail = typeof body === "string" ? body : JSON.stringify(body);
+        }
+    }
+    catch {
+        try {
+            detail = await response.text();
+        }
+        catch {
+            detail = `HTTP ${status}`;
+        }
+    }
+    if (status === 401) {
+        throw new InvalidApiKey(status, detail);
+    }
+    if (detail.startsWith("Insufficient escrow balance")) {
+        throw new InsufficientEscrowBalance(status, detail);
+    }
+    if (detail.includes("below the minimum")) {
+        throw new OrderSizeTooSmall(status, detail);
+    }
+    if (detail.includes("catalog: no outcome")) {
+        throw new OutcomeNotFound(status, detail);
+    }
+    if (detail.startsWith("catalog:")) {
+        throw new CatalogUnavailable(status, detail);
+    }
+    if (detail.includes("built_order_id expired") || detail.includes("cancel_id expired")) {
+        throw new BuiltOrderExpired(status, detail);
+    }
+    if (detail.includes("Invalid signature")) {
+        throw new InvalidSignature(status, detail);
+    }
+    if (detail.includes("book has no resting asks") || detail.includes("book has no resting bids")) {
+        throw new NoLiquidity(status, detail);
+    }
+    throw new HostedTradingError(status, detail);
+}

package/dist/esm/pmxt/hosted-mappers.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Hosted trading v0 response mappers.
+ *
+ * The hosted trading API exposes explicit `/v0/*` JSON shapes. These helpers
+ * translate those wire dictionaries to the SDK TypeScript interfaces.
+ *
+ * Mirrors `sdks/python/pmxt/_hosted_mappers.py`.
+ */
+import { Balance, Order, Position, UserTrade } from "./models.js";
+/**
+ * Convert a decimal amount to integer micro-units (6-decimal grid).
+ *
+ * Rejects amounts whose fractional part has more than 6 digits. Pure integer
+ * math via BigInt — no float rounding involved.
+ */
+export declare function to6dec(amount: number | string | bigint): bigint;
+/** Map an `OrderV0` JSON object to {@link Order}. */
+export declare function orderFromV0(payload: Record<string, unknown>): Order;
+/** Map an {@link Order} back to an `OrderV0` JSON object. */
+export declare function orderToV0(order: Order): Record<string, unknown>;
+/** Map a `UserTradeV0` JSON object to {@link UserTrade}. */
+export declare function userTradeFromV0(payload: Record<string, unknown>): UserTrade;
+/** Map a {@link UserTrade} back to a `UserTradeV0` JSON object. */
+export declare function userTradeToV0(trade: UserTrade): Record<string, unknown>;
+/**
+ * Map a `PositionV0` JSON object to {@link Position}.
+ *
+ * Optional fields (`outcomeLabel`, `entryPrice`, `currentPrice`,
+ * `unrealizedPnL`, `realizedPnL`) surface as `undefined` when missing —
+ * **never** a fake `0` or `""`. This keeps the SDK honest about which data
+ * the server actually provided.
+ */
+export declare function positionFromV0(payload: Record<string, unknown>): Position;
+/** Map a {@link Position} back to a `PositionV0` JSON object. */
+export declare function positionToV0(position: Position): Record<string, unknown>;
+/**
+ * Map a `BalanceV0` JSON object to {@link Balance}.
+ *
+ * Hosted-mode semantic: PreFundedEscrow doesn't reserve funds for resting
+ * orders, so `available = total` and `locked = 0`. Concurrent limit orders
+ * may fail at fill time if cumulative cost exceeds the escrow balance.
+ */
+export declare function balanceFromV0(payload: Record<string, unknown>): Balance;
+/** Map a {@link Balance} back to a `BalanceV0` JSON object. */
+export declare function balanceToV0(balance: Balance): Record<string, unknown>;