create-polymarket-strategy 0.1.0

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

@@ -0,0 +1,291 @@
+/**
+ * Scheduler Durable Object
+ *
+ * Uses DO alarms for granular, self-contained scheduling.
+ * Manages periodic scanning with configurable intervals.
+ */
+
+import type { Env } from "../types.js";
+
+interface SchedulerConfig {
+  interval: number; // milliseconds
+  enabled: boolean;
+  lastRun: string | null;
+  runCount: number;
+}
+
+export class SchedulerDO implements DurableObject {
+  private sql: SqlStorage;
+
+  constructor(
+    private state: DurableObjectState,
+    private env: Env
+  ) {
+    this.sql = state.storage.sql;
+    this.initSchema();
+  }
+
+  private initSchema(): void {
+    this.sql.exec(`
+      CREATE TABLE IF NOT EXISTS config (
+        key TEXT PRIMARY KEY,
+        value TEXT
+      );
+
+      CREATE TABLE IF NOT EXISTS runs (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        started_at TEXT NOT NULL,
+        completed_at TEXT,
+        status TEXT NOT NULL DEFAULT 'running',
+        signals_found INTEGER DEFAULT 0,
+        orders_placed INTEGER DEFAULT 0,
+        error TEXT
+      );
+    `);
+
+    const result = this.sql.exec(
+      `SELECT value FROM config WHERE key = 'interval'`
+    );
+    if (result.toArray().length === 0) {
+      this.sql.exec(
+        `INSERT INTO config (key, value) VALUES ('interval', '3600000')`
+      );
+      this.sql.exec(`INSERT INTO config (key, value) VALUES ('enabled', '0')`);
+      this.sql.exec(
+        `INSERT INTO config (key, value) VALUES ('run_count', '0')`
+      );
+    }
+  }
+
+  async fetch(request: Request): Promise<Response> {
+    const url = new URL(request.url);
+
+    try {
+      switch (url.pathname) {
+        case "/start":
+          return this.handleStart(url);
+        case "/stop":
+          return this.handleStop();
+        case "/trigger":
+          return this.handleTrigger();
+        case "/status":
+          return this.handleStatus();
+        case "/history":
+          return this.handleHistory();
+        case "/config":
+          return this.handleConfig(request, url);
+        default:
+          return new Response("Not found", { status: 404 });
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Unknown error";
+      return Response.json({ error: message }, { status: 500 });
+    }
+  }
+
+  async alarm(): Promise<void> {
+    const config = this.getConfig();
+
+    if (!config.enabled) {
+      return;
+    }
+
+    await this.runScan();
+    await this.scheduleNext(config.interval);
+  }
+
+  private async handleStart(url: URL): Promise<Response> {
+    const intervalParam = url.searchParams.get("interval");
+    const interval = intervalParam ? parseInt(intervalParam) : 3600000;
+
+    if (interval < 10000) {
+      return Response.json(
+        { error: "Interval must be at least 10000ms (10 seconds)" },
+        { status: 400 }
+      );
+    }
+
+    this.sql.exec(
+      `UPDATE config SET value = ? WHERE key = 'interval'`,
+      interval.toString()
+    );
+    this.sql.exec(`UPDATE config SET value = '1' WHERE key = 'enabled'`);
+
+    await this.scheduleNext(interval);
+
+    return Response.json({
+      status: "started",
+      interval,
+      nextRun: await this.state.storage.getAlarm(),
+    });
+  }
+
+  private async handleStop(): Promise<Response> {
+    this.sql.exec(`UPDATE config SET value = '0' WHERE key = 'enabled'`);
+    await this.state.storage.deleteAlarm();
+
+    return Response.json({ status: "stopped" });
+  }
+
+  private async handleTrigger(): Promise<Response> {
+    const result = await this.runScan();
+
+    return Response.json({
+      status: "triggered",
+      ...result,
+    });
+  }
+
+  private async handleStatus(): Promise<Response> {
+    const config = this.getConfig();
+    const nextAlarm = await this.state.storage.getAlarm();
+
+    const lastRunResult = this.sql.exec(
+      `SELECT * FROM runs ORDER BY id DESC LIMIT 1`
+    );
+    const lastRuns = lastRunResult.toArray();
+    const lastRun = lastRuns.length > 0 ? lastRuns[0] : null;
+
+    return Response.json({
+      enabled: config.enabled,
+      interval: config.interval,
+      nextRun: nextAlarm,
+      runCount: config.runCount,
+      lastRun: lastRun
+        ? {
+            startedAt: lastRun.started_at,
+            completedAt: lastRun.completed_at,
+            status: lastRun.status,
+            signalsFound: lastRun.signals_found,
+            ordersPlaced: lastRun.orders_placed,
+            error: lastRun.error,
+          }
+        : null,
+    });
+  }
+
+  private handleHistory(): Response {
+    const result = this.sql.exec(
+      `SELECT * FROM runs ORDER BY id DESC LIMIT 20`
+    );
+
+    const runs = result.toArray().map((row) => ({
+      id: row.id,
+      startedAt: row.started_at,
+      completedAt: row.completed_at,
+      status: row.status,
+      signalsFound: row.signals_found,
+      ordersPlaced: row.orders_placed,
+      error: row.error,
+    }));
+
+    return Response.json(runs);
+  }
+
+  private async handleConfig(request: Request, url: URL): Promise<Response> {
+    if (request.method === "GET") {
+      return Response.json(this.getConfig());
+    }
+
+    if (request.method === "PUT") {
+      const body = (await request.json()) as { interval?: number };
+
+      if (body.interval) {
+        if (body.interval < 10000) {
+          return Response.json(
+            { error: "Interval must be at least 10000ms" },
+            { status: 400 }
+          );
+        }
+        this.sql.exec(
+          `UPDATE config SET value = ? WHERE key = 'interval'`,
+          body.interval.toString()
+        );
+      }
+
+      return Response.json(this.getConfig());
+    }
+
+    return new Response("Method not allowed", { status: 405 });
+  }
+
+  private getConfig(): SchedulerConfig {
+    const result = this.sql.exec(`SELECT key, value FROM config`);
+    const rows = result.toArray();
+
+    const config: Record<string, string> = {};
+    for (const row of rows) {
+      config[row.key as string] = row.value as string;
+    }
+
+    return {
+      interval: parseInt(config.interval || "3600000"),
+      enabled: config.enabled === "1",
+      lastRun: config.last_run || null,
+      runCount: parseInt(config.run_count || "0"),
+    };
+  }
+
+  private async scheduleNext(intervalMs: number): Promise<void> {
+    const nextTime = Date.now() + intervalMs;
+    await this.state.storage.setAlarm(nextTime);
+  }
+
+  private async runScan(): Promise<{
+    signalsFound: number;
+    ordersPlaced: number;
+    error?: string;
+  }> {
+    const startedAt = new Date().toISOString();
+
+    this.sql.exec(
+      `INSERT INTO runs (started_at, status) VALUES (?, 'running')`,
+      startedAt
+    );
+
+    const runIdResult = this.sql.exec(`SELECT last_insert_rowid() as id`);
+    const runId = (runIdResult.toArray()[0]?.id as number) || 0;
+
+    try {
+      // TODO: Implement actual scanning logic via worker callback
+      const completedAt = new Date().toISOString();
+      const signalsFound = 0;
+      const ordersPlaced = 0;
+
+      this.sql.exec(
+        `UPDATE runs SET
+          completed_at = ?,
+          status = 'completed',
+          signals_found = ?,
+          orders_placed = ?
+        WHERE id = ?`,
+        completedAt,
+        signalsFound,
+        ordersPlaced,
+        runId
+      );
+
+      this.sql.exec(
+        `UPDATE config SET value = CAST(CAST(value AS INTEGER) + 1 AS TEXT)
+         WHERE key = 'run_count'`
+      );
+
+      return { signalsFound, ordersPlaced };
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : "Unknown error";
+
+      this.sql.exec(
+        `UPDATE runs SET
+          completed_at = ?,
+          status = 'error',
+          error = ?
+        WHERE id = ?`,
+        new Date().toISOString(),
+        errorMsg,
+        runId
+      );
+
+      return { signalsFound: 0, ordersPlaced: 0, error: errorMsg };
+    }
+  }
+}

package/templates/worker/src/index.ts

@@ -0,0 +1,221 @@
+/**
+ * {{name}} - Polymarket Trading Bot
+ *
+ * A Cloudflare Worker that runs the {{strategy-name}} trading strategy.
+ */
+
+import type { Env } from "./types.js";
+import {
+  MarketDataClient,
+  createOrderManagerFromEnv,
+  checkAuth,
+  unauthorizedResponse,
+  getStrategy,
+  listStrategies,
+} from "polymarket-trading-sdk";
+import { runScanner } from "./scanner.js";
+import { OrdersDO } from "./durable-objects/orders.js";
+import { PositionsDO } from "./durable-objects/positions.js";
+import { SchedulerDO } from "./durable-objects/scheduler.js";
+
+// Import strategies (self-register)
+import "./strategies/{{strategy-name}}.js";
+
+// Export Durable Objects
+export { OrdersDO, PositionsDO, SchedulerDO };
+
+// CORS headers
+const corsHeaders = {
+  "Access-Control-Allow-Origin": "*",
+  "Access-Control-Allow-Methods": "GET, POST, PUT, DELETE, OPTIONS",
+  "Access-Control-Allow-Headers": "Content-Type, X-API-Key, Authorization",
+};
+
+export default {
+  async fetch(
+    request: Request,
+    env: Env,
+    ctx: ExecutionContext
+  ): Promise<Response> {
+    // Handle CORS preflight
+    if (request.method === "OPTIONS") {
+      return new Response(null, { headers: corsHeaders });
+    }
+
+    // Auth check
+    const auth = checkAuth(request, env);
+    if (!auth.authorized) {
+      return unauthorizedResponse(auth.error || "Unauthorized");
+    }
+
+    const url = new URL(request.url);
+
+    try {
+      // Route handling
+      switch (url.pathname) {
+        case "/":
+          return Response.json(
+            {
+              name: "{{name}}",
+              strategy: env.STRATEGY_NAME,
+              mode: env.MODE,
+              endpoints: [
+                "GET /",
+                "GET /health",
+                "POST /scan",
+                "GET /orders",
+                "GET /positions",
+                "GET /balance",
+                "GET /stats",
+                "GET /strategies",
+                "GET /scheduler/status",
+                "POST /scheduler/start?interval=60000",
+                "POST /scheduler/stop",
+                "POST /scheduler/trigger",
+                "GET /scheduler/history",
+              ],
+            },
+            { headers: corsHeaders }
+          );
+
+        case "/health":
+          return Response.json({ status: "ok" }, { headers: corsHeaders });
+
+        case "/scan":
+          return handleScan(request, env);
+
+        case "/orders":
+          return handleOrders(request, env);
+
+        case "/positions":
+          return handlePositions(request, env);
+
+        case "/balance":
+          return handleBalance(env);
+
+        case "/stats":
+          return handleStats(env);
+
+        case "/strategies":
+          return Response.json(
+            { strategies: listStrategies() },
+            { headers: corsHeaders }
+          );
+
+        default:
+          // Scheduler routes
+          if (url.pathname.startsWith("/scheduler")) {
+            return handleScheduler(request, env, url);
+          }
+
+          return Response.json(
+            { error: "Not found" },
+            { status: 404, headers: corsHeaders }
+          );
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Internal error";
+      return Response.json(
+        { error: message },
+        { status: 500, headers: corsHeaders }
+      );
+    }
+  },
+};
+
+// =============================================================================
+// Route Handlers
+// =============================================================================
+
+async function handleScan(request: Request, env: Env): Promise<Response> {
+  if (request.method !== "POST") {
+    return Response.json(
+      { error: "Method not allowed" },
+      { status: 405, headers: corsHeaders }
+    );
+  }
+
+  const strategy = getStrategy<Env>(env.STRATEGY_NAME);
+  const result = await runScanner(strategy, env);
+
+  return Response.json(result, { headers: corsHeaders });
+}
+
+async function handleOrders(request: Request, env: Env): Promise<Response> {
+  const url = new URL(request.url);
+  const ordersId = env.ORDERS.idFromName("main");
+  const ordersStub = env.ORDERS.get(ordersId);
+
+  const status = url.searchParams.get("status");
+  const path = status === "pending" ? "/list-pending" : "/list-all";
+
+  const response = await ordersStub.fetch(new Request(`http://do${path}`));
+  const data = await response.json();
+
+  return Response.json(data, { headers: corsHeaders });
+}
+
+async function handlePositions(request: Request, env: Env): Promise<Response> {
+  const url = new URL(request.url);
+  const positionsId = env.POSITIONS.idFromName("main");
+  const positionsStub = env.POSITIONS.get(positionsId);
+
+  const status = url.searchParams.get("status");
+  const path = status === "open" ? "/list-open" : "/list-all";
+
+  const response = await positionsStub.fetch(new Request(`http://do${path}`));
+  const data = await response.json();
+
+  return Response.json(data, { headers: corsHeaders });
+}
+
+async function handleBalance(env: Env): Promise<Response> {
+  const orderManager = createOrderManagerFromEnv(env);
+  const balance = await orderManager.getBalance();
+
+  return Response.json(
+    {
+      balance,
+      mode: env.MODE,
+    },
+    { headers: corsHeaders }
+  );
+}
+
+async function handleStats(env: Env): Promise<Response> {
+  const positionsId = env.POSITIONS.idFromName("main");
+  const positionsStub = env.POSITIONS.get(positionsId);
+
+  const response = await positionsStub.fetch(new Request("http://do/stats"));
+  const stats = (await response.json()) as Record<string, unknown>;
+
+  return Response.json(
+    {
+      strategy: env.STRATEGY_NAME,
+      mode: env.MODE,
+      ...stats,
+    },
+    { headers: corsHeaders }
+  );
+}
+
+async function handleScheduler(
+  request: Request,
+  env: Env,
+  url: URL
+): Promise<Response> {
+  const schedulerId = env.SCHEDULER.idFromName("main");
+  const schedulerStub = env.SCHEDULER.get(schedulerId);
+
+  const subPath = url.pathname.replace("/scheduler", "") || "/status";
+
+  const response = await schedulerStub.fetch(
+    new Request(`http://do${subPath}${url.search}`, {
+      method: request.method,
+      body: request.body,
+    })
+  );
+
+  const data = await response.json();
+  return Response.json(data, { headers: corsHeaders });
+}

package/templates/worker/src/scanner.ts

@@ -0,0 +1,156 @@
+/**
+ * Scanner Module
+ *
+ * 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)
+ */
+
+import type { Env } from "./types.js";
+import {
+  type Strategy,
+  type StrategyContext,
+  type Order,
+  type NewOrder,
+  MarketDataClient,
+  createOrderManagerFromEnv,
+} from "polymarket-trading-sdk";
+
+export interface ScanResult {
+  signalsFound: number;
+  ordersPlaced: number;
+  errors: string[];
+}
+
+/**
+ * Run a full scan using the given strategy.
+ */
+export async function runScanner(
+  strategy: Strategy<Env>,
+  env: Env
+): Promise<ScanResult> {
+  const result: ScanResult = {
+    signalsFound: 0,
+    ordersPlaced: 0,
+    errors: [],
+  };
+
+  // Create clients
+  const marketData = new MarketDataClient({
+    clobApi: env.CLOB_API,
+    gammaApi: env.GAMMA_API,
+  });
+
+  // OrderManager routes to Lambda (live) or simulates (paper)
+  const orderManager = createOrderManagerFromEnv(env);
+
+  // Get strategy config
+  const config = strategy.getConfig?.(env) ?? {};
+
+  // Create context
+  const ctx: StrategyContext<Env> = {
+    marketData,
+    config,
+    env,
+  };
+
+  // Get Durable Object stubs
+  const ordersId = env.ORDERS.idFromName("main");
+  const ordersStub = env.ORDERS.get(ordersId);
+
+  try {
+    // 1. Scan for signals
+    const signals = await strategy.scan(ctx);
+    result.signalsFound = signals.length;
+
+    if (signals.length === 0) {
+      return result;
+    }
+
+    // 2. Get pending orders for dedup
+    const pendingOrdersResponse = await ordersStub.fetch(
+      new Request("http://do/list-pending")
+    );
+    const pendingOrders = (await pendingOrdersResponse.json()) as Order[];
+
+    // 3. Process each signal
+    for (const signal of signals) {
+      try {
+        // Check dedup
+        const hasPending = pendingOrders.some(
+          (o) => o.slug === signal.slug && o.label === signal.label
+        );
+
+        if (hasPending) {
+          continue; // Skip - already have pending order
+        }
+
+        // Custom shouldPlace check
+        if (strategy.shouldPlace && !strategy.shouldPlace(signal, pendingOrders)) {
+          continue;
+        }
+
+        // Get market data for pricing
+        const data = await marketData.getMarketData(signal.tokenId);
+
+        // Calculate price
+        const price = strategy.calculatePrice(signal, data, config);
+
+        if (price === null) {
+          continue; // Strategy decided not to place
+        }
+
+        // Determine order size
+        const size = (config.orderSize as number) ?? 5;
+
+        // Place order via OrderManager (handles live vs paper routing)
+        const orderResult = await orderManager.placeOrder({
+          slug: signal.slug,
+          label: signal.label,
+          tokenId: signal.tokenId,
+          side: signal.side,
+          price,
+          size,
+        });
+
+        if (!orderResult.success) {
+          result.errors.push(
+            `Failed to place order for ${signal.label}: ${orderResult.error}`
+          );
+          continue;
+        }
+
+        // Record in DO
+        await ordersStub.fetch(
+          new Request("http://do/create", {
+            method: "POST",
+            body: JSON.stringify({
+              slug: signal.slug,
+              label: signal.label,
+              tokenId: signal.tokenId,
+              side: signal.side,
+              price,
+              size,
+              clobOrderId: orderResult.clobOrderId,
+            } satisfies NewOrder & { clobOrderId?: string }),
+          })
+        );
+
+        result.ordersPlaced++;
+      } catch (error) {
+        const msg =
+          error instanceof Error
+            ? error.message
+            : `Error processing signal ${signal.label}`;
+        result.errors.push(msg);
+      }
+    }
+  } catch (error) {
+    const msg = error instanceof Error ? error.message : "Scan failed";
+    result.errors.push(msg);
+  }
+
+  return result;
+}