@vesper85/strategy-sdk 0.1.2 → 0.1.3

package/dist/index.js

@@ -9,6 +9,7 @@ import { createClient } from 'redis';
 import superjson from 'superjson';
 import { TechnicalAnalysisService } from '@osiris-ai/technical-indicators';
 import WebSocket from 'ws';
+import { RealTimeDataClient, ConnectionStatus } from '@polymarket/real-time-data-client';
 import { privateKeyToAccount } from 'viem/accounts';
 import { sepolia, base, optimism, arbitrum, polygon, mainnet } from 'viem/chains';
 
@@ -27,6 +28,30 @@ function isOpportunitySubscription(sub) {
 function isCustomSubscription(sub) {
   return sub.type === "custom";
 }
+function isClobMarketSubscription(sub) {
+  return sub.type === "clob_market";
+}
+function isClobUserSubscription(sub) {
+  return sub.type === "clob_user";
+}
+function isActivitySubscription(sub) {
+  return sub.type === "activity";
+}
+function isCommentsSubscription(sub) {
+  return sub.type === "comments";
+}
+function isCryptoPricesSubscription(sub) {
+  return sub.type === "crypto_prices";
+}
+function isRfqSubscription(sub) {
+  return sub.type === "rfq";
+}
+function isPolymarketSubscription(sub) {
+  return isClobMarketSubscription(sub) || isClobUserSubscription(sub) || isActivitySubscription(sub) || isCommentsSubscription(sub) || isCryptoPricesSubscription(sub) || isRfqSubscription(sub);
+}
+function isOsirisSubscription(sub) {
+  return isWalletSubscription(sub) || isOpportunitySubscription(sub);
+}
 var OsirisSigner = class {
   hubBaseUrl;
   accessToken;
@@ -161,6 +186,80 @@ var OsirisSigner = class {
     return void 0;
   }
 };
+
+// src/utils/index.ts
+function mapToGammaMarket(raw) {
+  const safeParse = (value) => {
+    try {
+      return typeof value === "string" ? JSON.parse(value) : value;
+    } catch {
+      return [];
+    }
+  };
+  return {
+    // Identity & Basic Info
+    id: raw.id,
+    question: raw.question,
+    slug: raw.slug,
+    condition_id: raw.conditionId,
+    question_id: raw.questionId,
+    // If present
+    description: raw.description,
+    // Dates
+    end_date: raw.endDate,
+    start_date: raw.startDate,
+    created_at: raw.createdAt,
+    updated_at: raw.updatedAt,
+    closed_time: raw.closedTime,
+    // Images
+    image: raw.image,
+    icon: raw.icon,
+    twitter_card_image: raw.twitterCardImage,
+    // Categorization
+    category: raw.category,
+    tags: raw.tags,
+    market_type: raw.marketType,
+    active: raw.active,
+    closed: raw.closed,
+    archived: raw.archived,
+    restricted: raw.restricted,
+    // Financials & Numbers (Type Conversions)
+    liquidity: raw.liquidity ? parseFloat(raw.liquidity) : 0,
+    volume: raw.volume,
+    // Interface keeps this as string
+    volume_24hr: raw.volume24hr?.toString(),
+    // Prices (Number -> String conversion based on your Interface)
+    best_bid: raw.bestBid?.toString(),
+    best_ask: raw.bestAsk?.toString(),
+    last_trade_price: raw.lastTradePrice?.toString(),
+    // Arrays (Parsing stringified JSON)
+    outcomes: safeParse(raw.outcomes),
+    outcome_prices: safeParse(raw.outcomePrices),
+    outcomePrices: safeParse(raw.outcomePrices),
+    // Populating alias
+    clob_token_ids: safeParse(raw.clobTokenIds),
+    clobTokenIds: safeParse(raw.clobTokenIds),
+    // Populating alias
+    uma_resolution_statuses: safeParse(raw.umaResolutionStatuses),
+    // Market Maker & Fees
+    market_maker_address: raw.marketMakerAddress,
+    maker_fee_bps: raw.makerFeeBps,
+    taker_fee_bps: raw.takerFeeBps,
+    // IDs
+    created_by: raw.updatedBy,
+    // Note: response has updatedBy, mapping to potentially relevant field
+    updated_by: raw.updatedBy,
+    // Misc
+    events: raw.events,
+    // Pass through if structure matches, otherwise map Event type similarly
+    new: raw.new,
+    featured: raw.featured,
+    cyom: raw.cyom,
+    competitive: raw.competitive
+  };
+}
+
+// src/clients/polymarket-client.ts
 var MaxUint256BigInt = typeof ethers.constants !== "undefined" && ethers.constants.MaxUint256 ? BigInt(ethers.MaxUint256.toString()) : BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 var POLYGON_CHAIN_ID = 137;
 var USDC_ADDRESS = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
@@ -178,6 +277,13 @@ var ERC1155_ABI = [
   "function setApprovalForAll(address operator, bool approved) external",
   "function isApprovedForAll(address account, address operator) external view returns (bool)"
 ];
+function wrapWalletForV5Compatibility(wallet) {
+  const wrappedWallet = wallet;
+  wrappedWallet._signTypedData = async function(domain, types, value) {
+    return wallet.signTypedData(domain, types, value);
+  };
+  return wrappedWallet;
+}
 var PolymarketClient = class {
   constructor(logger, signer, userAddress, options) {
     this.logger = logger;
@@ -185,7 +291,7 @@ var PolymarketClient = class {
     this.userAddress = userAddress;
     this.gammaClient = new PolymarketGammaClient();
     this.provider = new ethers.JsonRpcProvider(POLYGON_RPC_URL);
-    this.isOsirisSigner = signer instanceof OsirisSigner || signer.impl instanceof OsirisSigner || signer.getPrivateKey() === void 0;
+    this.isOsirisSigner = signer instanceof OsirisSigner || signer.getPrivateKey() === void 0;
     this.options = {
       chainId: options?.chainId ?? POLYGON_CHAIN_ID,
       autoApprove: options?.autoApprove ?? false,
@@ -244,10 +350,11 @@ var PolymarketClient = class {
         throw new Error("Could not obtain private key for CLOB client initialization. Private key signer is required for trading.");
       }
       this.wallet = new ethers.Wallet(privateKey, this.provider);
+      const v5CompatibleWallet = wrapWalletForV5Compatibility(this.wallet);
       const tempClient = new ClobClient(
         this.options.clobHost,
         this.options.chainId,
-        this.wallet
+        v5CompatibleWallet
       );
       this.logger.info("Deriving API credentials...");
       const apiCreds = await tempClient.createOrDeriveApiKey();
@@ -255,7 +362,7 @@ var PolymarketClient = class {
       this.clobClient = new ClobClient(
         this.options.clobHost,
         this.options.chainId,
-        this.wallet,
+        v5CompatibleWallet,
         apiCreds,
         signatureType
       );
@@ -269,15 +376,6 @@ var PolymarketClient = class {
   isTradingClientInitialized() {
     return this.tradingInitialized;
   }
-  async getPrivateKeyFromSigner() {
-    if (this.signer && "getPrivateKey" in this.signer) {
-      return this.signer.getPrivateKey();
-    }
-    if (this.signer && this.signer.account?.privateKey) {
-      return this.signer.account.privateKey;
-    }
-    return null;
-  }
   ensureTradingClient() {
     if (!this.clobClient || !this.tradingInitialized) {
       throw new Error("Trading client not initialized. Call initializeTradingClient() first.");
@@ -1099,7 +1197,8 @@ var PolymarketClient = class {
         throw new Error(`Gamma API error: ${response.status} ${response.statusText}`);
       }
       const data = await response.json();
-      return data;
+      const mappedData = data.map(mapToGammaMarket);
+      return mappedData;
     } catch (error) {
       this.logger.error("Error fetching markets from Gamma API", error);
       throw error;
@@ -1596,11 +1695,11 @@ async function runStrategy(strategy, config, context) {
     }
     return false;
   } catch (error) {
-    config.logger.error(`Error executing strategy: ${error.message}`, error);
+    config.logger?.error(`Error executing strategy: ${error.message}`, error);
     throw error;
   }
 }
-function createStrategyEngine(strategy, config, context) {
+function createStrategyEngine(strategy, context, config) {
   return new StrategyEngine(strategy, config, context);
 }
 var StrategyEngine = class {
@@ -1608,6 +1707,7 @@ var StrategyEngine = class {
     this.strategy = strategy;
     this.config = config;
     this.context = context;
+    this.config.logger = this.config.logger || createConsoleLogger();
   }
   intervalId = null;
   isRunning = false;
@@ -1615,6 +1715,9 @@ var StrategyEngine = class {
    * Start the engine with the configured tick interval
    */
   start() {
+    if (!this.config.logger) {
+      this.config.logger = createConsoleLogger();
+    }
     if (this.isRunning) {
       this.config.logger.warning("Strategy engine is already running");
       return;
@@ -1631,6 +1734,9 @@ var StrategyEngine = class {
    * Stop the engine
    */
   stop() {
+    if (!this.config.logger) {
+      this.config.logger = createConsoleLogger();
+    }
     if (!this.isRunning) {
       return;
     }
@@ -1649,6 +1755,9 @@ var StrategyEngine = class {
   }
   async tick() {
     const tickStart = Date.now();
+    if (!this.config.logger) {
+      this.config.logger = createConsoleLogger();
+    }
     this.config.logger.debug(`Tick start: ${(/* @__PURE__ */ new Date()).toISOString()}`);
     try {
       await runStrategy(this.strategy, this.config, this.context);
@@ -1862,7 +1971,59 @@ var PolymarketEventRunner = class {
     const rtdsSubscriptions = [];
     for (const sub of this.strategy.subscriptions) {
       let rtdsSub = null;
-      if (isMarketSubscription(sub)) {
+      if (isCryptoPricesSubscription(sub)) {
+        rtdsSub = {
+          topic: "crypto_prices",
+          type: "update"
+        };
+        if (sub.symbol) {
+          rtdsSub.filters = JSON.stringify({ symbol: sub.symbol.toLowerCase() });
+        }
+      } else if (isActivitySubscription(sub)) {
+        rtdsSub = {
+          topic: "activity",
+          type: sub.messageType || "*"
+        };
+        if (sub.eventSlug) {
+          rtdsSub.filters = JSON.stringify({ event_slug: sub.eventSlug });
+        } else if (sub.marketSlug) {
+          rtdsSub.filters = JSON.stringify({ market_slug: sub.marketSlug });
+        }
+      } else if (isClobMarketSubscription(sub)) {
+        rtdsSub = {
+          topic: "clob_market",
+          type: sub.messageType || "*",
+          filters: JSON.stringify([sub.marketId])
+        };
+      } else if (isClobUserSubscription(sub)) {
+        rtdsSub = {
+          topic: "clob_user",
+          type: sub.messageType || "*"
+        };
+        if (this.config.clobAuth) {
+          rtdsSub.clob_auth = this.config.clobAuth;
+        } else {
+          this.config.logger.warning(
+            `clob_user subscription requires clobAuth credentials`
+          );
+        }
+      } else if (isCommentsSubscription(sub)) {
+        rtdsSub = {
+          topic: "comments",
+          type: sub.messageType || "*"
+        };
+        if (sub.parentEntityId && sub.parentEntityType) {
+          rtdsSub.filters = JSON.stringify({
+            parentEntityID: sub.parentEntityId,
+            parentEntityType: sub.parentEntityType
+          });
+        }
+      } else if (isRfqSubscription(sub)) {
+        rtdsSub = {
+          topic: "rfq",
+          type: sub.messageType || "*"
+        };
+      } else if (isMarketSubscription(sub)) {
         const topic = this.mapEventTypeToTopic(sub.type);
         rtdsSub = {
           topic,
@@ -1891,7 +2052,7 @@ var PolymarketEventRunner = class {
         }
       } else {
         this.config.logger.warning(
-          `Subscription type '${sub.type}' is not supported by Polymarket RTDS. Only market subscriptions (price, orderbook, trade, fill) and custom subscriptions with valid RTDS topics are supported.`
+          `Subscription type '${sub.type}' is not supported by Polymarket RTDS. Osiris-only subscription types (wallet, opportunity) should use eventSource: 'osiris'.`
         );
         continue;
       }
@@ -1911,6 +2072,9 @@ var PolymarketEventRunner = class {
   /**
    * 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.
    */
   getMessageTypeForTopic(topic) {
     switch (topic) {
@@ -1918,15 +2082,18 @@ var PolymarketEventRunner = class {
         return "update";
       case "comments":
         return "comment_created";
-      // Subscribes to all comment events
       case "trades":
-        return "orders_matched";
+        this.config.logger.warning(
+          `Topic 'trades' may not be supported by Polymarket RTDS. Consider using the CLOB WebSocket API for order/trade events.`
+        );
+        return "trade";
       case "orders":
+        this.config.logger.warning(
+          `Topic 'orders' may not be supported by Polymarket RTDS. Consider using the CLOB WebSocket API for order/trade events.`
+        );
         return "order_placed";
-      // Can also be 'order_cancelled', 'order_filled'
       case "activity":
         return "trade";
-      // Can also be 'offer', etc.
       case "profile":
         return "update";
       default:
@@ -2525,6 +2692,888 @@ function createEventRunner(strategy, config, context) {
   if (!config.eventSourceUrl) ;
   return new OsirisEventRunner(strategy, config, context);
 }
+var PolymarketRTDSService = class {
+  client = null;
+  config;
+  isConnected = false;
+  activeSubscriptions = [];
+  constructor(config) {
+    this.config = config;
+  }
+  /**
+   * Connect to the Polymarket RTDS WebSocket
+   */
+  connect() {
+    if (this.isConnected) {
+      this.config.logger.warning("PolymarketRTDS: Already connected");
+      return;
+    }
+    this.config.logger.info("PolymarketRTDS: Connecting...");
+    this.client = new RealTimeDataClient({
+      onConnect: (_client) => {
+        this.isConnected = true;
+        this.config.logger.info("PolymarketRTDS: Connected");
+        this.config.onConnect?.();
+      },
+      onMessage: (_client, message) => {
+        this.handleMessage(message);
+      },
+      onStatusChange: (status) => {
+        if (status === ConnectionStatus.DISCONNECTED) {
+          this.isConnected = false;
+          this.config.logger.info("PolymarketRTDS: Disconnected");
+          this.config.onDisconnect?.();
+        } else if (status === ConnectionStatus.CONNECTING) {
+          this.config.logger.info("PolymarketRTDS: Reconnecting...");
+        }
+      },
+      pingInterval: this.config.pingIntervalMs ?? 5e3,
+      autoReconnect: this.config.autoReconnect ?? true
+    });
+    this.client.connect();
+  }
+  /**
+   * Disconnect from the Polymarket RTDS WebSocket
+   */
+  disconnect() {
+    if (!this.client) {
+      return;
+    }
+    this.config.logger.info("PolymarketRTDS: Disconnecting...");
+    this.client.disconnect();
+    this.client = null;
+    this.isConnected = false;
+    this.activeSubscriptions = [];
+  }
+  /**
+   * Check if connected
+   */
+  isActive() {
+    return this.isConnected;
+  }
+  /**
+   * Subscribe to events
+   * Converts SDK EventSubscription types to RTDS Subscription format
+   */
+  subscribe(subscriptions) {
+    if (!this.client) {
+      this.config.logger.warning("PolymarketRTDS: Cannot subscribe - not connected");
+      return;
+    }
+    const rtdsSubscriptions = this.mapToRTDSSubscriptions(subscriptions);
+    if (rtdsSubscriptions.length === 0) {
+      this.config.logger.warning("PolymarketRTDS: No valid subscriptions to add");
+      return;
+    }
+    const msg = { subscriptions: rtdsSubscriptions };
+    this.client.subscribe(msg);
+    this.activeSubscriptions.push(...rtdsSubscriptions);
+    this.config.logger.info(
+      `PolymarketRTDS: Subscribed to ${rtdsSubscriptions.length} topic(s): ` + rtdsSubscriptions.map((s) => `${s.topic}:${s.type}`).join(", ")
+    );
+  }
+  /**
+   * Unsubscribe from events
+   */
+  unsubscribe(subscriptions) {
+    if (!this.client) {
+      return;
+    }
+    const rtdsSubscriptions = this.mapToRTDSSubscriptions(subscriptions);
+    if (rtdsSubscriptions.length === 0) {
+      return;
+    }
+    const msg = { subscriptions: rtdsSubscriptions };
+    this.client.unsubscribe(msg);
+    for (const unsub of rtdsSubscriptions) {
+      const idx = this.activeSubscriptions.findIndex(
+        (s) => s.topic === unsub.topic && s.type === unsub.type
+      );
+      if (idx >= 0) {
+        this.activeSubscriptions.splice(idx, 1);
+      }
+    }
+    this.config.logger.info(
+      `PolymarketRTDS: Unsubscribed from ${rtdsSubscriptions.length} topic(s)`
+    );
+  }
+  /**
+   * Map SDK EventSubscription to RTDS Subscription format
+   */
+  mapToRTDSSubscriptions(subscriptions) {
+    const result = [];
+    for (const sub of subscriptions) {
+      const rtdsSub = this.mapSubscription(sub);
+      if (rtdsSub) {
+        result.push(rtdsSub);
+      }
+    }
+    return result;
+  }
+  /**
+   * Map a single SDK EventSubscription to RTDS Subscription
+   */
+  mapSubscription(sub) {
+    if (isClobMarketSubscription(sub)) {
+      return this.mapClobMarketSubscription(sub);
+    }
+    if (isClobUserSubscription(sub)) {
+      return this.mapClobUserSubscription(sub);
+    }
+    if (isActivitySubscription(sub)) {
+      return this.mapActivitySubscription(sub);
+    }
+    if (isCommentsSubscription(sub)) {
+      return this.mapCommentsSubscription(sub);
+    }
+    if (isCryptoPricesSubscription(sub)) {
+      return this.mapCryptoPricesSubscription(sub);
+    }
+    if (isRfqSubscription(sub)) {
+      return this.mapRfqSubscription(sub);
+    }
+    if (isMarketSubscription(sub)) {
+      return this.mapMarketSubscription(sub);
+    }
+    this.config.logger.warning(
+      `PolymarketRTDS: Unsupported subscription type '${sub.type}'`
+    );
+    return null;
+  }
+  mapClobMarketSubscription(sub) {
+    return {
+      topic: "clob_market",
+      type: sub.messageType || "*",
+      filters: JSON.stringify([sub.marketId])
+    };
+  }
+  mapClobUserSubscription(sub) {
+    if (!this.config.clobAuth) {
+      this.config.logger.warning(
+        "PolymarketRTDS: clob_user subscription requires clobAuth credentials"
+      );
+    }
+    return {
+      topic: "clob_user",
+      type: sub.messageType || "*",
+      clob_auth: this.config.clobAuth
+    };
+  }
+  mapActivitySubscription(sub) {
+    let filters;
+    if (sub.eventSlug) {
+      filters = JSON.stringify({ event_slug: sub.eventSlug });
+    } else if (sub.marketSlug) {
+      filters = JSON.stringify({ market_slug: sub.marketSlug });
+    }
+    return {
+      topic: "activity",
+      type: sub.messageType || "*",
+      filters
+    };
+  }
+  mapCommentsSubscription(sub) {
+    let filters;
+    if (sub.parentEntityId && sub.parentEntityType) {
+      filters = JSON.stringify({
+        parentEntityID: sub.parentEntityId,
+        parentEntityType: sub.parentEntityType
+      });
+    }
+    return {
+      topic: "comments",
+      type: sub.messageType || "*",
+      filters
+    };
+  }
+  mapCryptoPricesSubscription(sub) {
+    let filters;
+    if (sub.symbol) {
+      filters = JSON.stringify({ symbol: sub.symbol.toLowerCase() });
+    }
+    return {
+      topic: "crypto_prices",
+      type: "update",
+      filters
+    };
+  }
+  mapRfqSubscription(sub) {
+    return {
+      topic: "rfq",
+      type: sub.messageType || "*"
+    };
+  }
+  mapMarketSubscription(sub) {
+    switch (sub.type) {
+      case "price":
+        return {
+          topic: "clob_market",
+          type: "price_change",
+          filters: JSON.stringify([sub.market])
+        };
+      case "orderbook":
+        return {
+          topic: "clob_market",
+          type: "agg_orderbook",
+          filters: JSON.stringify([sub.market])
+        };
+      case "trade":
+        return {
+          topic: "activity",
+          type: "trades",
+          filters: JSON.stringify({ market_slug: sub.market })
+        };
+      case "fill":
+        if (!this.config.clobAuth) {
+          this.config.logger.warning(
+            "PolymarketRTDS: fill subscription requires clobAuth credentials"
+          );
+        }
+        return {
+          topic: "clob_user",
+          type: "order",
+          clob_auth: this.config.clobAuth
+        };
+      default:
+        return {
+          topic: "activity",
+          type: "trades",
+          filters: JSON.stringify({ market_slug: sub.market })
+        };
+    }
+  }
+  /**
+   * Handle incoming RTDS messages
+   */
+  handleMessage(message) {
+    try {
+      const event = this.convertToStrategyEvent(message);
+      this.config.onEvent(event);
+    } catch (error) {
+      this.config.logger.error(
+        `PolymarketRTDS: Error processing message - ${error.message}`
+      );
+    }
+  }
+  /**
+   * Convert RTDS Message to StrategyEvent
+   */
+  convertToStrategyEvent(message) {
+    const eventType = this.mapTopicToEventType(message.topic, message.type);
+    const eventData = this.extractEventData(message);
+    return {
+      type: eventType,
+      timestamp: message.timestamp || Date.now(),
+      market: eventData.market,
+      data: eventData
+    };
+  }
+  /**
+   * Map RTDS topic/type to SDK EventType
+   */
+  mapTopicToEventType(topic, type) {
+    switch (topic) {
+      case "crypto_prices":
+        return "price";
+      case "clob_market":
+        switch (type) {
+          case "price_change":
+          case "last_trade_price":
+            return "price";
+          case "agg_orderbook":
+            return "orderbook";
+          default:
+            return "custom";
+        }
+      case "activity":
+        return "trade";
+      case "clob_user":
+        return type === "trade" ? "trade" : "fill";
+      default:
+        return "custom";
+    }
+  }
+  /**
+   * Extract event data from RTDS message payload
+   */
+  extractEventData(message) {
+    const payload = message.payload;
+    const data = {
+      raw: {
+        topic: message.topic,
+        type: message.type,
+        ...payload
+      }
+    };
+    switch (message.topic) {
+      case "crypto_prices":
+        data.price = payload.value;
+        data.market = payload.symbol;
+        break;
+      case "clob_market":
+        if (message.type === "price_change") {
+          data.market = payload.market;
+          if (payload.price_changes?.length > 0) {
+            const change = payload.price_changes[0];
+            data.bestBid = parseFloat(change.best_bid);
+            data.bestAsk = parseFloat(change.best_ask);
+            data.price = parseFloat(change.price);
+          }
+        } else if (message.type === "agg_orderbook") {
+          data.market = payload.market;
+          data.bids = payload.bids;
+          data.asks = payload.asks;
+          if (payload.bids?.length > 0) {
+            data.bestBid = parseFloat(payload.bids[0].price);
+          }
+          if (payload.asks?.length > 0) {
+            data.bestAsk = parseFloat(payload.asks[0].price);
+          }
+        } else if (message.type === "last_trade_price") {
+          data.market = payload.market;
+          data.price = parseFloat(payload.price);
+          data.side = payload.side;
+          data.size = parseFloat(payload.size);
+        }
+        break;
+      case "activity":
+        data.market = payload.slug || payload.conditionId;
+        data.price = payload.price;
+        data.size = payload.size;
+        data.side = payload.side?.toLowerCase();
+        data.tradeId = payload.transactionHash;
+        break;
+      case "clob_user":
+        data.market = payload.market;
+        data.orderId = payload.id;
+        data.price = parseFloat(payload.price);
+        data.size = parseFloat(payload.size || payload.original_size);
+        data.side = payload.side?.toLowerCase();
+        break;
+      case "rfq":
+        data.market = payload.market;
+        data.price = payload.price;
+        data.size = payload.sizeIn || payload.sizeOut;
+        data.side = payload.side?.toLowerCase();
+        break;
+    }
+    return data;
+  }
+};
+function createPolymarketRTDSService(config) {
+  return new PolymarketRTDSService(config);
+}
+var DEFAULT_OSIRIS_RTDS_URL = "wss://rtds.osirislabs.xyz";
+var OsirisRTDSService = class {
+  ws = null;
+  config;
+  isConnected = false;
+  reconnectAttempts = 0;
+  reconnectTimeout = null;
+  pingInterval = null;
+  isIntentionallyClosed = false;
+  activeTopics = /* @__PURE__ */ new Set();
+  // Reconnection settings
+  maxReconnectAttempts;
+  baseReconnectDelay;
+  maxReconnectDelay;
+  pingIntervalMs;
+  url;
+  constructor(config) {
+    this.config = config;
+    this.maxReconnectAttempts = config.reconnect?.maxAttempts ?? 10;
+    this.baseReconnectDelay = config.reconnect?.delayMs ?? 1e3;
+    this.maxReconnectDelay = config.reconnect?.maxDelayMs ?? 3e4;
+    this.pingIntervalMs = config.pingIntervalMs ?? 3e4;
+    this.url = config.url || DEFAULT_OSIRIS_RTDS_URL;
+  }
+  /**
+   * Connect to the Osiris Pub/Sub WebSocket
+   */
+  connect() {
+    if (this.isConnected) {
+      this.config.logger.warning("OsirisRTDS: Already connected");
+      return;
+    }
+    this.isIntentionallyClosed = false;
+    this.config.logger.info(`OsirisRTDS: Connecting to ${this.url}...`);
+    try {
+      this.ws = new WebSocket(this.url);
+      this.ws.on("open", () => {
+        this.isConnected = true;
+        this.reconnectAttempts = 0;
+        this.config.logger.info("OsirisRTDS: Connected");
+        this.startPingInterval();
+        this.config.onConnect?.();
+      });
+      this.ws.on("message", (data) => {
+        this.handleMessage(data);
+      });
+      this.ws.on("error", (error) => {
+        this.config.logger.error(`OsirisRTDS: Error - ${error.message}`);
+        this.config.onError?.(error);
+      });
+      this.ws.on("close", (code, reason) => {
+        this.isConnected = false;
+        this.stopPingInterval();
+        const reasonStr = reason.toString() || "none";
+        this.config.logger.info(`OsirisRTDS: Disconnected (code: ${code}, reason: ${reasonStr})`);
+        this.config.onDisconnect?.();
+        if (!this.isIntentionallyClosed) {
+          this.attemptReconnect();
+        }
+      });
+    } catch (error) {
+      this.config.logger.error(`OsirisRTDS: Connection failed - ${error.message}`);
+      if (!this.isIntentionallyClosed) {
+        this.attemptReconnect();
+      }
+    }
+  }
+  /**
+   * Disconnect from the Osiris Pub/Sub WebSocket
+   */
+  disconnect() {
+    this.isIntentionallyClosed = true;
+    this.stopPingInterval();
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.ws) {
+      this.config.logger.info("OsirisRTDS: Disconnecting...");
+      try {
+        if (this.activeTopics.size > 0) {
+          this.unsubscribeFromTopics(Array.from(this.activeTopics));
+        }
+        this.ws.close(1e3, "Intentional close");
+      } catch {
+      }
+      this.ws = null;
+    }
+    this.isConnected = false;
+    this.activeTopics.clear();
+  }
+  /**
+   * Check if connected
+   */
+  isActive() {
+    return this.isConnected;
+  }
+  /**
+   * Subscribe to events
+   */
+  subscribe(subscriptions) {
+    if (!this.ws || !this.isConnected) {
+      this.config.logger.warning("OsirisRTDS: Cannot subscribe - not connected");
+      return;
+    }
+    const { topics, filters } = this.mapToOsirisSubscriptions(subscriptions);
+    if (topics.length === 0) {
+      this.config.logger.warning("OsirisRTDS: No valid topics to subscribe");
+      return;
+    }
+    const message = {
+      action: "subscribe",
+      topics,
+      ...Object.keys(filters).length > 0 ? { filters } : {}
+    };
+    try {
+      this.ws.send(JSON.stringify(message));
+      topics.forEach((t) => this.activeTopics.add(t));
+      this.config.logger.info(`OsirisRTDS: Subscribing to ${topics.join(", ")}`);
+    } catch (error) {
+      this.config.logger.error(`OsirisRTDS: Failed to subscribe - ${error.message}`);
+    }
+  }
+  /**
+   * Unsubscribe from topics
+   */
+  unsubscribe(subscriptions) {
+    if (!this.ws || !this.isConnected) {
+      return;
+    }
+    const { topics } = this.mapToOsirisSubscriptions(subscriptions);
+    this.unsubscribeFromTopics(topics);
+  }
+  /**
+   * Unsubscribe from topics by name
+   */
+  unsubscribeFromTopics(topics) {
+    if (topics.length === 0) return;
+    const message = {
+      action: "unsubscribe",
+      topics
+    };
+    try {
+      this.ws?.send(JSON.stringify(message));
+      topics.forEach((t) => this.activeTopics.delete(t));
+      this.config.logger.info(`OsirisRTDS: Unsubscribed from ${topics.join(", ")}`);
+    } catch {
+    }
+  }
+  /**
+   * Send ping to keep connection alive
+   */
+  ping() {
+    if (this.ws && this.isConnected) {
+      try {
+        this.ws.send(JSON.stringify({ action: "ping" }));
+      } catch {
+      }
+    }
+  }
+  /**
+   * Map SDK subscriptions to Osiris Pub/Sub format
+   */
+  mapToOsirisSubscriptions(subscriptions) {
+    const topics = [];
+    const filters = {};
+    for (const sub of subscriptions) {
+      const topic = this.mapSubscriptionToTopic(sub);
+      if (topic) {
+        topics.push(topic);
+        if (sub.conditions) {
+          filters[topic] = sub.conditions;
+        }
+      }
+    }
+    return { topics, filters };
+  }
+  /**
+   * Map SDK subscription to Osiris topic string
+   */
+  mapSubscriptionToTopic(sub) {
+    if (isMarketSubscription(sub)) {
+      return sub.market ? `market:${sub.market}` : null;
+    }
+    if (isWalletSubscription(sub)) {
+      return sub.wallet ? `wallet:${sub.wallet.toLowerCase()}` : null;
+    }
+    if (isOpportunitySubscription(sub)) {
+      return `opps:${sub.filter || "all"}`;
+    }
+    if (isCustomSubscription(sub)) {
+      return sub.topic || null;
+    }
+    return null;
+  }
+  /**
+   * Start ping interval
+   */
+  startPingInterval() {
+    this.stopPingInterval();
+    this.pingInterval = setInterval(() => this.ping(), this.pingIntervalMs);
+  }
+  /**
+   * Stop ping interval
+   */
+  stopPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+  }
+  /**
+   * Attempt reconnection with exponential backoff
+   */
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.config.logger.error(
+        `OsirisRTDS: Max reconnection attempts (${this.maxReconnectAttempts}) reached`
+      );
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts - 1) + Math.random() * 1e3,
+      this.maxReconnectDelay
+    );
+    this.config.logger.info(
+      `OsirisRTDS: Reconnecting in ${Math.round(delay)}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`
+    );
+    this.reconnectTimeout = setTimeout(() => {
+      this.reconnectTimeout = null;
+      this.connect();
+    }, delay);
+  }
+  /**
+   * Handle incoming WebSocket messages
+   */
+  handleMessage(data) {
+    try {
+      const rawData = typeof data === "string" ? data : data.toString();
+      if (!rawData.trim()) return;
+      let message;
+      try {
+        message = JSON.parse(rawData);
+      } catch {
+        this.config.logger.warning(`OsirisRTDS: Non-JSON message received`);
+        return;
+      }
+      switch (message.type) {
+        case "connected":
+          this.config.logger.info(`OsirisRTDS: ${message.message}`);
+          return;
+        case "subscribe.result":
+          if (message.success) {
+            this.config.logger.info(
+              `OsirisRTDS: Subscribed to ${message.subscribed?.join(", ")}`
+            );
+          } else {
+            this.config.logger.error(
+              `OsirisRTDS: Subscription failed - ${message.errors?.join(", ")}`
+            );
+          }
+          return;
+        case "error":
+          this.config.logger.error(`OsirisRTDS: Server error - ${message.error}`);
+          return;
+        case "pong":
+          return;
+      }
+      const event = this.convertToStrategyEvent(message);
+      if (event) {
+        this.config.onEvent(event);
+      }
+    } catch (error) {
+      this.config.logger.error(`OsirisRTDS: Error processing message - ${error.message}`);
+    }
+  }
+  /**
+   * Convert Osiris message to StrategyEvent
+   */
+  convertToStrategyEvent(message) {
+    const timestamp = message.ts || Date.now();
+    switch (message.type) {
+      case "market.analysis":
+        return {
+          type: "price",
+          // Market analysis treated as price/market update
+          market: message.slug,
+          timestamp,
+          data: {
+            ...message.data,
+            raw: message
+          }
+        };
+      case "wallet.analysis":
+        return {
+          type: "wallet",
+          wallet: message.address,
+          timestamp,
+          data: {
+            ...message.data,
+            raw: message
+          }
+        };
+      case "opportunity":
+        return {
+          type: "opportunity",
+          market: message.slug,
+          timestamp,
+          data: {
+            ...message.data,
+            raw: message
+          }
+        };
+      default:
+        return null;
+    }
+  }
+};
+function createOsirisRTDSService(config) {
+  return new OsirisRTDSService(config);
+}
+
+// src/rtds/unified-rtds.service.ts
+var UnifiedRTDSService = class {
+  config;
+  polymarketService = null;
+  osirisService = null;
+  polymarketConnected = false;
+  osirisConnected = false;
+  constructor(config) {
+    this.config = config;
+    this.initializeServices();
+  }
+  /**
+   * Initialize the underlying services based on configuration
+   */
+  initializeServices() {
+    if (this.config.polymarket?.enabled !== false) {
+      this.polymarketService = new PolymarketRTDSService({
+        logger: this.config.logger,
+        onEvent: this.config.onEvent,
+        onError: this.config.onError,
+        onConnect: () => {
+          this.polymarketConnected = true;
+          this.checkAllConnected();
+        },
+        onDisconnect: () => {
+          this.polymarketConnected = false;
+          this.checkAnyDisconnected();
+        },
+        clobAuth: this.config.polymarket?.clobAuth
+      });
+    }
+    if (this.config.osiris?.enabled !== false) {
+      this.osirisService = new OsirisRTDSService({
+        logger: this.config.logger,
+        onEvent: this.config.onEvent,
+        onError: this.config.onError,
+        onConnect: () => {
+          this.osirisConnected = true;
+          this.checkAllConnected();
+        },
+        onDisconnect: () => {
+          this.osirisConnected = false;
+          this.checkAnyDisconnected();
+        },
+        url: this.config.osiris?.url || DEFAULT_OSIRIS_RTDS_URL,
+        pingIntervalMs: this.config.osiris?.pingIntervalMs,
+        reconnect: this.config.reconnect
+      });
+    }
+  }
+  /**
+   * Connect to all enabled services
+   */
+  connect() {
+    this.config.logger.info("UnifiedRTDS: Connecting to enabled services...");
+    if (this.polymarketService) {
+      this.polymarketService.connect();
+    }
+    if (this.osirisService) {
+      this.osirisService.connect();
+    }
+  }
+  /**
+   * Disconnect from all services
+   */
+  disconnect() {
+    this.config.logger.info("UnifiedRTDS: Disconnecting from all services...");
+    if (this.polymarketService) {
+      this.polymarketService.disconnect();
+    }
+    if (this.osirisService) {
+      this.osirisService.disconnect();
+    }
+  }
+  /**
+   * Check if connected to at least one service
+   */
+  isActive() {
+    return (this.polymarketService?.isActive() ?? false) || (this.osirisService?.isActive() ?? false);
+  }
+  /**
+   * Get connection status for each service
+   */
+  getStatus() {
+    return {
+      polymarket: {
+        enabled: this.polymarketService !== null,
+        connected: this.polymarketConnected
+      },
+      osiris: {
+        enabled: this.osirisService !== null,
+        connected: this.osirisConnected
+      }
+    };
+  }
+  /**
+   * Subscribe to events
+   * Automatically routes subscriptions to the appropriate backend
+   */
+  subscribe(subscriptions) {
+    const { polymarketSubs, osirisSubs } = this.routeSubscriptions(subscriptions);
+    if (polymarketSubs.length > 0) {
+      if (this.polymarketService) {
+        this.polymarketService.subscribe(polymarketSubs);
+      } else {
+        this.config.logger.warning(
+          "UnifiedRTDS: Polymarket subscriptions requested but service not enabled"
+        );
+      }
+    }
+    if (osirisSubs.length > 0) {
+      if (this.osirisService) {
+        this.osirisService.subscribe(osirisSubs);
+      } else {
+        this.config.logger.warning(
+          "UnifiedRTDS: Osiris subscriptions requested but service not enabled"
+        );
+      }
+    }
+  }
+  /**
+   * Unsubscribe from events
+   */
+  unsubscribe(subscriptions) {
+    const { polymarketSubs, osirisSubs } = this.routeSubscriptions(subscriptions);
+    if (polymarketSubs.length > 0 && this.polymarketService) {
+      this.polymarketService.unsubscribe(polymarketSubs);
+    }
+    if (osirisSubs.length > 0 && this.osirisService) {
+      this.osirisService.unsubscribe(osirisSubs);
+    }
+  }
+  /**
+   * Route subscriptions to appropriate backends based on type and eventSource
+   */
+  routeSubscriptions(subscriptions) {
+    const polymarketSubs = [];
+    const osirisSubs = [];
+    for (const sub of subscriptions) {
+      if (sub.eventSource === "polymarket") {
+        polymarketSubs.push(sub);
+        continue;
+      }
+      if (sub.eventSource === "osiris") {
+        osirisSubs.push(sub);
+        continue;
+      }
+      if (isPolymarketSubscription(sub)) {
+        polymarketSubs.push(sub);
+      } else if (isOsirisSubscription(sub)) {
+        osirisSubs.push(sub);
+      } else if (isMarketSubscription(sub)) {
+        polymarketSubs.push(sub);
+      } else if (isCustomSubscription(sub)) {
+        const topic = sub.topic;
+        if (topic.startsWith("market:") || topic.startsWith("wallet:") || topic.startsWith("opps:")) {
+          osirisSubs.push(sub);
+        } else {
+          polymarketSubs.push(sub);
+        }
+      } else {
+        polymarketSubs.push(sub);
+      }
+    }
+    return { polymarketSubs, osirisSubs };
+  }
+  /**
+   * Check if all enabled services are connected
+   */
+  checkAllConnected() {
+    const polymarketOk = !this.polymarketService || this.polymarketConnected;
+    const osirisOk = !this.osirisService || this.osirisConnected;
+    if (polymarketOk && osirisOk) {
+      this.config.onConnect?.();
+    }
+  }
+  /**
+   * Check if any service disconnected
+   */
+  checkAnyDisconnected() {
+    if (!this.polymarketConnected && !this.osirisConnected) {
+      this.config.onDisconnect?.();
+    }
+  }
+};
+function createUnifiedRTDSService(config) {
+  return new UnifiedRTDSService(config);
+}
 var CHAIN_MAP = {
   "evm:eip155:1": mainnet,
   "evm:eip155:137": polygon,
@@ -2675,6 +3724,6 @@ var Signer = class {
   }
 };
 
-export { HyperliquidClient, MemoryStateManager, OsirisEventRunner, OsirisSigner, PolymarketClient, PolymarketEventRunner, PrivateKeySigner, RedisStateManager, Signer, StrategyEngine, createConsoleLogger, createEventRunner, createOsirisContext, createPolymarketEventRunner, createStrategyEngine, isCustomSubscription, isEventBasedStrategy, isMarketSubscription, isOpportunitySubscription, isTickBasedStrategy, isWalletSubscription, runStrategy, validateStrategy };
+export { DEFAULT_OSIRIS_RTDS_URL, HyperliquidClient, MemoryStateManager, OsirisEventRunner, OsirisRTDSService, OsirisSigner, PolymarketClient, PolymarketEventRunner, PolymarketRTDSService, PrivateKeySigner, RedisStateManager, Signer, StrategyEngine, UnifiedRTDSService, createConsoleLogger, createEventRunner, createOsirisContext, createOsirisRTDSService, createPolymarketEventRunner, createPolymarketRTDSService, createStrategyEngine, createUnifiedRTDSService, isActivitySubscription, isClobMarketSubscription, isClobUserSubscription, isCommentsSubscription, isCryptoPricesSubscription, isCustomSubscription, isEventBasedStrategy, isMarketSubscription, isOpportunitySubscription, isOsirisSubscription, isPolymarketSubscription, isRfqSubscription, isTickBasedStrategy, isWalletSubscription, runStrategy, validateStrategy };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map