create-polymarket-strategy 0.2.0 → 0.2.2

package/templates/worker/src/lib/quote-manager.ts

@@ -0,0 +1,358 @@
+/**
+ * Quote Manager
+ *
+ * Manages two-sided quotes (bid + ask pairs) for market making.
+ * Handles placing, updating, and cancelling quote pairs atomically.
+ */
+
+import type { Env } from "../types.js";
+import {
+  type OrderManager,
+  type QuotePair,
+  type Order,
+  createOrderManagerFromEnv,
+} from "polymarket-trading-sdk";
+
+// =============================================================================
+// Types
+// =============================================================================
+
+/**
+ * Result of placing a quote.
+ */
+export interface QuotePlacementResult {
+  success: boolean;
+  tokenId: string;
+  bidOrderId?: string;
+  askOrderId?: string;
+  bidError?: string;
+  askError?: string;
+}
+
+/**
+ * An active quote tracked by the manager.
+ */
+export interface ActiveQuote {
+  tokenId: string;
+  bidOrderId: string;
+  askOrderId: string;
+  bidPrice: number;
+  askPrice: number;
+  bidSize: number;
+  askSize: number;
+  placedAt: number;
+}
+
+/**
+ * Options for quote placement.
+ */
+export interface QuotePlacementOptions {
+  /** Slug for order tracking */
+  slug?: string;
+  /** Label for order tracking */
+  label?: string;
+}
+
+// =============================================================================
+// Quote Manager
+// =============================================================================
+
+/**
+ * Manages two-sided quotes for a trading strategy.
+ *
+ * @example
+ * ```typescript
+ * const manager = new QuoteManager(env);
+ *
+ * // Place a quote
+ * const result = await manager.placeQuote({
+ *   tokenId: "abc123",
+ *   bidPrice: 0.48,
+ *   bidSize: 10,
+ *   askPrice: 0.52,
+ *   askSize: 10,
+ * });
+ *
+ * // Update quote
+ * await manager.updateQuote("abc123", {
+ *   tokenId: "abc123",
+ *   bidPrice: 0.47,
+ *   bidSize: 10,
+ *   askPrice: 0.53,
+ *   askSize: 10,
+ * });
+ *
+ * // Cancel quote
+ * await manager.cancelQuote("abc123");
+ * ```
+ */
+export class QuoteManager {
+  private orderManager: OrderManager;
+  private ordersStub: DurableObjectStub;
+  private activeQuotes: Map<string, ActiveQuote> = new Map();
+
+  constructor(private env: Env) {
+    this.orderManager = createOrderManagerFromEnv(env);
+
+    const ordersId = env.ORDERS.idFromName("main");
+    this.ordersStub = env.ORDERS.get(ordersId);
+  }
+
+  /**
+   * Place a two-sided quote (bid and ask).
+   *
+   * Both orders are placed in parallel. If one fails, the other may still succeed.
+   * Check the result for individual order status.
+   */
+  async placeQuote(
+    quote: QuotePair,
+    options: QuotePlacementOptions = {}
+  ): Promise<QuotePlacementResult> {
+    const { slug = "quote", label = quote.tokenId.slice(-8) } = options;
+
+    const result: QuotePlacementResult = {
+      success: false,
+      tokenId: quote.tokenId,
+    };
+
+    // Place bid and ask in parallel
+    const [bidResult, askResult] = await Promise.all([
+      this.orderManager.placeOrder({
+        slug: `${slug}-bid`,
+        label,
+        tokenId: quote.tokenId,
+        side: "buy",
+        price: quote.bidPrice,
+        size: quote.bidSize,
+      }),
+      this.orderManager.placeOrder({
+        slug: `${slug}-ask`,
+        label,
+        tokenId: quote.tokenId,
+        side: "sell",
+        price: quote.askPrice,
+        size: quote.askSize,
+      }),
+    ]);
+
+    // Record results
+    if (bidResult.success) {
+      result.bidOrderId = bidResult.clobOrderId;
+
+      // Record in DO
+      await this.recordOrder({
+        slug: `${slug}-bid`,
+        label,
+        tokenId: quote.tokenId,
+        side: "buy",
+        price: quote.bidPrice,
+        size: quote.bidSize,
+        clobOrderId: bidResult.clobOrderId,
+      });
+    } else {
+      result.bidError = bidResult.error;
+    }
+
+    if (askResult.success) {
+      result.askOrderId = askResult.clobOrderId;
+
+      // Record in DO
+      await this.recordOrder({
+        slug: `${slug}-ask`,
+        label,
+        tokenId: quote.tokenId,
+        side: "sell",
+        price: quote.askPrice,
+        size: quote.askSize,
+        clobOrderId: askResult.clobOrderId,
+      });
+    } else {
+      result.askError = askResult.error;
+    }
+
+    // Track active quote if at least one side succeeded
+    if (result.bidOrderId || result.askOrderId) {
+      this.activeQuotes.set(quote.tokenId, {
+        tokenId: quote.tokenId,
+        bidOrderId: result.bidOrderId || "",
+        askOrderId: result.askOrderId || "",
+        bidPrice: quote.bidPrice,
+        askPrice: quote.askPrice,
+        bidSize: quote.bidSize,
+        askSize: quote.askSize,
+        placedAt: Date.now(),
+      });
+      result.success = true;
+    }
+
+    return result;
+  }
+
+  /**
+   * Cancel all orders for a token.
+   */
+  async cancelQuote(tokenId: string): Promise<{ success: boolean; error?: string }> {
+    try {
+      // Cancel on CLOB
+      const cancelResult = await this.orderManager.cancelAllOrders(tokenId);
+
+      if (!cancelResult.success) {
+        return { success: false, error: cancelResult.error };
+      }
+
+      // Remove from tracking
+      this.activeQuotes.delete(tokenId);
+
+      // Note: Orders will be marked as cancelled by reconciliation
+      // or we could explicitly mark them here
+
+      return { success: true };
+    } catch (e) {
+      return {
+        success: false,
+        error: e instanceof Error ? e.message : String(e),
+      };
+    }
+  }
+
+  /**
+   * Update a quote by cancelling the old one and placing a new one.
+   *
+   * This is a cancel-and-replace operation. The new quote is placed
+   * after the old one is cancelled.
+   */
+  async updateQuote(
+    tokenId: string,
+    newQuote: QuotePair,
+    options: QuotePlacementOptions = {}
+  ): Promise<QuotePlacementResult> {
+    // First cancel existing quote
+    await this.cancelQuote(tokenId);
+
+    // Small delay to ensure cancellation propagates
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Place new quote
+    return this.placeQuote(newQuote, options);
+  }
+
+  /**
+   * Get all active quotes.
+   */
+  getActiveQuotes(): Map<string, ActiveQuote> {
+    return new Map(this.activeQuotes);
+  }
+
+  /**
+   * Get active quote for a specific token.
+   */
+  getQuote(tokenId: string): ActiveQuote | undefined {
+    return this.activeQuotes.get(tokenId);
+  }
+
+  /**
+   * Check if there's an active quote for a token.
+   */
+  hasQuote(tokenId: string): boolean {
+    return this.activeQuotes.has(tokenId);
+  }
+
+  /**
+   * Cancel all active quotes.
+   */
+  async cancelAllQuotes(): Promise<{ cancelled: number; errors: string[] }> {
+    const tokenIds = [...this.activeQuotes.keys()];
+    let cancelled = 0;
+    const errors: string[] = [];
+
+    for (const tokenId of tokenIds) {
+      const result = await this.cancelQuote(tokenId);
+      if (result.success) {
+        cancelled++;
+      } else {
+        errors.push(`${tokenId}: ${result.error}`);
+      }
+    }
+
+    return { cancelled, errors };
+  }
+
+  /**
+   * Refresh active quotes from the orders DO.
+   * Call this when starting up to restore state.
+   */
+  async refreshFromDO(): Promise<void> {
+    try {
+      const response = await this.ordersStub.fetch(
+        new Request("http://do/list-pending")
+      );
+      const pendingOrders = (await response.json()) as Order[];
+
+      // Group by token
+      const byToken = new Map<string, { bids: Order[]; asks: Order[] }>();
+
+      for (const order of pendingOrders) {
+        if (!byToken.has(order.tokenId)) {
+          byToken.set(order.tokenId, { bids: [], asks: [] });
+        }
+        const entry = byToken.get(order.tokenId)!;
+        if (order.side === "buy") {
+          entry.bids.push(order);
+        } else {
+          entry.asks.push(order);
+        }
+      }
+
+      // Reconstruct active quotes
+      this.activeQuotes.clear();
+      for (const [tokenId, { bids, asks }] of byToken) {
+        // Take the most recent bid and ask
+        const bid = bids[0];
+        const ask = asks[0];
+
+        if (bid && ask) {
+          this.activeQuotes.set(tokenId, {
+            tokenId,
+            bidOrderId: bid.clobOrderId || bid.id,
+            askOrderId: ask.clobOrderId || ask.id,
+            bidPrice: bid.price,
+            askPrice: ask.price,
+            bidSize: bid.size,
+            askSize: ask.size,
+            placedAt: new Date(bid.createdAt).getTime(),
+          });
+        }
+      }
+    } catch (e) {
+      console.error("Failed to refresh quotes from DO:", e);
+    }
+  }
+
+  /**
+   * Record an order in the orders DO.
+   */
+  private async recordOrder(order: {
+    slug: string;
+    label: string;
+    tokenId: string;
+    side: "buy" | "sell";
+    price: number;
+    size: number;
+    clobOrderId?: string;
+  }): Promise<void> {
+    await this.ordersStub.fetch(
+      new Request("http://do/create", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(order),
+      })
+    );
+  }
+}
+
+/**
+ * Create a QuoteManager from environment.
+ */
+export function createQuoteManager(env: Env): QuoteManager {
+  return new QuoteManager(env);
+}

package/templates/worker/src/scanner.ts

@@ -4,8 +4,9 @@
  * Orchestrates the scanning process:
  * 1. Calls strategy.scan() to find signals
  * 2. Checks for duplicate pending orders
- * 3. Calculates prices using strategy.calculatePrice()
- * 4. Places orders via OrderManager (routes to Lambda for live mode)
+ * 3. Checks risk limits before placing
+ * 4. Calculates prices using strategy.calculatePrice()
+ * 5. Places orders via OrderManager (routes to Lambda for live mode)
  */
 
 import type { Env } from "./types.js";
@@ -14,13 +15,17 @@ import {
   type StrategyContext,
   type Order,
   type NewOrder,
+  type TokenInventory,
+  type RiskLimits,
   MarketDataClient,
   createOrderManagerFromEnv,
+  checkOrderRisk,
 } from "polymarket-trading-sdk";
 
 export interface ScanResult {
   signalsFound: number;
   ordersPlaced: number;
+  ordersSkippedRisk: number;
   errors: string[];
 }
 
@@ -34,6 +39,7 @@ export async function runScanner(
   const result: ScanResult = {
     signalsFound: 0,
     ordersPlaced: 0,
+    ordersSkippedRisk: 0,
     errors: [],
   };
 
@@ -60,6 +66,9 @@ export async function runScanner(
   const ordersId = env.ORDERS.idFromName("main");
   const ordersStub = env.ORDERS.get(ordersId);
 
+  const positionsId = env.POSITIONS.idFromName("main");
+  const positionsStub = env.POSITIONS.get(positionsId);
+
   try {
     // 1. Scan for signals
     const signals = await strategy.scan(ctx);
@@ -75,7 +84,24 @@ export async function runScanner(
     );
     const pendingOrders = (await pendingOrdersResponse.json()) as Order[];
 
-    // 3. Process each signal
+    // 3. Get current inventories for risk checking
+    const inventoryResponse = await positionsStub.fetch(
+      new Request("http://do/inventory/all")
+    );
+    const inventories = (await inventoryResponse.json()) as TokenInventory[];
+
+    // 4. Get risk limits from config (with defaults)
+    const riskLimits: RiskLimits = {
+      maxPositionPerToken: (config.maxPositionPerToken as number) ?? 100,
+      maxTotalExposure: (config.maxTotalExposure as number) ?? 500,
+      maxLossPerToken: config.maxLossPerToken as number | undefined,
+      maxDailyLoss: config.maxDailyLoss as number | undefined,
+    };
+
+    // Track current prices for risk calculations
+    const currentPrices = new Map<string, number>();
+
+    // 5. Process each signal
     for (const signal of signals) {
       try {
         // Check dedup
@@ -95,6 +121,11 @@ export async function runScanner(
         // Get market data for pricing
         const data = await marketData.getMarketData(signal.tokenId);
 
+        // Track price for risk calc
+        if (data.midpoint !== null) {
+          currentPrices.set(signal.tokenId, data.midpoint);
+        }
+
         // Calculate price
         const price = strategy.calculatePrice(signal, data, config);
 
@@ -105,6 +136,27 @@ export async function runScanner(
         // Determine order size
         const size = (config.orderSize as number) ?? 5;
 
+        // Check risk limits before placing
+        const riskCheck = checkOrderRisk(
+          inventories,
+          {
+            tokenId: signal.tokenId,
+            side: signal.side,
+            size,
+            price,
+          },
+          riskLimits,
+          currentPrices
+        );
+
+        if (!riskCheck.allowed) {
+          result.ordersSkippedRisk++;
+          result.errors.push(
+            `Risk limit blocked ${signal.label}: ${riskCheck.reason}`
+          );
+          continue;
+        }
+
         // Place order via OrderManager (handles live vs paper routing)
         const orderResult = await orderManager.placeOrder({
           slug: signal.slug,