@vesper85/strategy-sdk 0.1.0 → 0.1.3

package/dist/clients/polymarket-client.d.ts

@@ -1,4 +1,4 @@
-import { type GammaMarket, type Event as GammaEvent, type Tag, type Team, type Sport, type Series, type Comment as GammaComment, type SearchResults, type PaginatedResponse, type MarketFilters, type EventFilters, type EventPaginationFilters, type PaginationParams, type SearchParams } from "polymarket-gamma";
+import { GammaMarket, type Event as GammaEvent, type Tag, type Team, type Sport, type Series, type Comment as GammaComment, type SearchResults, type PaginatedResponse, type MarketFilters, type EventFilters, type EventPaginationFilters, type PaginationParams, type SearchParams } from "polymarket-gamma";
 import type { PolymarketAPI, PolymarketClientOptions, PolymarketLimitOrderParams, PolymarketMarketOrderParams, PolymarketOrderResponse, PolymarketOpenOrder, PolymarketCancelResponse, PolymarketOrderBook, PolymarketApprovalResult, SignerAPI } from "../types/osiris";
 import type { Logger } from "../utils/logger";
 export declare class PolymarketClient implements PolymarketAPI {
@@ -16,7 +16,6 @@ export declare class PolymarketClient implements PolymarketAPI {
     constructor(logger: Logger, signer: SignerAPI, userAddress: string, options?: PolymarketClientOptions);
     initializeTradingClient(): Promise<void>;
     isTradingClientInitialized(): boolean;
-    private getPrivateKeyFromSigner;
     private ensureTradingClient;
     private ensureMcpInstance;
     /**
@@ -87,22 +86,6 @@ export declare class PolymarketClient implements PolymarketAPI {
     private ensureApprovals;
     buy(tokenId: string, size: number): Promise<void>;
     sell(tokenId: string, size: number): Promise<void>;
-    /**
-     * Place a limit buy order
-     */
-    buyLimit(tokenId: string, price: number, size: number): Promise<PolymarketOrderResponse>;
-    /**
-     * Place a limit sell order
-     */
-    sellLimit(tokenId: string, price: number, size: number): Promise<PolymarketOrderResponse>;
-    /**
-     * Place a market buy order
-     */
-    buyMarket(tokenId: string, amount: number, slippage?: number): Promise<PolymarketOrderResponse>;
-    /**
-     * Place a market sell order
-     */
-    sellMarket(tokenId: string, size: number, slippage?: number): Promise<PolymarketOrderResponse>;
     getPrice(ticker: string): Promise<number>;
     getIndicator(ticker: string, indicator: string, params?: any): Promise<number>;
     search(params: SearchParams): Promise<SearchResults>;

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

@@ -1,16 +1,24 @@
 import type { CodeStrategy } from "../types/strategy";
 import type { OsirisContext } from "../types/osiris";
 import type { Logger } from "../utils/logger";
+import { PolymarketEventRunner, type PolymarketClobAuth } from "./polymarket-event-runner";
+export type EventRunner = OsirisEventRunner | PolymarketEventRunner;
 /**
  * Configuration for the EventRunner
  */
 export interface EventRunnerConfig {
     /** Logger instance for logging */
     logger: Logger;
-    /** WebSocket URL for the event source server */
-    eventSourceUrl: string;
+    /** WebSocket URL for the event source server (Required for 'osiris' source) */
+    eventSourceUrl?: string;
     /** Optional strategy ID for logging (defaults to 'unnamed-strategy') */
     strategyId?: string;
+    /** Polymarket specific configuration */
+    polymarket?: {
+        clobAuth?: PolymarketClobAuth;
+        walletAddress?: string;
+        pingIntervalMs?: number;
+    };
     /** Reconnection settings */
     reconnect?: {
         /** Maximum number of reconnection attempts (default: 10) */
@@ -41,7 +49,12 @@ export interface EventRunnerConfig {
  * runner.stop();
  * ```
  */
-export declare class EventRunner {
+/**
+ * Osiris Event Runner (Generic)
+ *
+ * Connects to a generic Osiris WebSocket event source.
+ */
+export declare class OsirisEventRunner {
     private strategy;
     private config;
     private context;
@@ -87,7 +100,19 @@ export declare class EventRunner {
     /**
      * Subscribe to events based on strategy's subscriptions
      */
+    /**
+     * Subscribe to events based on strategy's subscriptions
+     * Maps SDK subscriptions to Osiris Pub/Sub protocol
+     */
     private subscribeToEvents;
+    /**
+     * Map EventSubscription to Osiris Pub/Sub topic string
+     * Uses discriminated union to properly handle each subscription type
+     */
+    private mapSubscriptionToTopic;
+    /**
+     * Unsubscribe from events before disconnecting
+     */
     /**
      * Unsubscribe from events before disconnecting
      */
@@ -96,6 +121,11 @@ export declare class EventRunner {
      * Handle incoming WebSocket messages
      */
     private handleMessage;
+    /**
+     * Map incoming Osiris message to StrategyEvent
+     * Uses proper fields for each event type (market vs wallet)
+     */
+    private mapMessageToStrategyEvent;
     /**
      * Validate that a message is a valid StrategyEvent
      */

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

@@ -0,0 +1,205 @@
+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
+     *
+     * Note: Only 'crypto_prices' and 'comments' are documented RTDS topics.
+     * 'trades' and 'orders' subscriptions require the CLOB WebSocket API, not RTDS.
+     */
+    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/engine/strategy-runner.d.ts

@@ -1,11 +1,10 @@
 import type { CodeStrategy } from "../types/strategy";
 import type { OsirisContext } from "../types/osiris";
-import type { Logger } from "../utils/logger";
+import { type Logger } from "../utils/logger";
 export interface StrategyRunnerConfig {
-    /** Logger instance for logging */
-    logger: Logger;
     /** Optional strategy ID for logging (defaults to 'unnamed-strategy') */
     strategyId?: string;
+    logger?: Logger;
 }
 export interface StrategyEngineConfig extends StrategyRunnerConfig {
     /** Interval between ticks in milliseconds (default: 60000) */
@@ -22,7 +21,7 @@ export declare function runStrategy(strategy: CodeStrategy, config: StrategyRunn
  * Create a strategy engine that runs a strategy on a tick interval
  * Returns a controller object to start/stop the engine
  */
-export declare function createStrategyEngine(strategy: CodeStrategy, config: StrategyEngineConfig, context: OsirisContext): StrategyEngine;
+export declare function createStrategyEngine(strategy: CodeStrategy, context: OsirisContext, config: StrategyEngineConfig): StrategyEngine;
 /**
  * Strategy Engine that runs a strategy on a tick interval
  */

package/dist/index.d.ts

@@ -1,13 +1,16 @@
 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, ClobMarketSubscription, ClobUserSubscription, ActivitySubscription, CommentsSubscription, CryptoPricesSubscription, RfqSubscription, } from './types/event-types';
+export { isMarketSubscription, isWalletSubscription, isOpportunitySubscription, isCustomSubscription, isClobMarketSubscription, isClobUserSubscription, isActivitySubscription, isCommentsSubscription, isCryptoPricesSubscription, isRfqSubscription, isPolymarketSubscription, isOsirisSubscription, } 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 { UnifiedRTDSService, createUnifiedRTDSService, PolymarketRTDSService, createPolymarketRTDSService, OsirisRTDSService, createOsirisRTDSService, DEFAULT_OSIRIS_RTDS_URL, type UnifiedRTDSConfig, type PolymarketRTDSConfig, type OsirisRTDSConfig, type ClobApiKeyCreds, } from './rtds';
 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