create-polymarket-strategy 0.2.0 → 0.2.1

package/templates/worker/src/durable-objects/positions.ts

@@ -2,10 +2,14 @@
  * Positions Durable Object
  *
  * SQL-backed persistent storage for position tracking.
- * Tracks open positions and calculates P&L.
+ * Tracks open positions, calculates P&L, and manages inventory.
+ *
+ * Inventory tracking is for market making - tracks net position per token.
+ * Position tracking is for directional strategies - tracks individual entries.
  */
 
-import type { Position } from "polymarket-trading-sdk";
+import type { Position, TokenInventory, InventoryFill } from "polymarket-trading-sdk";
+import { applyFillToInventory, createEmptyInventory } from "polymarket-trading-sdk";
 
 interface NewPosition {
   orderId: string;
@@ -54,6 +58,18 @@ export class PositionsDO implements DurableObject {
 
       CREATE INDEX IF NOT EXISTS idx_positions_status ON positions(status);
       CREATE INDEX IF NOT EXISTS idx_positions_order_id ON positions(order_id);
+
+      -- Inventory table for market making (net position per token)
+      CREATE TABLE IF NOT EXISTS inventory (
+        token_id TEXT PRIMARY KEY,
+        net_shares REAL NOT NULL DEFAULT 0,
+        avg_entry_price REAL,
+        realized_pnl REAL NOT NULL DEFAULT 0,
+        cost_basis REAL NOT NULL DEFAULT 0,
+        last_updated INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_inventory_updated ON inventory(last_updated);
     `);
   }
 
@@ -62,6 +78,7 @@ export class PositionsDO implements DurableObject {
 
     try {
       switch (url.pathname) {
+        // Position tracking endpoints
         case "/create":
           return this.handleCreate(request);
         case "/list-open":
@@ -74,6 +91,19 @@ export class PositionsDO implements DurableObject {
           return this.handleGet(url);
         case "/stats":
           return this.handleStats();
+
+        // Inventory tracking endpoints (for market making)
+        case "/inventory":
+          return this.handleGetInventory(url);
+        case "/inventory/all":
+          return this.handleGetAllInventory();
+        case "/inventory/fill":
+          return this.handleRecordFill(request);
+        case "/inventory/reset":
+          return this.handleResetInventory(request);
+        case "/inventory/summary":
+          return this.handleInventorySummary();
+
         default:
           return new Response("Not found", { status: 404 });
       }
@@ -244,4 +274,161 @@ export class PositionsDO implements DurableObject {
       closedAt: row.closed_at as string | undefined,
     };
   }
+
+  // ===========================================================================
+  // Inventory Methods (for market making)
+  // ===========================================================================
+
+  /**
+   * Get inventory for a single token.
+   */
+  private handleGetInventory(url: URL): Response {
+    const tokenId = url.searchParams.get("token_id");
+
+    if (!tokenId) {
+      return Response.json({ error: "token_id required" }, { status: 400 });
+    }
+
+    const result = this.sql.exec(
+      `SELECT * FROM inventory WHERE token_id = ?`,
+      tokenId
+    );
+    const rows = result.toArray();
+
+    if (rows.length === 0) {
+      // Return empty inventory
+      return Response.json(createEmptyInventory(tokenId));
+    }
+
+    return Response.json(this.rowToInventory(rows[0]));
+  }
+
+  /**
+   * Get all inventories with non-zero positions.
+   */
+  private handleGetAllInventory(): Response {
+    const result = this.sql.exec(
+      `SELECT * FROM inventory WHERE net_shares != 0 ORDER BY last_updated DESC`
+    );
+
+    const inventories = result.toArray().map((row) => this.rowToInventory(row));
+    return Response.json(inventories);
+  }
+
+  /**
+   * Record a fill and update inventory.
+   */
+  private async handleRecordFill(request: Request): Promise<Response> {
+    const fill = (await request.json()) as InventoryFill;
+
+    if (!fill.tokenId || !fill.side || fill.size == null || fill.price == null) {
+      return Response.json(
+        { error: "tokenId, side, size, and price required" },
+        { status: 400 }
+      );
+    }
+
+    // Get current inventory
+    const result = this.sql.exec(
+      `SELECT * FROM inventory WHERE token_id = ?`,
+      fill.tokenId
+    );
+    const rows = result.toArray();
+
+    const current: TokenInventory | null =
+      rows.length > 0 ? this.rowToInventory(rows[0]) : null;
+
+    // Apply fill using SDK function
+    const updated = applyFillToInventory(current, fill);
+
+    // Upsert into database
+    this.sql.exec(
+      `INSERT INTO inventory (token_id, net_shares, avg_entry_price, realized_pnl, cost_basis, last_updated)
+       VALUES (?, ?, ?, ?, ?, ?)
+       ON CONFLICT(token_id) DO UPDATE SET
+         net_shares = excluded.net_shares,
+         avg_entry_price = excluded.avg_entry_price,
+         realized_pnl = excluded.realized_pnl,
+         cost_basis = excluded.cost_basis,
+         last_updated = excluded.last_updated`,
+      updated.tokenId,
+      updated.netShares,
+      updated.avgEntryPrice,
+      updated.realizedPnL,
+      updated.costBasis,
+      updated.lastUpdated
+    );
+
+    return Response.json({
+      success: true,
+      inventory: updated,
+      fill,
+    });
+  }
+
+  /**
+   * Reset inventory for a token (or all tokens).
+   */
+  private async handleResetInventory(request: Request): Promise<Response> {
+    const body = (await request.json()) as { tokenId?: string };
+
+    if (body.tokenId) {
+      this.sql.exec(`DELETE FROM inventory WHERE token_id = ?`, body.tokenId);
+      return Response.json({ success: true, reset: body.tokenId });
+    } else {
+      this.sql.exec(`DELETE FROM inventory`);
+      return Response.json({ success: true, reset: "all" });
+    }
+  }
+
+  /**
+   * Get inventory summary (totals across all tokens).
+   */
+  private handleInventorySummary(): Response {
+    const result = this.sql.exec(`
+      SELECT
+        SUM(CASE WHEN net_shares > 0 THEN net_shares * avg_entry_price ELSE 0 END) as long_exposure,
+        SUM(CASE WHEN net_shares < 0 THEN ABS(net_shares) * avg_entry_price ELSE 0 END) as short_exposure,
+        SUM(realized_pnl) as total_realized_pnl,
+        COUNT(CASE WHEN net_shares != 0 THEN 1 END) as active_tokens
+      FROM inventory
+    `);
+
+    const rows = result.toArray();
+    if (rows.length === 0) {
+      return Response.json({
+        longExposure: 0,
+        shortExposure: 0,
+        netExposure: 0,
+        totalRealizedPnL: 0,
+        activeTokens: 0,
+      });
+    }
+
+    const row = rows[0];
+    const longExposure = (row.long_exposure as number) || 0;
+    const shortExposure = (row.short_exposure as number) || 0;
+
+    return Response.json({
+      longExposure,
+      shortExposure,
+      netExposure: longExposure - shortExposure,
+      totalRealizedPnL: (row.total_realized_pnl as number) || 0,
+      activeTokens: (row.active_tokens as number) || 0,
+    });
+  }
+
+  /**
+   * Convert database row to TokenInventory.
+   */
+  private rowToInventory(row: Record<string, unknown>): TokenInventory {
+    return {
+      tokenId: row.token_id as string,
+      netShares: row.net_shares as number,
+      avgEntryPrice: (row.avg_entry_price as number) || 0,
+      realizedPnL: row.realized_pnl as number,
+      costBasis: row.cost_basis as number,
+      lastUpdated: row.last_updated as number,
+    };
+  }
 }

package/templates/worker/src/durable-objects/scheduler.ts

@@ -3,9 +3,12 @@
  *
  * Uses DO alarms for granular, self-contained scheduling.
  * Manages periodic scanning with configurable intervals.
+ * Also handles fill reconciliation - polling executor for fills
+ * and updating inventory.
  */
 
 import type { Env } from "../types.js";
+import { createOrderManagerFromEnv, type Order } from "polymarket-trading-sdk";
 
 interface SchedulerConfig {
   interval: number; // milliseconds
@@ -90,7 +93,12 @@ export class SchedulerDO implements DurableObject {
       return;
     }
 
+    // Run fill reconciliation first (update inventory from fills)
+    await this.reconcileFills();
+
+    // Then run the scan
     await this.runScan();
+
     await this.scheduleNext(config.interval);
   }
 
@@ -288,4 +296,104 @@ export class SchedulerDO implements DurableObject {
       return { signalsFound: 0, ordersPlaced: 0, error: errorMsg };
     }
   }
+
+  /**
+   * Reconcile fills by polling the executor and updating inventory.
+   *
+   * Process:
+   * 1. Get pending orders from OrdersDO
+   * 2. Get open orders from executor (CLOB)
+   * 3. Any order that's pending locally but not open on CLOB = filled
+   * 4. Update inventory via PositionsDO
+   * 5. Mark orders as filled in OrdersDO
+   */
+  private async reconcileFills(): Promise<{
+    fillsDetected: number;
+    errors: string[];
+  }> {
+    const result = { fillsDetected: 0, errors: [] as string[] };
+
+    try {
+      // Skip if not in live mode or executor not configured
+      const orderManager = createOrderManagerFromEnv(this.env);
+      if (!orderManager.isLiveEnabled()) {
+        return result;
+      }
+
+      // Get pending orders from local DO
+      const ordersId = this.env.ORDERS.idFromName("main");
+      const ordersStub = this.env.ORDERS.get(ordersId);
+
+      const pendingResponse = await ordersStub.fetch(
+        new Request("http://do/list-pending")
+      );
+      const pendingOrders = (await pendingResponse.json()) as Order[];
+
+      if (pendingOrders.length === 0) {
+        return result;
+      }
+
+      // Get open orders from executor/CLOB
+      const clobOrders = await orderManager.getOpenOrders();
+      const clobOrderIds = new Set(clobOrders.map((o) => o.clobOrderId));
+
+      // Get positions DO for inventory updates
+      const positionsId = this.env.POSITIONS.idFromName("main");
+      const positionsStub = this.env.POSITIONS.get(positionsId);
+
+      // Check each pending order
+      for (const order of pendingOrders) {
+        try {
+          // If no CLOB order ID, skip (might be paper order)
+          if (!order.clobOrderId) continue;
+
+          // If order is still open on CLOB, skip
+          if (clobOrderIds.has(order.clobOrderId)) continue;
+
+          // Order is not open on CLOB = filled (or cancelled)
+          // For now, assume filled at limit price
+          // TODO: Could query executor for actual fill details
+
+          // Update inventory
+          await positionsStub.fetch(
+            new Request("http://do/inventory/fill", {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                tokenId: order.tokenId,
+                side: order.side,
+                size: order.size,
+                price: order.price,
+                timestamp: Date.now(),
+              }),
+            })
+          );
+
+          // Mark order as filled in OrdersDO
+          await ordersStub.fetch(
+            new Request("http://do/mark-filled", {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                id: order.id,
+                fillPrice: order.price,
+              }),
+            })
+          );
+
+          result.fillsDetected++;
+        } catch (e) {
+          result.errors.push(
+            `Error processing order ${order.id}: ${e instanceof Error ? e.message : String(e)}`
+          );
+        }
+      }
+    } catch (e) {
+      result.errors.push(
+        `Reconciliation error: ${e instanceof Error ? e.message : String(e)}`
+      );
+    }
+
+    return result;
+  }
 }

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);
+}