@vesper85/strategy-sdk 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,19 +1,32 @@
 import { PolymarketGammaClient } from 'polymarket-gamma';
 import { ClobClient, Side } from '@polymarket/clob-client';
-import { MaxUint256, ethers } from 'ethers';
+import { ethers } from 'ethers';
 import axios from 'axios';
 import { serializeSignature, createWalletClient, http } from 'viem';
 import { connectMCPServer, removeConnection } from '@osiris-ai/agent-sdk';
 import { Hyperliquid } from 'hyperliquid';
 import { createClient } from 'redis';
 import superjson from 'superjson';
-import { TechnicalAnalysisService } from '@vesper85/technical-indicators';
+import { TechnicalAnalysisService } from '@osiris-ai/technical-indicators';
 import WebSocket from 'ws';
 import { privateKeyToAccount } from 'viem/accounts';
 import { sepolia, base, optimism, arbitrum, polygon, mainnet } from 'viem/chains';
 
 // @osiris-ai/strategy-sdk - Strategy SDK for Trading
 
+// src/types/event-types.ts
+function isMarketSubscription(sub) {
+  return sub.type === "price" || sub.type === "orderbook" || sub.type === "trade" || sub.type === "fill";
+}
+function isWalletSubscription(sub) {
+  return sub.type === "wallet";
+}
+function isOpportunitySubscription(sub) {
+  return sub.type === "opportunity";
+}
+function isCustomSubscription(sub) {
+  return sub.type === "custom";
+}
 var OsirisSigner = class {
   hubBaseUrl;
   accessToken;
@@ -148,13 +161,14 @@ var OsirisSigner = class {
     return void 0;
   }
 };
-var MaxUint256BigInt = BigInt(MaxUint256.toString());
+var MaxUint256BigInt = typeof ethers.constants !== "undefined" && ethers.constants.MaxUint256 ? BigInt(ethers.MaxUint256.toString()) : BigInt("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff");
 var POLYGON_CHAIN_ID = 137;
 var USDC_ADDRESS = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174";
 var CTF_ADDRESS = "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045";
 var CTF_EXCHANGE_ADDRESS = "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E";
 var DEFAULT_CLOB_HOST = "https://clob.polymarket.com";
 var POLYGON_RPC_URL = "https://polygon-rpc.com";
+process.env.MCP_GATEWAY_URL ? `${process.env.MCP_GATEWAY_URL}/@osiris/polymarket/mcp` : "https://gateway.backend.osirislabs.xyz/@osiris/polymarket/mcp";
 var ERC20_ABI = [
   "function approve(address spender, uint256 amount) external returns (bool)",
   "function allowance(address owner, address spender) external view returns (uint256)",
@@ -234,7 +248,6 @@ var PolymarketClient = class {
         this.options.clobHost,
         this.options.chainId,
         this.wallet
-        // Cast to any for CLOB client v5 compatibility
       );
       this.logger.info("Deriving API credentials...");
       const apiCreds = await tempClient.createOrDeriveApiKey();
@@ -243,7 +256,6 @@ var PolymarketClient = class {
         this.options.clobHost,
         this.options.chainId,
         this.wallet,
-        // Cast to any for CLOB client v5 compatibility
         apiCreds,
         signatureType
       );
@@ -568,7 +580,7 @@ var PolymarketClient = class {
       const allowanceResult = await this.callMCPTool("check_allowance", {
         token: tokenType
       });
-      this.logger.debug("[MCP] Allowance check result:", allowanceResult);
+      console.log("allowanceResult", allowanceResult);
       const allowanceContent = this.extractMCPContent(allowanceResult);
       const contractMatches = allowanceContent?.match(/0x[a-fA-F0-9]{40}:\s*(true|false)/gi);
       let hasFullAllowance = true;
@@ -661,18 +673,6 @@ var PolymarketClient = class {
       ctfWasAlreadyApproved: false
     };
     try {
-      const address = this.userAddress;
-      if (!address) {
-        throw new Error("userAddress is required for MCP approvals");
-      }
-      const chooseWalletResult = await this.callMCPTool("choose_wallet", {
-        address
-      });
-      const walletError = this.detectMCPError(chooseWalletResult);
-      if (walletError) {
-        this.logger.error(`[MCP] Choose wallet failed: ${walletError}`);
-        throw new Error(`Choose wallet failed: ${walletError}`);
-      }
       const usdcHasAllowance = await this.checkAllowanceViaMCP("USDC");
       if (usdcHasAllowance) {
         result.usdcWasAlreadyApproved = true;
@@ -753,16 +753,13 @@ var PolymarketClient = class {
       if (!address) {
         throw new Error("userAddress is required for MCP order placement");
       }
-      this.logger.info(`[MCP] Creating limit order: ${params.side} ${params.size} @ ${params.price}`);
-      this.logger.debug(`[MCP] Using wallet address: ${address}`);
-      this.logger.debug(`[MCP] Calling choose_wallet for address: ${address}`);
+      this.logger.info(`Creating limit order via MCP: ${params.side} ${params.size} @ ${params.price}`);
       const chooseWalletResult = await this.callMCPTool("choose_wallet", {
         address
       });
-      this.logger.debug(`[MCP] choose_wallet result: ${JSON.stringify(chooseWalletResult, null, 2)}`);
       const walletError = this.detectMCPError(chooseWalletResult);
       if (walletError) {
-        this.logger.error(`[MCP] Choose wallet failed: ${walletError}`);
+        this.logger.error(`Choose wallet failed: ${walletError}`);
         return {
           success: false,
           errorMsg: walletError
@@ -775,7 +772,7 @@ var PolymarketClient = class {
           errorMsg: `Failed to approve ${params.side === "BUY" ? "USDC" : "Conditional Token"}. Please try again.`
         };
       }
-      const orderParams = {
+      const orderResult = await this.callMCPTool("create_and_post_order", {
         userOrder: {
           tokenID: params.tokenId,
           side: params.side,
@@ -784,11 +781,7 @@ var PolymarketClient = class {
         },
         orderType: params.expiration ? "GTD" : "GTC",
         deferExec: false
-      };
-      this.logger.debug(`[MCP] Limit order params:`, orderParams);
-      this.logger.info(`[MCP] Submitting limit order: ${params.side} ${params.size} @ ${params.price} for token ${params.tokenId.substring(0, 20)}...`);
-      const orderResult = await this.callMCPTool("create_and_post_order", orderParams);
-      this.logger.debug(`[MCP] Raw limit order result: ${JSON.stringify(orderResult, null, 2)}`);
+      });
       const orderError = this.detectMCPError(orderResult);
       if (orderError) {
         this.logger.error(`Limit order via MCP failed: ${orderError}`);
@@ -799,13 +792,13 @@ var PolymarketClient = class {
       }
       const orderDetails = this.extractOrderDetails(orderResult);
       if (!orderDetails) {
-        this.logger.error(`Failed to extract order details from MCP response`, orderResult);
+        this.logger.error("Failed to extract order details from MCP response");
         return {
           success: false,
           errorMsg: "Failed to extract order details from MCP response"
         };
       }
-      this.logger.info(`[MCP] Limit order created: ${orderDetails.orderID}`);
+      this.logger.info(`Limit order via MCP created: ${orderDetails.orderID}`);
       return {
         success: true,
         orderId: orderDetails.orderID,
@@ -866,14 +859,10 @@ var PolymarketClient = class {
       if (!address) {
         throw new Error("userAddress is required for MCP order placement");
       }
-      this.logger.info(`[MCP] Creating market order: ${params.side} ${params.amount} USDC`);
-      this.logger.debug(`[MCP] Using wallet address: ${address}`);
-      this.logger.debug(`[MCP] Order details: tokenId=${params.tokenId}, side=${params.side}, amount=${params.amount}`);
-      this.logger.debug(`[MCP] Calling choose_wallet for address: ${address}`);
+      this.logger.info(`Creating market order via MCP: ${params.side} ${params.amount}`);
       const chooseWalletResult = await this.callMCPTool("choose_wallet", {
         address
       });
-      this.logger.debug(`[MCP] choose_wallet result: ${JSON.stringify(chooseWalletResult, null, 2)}`);
       const walletError = this.detectMCPError(chooseWalletResult);
       if (walletError) {
         this.logger.error(`Choose wallet failed: ${walletError}`);
@@ -889,19 +878,16 @@ var PolymarketClient = class {
           errorMsg: `Failed to approve ${params.side === "BUY" ? "USDC" : "Conditional Token"}. Please try again.`
         };
       }
-      const orderParams = {
+      const orderResult = await this.callMCPTool("create_and_post_market_order", {
         userMarketOrder: {
           tokenID: params.tokenId,
           side: params.side,
-          amount: params.amount
+          amount: params.amount,
+          orderType: params.slippageTolerance ? "FOK" : "FOK"
+          // Fill or Kill
         },
         orderType: "FOK"
-        // Fill or Kill
-      };
-      this.logger.debug(`[MCP] Market order params:`, orderParams);
-      this.logger.info(`[MCP] Submitting market order: ${params.side} ${params.amount} USDC for token ${params.tokenId.substring(0, 20)}...`);
-      const orderResult = await this.callMCPTool("create_and_post_market_order", orderParams);
-      this.logger.debug(`[MCP] Raw order result: ${JSON.stringify(orderResult, null, 2)}`);
+      });
       const orderError = this.detectMCPError(orderResult);
       if (orderError) {
         this.logger.error(`Market order via MCP failed: ${orderError}`);
@@ -912,7 +898,7 @@ var PolymarketClient = class {
       }
       const orderDetails = this.extractOrderDetails(orderResult);
       if (!orderDetails) {
-        this.logger.error(`Failed to extract order details from MCP response`, orderResult);
+        this.logger.error("Failed to extract order details from MCP response");
         return {
           success: false,
           errorMsg: "Failed to extract order details from MCP response"
@@ -1027,9 +1013,8 @@ var PolymarketClient = class {
   // ============================================
   async buy(tokenId, size) {
     if (!this.tradingInitialized) {
-      throw new Error(
-        `Trading client not initialized. Call initializeTradingClient() before placing orders. Attempted to buy ${size} USDC of token ${tokenId}.`
-      );
+      this.logger.warning(`[Dummy] Buying ${size} of ${tokenId} - trading client not initialized`);
+      return;
     }
     const response = await this.createMarketOrder({
       tokenId,
@@ -1042,9 +1027,8 @@ var PolymarketClient = class {
   }
   async sell(tokenId, size) {
     if (!this.tradingInitialized) {
-      throw new Error(
-        `Trading client not initialized. Call initializeTradingClient() before placing orders. Attempted to sell ${size} shares of token ${tokenId}.`
-      );
+      this.logger.warning(`[Dummy] Selling ${size} of ${tokenId} - trading client not initialized`);
+      return;
     }
     const response = await this.createMarketOrder({
       tokenId,
@@ -1056,73 +1040,6 @@ var PolymarketClient = class {
     }
   }
   // ============================================
-  // Convenience Trading Methods
-  // ============================================
-  /**
-   * Place a limit buy order
-   */
-  async buyLimit(tokenId, price, size) {
-    if (!this.tradingInitialized) {
-      throw new Error(
-        `Trading client not initialized. Call initializeTradingClient() before placing orders.`
-      );
-    }
-    return this.createLimitOrder({
-      tokenId,
-      price,
-      size,
-      side: "BUY"
-    });
-  }
-  /**
-   * Place a limit sell order
-   */
-  async sellLimit(tokenId, price, size) {
-    if (!this.tradingInitialized) {
-      throw new Error(
-        `Trading client not initialized. Call initializeTradingClient() before placing orders.`
-      );
-    }
-    return this.createLimitOrder({
-      tokenId,
-      price,
-      size,
-      side: "SELL"
-    });
-  }
-  /**
-   * Place a market buy order
-   */
-  async buyMarket(tokenId, amount, slippage = 0.05) {
-    if (!this.tradingInitialized) {
-      throw new Error(
-        `Trading client not initialized. Call initializeTradingClient() before placing orders.`
-      );
-    }
-    return this.createMarketOrder({
-      tokenId,
-      amount,
-      side: "BUY",
-      slippageTolerance: slippage
-    });
-  }
-  /**
-   * Place a market sell order
-   */
-  async sellMarket(tokenId, size, slippage = 0.05) {
-    if (!this.tradingInitialized) {
-      throw new Error(
-        `Trading client not initialized. Call initializeTradingClient() before placing orders.`
-      );
-    }
-    return this.createMarketOrder({
-      tokenId,
-      amount: size,
-      side: "SELL",
-      slippageTolerance: slippage
-    });
-  }
-  // ============================================
   // Data Methods
   // ============================================
   async getPrice(ticker) {
@@ -1270,26 +1187,8 @@ var PolymarketClient = class {
     return this.fetchData("/activity", { user, ...params });
   }
   async getTopHolders(marketId) {
-    try {
-      if (this.clobClient) {
-        try {
-          const market = await this.getMarket(marketId);
-          if (market && market.tokens) {
-            return market.tokens.map((token) => ({
-              tokenId: token.token_id,
-              outcome: token.outcome,
-              holders: token.holders || 0
-            }));
-          }
-        } catch (e) {
-        }
-      }
-      this.logger.debug("getTopHolders: No direct API available, returning market token info if available");
-      return [];
-    } catch (error) {
-      this.logger.error(`Error fetching top holders for ${marketId}`, error);
-      return [];
-    }
+    this.logger.warning("getTopHolders not directly supported by public Data API");
+    return [];
   }
   async getPortfolioValue(user) {
     try {
@@ -1304,18 +1203,8 @@ var PolymarketClient = class {
     }
   }
   async getClosedPositions(user, params) {
-    try {
-      const allPositions = await this.getPositions(user, params);
-      const closedPositions = allPositions.filter((pos) => {
-        const size = parseFloat(pos.size || pos.amount || "0");
-        const isClosed = size === 0 || pos.closed === true || pos.status === "closed";
-        return isClosed;
-      });
-      return closedPositions;
-    } catch (error) {
-      this.logger.error("Error fetching closed positions", error);
-      return [];
-    }
+    this.logger.warning("getClosedPositions not directly supported, returning empty");
+    return [];
   }
   async getTradedMarketsCount(user) {
     try {
@@ -1338,21 +1227,8 @@ var PolymarketClient = class {
   }
   // Account methods
   async getPosition(ticker) {
-    try {
-      if (!this.userAddress) {
-        this.logger.error("getPosition requires userAddress to be set");
-        return null;
-      }
-      const positions = await this.getPositions(this.userAddress);
-      const matchingPosition = positions.find((pos) => {
-        const marketMatch = pos.market === ticker || pos.slug === ticker || pos.condition_id === ticker || pos.asset_id === ticker || pos.token_id === ticker;
-        return marketMatch && parseFloat(pos.size || pos.amount || "0") > 0;
-      });
-      return matchingPosition || null;
-    } catch (error) {
-      this.logger.error(`Error fetching position for ${ticker}`, error);
-      return null;
-    }
+    this.logger.warning("getPosition(ticker) not implemented. Use getPositions(user) instead.");
+    return null;
   }
 };
 var HyperliquidClient = class {
@@ -1803,7 +1679,8 @@ function validateStrategy(strategy) {
     );
   }
 }
-var EventRunner = class {
+var POLYMARKET_RTDS_URL = "wss://ws-live-data.polymarket.com";
+var PolymarketEventRunner = class {
   constructor(strategy, config, context) {
     this.strategy = strategy;
     this.config = config;
@@ -1817,6 +1694,464 @@ var EventRunner = class {
     this.maxReconnectAttempts = config.reconnect?.maxAttempts ?? 10;
     this.baseReconnectDelay = config.reconnect?.delayMs ?? 1e3;
     this.maxReconnectDelay = config.reconnect?.maxDelayMs ?? 3e4;
+    this.pingIntervalMs = config.pingIntervalMs ?? 5e3;
+  }
+  ws = null;
+  isRunning = false;
+  reconnectAttempts = 0;
+  reconnectTimeout = null;
+  pingInterval = null;
+  isIntentionallyClosed = false;
+  // Default reconnection settings
+  maxReconnectAttempts;
+  baseReconnectDelay;
+  maxReconnectDelay;
+  pingIntervalMs;
+  /**
+   * Start listening to events
+   * Connects to Polymarket RTDS and subscribes to events
+   */
+  start() {
+    if (this.isRunning) {
+      this.config.logger.warning("Polymarket event runner is already running");
+      return;
+    }
+    this.isRunning = true;
+    this.isIntentionallyClosed = false;
+    this.reconnectAttempts = 0;
+    const strategyName = this.config.strategyId || "unnamed-strategy";
+    this.config.logger.info(`Starting Polymarket event runner for strategy ${strategyName}`);
+    this.config.logger.info(`Connecting to Polymarket RTDS: ${POLYMARKET_RTDS_URL}`);
+    this.connect();
+  }
+  /**
+   * Stop listening and disconnect from WebSocket
+   */
+  stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    this.isIntentionallyClosed = true;
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+      this.pingInterval = null;
+    }
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.ws) {
+      try {
+        this.unsubscribeFromEvents();
+        this.ws.close(1e3, "Intentional close");
+      } catch (error) {
+      }
+      this.ws = null;
+    }
+    this.config.logger.info("Polymarket event runner stopped");
+  }
+  /**
+   * Check if the runner is currently active
+   */
+  isActive() {
+    return this.isRunning;
+  }
+  /**
+   * Get current connection status
+   */
+  getStatus() {
+    return {
+      running: this.isRunning,
+      connected: this.ws?.readyState === WebSocket.OPEN,
+      reconnectAttempts: this.reconnectAttempts,
+      subscriptionCount: this.strategy.subscriptions?.length ?? 0
+    };
+  }
+  /**
+   * Connect to Polymarket RTDS WebSocket
+   */
+  connect() {
+    if (this.isIntentionallyClosed) {
+      return;
+    }
+    try {
+      this.ws = new WebSocket(POLYMARKET_RTDS_URL);
+      this.ws.on("open", () => {
+        this.config.logger.info("Connected to Polymarket RTDS");
+        this.reconnectAttempts = 0;
+        this.startPingInterval();
+        this.subscribeToEvents();
+      });
+      this.ws.on("message", (data) => {
+        this.handleMessage(data);
+      });
+      this.ws.on("error", (error) => {
+        this.config.logger.error(`Polymarket RTDS WebSocket error: ${error.message}`, error);
+      });
+      this.ws.on("close", (code, reason) => {
+        const reasonStr = reason.toString() || "none";
+        this.config.logger.info(`Polymarket RTDS WebSocket closed (code: ${code}, reason: ${reasonStr})`);
+        if (this.pingInterval) {
+          clearInterval(this.pingInterval);
+          this.pingInterval = null;
+        }
+        if (!this.isIntentionallyClosed && this.isRunning) {
+          this.attemptReconnect();
+        }
+      });
+      this.ws.on("pong", () => {
+        this.config.logger.debug("Received PONG from Polymarket RTDS");
+      });
+    } catch (error) {
+      this.config.logger.error(`Failed to connect to Polymarket RTDS: ${error.message}`, error);
+      if (this.isRunning && !this.isIntentionallyClosed) {
+        this.attemptReconnect();
+      }
+    }
+  }
+  /**
+   * Start ping interval to maintain connection (Polymarket recommends 5 seconds)
+   */
+  startPingInterval() {
+    if (this.pingInterval) {
+      clearInterval(this.pingInterval);
+    }
+    this.pingInterval = setInterval(() => {
+      if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+        try {
+          this.ws.send("PING");
+          this.config.logger.debug("Sent PING to Polymarket RTDS");
+        } catch (error) {
+          this.config.logger.warning("Failed to send PING");
+        }
+      }
+    }, this.pingIntervalMs);
+  }
+  /**
+   * Attempt to reconnect with exponential backoff
+   */
+  attemptReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.config.logger.error(`Max reconnection attempts (${this.maxReconnectAttempts}) reached`);
+      this.isRunning = false;
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = Math.min(
+      this.baseReconnectDelay * Math.pow(2, this.reconnectAttempts - 1) + Math.random() * 1e3,
+      this.maxReconnectDelay
+    );
+    this.config.logger.info(
+      `Reconnecting in ${Math.round(delay)}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`
+    );
+    this.reconnectTimeout = setTimeout(() => {
+      this.reconnectTimeout = null;
+      this.connect();
+    }, delay);
+  }
+  /**
+   * Map strategy subscriptions to Polymarket RTDS subscriptions
+   * Only MarketSubscription types are supported by Polymarket RTDS
+   * WalletSubscription and OpportunitySubscription are Osiris-only features
+   */
+  mapToRTDSSubscriptions() {
+    if (!this.strategy.subscriptions) {
+      return [];
+    }
+    const rtdsSubscriptions = [];
+    for (const sub of this.strategy.subscriptions) {
+      let rtdsSub = null;
+      if (isMarketSubscription(sub)) {
+        const topic = this.mapEventTypeToTopic(sub.type);
+        rtdsSub = {
+          topic,
+          type: this.getMessageTypeForTopic(topic)
+        };
+      } else if (isCustomSubscription(sub)) {
+        const validRTDSTopics = [
+          "crypto_prices",
+          "comments",
+          "activity",
+          "orders",
+          "trades",
+          "profile"
+        ];
+        if (validRTDSTopics.includes(sub.topic)) {
+          const topic = sub.topic;
+          rtdsSub = {
+            topic,
+            type: this.getMessageTypeForTopic(topic)
+          };
+        } else {
+          this.config.logger.warning(
+            `Custom subscription topic '${sub.topic}' is not a valid Polymarket RTDS topic. Valid topics: ${validRTDSTopics.join(", ")}`
+          );
+          continue;
+        }
+      } 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.`
+        );
+        continue;
+      }
+      if (!rtdsSub) continue;
+      if (this.config.clobAuth && ["orders", "trades"].includes(rtdsSub.topic)) {
+        rtdsSub.clob_auth = this.config.clobAuth;
+      }
+      if (this.config.walletAddress && ["activity", "profile"].includes(rtdsSub.topic)) {
+        rtdsSub.gamma_auth = {
+          address: this.config.walletAddress
+        };
+      }
+      rtdsSubscriptions.push(rtdsSub);
+    }
+    return rtdsSubscriptions;
+  }
+  /**
+   * Get the message type for a given RTDS topic
+   * Each topic has specific message types as per the Polymarket RTDS documentation
+   */
+  getMessageTypeForTopic(topic) {
+    switch (topic) {
+      case "crypto_prices":
+        return "update";
+      case "comments":
+        return "comment_created";
+      // Subscribes to all comment events
+      case "trades":
+        return "orders_matched";
+      case "orders":
+        return "order_placed";
+      // Can also be 'order_cancelled', 'order_filled'
+      case "activity":
+        return "trade";
+      // Can also be 'offer', etc.
+      case "profile":
+        return "update";
+      default:
+        return "update";
+    }
+  }
+  /**
+   * Map EventType to Polymarket RTDS topic
+   */
+  mapEventTypeToTopic(eventType) {
+    switch (eventType) {
+      case "price":
+        return "crypto_prices";
+      case "trade":
+        return "trades";
+      case "orderbook":
+      case "fill":
+        return "orders";
+      case "custom":
+        return "activity";
+      default:
+        return "activity";
+    }
+  }
+  /**
+   * Subscribe to events based on strategy's subscriptions
+   */
+  subscribeToEvents() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      this.config.logger.warning("Cannot subscribe - WebSocket not connected");
+      return;
+    }
+    if (!this.strategy.subscriptions || this.strategy.subscriptions.length === 0) {
+      this.config.logger.warning("No subscriptions defined for strategy");
+      return;
+    }
+    const rtdsSubscriptions = this.mapToRTDSSubscriptions();
+    const subscribeMessage = {
+      action: "subscribe",
+      subscriptions: rtdsSubscriptions
+    };
+    try {
+      this.ws.send(JSON.stringify(subscribeMessage));
+      this.config.logger.info(
+        `Subscribed to ${rtdsSubscriptions.length} Polymarket RTDS topic(s): ` + rtdsSubscriptions.map((s) => s.topic).join(", ")
+      );
+    } catch (error) {
+      this.config.logger.error(`Failed to send subscription: ${error.message}`, error);
+    }
+  }
+  /**
+   * Unsubscribe from events before disconnecting
+   */
+  unsubscribeFromEvents() {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    if (!this.strategy.subscriptions || this.strategy.subscriptions.length === 0) {
+      return;
+    }
+    const rtdsSubscriptions = this.mapToRTDSSubscriptions();
+    const unsubscribeMessage = {
+      action: "unsubscribe",
+      subscriptions: rtdsSubscriptions
+    };
+    try {
+      this.ws.send(JSON.stringify(unsubscribeMessage));
+    } catch (error) {
+    }
+  }
+  /**
+   * Handle incoming WebSocket messages
+   */
+  handleMessage(data) {
+    try {
+      const rawData = typeof data === "string" ? data : data.toString();
+      if (rawData === "PING") {
+        this.ws?.send("PONG");
+        return;
+      }
+      if (rawData === "PONG" || rawData.trim() === "") {
+        return;
+      }
+      let message;
+      try {
+        message = JSON.parse(rawData);
+      } catch (parseError) {
+        this.config.logger.warning(`Received non-JSON message: ${rawData.slice(0, 100)}`);
+        return;
+      }
+      if (!this.isValidRTDSMessage(message)) {
+        this.config.logger.debug(`Received non-event message: ${JSON.stringify(message).slice(0, 200)}`);
+        return;
+      }
+      const strategyEvent = this.convertToStrategyEvent(message);
+      this.dispatchEvent(strategyEvent);
+    } catch (error) {
+      this.config.logger.error(`Error handling message: ${error.message}`, error);
+    }
+  }
+  /**
+   * Validate that a message is a valid Polymarket RTDS message
+   */
+  isValidRTDSMessage(message) {
+    return message && typeof message === "object" && typeof message.topic === "string" && typeof message.type === "string" && typeof message.timestamp === "number" && typeof message.payload === "object";
+  }
+  /**
+   * Convert Polymarket RTDS message to StrategyEvent
+   */
+  convertToStrategyEvent(message) {
+    const eventType = this.mapTopicToEventType(message.topic);
+    const eventData = this.extractEventData(message);
+    return {
+      type: eventType,
+      timestamp: message.timestamp,
+      market: eventData.market,
+      data: eventData
+    };
+  }
+  /**
+   * Map Polymarket RTDS topic to EventType
+   */
+  mapTopicToEventType(topic) {
+    switch (topic) {
+      case "crypto_prices":
+        return "price";
+      case "trades":
+        return "trade";
+      case "orders":
+        return "orderbook";
+      case "activity":
+      case "comments":
+      case "profile":
+      default:
+        return "custom";
+    }
+  }
+  /**
+   * Extract event data from Polymarket RTDS payload
+   */
+  extractEventData(message) {
+    const payload = message.payload;
+    const data = {
+      raw: {
+        ...payload,
+        topic: message.topic,
+        // Include topic for easier filtering
+        type: message.type
+        // Include message type
+      }
+    };
+    switch (message.topic) {
+      case "crypto_prices":
+        data.price = payload.price ?? payload.value;
+        data.previousPrice = payload.previousPrice ?? payload.previous;
+        data.changePercent = payload.changePercent ?? payload.change;
+        break;
+      case "trades":
+        data.price = payload.price;
+        data.size = payload.size ?? payload.amount;
+        data.side = payload.side;
+        data.tradeId = payload.tradeId ?? payload.id;
+        break;
+      case "orders":
+        data.bestBid = payload.bestBid ?? payload.bid;
+        data.bestAsk = payload.bestAsk ?? payload.ask;
+        data.spread = payload.spread;
+        data.orderId = payload.orderId ?? payload.id;
+        break;
+      case "comments":
+        data.commentText = payload.text ?? payload.comment;
+        data.author = payload.author ?? payload.user;
+        data.market = payload.market ?? payload.slug;
+        data.commentType = payload.type;
+        data.reactions = payload.reactions;
+        break;
+    }
+    if (payload.market) data.market = payload.market;
+    if (payload.asset) data.market = payload.asset;
+    if (payload.tokenId) data.market = payload.tokenId;
+    if (payload.conditionId) data.market = payload.conditionId;
+    return data;
+  }
+  /**
+   * Dispatch an event to the strategy's onEvent handler
+   */
+  async dispatchEvent(event) {
+    const eventStart = Date.now();
+    this.config.logger.debug(
+      `Dispatching ${event.type} event${event.market ? ` for ${event.market}` : ""}`
+    );
+    try {
+      if (this.strategy.onEvent) {
+        await this.strategy.onEvent(event, this.context);
+      }
+    } catch (error) {
+      this.config.logger.error(
+        `Error in strategy onEvent handler: ${error.message}`,
+        error
+      );
+    }
+    const eventDuration = Date.now() - eventStart;
+    this.config.logger.debug(`Event handling completed in ${eventDuration}ms`);
+  }
+};
+function createPolymarketEventRunner(strategy, config, context) {
+  return new PolymarketEventRunner(strategy, config, context);
+}
+
+// src/engine/event-runner.ts
+var OsirisEventRunner = class {
+  constructor(strategy, config, context) {
+    this.strategy = strategy;
+    this.config = config;
+    this.context = context;
+    if (!this.strategy.subscriptions || this.strategy.subscriptions.length === 0) {
+      throw new Error("Strategy must have subscriptions defined for event-based execution");
+    }
+    if (typeof this.strategy.onEvent !== "function") {
+      throw new Error("Strategy must implement onEvent method for event-based execution");
+    }
+    this.maxReconnectAttempts = config.reconnect?.maxAttempts ?? 10;
+    this.baseReconnectDelay = config.reconnect?.delayMs ?? 1e3;
+    this.maxReconnectDelay = config.reconnect?.maxDelayMs ?? 3e4;
+    if (!config.eventSourceUrl) ;
   }
   ws = null;
   isRunning = false;
@@ -1892,6 +2227,9 @@ var EventRunner = class {
       return;
     }
     try {
+      if (!this.config.eventSourceUrl) {
+        throw new Error("eventSourceUrl is required for OsirisEventRunner");
+      }
       this.ws = new WebSocket(this.config.eventSourceUrl);
       this.ws.on("open", () => {
         this.config.logger.info("Connected to event source");
@@ -1943,6 +2281,10 @@ var EventRunner = class {
   /**
    * Subscribe to events based on strategy's subscriptions
    */
+  /**
+   * Subscribe to events based on strategy's subscriptions
+   * Maps SDK subscriptions to Osiris Pub/Sub protocol
+   */
   subscribeToEvents() {
     if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
       this.config.logger.warning("Cannot subscribe - WebSocket not connected");
@@ -1952,19 +2294,63 @@ var EventRunner = class {
       this.config.logger.warning("No subscriptions defined for strategy");
       return;
     }
+    const topics = [];
+    const filters = {};
+    for (const sub of this.strategy.subscriptions) {
+      const topic = this.mapSubscriptionToTopic(sub);
+      if (topic) {
+        topics.push(topic);
+        if (sub.conditions) {
+          filters[topic] = sub.conditions;
+        }
+      }
+    }
+    if (topics.length === 0) {
+      this.config.logger.warning("No valid topics mapped from subscriptions");
+      return;
+    }
     const subscribeMessage = {
       action: "subscribe",
-      subscriptions: this.strategy.subscriptions
+      topics,
+      filters: Object.keys(filters).length > 0 ? filters : void 0
     };
     try {
       this.ws.send(JSON.stringify(subscribeMessage));
       this.config.logger.info(
-        `Subscribed to ${this.strategy.subscriptions.length} event(s): ` + this.strategy.subscriptions.map((s) => `${s.type}${s.market ? `@${s.market}` : ""}`).join(", ")
+        `Subscribed to ${topics.length} topics: ${topics.join(", ")}`
       );
     } catch (error) {
       this.config.logger.error(`Failed to send subscription: ${error.message}`, error);
     }
   }
+  /**
+   * Map EventSubscription to Osiris Pub/Sub topic string
+   * Uses discriminated union to properly handle each subscription type
+   */
+  mapSubscriptionToTopic(sub) {
+    switch (sub.type) {
+      // Market subscriptions → market:{market}
+      case "price":
+      case "orderbook":
+      case "trade":
+      case "fill":
+        return sub.market ? `market:${sub.market}` : null;
+      // Wallet subscriptions → wallet:{wallet}
+      case "wallet":
+        return sub.wallet ? `wallet:${sub.wallet}` : null;
+      // Opportunity subscriptions → opps:{filter}
+      case "opportunity":
+        return `opps:${sub.filter || "all"}`;
+      // Custom subscriptions → use topic directly
+      case "custom":
+        return sub.topic || null;
+      default:
+        return null;
+    }
+  }
+  /**
+   * Unsubscribe from events before disconnecting
+   */
   /**
    * Unsubscribe from events before disconnecting
    */
@@ -1975,9 +2361,11 @@ var EventRunner = class {
     if (!this.strategy.subscriptions || this.strategy.subscriptions.length === 0) {
       return;
     }
+    const topics = this.strategy.subscriptions.map((s) => this.mapSubscriptionToTopic(s)).filter((t) => t !== null);
+    if (topics.length === 0) return;
     const unsubscribeMessage = {
       action: "unsubscribe",
-      subscriptions: this.strategy.subscriptions
+      topics
     };
     try {
       this.ws.send(JSON.stringify(unsubscribeMessage));
@@ -2000,28 +2388,103 @@ var EventRunner = class {
         this.config.logger.warning(`Received non-JSON message: ${rawData.slice(0, 100)}`);
         return;
       }
-      if (!this.isValidEvent(message)) {
-        this.config.logger.debug(`Received non-event message: ${JSON.stringify(message).slice(0, 200)}`);
+      if (message.type === "connected") {
+        this.config.logger.info(`Osiris Pub/Sub: ${message.message}`);
+        return;
+      }
+      if (message.type === "subscribe.result") {
+        if (message.success) {
+          this.config.logger.info(`Successfully subscribed to: ${message.subscribed.join(", ")}`);
+        } else {
+          this.config.logger.error(`Subscription failed: ${JSON.stringify(message.errors)}`);
+        }
         return;
       }
-      this.dispatchEvent(message);
+      if (message.type === "error") {
+        this.config.logger.error(`Osiris Pub/Sub Error: ${message.error}`);
+        return;
+      }
+      if (message.type === "pong") {
+        return;
+      }
+      const event = this.mapMessageToStrategyEvent(message);
+      if (event) {
+        this.dispatchEvent(event);
+      } else {
+        this.config.logger.debug(`Unhandled message type: ${message.type}`);
+      }
     } catch (error) {
       this.config.logger.error(`Error handling message: ${error.message}`, error);
     }
   }
+  /**
+   * Map incoming Osiris message to StrategyEvent
+   * Uses proper fields for each event type (market vs wallet)
+   */
+  mapMessageToStrategyEvent(message) {
+    const timestamp = message.ts || Date.now();
+    switch (message.type) {
+      case "market.analysis":
+        return {
+          type: "price",
+          // Treating analysis as 'price/market' update
+          market: message.slug,
+          timestamp,
+          data: {
+            ...message.data,
+            raw: message
+          }
+        };
+      case "wallet.analysis":
+        return {
+          type: "wallet",
+          wallet: message.address,
+          // Use wallet field, not market
+          timestamp,
+          data: {
+            ...message.data,
+            raw: message
+          }
+        };
+      case "opportunity":
+        return {
+          type: "opportunity",
+          market: message.slug,
+          timestamp,
+          data: {
+            ...message.data,
+            raw: message
+          }
+        };
+      default:
+        if (message.type && message.data) {
+          return {
+            type: "custom",
+            market: message.slug || message.topic,
+            timestamp,
+            data: {
+              ...message.data,
+              raw: message
+            }
+          };
+        }
+        return null;
+    }
+  }
   /**
    * Validate that a message is a valid StrategyEvent
    */
   isValidEvent(message) {
-    return message && typeof message === "object" && typeof message.type === "string" && typeof message.timestamp === "number" && typeof message.data === "object";
+    return message && typeof message === "object" && typeof message.type === "string";
   }
   /**
    * Dispatch an event to the strategy's onEvent handler
    */
   async dispatchEvent(event) {
     const eventStart = Date.now();
+    const target = event.market || event.wallet || "";
     this.config.logger.debug(
-      `Dispatching ${event.type} event${event.market ? ` for ${event.market}` : ""}`
+      `Dispatching ${event.type} event${target ? ` for ${target}` : ""}`
     );
     try {
       if (this.strategy.onEvent) {
@@ -2038,7 +2501,29 @@ var EventRunner = class {
   }
 };
 function createEventRunner(strategy, config, context) {
-  return new EventRunner(strategy, config, context);
+  const hasPolymarketSubscription = strategy.subscriptions?.some(
+    (sub) => sub.eventSource === "polymarket"
+  );
+  const hasOsirisSubscription = strategy.subscriptions?.some(
+    (sub) => !sub.eventSource || sub.eventSource === "osiris"
+  );
+  if (hasPolymarketSubscription) {
+    if (hasOsirisSubscription) {
+      config.logger.warning(
+        "Strategy has both Polymarket and generic Osiris subscriptions. Only Polymarket events will be processed by this runner. Mixed sources are not currently supported in a single runner."
+      );
+    }
+    return createPolymarketEventRunner(strategy, {
+      logger: config.logger,
+      strategyId: config.strategyId,
+      clobAuth: config.polymarket?.clobAuth,
+      walletAddress: config.polymarket?.walletAddress,
+      pingIntervalMs: config.polymarket?.pingIntervalMs,
+      reconnect: config.reconnect
+    }, context);
+  }
+  if (!config.eventSourceUrl) ;
+  return new OsirisEventRunner(strategy, config, context);
 }
 var CHAIN_MAP = {
   "evm:eip155:1": mainnet,
@@ -2190,6 +2675,6 @@ var Signer = class {
   }
 };
 
-export { EventRunner, HyperliquidClient, MemoryStateManager, OsirisSigner, PolymarketClient, PrivateKeySigner, RedisStateManager, Signer, StrategyEngine, createConsoleLogger, createEventRunner, createOsirisContext, createStrategyEngine, isEventBasedStrategy, isTickBasedStrategy, runStrategy, validateStrategy };
+export { HyperliquidClient, MemoryStateManager, OsirisEventRunner, OsirisSigner, PolymarketClient, PolymarketEventRunner, PrivateKeySigner, RedisStateManager, Signer, StrategyEngine, createConsoleLogger, createEventRunner, createOsirisContext, createPolymarketEventRunner, createStrategyEngine, isCustomSubscription, isEventBasedStrategy, isMarketSubscription, isOpportunitySubscription, isTickBasedStrategy, isWalletSubscription, runStrategy, validateStrategy };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map