@vesper85/strategy-sdk 0.1.0 → 0.1.3

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