@structbuild/sdk 0.3.0 → 0.3.2

package/dist/types/ws.d.ts

@@ -1,90 +1,93 @@
-import type { Address } from "./common.js";
 import type { RetryConfig } from "./http.js";
+import type { WsSchemas, WsAlertSchemas, WsAlertSubscribeMap, WsAlertEventDataMap, WsAlertEventName } from "./ws-helpers.js";
 export type ConnectionState = "disconnected" | "connecting" | "connected" | "reconnecting";
 export interface StructWebSocketConfig {
     apiKey: string;
     jwt?: string;
+    getJwt?: () => string | undefined;
     baseUrl?: string;
     reconnect?: RetryConfig;
+    subscribeTimeout?: number;
 }
-export interface PredictionTrade {
-    id: string;
-    hash: string;
-    chain_id: number;
-    block: number;
-    confirmed_at: number;
-    log_index: number;
-    block_index?: number;
-    order_hash?: string;
-    trader: Address;
-    taker: Address;
-    side: number;
-    condition_id: string | null;
-    position_id: string;
-    outcome: string | null;
-    outcome_index: number | null;
-    question: string | null;
-    slug: string | null;
-    event_slug?: string | null;
-    usd_amount: string;
-    shares_amount: string;
-    price: number;
-    probability: number | null;
-    fee?: string;
-    exchange?: number;
-    trade_type?: number;
-}
-export interface EnrichedPredictionTrade {
-    id: string;
-    hash: string;
-    block: number;
-    confirmed_at: number;
-    trader: Address;
-    side: number;
-    position_id: string;
-    condition_id: string | null;
-    outcome: string | null;
-    outcome_index: number | null;
-    question: string;
-    slug: string;
-    event_slug: string;
-    image_url: string | null;
-    market_id: string | null;
-    title: string | null;
-    usd_amount: string;
-    shares_amount: string;
-    price: number;
-    probability: number | null;
-    smart_money_score: number;
-    insider_score: number;
-    categories: string[];
-}
-export interface PredictionMarketMetadata {
-    slug: string | null;
-    question: string | null;
-    outcome: string | null;
-    outcome_index?: number | null;
-    image_url?: string | null;
-}
-export interface PredictionWalletTrackingAlert {
-    is_buy: boolean;
-    trader: Address;
-    condition_id: string | null;
-    position_id: string;
-    usd_amount: string;
-    shares_amount: string;
-    price: number;
-    probability: number | null;
-    metadata: PredictionMarketMetadata | null;
-    confirmed_at: number;
-}
+export type WsRoomId = "polymarket_trades" | "polymarket_asset_prices" | "polymarket_asset_window_updates" | "polymarket_market_metrics" | "polymarket_event_metrics" | "polymarket_position_metrics" | "polymarket_trader_pnl" | "polymarket_trader_positions" | "polymarket_accounts" | "polymarket_order_book" | "polymarket_clob_rewards";
+export type WsFiltersOptionalRoom = "polymarket_trades" | "polymarket_asset_prices" | "polymarket_clob_rewards";
+export type WsFiltersRequiredRoom = Exclude<WsRoomId, WsFiltersOptionalRoom>;
+export type TradesSubscribeFilters = Omit<WsSchemas["TradesStreamSubscribeMessage"], "action">;
+export type AssetPricesSubscribeFilters = Omit<WsSchemas["AssetPricesSubscribeMessage"], "action">;
+export type AssetWindowUpdatesSubscribeFilters = Omit<WsSchemas["AssetWindowUpdatesSubscribeMessage"], "action">;
+export type MarketMetricsSubscribeFilters = Omit<WsSchemas["MarketMetricsSubscribeMessage"], "action">;
+export type EventMetricsSubscribeFilters = Omit<WsSchemas["EventMetricsSubscribeMessage"], "action">;
+export type PositionMetricsSubscribeFilters = Omit<WsSchemas["PositionMetricsSubscribeMessage"], "action">;
+export type TraderPnlSubscribeFilters = Omit<WsSchemas["TraderPnlSubscribeMessage"], "action">;
+export type AccountsSubscribeFilters = Omit<WsSchemas["AccountsSubscribeMessage"], "action">;
+export type OrderBookSubscribeFilters = Omit<WsSchemas["OrderBookSubscribeMessage"], "action">;
+export type TraderPositionsSubscribeFilters = Omit<WsSchemas["TraderPositionsSubscribeMessage"], "action">;
+export type ClobRewardsSubscribeFilters = Omit<WsSchemas["ClobRewardsSubscribeMessage"], "action">;
+export type WsTradeType = NonNullable<TradesSubscribeFilters["trade_types"]>[number];
+export type WsTradeStatus = NonNullable<TradesSubscribeFilters["status"]>;
+export type WsAssetTimeframe = NonNullable<AssetWindowUpdatesSubscribeFilters["timeframes"]>[number];
+export type TradeStreamEvent = WsSchemas["TradeStreamEvent"];
+export type AssetPriceTickEvent = WsSchemas["AssetPriceTickEvent"];
+export type AssetPriceWindowUpdateEvent = WsSchemas["AssetPriceWindowUpdateEvent"];
+export type AssetWindowUpdateEvent = WsSchemas["AssetWindowUpdateEvent"];
+export type MarketMetricsEvent = WsSchemas["MarketMetricsEvent"];
+export type EventMetricsEvent = WsSchemas["EventMetricsEvent"];
+export type PositionMetricsEvent = WsSchemas["PositionMetricsEvent"];
+export type TraderGlobalPnlEvent = WsSchemas["TraderGlobalPnlEvent"];
+export type TraderMarketPnlEvent = WsSchemas["TraderMarketPnlEvent"];
+export type TraderEventPnlEvent = WsSchemas["TraderEventPnlEvent"];
+export type AccountsUpdateEvent = WsSchemas["AccountsUpdateEvent"];
+export type UsdceUpdateEvent = WsSchemas["UsdceUpdateEvent"];
+export type MaticUpdateEvent = WsSchemas["MaticUpdateEvent"];
+export type WsOrderBookLevel = WsSchemas["OrderBookLevel"];
+export type OrderBookUpdateEvent = WsSchemas["OrderBookUpdateEvent"];
+export type TraderPositionUpdateEvent = WsSchemas["TraderPositionUpdateEvent"];
+export type TraderPositionsSubscribeResponse = WsSchemas["TraderPositionsSubscribeResponse"];
+export type ClobRewardsUpdateEvent = WsSchemas["ClobRewardsUpdateEvent"];
+export type ClobRewardsSubscribeResponse = WsSchemas["ClobRewardsSubscribeResponse"];
+export type TradeOrderFilledEvent = WsSchemas["TradeOrderFilledEvent"];
+export type TradeRedemptionEvent = WsSchemas["TradeRedemptionEvent"];
+export type TradeMergeEvent = WsSchemas["TradeMergeEvent"];
+export type TradeSplitEvent = WsSchemas["TradeSplitEvent"];
+export type TradePositionsConvertedEvent = WsSchemas["TradePositionsConvertedEvent"];
+export type TradeCancelledEvent = WsSchemas["TradeCancelledEvent"];
+export type TradeOracleLifecycleEvent = WsSchemas["TradeOracleLifecycleEvent"];
+export type TradeRegisterTokenEvent = WsSchemas["TradeRegisterTokenEvent"];
+export type TradeApprovalEvent = WsSchemas["TradeApprovalEvent"];
+export type WsAlertSubscribeMessage = WsAlertSchemas["WsAlertSubscribeMessage"];
+export type WsAlertUnsubscribeMessage = WsAlertSchemas["WsAlertUnsubscribeMessage"];
+export type WsAlertEventPayload = WsAlertSchemas["WsAlertEventPayload"];
+export type WsAlertSubscribedResponse = WsAlertSchemas["WsAlertSubscribedResponse"];
+export type WsAlertUnsubscribedResponse = WsAlertSchemas["WsAlertUnsubscribedResponse"];
+export type WsAlertErrorResponse = WsAlertSchemas["WsAlertErrorResponse"];
+export type WsAlertEventType = WsAlertSchemas["WsAlertEventType"];
+export type { WsAlertSubscribeMap, WsAlertEventDataMap, WsAlertEventName };
+export type TradesStreamSubscribeResponse = WsSchemas["TradesStreamSubscribeResponse"];
+export type AssetPricesSubscribeResponse = WsSchemas["AssetPricesSubscribeResponse"];
+export type AssetWindowUpdatesSubscribeResponse = WsSchemas["AssetWindowUpdatesSubscribeResponse"];
+export type MarketMetricsSubscribeResponse = WsSchemas["MarketMetricsSubscribeResponse"];
+export type EventMetricsSubscribeResponse = WsSchemas["EventMetricsSubscribeResponse"];
+export type PositionMetricsSubscribeResponse = WsSchemas["PositionMetricsSubscribeResponse"];
+export type TraderPnlSubscribeResponse = WsSchemas["TraderPnlSubscribeResponse"];
+export type AccountsSubscribeResponse = WsSchemas["AccountsSubscribeResponse"];
+export type OrderBookSubscribeResponse = WsSchemas["OrderBookSubscribeResponse"];
 export interface WebSocketEventMap {
-    market_trade: PredictionTrade;
-    whale_trade: EnrichedPredictionTrade;
-    smart_money_trade: EnrichedPredictionTrade;
-    insider_trade: EnrichedPredictionTrade;
-    wallet_tracking_alert: PredictionWalletTrackingAlert;
-    conditions_tracking_alert: PredictionTrade;
+    trade_stream_update: TradeStreamEvent;
+    asset_price_tick: AssetPriceTickEvent;
+    asset_price_window_update: AssetPriceWindowUpdateEvent;
+    asset_window_update: AssetWindowUpdateEvent;
+    market_metrics_update: MarketMetricsEvent;
+    event_metrics_update: EventMetricsEvent;
+    position_metrics_update: PositionMetricsEvent;
+    trader_global_pnl_update: TraderGlobalPnlEvent;
+    trader_market_pnl_update: TraderMarketPnlEvent;
+    trader_event_pnl_update: TraderEventPnlEvent;
+    accounts_update: AccountsUpdateEvent;
+    usdce_update: UsdceUpdateEvent;
+    matic_update: MaticUpdateEvent;
+    order_book_update: OrderBookUpdateEvent;
+    trader_position_update: TraderPositionUpdateEvent;
+    clob_rewards_update: ClobRewardsUpdateEvent;
     connected: void;
     disconnected: {
         code: number;
@@ -93,19 +96,54 @@ export interface WebSocketEventMap {
     reconnecting: {
         attempt: number;
     };
+    reconnect_failed: Error;
+    auth_failed: Error;
     error: Error;
+    warning: Error;
 }
-export interface WebSocketMessage {
-    type: string;
-    room_id?: string;
-    action?: string;
-    message?: Record<string, unknown>;
-    wallet_addresses?: string[];
-    condition_ids?: string[];
+export interface WsSubscriptionMap {
+    polymarket_trades: TradesSubscribeFilters;
+    polymarket_asset_prices: AssetPricesSubscribeFilters;
+    polymarket_asset_window_updates: AssetWindowUpdatesSubscribeFilters;
+    polymarket_market_metrics: MarketMetricsSubscribeFilters;
+    polymarket_event_metrics: EventMetricsSubscribeFilters;
+    polymarket_position_metrics: PositionMetricsSubscribeFilters;
+    polymarket_trader_pnl: TraderPnlSubscribeFilters;
+    polymarket_trader_positions: TraderPositionsSubscribeFilters;
+    polymarket_accounts: AccountsSubscribeFilters;
+    polymarket_order_book: OrderBookSubscribeFilters;
+    polymarket_clob_rewards: ClobRewardsSubscribeFilters;
 }
-export interface WebSocketServerMessage {
-    type: string;
-    data?: unknown;
-    room_id?: string;
-    message?: string;
+export interface WsSubscribeResponseMap {
+    polymarket_trades: TradesStreamSubscribeResponse;
+    polymarket_asset_prices: AssetPricesSubscribeResponse;
+    polymarket_asset_window_updates: AssetWindowUpdatesSubscribeResponse;
+    polymarket_market_metrics: MarketMetricsSubscribeResponse;
+    polymarket_event_metrics: EventMetricsSubscribeResponse;
+    polymarket_position_metrics: PositionMetricsSubscribeResponse;
+    polymarket_trader_pnl: TraderPnlSubscribeResponse;
+    polymarket_trader_positions: TraderPositionsSubscribeResponse;
+    polymarket_accounts: AccountsSubscribeResponse;
+    polymarket_order_book: OrderBookSubscribeResponse;
+    polymarket_clob_rewards: ClobRewardsSubscribeResponse;
 }
+export type AlertsWebSocketEventMap = {
+    [E in WsAlertEventName]: {
+        event: E;
+        timestamp: number;
+        data: WsAlertEventDataMap[E];
+    };
+} & {
+    connected: void;
+    disconnected: {
+        code: number;
+        reason: string;
+    };
+    reconnecting: {
+        attempt: number;
+    };
+    reconnect_failed: Error;
+    auth_failed: Error;
+    error: Error;
+    warning: Error;
+};

package/dist/ws-alerts.d.ts

@@ -0,0 +1,39 @@
+import type { ConnectionState, StructWebSocketConfig, AlertsWebSocketEventMap, WsAlertSubscribedResponse } from "./types/ws.js";
+import type { WsAlertSubscribeMap, WsAlertEventName } from "./types/ws-helpers.js";
+type Listener<T> = (payload: T) => void;
+export declare class StructAlertsWebSocket {
+    private readonly transport;
+    private readonly listeners;
+    private readonly subscriptions;
+    private readonly pendingSubscribes;
+    private readonly subscribeTimeout;
+    private pingTimer;
+    private pongTimer;
+    private isEmittingListenerError;
+    constructor(config: StructWebSocketConfig);
+    get state(): ConnectionState;
+    connect(): Promise<void>;
+    disconnect(): void;
+    on<K extends keyof AlertsWebSocketEventMap>(event: K, listener: Listener<AlertsWebSocketEventMap[K]>): () => void;
+    off<K extends keyof AlertsWebSocketEventMap>(event: K, listener: Listener<AlertsWebSocketEventMap[K]>): void;
+    once<K extends keyof AlertsWebSocketEventMap>(event: K, listener: Listener<AlertsWebSocketEventMap[K]>): () => void;
+    removeAllListeners(event?: keyof AlertsWebSocketEventMap): void;
+    subscribe<E extends WsAlertEventName>(event: E, filters: Omit<WsAlertSubscribeMap[E], "op" | "event">): Promise<WsAlertSubscribedResponse>;
+    unsubscribe(event: WsAlertEventName): void;
+    private rebuildReplay;
+    private handleOpen;
+    private handleClose;
+    private handleMessage;
+    private emit;
+    private startPing;
+    private stopPing;
+    private sendSubscription;
+    private restartPendingSubscribes;
+    private pausePendingSubscribes;
+    private armSubscribeTimer;
+    private clearSubscribeTimer;
+    private armPongTimer;
+    private clearPongTimer;
+    private handleListenerError;
+}
+export {};

package/dist/ws-transport.d.ts

@@ -1,11 +1,20 @@
-import type { ConnectionState, WebSocketMessage } from "./types/ws.js";
+import { WebSocketClosedError } from "./errors.js";
+import type { ConnectionState } from "./types/ws.js";
 import type { RetryConfig } from "./types/http.js";
+export declare function buildWebSocketUrl(path: string, config: {
+    apiKey: string;
+    jwt?: string;
+    baseUrl?: string;
+}, defaultBaseUrl: string): string;
 export interface WebSocketTransportCallbacks {
     onOpen: () => void;
     onClose: (code: number, reason: string) => void;
     onError: (error: Error) => void;
     onMessage: (data: unknown) => void;
     onReconnecting: (attempt: number) => void;
+    onReconnectFailed: (error: Error) => void;
+    onAuthFailed: (error: WebSocketClosedError) => void;
+    onWarning: (warning: Error) => void;
 }
 export declare class WebSocketTransport {
     private ws;
@@ -13,23 +22,33 @@ export declare class WebSocketTransport {
     private reconnectTimer;
     private reconnectAttempt;
     private intentionalClose;
+    private readonly connectWaiters;
     private readonly pendingMessages;
     private readonly replayMessages;
-    private readonly url;
+    private readonly getUrl;
     private readonly retry;
     private readonly callbacks;
-    constructor(url: string, retry: RetryConfig, callbacks: WebSocketTransportCallbacks);
+    constructor(url: string | (() => string), retry: RetryConfig, callbacks: WebSocketTransportCallbacks);
     get state(): ConnectionState;
-    connect(): void;
+    connect(): Promise<void>;
     disconnect(): void;
-    send(message: WebSocketMessage): void;
-    addReplayMessage(message: WebSocketMessage): void;
-    removeReplayMessages(predicate: (msg: WebSocketMessage) => boolean): void;
+    send(message: Record<string, unknown>): boolean;
+    sendNow(message: Record<string, unknown>): boolean;
+    addReplayMessage(message: Record<string, unknown>): void;
+    addReplayMessages(messages: Record<string, unknown>[]): void;
     clearReplayMessages(): void;
+    close(code: number, reason: string): void;
+    private createConnectPromise;
+    private resolveConnect;
+    private rejectConnect;
     private createSocket;
     private replaySubscriptions;
     private flushPendingMessages;
     private scheduleReconnect;
     private clearReconnectTimer;
+    private sendMessage;
+    private enqueueMessage;
+    private enqueueReplayMessages;
+    private isAuthFailure;
     private setState;
 }

package/dist/ws.d.ts

@@ -1,46 +1,41 @@
-import type { ConnectionState, StructWebSocketConfig, WebSocketEventMap } from "./types/ws.js";
-import type { Address } from "./types/common.js";
+import type { ConnectionState, StructWebSocketConfig, WebSocketEventMap, WsRoomId, WsFiltersOptionalRoom, WsFiltersRequiredRoom, WsSubscriptionMap, WsSubscribeResponseMap } from "./types/ws.js";
 type Listener<T> = (payload: T) => void;
 export declare class StructWebSocket {
     private readonly transport;
     private readonly listeners;
-    private readonly activeMarkets;
-    private readonly activeMarketPositions;
-    private readonly activeWallets;
-    private readonly activeConditions;
-    private readonly activeSpecialRooms;
+    private readonly subscriptions;
+    private readonly pendingSubscribes;
+    private readonly subscribeTimeout;
+    private pingTimer;
+    private pongTimer;
+    private isEmittingListenerError;
     constructor(config: StructWebSocketConfig);
     get state(): ConnectionState;
-    connect(): void;
+    connect(): Promise<void>;
     disconnect(): void;
-    on<K extends keyof WebSocketEventMap>(event: K, listener: Listener<WebSocketEventMap[K]>): this;
-    off<K extends keyof WebSocketEventMap>(event: K, listener: Listener<WebSocketEventMap[K]>): this;
-    once<K extends keyof WebSocketEventMap>(event: K, listener: Listener<WebSocketEventMap[K]>): this;
-    subscribeMarket(conditionId: string): void;
-    unsubscribeMarket(conditionId: string): void;
-    subscribeMarketByPosition(positionId: string): void;
-    unsubscribeMarketByPosition(positionId: string): void;
-    trackWallets(addresses: Address[]): void;
-    untrackWallets(addresses: Address[]): void;
-    subscribeWhaleTrades(): void;
-    unsubscribeWhaleTrades(): void;
-    subscribeSmartMoneyTrades(): void;
-    unsubscribeSmartMoneyTrades(): void;
-    subscribeInsiderTrades(): void;
-    unsubscribeInsiderTrades(): void;
-    trackConditions(conditionIds: string[]): void;
-    untrackConditions(conditionIds: string[]): void;
+    on<K extends keyof WebSocketEventMap>(event: K, listener: Listener<WebSocketEventMap[K]>): () => void;
+    off<K extends keyof WebSocketEventMap>(event: K, listener: Listener<WebSocketEventMap[K]>): void;
+    once<K extends keyof WebSocketEventMap>(event: K, listener: Listener<WebSocketEventMap[K]>): () => void;
+    removeAllListeners(event?: keyof WebSocketEventMap): void;
+    subscribe<R extends WsFiltersOptionalRoom>(room: R, filters?: WsSubscriptionMap[R]): Promise<WsSubscribeResponseMap[R]>;
+    subscribe<R extends WsFiltersRequiredRoom>(room: R, filters: WsSubscriptionMap[R]): Promise<WsSubscribeResponseMap[R]>;
+    unsubscribe(room: WsRoomId): void;
+    private rebuildReplay;
     private handleOpen;
     private handleClose;
     private handleMessage;
+    private isSubscribeResponseMessage;
     private emit;
-    private marketSubscribeMessage;
-    private marketPositionSubscribeMessage;
-    private walletTrackMessage;
-    private conditionsTrackMessage;
-    private subscribeSpecialRoom;
-    private unsubscribeSpecialRoom;
-    private rebuildWalletReplay;
-    private rebuildConditionsReplay;
+    private startPing;
+    private stopPing;
+    private sendSubscription;
+    private restartPendingSubscribes;
+    private pausePendingSubscribes;
+    private armSubscribeTimer;
+    private clearSubscribeTimer;
+    private armPongTimer;
+    private clearPongTimer;
+    private getSubscribeError;
+    private handleListenerError;
 }
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@structbuild/sdk",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
@@ -24,14 +24,18 @@
     "build": "rm -rf dist && bun build ./src/index.ts --target browser --format esm --sourcemap --outdir ./dist && bun build ./src/index.ts --target browser --format cjs --sourcemap --outdir ./dist-cjs && mv ./dist-cjs/index.js ./dist/index.cjs && mv ./dist-cjs/index.js.map ./dist/index.cjs.map && rm -rf dist-cjs && tsc --emitDeclarationOnly",
     "check-routes": "bun run scripts/check-routes.ts",
     "fix-spec": "bun run scripts/fix-spec.ts",
-    "prep": "bun run fetch-spec:polymarket && bun run fix-spec && bun run generate:polymarket && bun run fetch-spec:webhooks && bun run generate:webhooks && bun run check-routes && bun run build",
+    "fetch-specs": "bun run scripts/fetch-specs.ts",
+    "prep": "bun run fetch-specs && bun run fix-spec && bun run generate:polymarket && bun run generate:webhooks && bun run generate:ws && bun run check-routes && bun run build",
+    "prep:staging": "STRUCT_ENV=staging bun run prep",
     "test": "bun test",
+    "test:ws:live": "bun test tests/ws.live.test.ts --timeout 900000",
     "test:watch": "bun test --watch",
     "typecheck": "bun run tsc -p tsconfig.check.json",
-    "fetch-spec:polymarket": "curl -s -o openapi/polymarket.json https://api.struct.to/api-docs/openapi.json",
     "generate:polymarket": "openapi-typescript openapi/polymarket.json -o src/generated/polymarket.ts",
-    "fetch-spec:webhooks": "curl -s -o openapi/webhooks.json https://api.struct.to/webhookopenapi.json",
-    "generate:webhooks": "openapi-typescript openapi/webhooks.json -o src/generated/webhooks.ts"
+    "generate:webhooks": "openapi-typescript openapi/webhooks.json -o src/generated/webhooks.ts",
+    "generate:ws": "bun run scripts/generate-ws-types.ts",
+    "link": "bun link",
+    "pack": "bun run build && bun pm pack"
   },
   "devDependencies": {
     "@types/bun": "latest",