@vesper85/strategy-sdk 0.1.0 → 0.1.2

package/dist/engine/polymarket-event-runner.d.ts

@@ -0,0 +1,202 @@
+import type { CodeStrategy } from "../types/strategy";
+import type { OsirisContext } from "../types/osiris";
+import type { Logger } from "../utils/logger";
+/**
+ * Polymarket RTDS subscription topics
+ */
+export type PolymarketRTDSTopic = 'crypto_prices' | 'comments' | 'activity' | 'orders' | 'trades' | 'profile';
+/**
+ * CLOB authentication for trading-related subscriptions
+ */
+export interface PolymarketClobAuth {
+    key: string;
+    secret: string;
+    passphrase: string;
+}
+/**
+ * Gamma authentication for user-specific data
+ */
+export interface PolymarketGammaAuth {
+    address: string;
+}
+/**
+ * Polymarket RTDS subscription configuration
+ */
+export interface PolymarketRTDSSubscription {
+    topic: PolymarketRTDSTopic;
+    type?: string;
+    filters?: string;
+    clob_auth?: PolymarketClobAuth;
+    gamma_auth?: PolymarketGammaAuth;
+}
+/**
+ * Configuration for the PolymarketEventRunner
+ */
+export interface PolymarketEventRunnerConfig {
+    /** Logger instance for logging */
+    logger: Logger;
+    /** Optional strategy ID for logging (defaults to 'unnamed-strategy') */
+    strategyId?: string;
+    /** CLOB API credentials (required for order/trade subscriptions) */
+    clobAuth?: PolymarketClobAuth;
+    /** Wallet address for user-specific subscriptions */
+    walletAddress?: 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: 5000) - Polymarket recommends 5 seconds */
+    pingIntervalMs?: number;
+}
+/**
+ * Polymarket Event Runner for event-based strategy execution
+ *
+ * Connects directly to Polymarket's Real-Time Data Socket (RTDS) and dispatches
+ * events to the strategy's onEvent handler.
+ *
+ * @see https://docs.polymarket.com/developers/RTDS/RTDS-overview
+ *
+ * @example
+ * ```typescript
+ * const runner = createPolymarketEventRunner(strategy, {
+ *     strategyId: 'price-alert-strategy',
+ *     logger: createConsoleLogger(),
+ *     walletAddress: '0x...',
+ * }, context);
+ *
+ * runner.start();
+ * // ... later
+ * runner.stop();
+ * ```
+ */
+export declare class PolymarketEventRunner {
+    private strategy;
+    private config;
+    private context;
+    private ws;
+    private isRunning;
+    private reconnectAttempts;
+    private reconnectTimeout;
+    private pingInterval;
+    private isIntentionallyClosed;
+    private readonly maxReconnectAttempts;
+    private readonly baseReconnectDelay;
+    private readonly maxReconnectDelay;
+    private readonly pingIntervalMs;
+    constructor(strategy: CodeStrategy, config: PolymarketEventRunnerConfig, context: OsirisContext);
+    /**
+     * Start listening to events
+     * Connects to Polymarket RTDS and subscribes to events
+     */
+    start(): void;
+    /**
+     * Stop listening and disconnect from WebSocket
+     */
+    stop(): void;
+    /**
+     * Check if the runner is currently active
+     */
+    isActive(): boolean;
+    /**
+     * Get current connection status
+     */
+    getStatus(): {
+        running: boolean;
+        connected: boolean;
+        reconnectAttempts: number;
+        subscriptionCount: number;
+    };
+    /**
+     * Connect to Polymarket RTDS WebSocket
+     */
+    private connect;
+    /**
+     * Start ping interval to maintain connection (Polymarket recommends 5 seconds)
+     */
+    private startPingInterval;
+    /**
+     * Attempt to reconnect with exponential backoff
+     */
+    private attemptReconnect;
+    /**
+     * Map strategy subscriptions to Polymarket RTDS subscriptions
+     * Only MarketSubscription types are supported by Polymarket RTDS
+     * WalletSubscription and OpportunitySubscription are Osiris-only features
+     */
+    private mapToRTDSSubscriptions;
+    /**
+     * Get the message type for a given RTDS topic
+     * Each topic has specific message types as per the Polymarket RTDS documentation
+     */
+    private getMessageTypeForTopic;
+    /**
+     * Map EventType to Polymarket RTDS topic
+     */
+    private mapEventTypeToTopic;
+    /**
+     * Subscribe to events based on strategy's subscriptions
+     */
+    private subscribeToEvents;
+    /**
+     * Unsubscribe from events before disconnecting
+     */
+    private unsubscribeFromEvents;
+    /**
+     * Handle incoming WebSocket messages
+     */
+    private handleMessage;
+    /**
+     * Validate that a message is a valid Polymarket RTDS message
+     */
+    private isValidRTDSMessage;
+    /**
+     * Convert Polymarket RTDS message to StrategyEvent
+     */
+    private convertToStrategyEvent;
+    /**
+     * Map Polymarket RTDS topic to EventType
+     */
+    private mapTopicToEventType;
+    /**
+     * Extract event data from Polymarket RTDS payload
+     */
+    private extractEventData;
+    /**
+     * Dispatch an event to the strategy's onEvent handler
+     */
+    private dispatchEvent;
+}
+/**
+ * Create a PolymarketEventRunner instance for event-based strategy execution
+ *
+ * Connects directly to Polymarket's Real-Time Data Socket (RTDS) without
+ * requiring an external event source server.
+ *
+ * @param strategy - The strategy to run (must have subscriptions and onEvent)
+ * @param config - Runner configuration
+ * @param context - Osiris context with market APIs
+ * @returns PolymarketEventRunner instance
+ *
+ * @example
+ * ```typescript
+ * const runner = createPolymarketEventRunner(myStrategy, {
+ *     strategyId: 'price-alert-strategy',
+ *     logger: createConsoleLogger(),
+ *     walletAddress: '0x...', // For user-specific events
+ *     clobAuth: { // For order/trade events
+ *         key: 'your-api-key',
+ *         secret: 'your-api-secret',
+ *         passphrase: 'your-passphrase',
+ *     },
+ * }, context);
+ *
+ * runner.start();
+ * ```
+ */
+export declare function createPolymarketEventRunner(strategy: CodeStrategy, config: PolymarketEventRunnerConfig, context: OsirisContext): PolymarketEventRunner;
+//# sourceMappingURL=polymarket-event-runner.d.ts.map

package/dist/index.d.ts

@@ -1,13 +1,15 @@
 export type { CodeStrategy, } from './types/strategy';
 export type { OsirisContext, OsirisState, PolymarketAPI, HyperliquidAPI, TechnicalAnalysisAPI, SignerAPI, PolymarketOrderSide, PolymarketLimitOrderParams, PolymarketMarketOrderParams, PolymarketOrderResponse, PolymarketOpenOrder, PolymarketCancelResponse, PolymarketOrderBook, PolymarketOrderBookEntry, PolymarketApprovalResult, PolymarketClientOptions, } from './types/osiris';
-export type { EventType, EventSubscription, EventConditions, StrategyEvent, EventData, EventSourceSubscribeMessage, EventSourceUnsubscribeMessage, EventSourceMessage, } from './types/event-types';
+export type { EventType, EventSourceType, EventSubscription, EventConditions, StrategyEvent, EventData, EventSourceSubscribeMessage, EventSourceUnsubscribeMessage, EventSourceMessage, MarketSubscription, WalletSubscription, OpportunitySubscription, CustomSubscription, } from './types/event-types';
+export { isMarketSubscription, isWalletSubscription, isOpportunitySubscription, isCustomSubscription, } from './types/event-types';
 export { PolymarketClient, } from './clients/polymarket-client';
 export { HyperliquidClient, } from './clients/hyperliquid-client';
 export { MemoryStateManager, } from './state/memory-state';
 export { RedisStateManager, } from './state/redis-state';
 export { createOsirisContext, type OsirisContextConfig, } from './context/osiris-context';
 export { runStrategy, createStrategyEngine, StrategyEngine, isEventBasedStrategy, isTickBasedStrategy, validateStrategy, type StrategyRunnerConfig, type StrategyEngineConfig, } from './engine/strategy-runner';
-export { EventRunner, createEventRunner, type EventRunnerConfig, } from './engine/event-runner';
+export { OsirisEventRunner, createEventRunner, type EventRunner, type EventRunnerConfig, } from './engine/event-runner';
+export { PolymarketEventRunner, createPolymarketEventRunner, type PolymarketEventRunnerConfig, type PolymarketClobAuth, type PolymarketGammaAuth, type PolymarketRTDSSubscription, type PolymarketRTDSTopic, } from './engine/polymarket-event-runner';
 export { createConsoleLogger, type Logger, } from './utils/logger';
 export { Signer, OsirisSigner, PrivateKeySigner, type ISigner, type SignerConfig, type OsirisSignerConfig, type PrivateKeySignerConfig, } from './signer';
 //# sourceMappingURL=index.d.ts.map