@vesper85/strategy-sdk 0.1.2 → 0.1.4

package/dist/rtds/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * RTDS Services
+ *
+ * Real-time data subscription services for Polymarket and Osiris.
+ */
+export * from './unified-rtds.service';
+export * from './polymarket-rtds.service';
+export * from './osiris-rtds.service';
+//# sourceMappingURL=index.d.ts.map

package/dist/rtds/osiris-rtds.service.d.ts

@@ -0,0 +1,134 @@
+import type { Logger } from '../utils/logger';
+import type { EventSubscription, StrategyEvent } from '../types/event-types';
+/**
+ * Default Osiris Pub/Sub server URL
+ */
+export declare const DEFAULT_OSIRIS_RTDS_URL = "wss://rtds.osirislabs.xyz";
+/**
+ * Configuration for the OsirisRTDSService
+ */
+export interface OsirisRTDSConfig {
+    /** Logger instance */
+    logger: Logger;
+    /** Callback for received events */
+    onEvent: (event: StrategyEvent) => void;
+    /** Callback for errors */
+    onError?: (error: Error) => void;
+    /** Callback when connected */
+    onConnect?: () => void;
+    /** Callback when disconnected */
+    onDisconnect?: () => void;
+    /** WebSocket URL (defaults to DEFAULT_OSIRIS_RTDS_URL) */
+    url?: string;
+    /** Reconnection settings */
+    reconnect?: {
+        /** Maximum number of reconnection attempts (default: 10) */
+        maxAttempts?: number;
+        /** Base delay between reconnection attempts in ms (default: 1000) */
+        delayMs?: number;
+        /** Maximum delay between reconnection attempts in ms (default: 30000) */
+        maxDelayMs?: number;
+    };
+    /** Ping interval in ms (default: 30000) */
+    pingIntervalMs?: number;
+}
+/**
+ * Osiris Real-Time Data Service
+ *
+ * Connects to Osiris Pub/Sub WebSocket for:
+ * - Market analysis events (smart scores, conviction rates, liquidity)
+ * - Wallet analysis events (trading metrics, PnL)
+ * - Trading opportunity events
+ *
+ * @example
+ * ```typescript
+ * const service = new OsirisRTDSService({
+ *     logger: createConsoleLogger(),
+ *     onEvent: (event) => console.log('Event:', event),
+ *     url: 'wss://rtds.osirislabs.xyz'
+ * });
+ *
+ * service.connect();
+ * service.subscribe([
+ *     { type: 'wallet', wallet: '0x123...' },
+ *     { type: 'opportunity', filter: 'wide_spread_markets' }
+ * ]);
+ * ```
+ */
+export declare class OsirisRTDSService {
+    private ws;
+    private config;
+    private isConnected;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private pingInterval;
+    private isIntentionallyClosed;
+    private activeTopics;
+    private readonly maxReconnectAttempts;
+    private readonly baseReconnectDelay;
+    private readonly maxReconnectDelay;
+    private readonly pingIntervalMs;
+    private readonly url;
+    constructor(config: OsirisRTDSConfig);
+    /**
+     * Connect to the Osiris Pub/Sub WebSocket
+     */
+    connect(): void;
+    /**
+     * Disconnect from the Osiris Pub/Sub WebSocket
+     */
+    disconnect(): void;
+    /**
+     * Check if connected
+     */
+    isActive(): boolean;
+    /**
+     * Subscribe to events
+     */
+    subscribe(subscriptions: EventSubscription[]): void;
+    /**
+     * Unsubscribe from topics
+     */
+    unsubscribe(subscriptions: EventSubscription[]): void;
+    /**
+     * Unsubscribe from topics by name
+     */
+    private unsubscribeFromTopics;
+    /**
+     * Send ping to keep connection alive
+     */
+    ping(): void;
+    /**
+     * Map SDK subscriptions to Osiris Pub/Sub format
+     */
+    private mapToOsirisSubscriptions;
+    /**
+     * Map SDK subscription to Osiris topic string
+     */
+    private mapSubscriptionToTopic;
+    /**
+     * Start ping interval
+     */
+    private startPingInterval;
+    /**
+     * Stop ping interval
+     */
+    private stopPingInterval;
+    /**
+     * Attempt reconnection with exponential backoff
+     */
+    private attemptReconnect;
+    /**
+     * Handle incoming WebSocket messages
+     */
+    private handleMessage;
+    /**
+     * Convert Osiris message to StrategyEvent
+     */
+    private convertToStrategyEvent;
+}
+/**
+ * Create an OsirisRTDSService instance
+ */
+export declare function createOsirisRTDSService(config: OsirisRTDSConfig): OsirisRTDSService;
+//# sourceMappingURL=osiris-rtds.service.d.ts.map

package/dist/rtds/polymarket-rtds.service.d.ts

@@ -0,0 +1,117 @@
+import type { Logger } from '../utils/logger';
+import type { EventSubscription, StrategyEvent } from '../types/event-types';
+/**
+ * CLOB API key credentials for authenticated subscriptions
+ */
+export interface ClobApiKeyCreds {
+    key: string;
+    secret: string;
+    passphrase: string;
+}
+/**
+ * Configuration for the PolymarketRTDSService
+ */
+export interface PolymarketRTDSConfig {
+    /** Logger instance */
+    logger: Logger;
+    /** Callback for received events */
+    onEvent: (event: StrategyEvent) => void;
+    /** Callback for errors */
+    onError?: (error: Error) => void;
+    /** Callback when connected */
+    onConnect?: () => void;
+    /** Callback when disconnected */
+    onDisconnect?: () => void;
+    /** CLOB API credentials for authenticated subscriptions (clob_user topic) */
+    clobAuth?: ClobApiKeyCreds;
+    /** Ping interval in ms (default: 5000) */
+    pingIntervalMs?: number;
+    /** Auto-reconnect on disconnect (default: true) */
+    autoReconnect?: boolean;
+}
+/**
+ * Polymarket Real-Time Data Service
+ *
+ * A wrapper around @polymarket/real-time-data-client that handles:
+ * - Connection lifecycle management
+ * - Subscription mapping from SDK types to RTDS format
+ * - Message normalization to StrategyEvent format
+ *
+ * @example
+ * ```typescript
+ * const service = new PolymarketRTDSService({
+ *     logger: createConsoleLogger(),
+ *     onEvent: (event) => console.log('Event:', event),
+ *     clobAuth: { key: '...', secret: '...', passphrase: '...' }
+ * });
+ *
+ * service.connect();
+ * service.subscribe([
+ *     { type: 'clob_market', marketId: 'condition-id', messageType: 'agg_orderbook' }
+ * ]);
+ * ```
+ */
+export declare class PolymarketRTDSService {
+    private client;
+    private config;
+    private isConnected;
+    private activeSubscriptions;
+    constructor(config: PolymarketRTDSConfig);
+    /**
+     * Connect to the Polymarket RTDS WebSocket
+     */
+    connect(): void;
+    /**
+     * Disconnect from the Polymarket RTDS WebSocket
+     */
+    disconnect(): void;
+    /**
+     * Check if connected
+     */
+    isActive(): boolean;
+    /**
+     * Subscribe to events
+     * Converts SDK EventSubscription types to RTDS Subscription format
+     */
+    subscribe(subscriptions: EventSubscription[]): void;
+    /**
+     * Unsubscribe from events
+     */
+    unsubscribe(subscriptions: EventSubscription[]): void;
+    /**
+     * Map SDK EventSubscription to RTDS Subscription format
+     */
+    private mapToRTDSSubscriptions;
+    /**
+     * Map a single SDK EventSubscription to RTDS Subscription
+     */
+    private mapSubscription;
+    private mapClobMarketSubscription;
+    private mapClobUserSubscription;
+    private mapActivitySubscription;
+    private mapCommentsSubscription;
+    private mapCryptoPricesSubscription;
+    private mapRfqSubscription;
+    private mapMarketSubscription;
+    /**
+     * Handle incoming RTDS messages
+     */
+    private handleMessage;
+    /**
+     * Convert RTDS Message to StrategyEvent
+     */
+    private convertToStrategyEvent;
+    /**
+     * Map RTDS topic/type to SDK EventType
+     */
+    private mapTopicToEventType;
+    /**
+     * Extract event data from RTDS message payload
+     */
+    private extractEventData;
+}
+/**
+ * Create a PolymarketRTDSService instance
+ */
+export declare function createPolymarketRTDSService(config: PolymarketRTDSConfig): PolymarketRTDSService;
+//# sourceMappingURL=polymarket-rtds.service.d.ts.map

package/dist/rtds/unified-rtds.service.d.ts

@@ -0,0 +1,146 @@
+/**
+ * Unified RTDS Service
+ *
+ * Provides a unified interface for subscribing to real-time events
+ * from both Polymarket RTDS and Osiris Pub/Sub services.
+ */
+import type { Logger } from '../utils/logger';
+import type { EventSubscription, StrategyEvent } from '../types/event-types';
+import { type ClobApiKeyCreds } from './polymarket-rtds.service';
+/**
+ * Configuration for the UnifiedRTDSService
+ */
+export interface UnifiedRTDSConfig {
+    /** Logger instance */
+    logger: Logger;
+    /** Callback for received events */
+    onEvent: (event: StrategyEvent) => void;
+    /** Callback for errors */
+    onError?: (error: Error) => void;
+    /** Callback when connected */
+    onConnect?: () => void;
+    /** Callback when disconnected */
+    onDisconnect?: () => void;
+    /** Polymarket-specific configuration */
+    polymarket?: {
+        /** Enable Polymarket RTDS connection */
+        enabled?: boolean;
+        /** CLOB API credentials for authenticated subscriptions */
+        clobAuth?: ClobApiKeyCreds;
+    };
+    /** Osiris-specific configuration */
+    osiris?: {
+        /** Enable Osiris Pub/Sub connection */
+        enabled?: boolean;
+        /** WebSocket URL (defaults to DEFAULT_OSIRIS_RTDS_URL) */
+        url?: string;
+        /** Ping interval in ms */
+        pingIntervalMs?: number;
+    };
+    /** Reconnection settings (applied to both services) */
+    reconnect?: {
+        maxAttempts?: number;
+        delayMs?: number;
+        maxDelayMs?: number;
+    };
+}
+/**
+ * Unified Real-Time Data Service
+ *
+ * Manages connections to both Polymarket RTDS and Osiris Pub/Sub,
+ * automatically routing subscriptions to the appropriate backend.
+ *
+ * @example
+ * ```typescript
+ * const service = new UnifiedRTDSService({
+ *     logger: createConsoleLogger(),
+ *     onEvent: (event) => console.log('Event:', event),
+ *     polymarket: {
+ *         enabled: true,
+ *         clobAuth: { key: '...', secret: '...', passphrase: '...' }
+ *     },
+ *     osiris: {
+ *         enabled: true,
+ *         url: 'wss://rtds.osirislabs.xyz'
+ *     }
+ * });
+ *
+ * service.connect();
+ *
+ * // Subscriptions are automatically routed
+ * service.subscribe([
+ *     // Goes to Polymarket
+ *     { type: 'clob_market', marketId: 'cond-id', messageType: 'agg_orderbook' },
+ *     // Goes to Osiris
+ *     { type: 'wallet', wallet: '0x123...' },
+ *     { type: 'opportunity', filter: 'wide_spread_markets' }
+ * ]);
+ * ```
+ */
+export declare class UnifiedRTDSService {
+    private config;
+    private polymarketService;
+    private osirisService;
+    private polymarketConnected;
+    private osirisConnected;
+    constructor(config: UnifiedRTDSConfig);
+    /**
+     * Initialize the underlying services based on configuration
+     */
+    private initializeServices;
+    /**
+     * Connect to all enabled services
+     */
+    connect(): void;
+    /**
+     * Disconnect from all services
+     */
+    disconnect(): void;
+    /**
+     * Check if connected to at least one service
+     */
+    isActive(): boolean;
+    /**
+     * Get connection status for each service
+     */
+    getStatus(): {
+        polymarket: {
+            enabled: boolean;
+            connected: boolean;
+        };
+        osiris: {
+            enabled: boolean;
+            connected: boolean;
+        };
+    };
+    /**
+     * Subscribe to events
+     * Automatically routes subscriptions to the appropriate backend
+     */
+    subscribe(subscriptions: EventSubscription[]): void;
+    /**
+     * Unsubscribe from events
+     */
+    unsubscribe(subscriptions: EventSubscription[]): void;
+    /**
+     * Route subscriptions to appropriate backends based on type and eventSource
+     */
+    private routeSubscriptions;
+    /**
+     * Check if all enabled services are connected
+     */
+    private checkAllConnected;
+    /**
+     * Check if any service disconnected
+     */
+    private checkAnyDisconnected;
+}
+/**
+ * Create a UnifiedRTDSService instance
+ */
+export declare function createUnifiedRTDSService(config: UnifiedRTDSConfig): UnifiedRTDSService;
+export { PolymarketRTDSService, createPolymarketRTDSService } from './polymarket-rtds.service';
+export { OsirisRTDSService, createOsirisRTDSService, DEFAULT_OSIRIS_RTDS_URL } from './osiris-rtds.service';
+export type { ClobApiKeyCreds, PolymarketRTDSConfig } from './polymarket-rtds.service';
+export type { OsirisRTDSConfig } from './osiris-rtds.service';
+//# sourceMappingURL=unified-rtds.service.d.ts.map

package/dist/types/event-types.d.ts

@@ -102,6 +102,139 @@ export interface CustomSubscription extends BaseSubscription {
     /** Full topic string (e.g., 'custom:my-topic' or any valid topic) */
     topic: string;
 }
+/**
+ * CLOB Market subscription for Polymarket-specific market events
+ * Connects to the clob_market topic for real-time orderbook and price data
+ *
+ * @example
+ * ```typescript
+ * { type: 'clob_market', marketId: 'condition-id', messageType: 'agg_orderbook' }
+ * ```
+ */
+export interface ClobMarketSubscription extends BaseSubscription {
+    /** CLOB market subscription type */
+    type: 'clob_market';
+    /** Token ID or condition ID for CLOB market events */
+    marketId: string;
+    /**
+     * Specific message types:
+     * - 'price_change' - Price changes for the market
+     * - 'agg_orderbook' - Aggregated orderbook updates
+     * - 'last_trade_price' - Last trade price updates
+     * - 'tick_size_change' - Tick size changes
+     * - 'market_created' - New market creation events
+     * - 'market_resolved' - Market resolution events
+     * - '*' - All message types (default)
+     */
+    messageType?: 'price_change' | 'agg_orderbook' | 'last_trade_price' | 'tick_size_change' | 'market_created' | 'market_resolved' | '*';
+}
+/**
+ * CLOB User subscription for authenticated user-specific events
+ * Requires CLOB API credentials for authentication
+ *
+ * @example
+ * ```typescript
+ * { type: 'clob_user', messageType: 'order' }
+ * ```
+ */
+export interface ClobUserSubscription extends BaseSubscription {
+    /** CLOB user subscription type */
+    type: 'clob_user';
+    /**
+     * Specific message types:
+     * - 'order' - Order updates (placement, cancellation, fill)
+     * - 'trade' - Trade execution events
+     * - '*' - All message types (default)
+     */
+    messageType?: 'order' | 'trade' | '*';
+}
+/**
+ * Activity subscription for trade activity feed events
+ *
+ * @example
+ * ```typescript
+ * { type: 'activity', eventSlug: 'will-bitcoin-hit-100k' }
+ * ```
+ */
+export interface ActivitySubscription extends BaseSubscription {
+    /** Activity subscription type */
+    type: 'activity';
+    /** Event slug to filter trades (optional) */
+    eventSlug?: string;
+    /** Market slug to filter trades (optional) */
+    marketSlug?: string;
+    /**
+     * Specific message types:
+     * - 'trades' - Trade events
+     * - 'orders_matched' - Order match events
+     * - '*' - All message types (default)
+     */
+    messageType?: 'trades' | 'orders_matched' | '*';
+}
+/**
+ * Comments subscription for comment and reaction events
+ *
+ * @example
+ * ```typescript
+ * { type: 'comments', parentEntityId: 100, parentEntityType: 'Event' }
+ * ```
+ */
+export interface CommentsSubscription extends BaseSubscription {
+    /** Comments subscription type */
+    type: 'comments';
+    /** Parent entity ID to filter comments */
+    parentEntityId?: number;
+    /** Parent entity type */
+    parentEntityType?: 'Event' | 'Series';
+    /**
+     * Specific message types:
+     * - 'comment_created' - New comment events
+     * - 'comment_removed' - Comment removal events
+     * - 'reaction_created' - Reaction added events
+     * - 'reaction_removed' - Reaction removed events
+     * - '*' - All message types (default)
+     */
+    messageType?: 'comment_created' | 'comment_removed' | 'reaction_created' | 'reaction_removed' | '*';
+}
+/**
+ * Crypto prices subscription for real-time cryptocurrency price updates
+ *
+ * @example
+ * ```typescript
+ * { type: 'crypto_prices', symbol: 'btcusdt' }
+ * ```
+ */
+export interface CryptoPricesSubscription extends BaseSubscription {
+    /** Crypto prices subscription type */
+    type: 'crypto_prices';
+    /** Symbol to filter (e.g., 'btcusdt', 'ethusdt') */
+    symbol?: string;
+}
+/**
+ * RFQ subscription for Request for Quote events
+ *
+ * @example
+ * ```typescript
+ * { type: 'rfq', messageType: 'request_created' }
+ * ```
+ */
+export interface RfqSubscription extends BaseSubscription {
+    /** RFQ subscription type */
+    type: 'rfq';
+    /**
+     * Specific message types:
+     * - 'request_created' - New RFQ request
+     * - 'request_edited' - RFQ request edited
+     * - 'request_canceled' - RFQ request canceled
+     * - 'request_expired' - RFQ request expired
+     * - 'quote_created' - New quote
+     * - 'quote_edited' - Quote edited
+     * - 'quote_canceled' - Quote canceled
+     * - 'quote_expired' - Quote expired
+     * - '*' - All message types (default)
+     */
+    messageType?: 'request_created' | 'request_edited' | 'request_canceled' | 'request_expired' | 'quote_created' | 'quote_edited' | 'quote_canceled' | 'quote_expired' | '*';
+}
 /**
  * Event subscription configuration (discriminated union)
  * Defines what events a strategy wants to receive
@@ -111,17 +244,22 @@ export interface CustomSubscription extends BaseSubscription {
  * { type: 'price', market: 'BTC-USD' }
  * ```
  *
- * @example Wallet subscription
+ * @example Wallet subscription (Osiris only)
  * ```typescript
  * { type: 'wallet', wallet: '0x123...', conditions: { minWinRate: 60 } }
  * ```
  *
- * @example Opportunity subscription
+ * @example Opportunity subscription (Osiris only)
  * ```typescript
  * { type: 'opportunity', filter: 'wide_spread_markets' }
  * ```
+ *
+ * @example CLOB Market subscription (Polymarket only)
+ * ```typescript
+ * { type: 'clob_market', marketId: 'condition-id', messageType: 'agg_orderbook' }
+ * ```
  */
-export type EventSubscription = MarketSubscription | WalletSubscription | OpportunitySubscription | CustomSubscription;
+export type EventSubscription = MarketSubscription | WalletSubscription | OpportunitySubscription | CustomSubscription | ClobMarketSubscription | ClobUserSubscription | ActivitySubscription | CommentsSubscription | CryptoPricesSubscription | RfqSubscription;
 /**
  * Data payload for strategy events
  */
@@ -198,5 +336,37 @@ export declare function isOpportunitySubscription(sub: EventSubscription): sub i
  * Check if subscription is a CustomSubscription
  */
 export declare function isCustomSubscription(sub: EventSubscription): sub is CustomSubscription;
+/**
+ * Check if subscription is a ClobMarketSubscription
+ */
+export declare function isClobMarketSubscription(sub: EventSubscription): sub is ClobMarketSubscription;
+/**
+ * Check if subscription is a ClobUserSubscription
+ */
+export declare function isClobUserSubscription(sub: EventSubscription): sub is ClobUserSubscription;
+/**
+ * Check if subscription is an ActivitySubscription
+ */
+export declare function isActivitySubscription(sub: EventSubscription): sub is ActivitySubscription;
+/**
+ * Check if subscription is a CommentsSubscription
+ */
+export declare function isCommentsSubscription(sub: EventSubscription): sub is CommentsSubscription;
+/**
+ * Check if subscription is a CryptoPricesSubscription
+ */
+export declare function isCryptoPricesSubscription(sub: EventSubscription): sub is CryptoPricesSubscription;
+/**
+ * Check if subscription is an RfqSubscription
+ */
+export declare function isRfqSubscription(sub: EventSubscription): sub is RfqSubscription;
+/**
+ * Check if subscription is a Polymarket-specific subscription
+ */
+export declare function isPolymarketSubscription(sub: EventSubscription): boolean;
+/**
+ * Check if subscription is an Osiris-specific subscription
+ */
+export declare function isOsirisSubscription(sub: EventSubscription): boolean;
 export {};
 //# sourceMappingURL=event-types.d.ts.map