@vesper85/strategy-sdk 0.1.2 → 0.1.3

package/README.md

@@ -232,41 +232,182 @@ const runner = createEventRunner(strategy, {
 
 ### Polymarket RTDS
 
-Connect directly to Polymarket's Real-Time Data Socket:
+Connect directly to Polymarket's Real-Time Data Socket for live market data.
+
+#### Strategy-Based Usage
+
+Set `eventSource: 'polymarket'` in your subscriptions:
 
 ```typescript
-// Set eventSource: 'polymarket' in subscriptions
-subscriptions: EventSubscription[] = [
-    {
-        type: 'price',
-        eventSource: 'polymarket',
-        market: 'ETH',
+import type { 
+    CodeStrategy, 
+    EventSubscription, 
+    StrategyEvent,
+    CryptoPricesSubscription,
+    ActivitySubscription,
+    ClobMarketSubscription,
+    CommentsSubscription
+} from '@osiris-ai/strategy-sdk';
+
+class MyPolymarketStrategy implements CodeStrategy {
+    subscriptions: EventSubscription[] = [
+        // Crypto price updates
+        { type: 'crypto_prices', symbol: 'btcusdt', eventSource: 'polymarket' },
+        
+        // Trade activity feed
+        { type: 'activity', messageType: '*', eventSource: 'polymarket' },
+        
+        // CLOB orderbook data (requires market condition ID)
+        { type: 'clob_market', marketId: 'condition-id', messageType: 'agg_orderbook', eventSource: 'polymarket' },
+        
+        // Comments and reactions
+        { type: 'comments', messageType: '*', eventSource: 'polymarket' },
+    ];
+
+    async onEvent(event: StrategyEvent, osiris: OsirisContext): Promise<void> {
+        const topic = event.data.raw?.topic;
+        
+        if (topic === 'crypto_prices') {
+            console.log(`BTC: $${event.data.price}`);
+        } else if (topic === 'activity') {
+            console.log(`Trade: ${event.data.side} ${event.data.size} @ ${event.data.price}`);
+        }
     }
-];
+}
 
 const runner = createEventRunner(strategy, {
     logger,
     polymarket: {
         walletAddress: '0x...',
-        // clobAuth: { ... } for private subscriptions
+        // clobAuth: { key, secret, passphrase } for clob_user subscriptions
     },
 }, context);
 ```
 
+#### Polymarket Subscription Types
+
+| Type | Description | Auth Required |
+|------|-------------|---------------|
+| `crypto_prices` | Real-time BTC/ETH/etc prices | No |
+| `activity` | Global trade activity feed | No |
+| `clob_market` | Orderbook, price changes for specific market | No |
+| `comments` | Comments and reactions | No |
+| `rfq` | Request for Quote events | No |
+| `clob_user` | Your orders and trades | Yes (clobAuth) |
+
+#### CryptoPricesSubscription
+
+```typescript
+{
+    type: 'crypto_prices',
+    symbol: 'btcusdt',  // or 'ethusdt', etc.
+    eventSource: 'polymarket'
+}
+```
+
+#### ActivitySubscription
+
+```typescript
+{
+    type: 'activity',
+    eventSlug: 'will-bitcoin-hit-100k',  // optional filter
+    marketSlug: 'market-slug',           // optional filter
+    messageType: '*',                    // 'trades', 'positions', or '*'
+    eventSource: 'polymarket'
+}
+```
+
+#### ClobMarketSubscription
+
+```typescript
+{
+    type: 'clob_market',
+    marketId: '0x1234...condition-id',   // Market condition ID
+    messageType: 'agg_orderbook',        // 'price_change', 'last_trade_price', 'tick_size_change', '*'
+    eventSource: 'polymarket'
+}
+```
+
+#### ClobUserSubscription (Requires Auth)
+
+```typescript
+{
+    type: 'clob_user',
+    messageType: '*',  // 'order', 'trade', or '*'
+    eventSource: 'polymarket'
+}
+
+// Config with clobAuth:
+const runner = createEventRunner(strategy, {
+    logger,
+    polymarket: {
+        clobAuth: {
+            key: process.env.POLYMARKET_API_KEY!,
+            secret: process.env.POLYMARKET_API_SECRET!,
+            passphrase: process.env.POLYMARKET_PASSPHRASE!,
+        }
+    }
+}, context);
+```
+
+#### CommentsSubscription
+
+```typescript
+{
+    type: 'comments',
+    parentEntityId: 'market-id',     // optional filter
+    parentEntityType: 'market',      // optional filter
+    messageType: '*',                // 'comment_created', 'reaction_created', '*'
+    eventSource: 'polymarket'
+}
+```
+
+#### RfqSubscription
+
+```typescript
+{
+    type: 'rfq',
+    messageType: '*',
+    eventSource: 'polymarket'
+}
+
 ## Type Guards
 
 Use type guards for runtime type checking:
 
 ```typescript
 import { 
+    // Generic subscription types
     isMarketSubscription, 
     isWalletSubscription,
     isOpportunitySubscription,
-    isCustomSubscription 
+    isCustomSubscription,
+    
+    // Polymarket RTDS subscription types
+    isClobMarketSubscription,
+    isClobUserSubscription,
+    isActivitySubscription,
+    isCommentsSubscription,
+    isCryptoPricesSubscription,
+    isRfqSubscription,
+    
+    // Source routing helpers
+    isPolymarketSubscription,
+    isOsirisSubscription
 } from '@osiris-ai/strategy-sdk';
 
-if (isWalletSubscription(subscription)) {
-    console.log(subscription.wallet); // TypeScript knows this is WalletSubscription
+// Check if subscription is for Polymarket
+if (isPolymarketSubscription(subscription)) {
+    // Subscription will be routed to Polymarket RTDS
+}
+
+// Check specific Polymarket types
+if (isClobMarketSubscription(subscription)) {
+    console.log(subscription.marketId); // TypeScript knows this is ClobMarketSubscription
+}
+
+if (isCryptoPricesSubscription(subscription)) {
+    console.log(subscription.symbol); // TypeScript knows this is CryptoPricesSubscription
 }
 ```
 

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;
     /**

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

@@ -132,6 +132,9 @@ export declare class PolymarketEventRunner {
     /**
      * 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;
     /**

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,7 +1,7 @@
 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, 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 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';
@@ -10,6 +10,7 @@ export { createOsirisContext, type OsirisContextConfig, } from './context/osiris
 export { runStrategy, createStrategyEngine, StrategyEngine, isEventBasedStrategy, isTickBasedStrategy, validateStrategy, type StrategyRunnerConfig, type StrategyEngineConfig, } from './engine/strategy-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