polly-gamba 1.0.1

package/src/position-monitor.ts

@@ -0,0 +1,170 @@
+import Redis from 'ioredis'
+
+export interface Position {
+  market_id: string
+  market_question: string
+  outcome: string
+  side: string
+  size_usdc: number
+  price: number  // entry price
+  ts: number
+  status: 'open' | 'closed'
+  exit_price?: number
+  pnl?: number
+  closed_at?: number
+  reason?: 'take_profit' | 'stop_loss' | 'expiry' | 'manual'
+}
+
+interface MarketPrice {
+  price: number
+  endDate: string
+}
+
+export class PositionMonitor {
+  private redis: Redis
+  private prefix: string
+
+  constructor(redisUrl: string, prefix: string) {
+    this.redis = new Redis(redisUrl, {
+      retryStrategy: (times) => Math.min(times * 500, 5000),
+      maxRetriesPerRequest: null,
+      enableReadyCheck: false,
+    })
+    this.redis.on('error', (e) => console.error('[position-monitor:redis]', e.message))
+    this.prefix = prefix
+  }
+
+  async checkPositions(): Promise<void> {
+    const raw = await this.redis.lrange(`${this.prefix}:positions`, 0, -1)
+    const all: Position[] = raw.map(r => {
+      try { return JSON.parse(r) } catch { return null }
+    }).filter(Boolean)
+
+    const open = all.filter(p => p.status === 'open')
+
+    // Check which are already tracked as closed
+    const closedIds = open.length > 0
+      ? await this.redis.smembers(`${this.prefix}:closed_ids`)
+      : []
+    const closedSet = new Set(closedIds)
+
+    const toCheck = open.filter(p => !closedSet.has(`${p.market_id}_${p.outcome}_${p.ts}`))
+
+    if (toCheck.length === 0) {
+      console.log(`[position-monitor] 0 open positions to check`)
+      return
+    }
+
+    // Deduplicate market fetches
+    const marketPriceCache = new Map<string, MarketPrice | null>()
+    const uniqueMarkets = [...new Set(toCheck.map(p => p.market_id))]
+    await Promise.all(uniqueMarkets.map(async (marketId) => {
+      const result = await this.fetchCurrentPrice(marketId, 'Yes').catch(() => null)
+      marketPriceCache.set(marketId, result)
+    }))
+
+    const counts = { take_profit: 0, stop_loss: 0, expiry: 0 }
+    let closedCount = 0
+
+    for (const pos of toCheck) {
+      const marketData = marketPriceCache.get(pos.market_id)
+      if (!marketData) continue
+
+      const outcome = pos.outcome
+      const currentPrice = await this.fetchCurrentPrice(pos.market_id, outcome)
+      if (!currentPrice) continue
+
+      const entryPrice = pos.price
+      const exitPrice = currentPrice.price
+      const gain = (exitPrice - entryPrice) / entryPrice
+
+      let reason: Position['reason'] | null = null
+
+      // Check exit conditions
+      const hoursToEnd = (new Date(currentPrice.endDate).getTime() - Date.now()) / (1000 * 60 * 60)
+      if (hoursToEnd <= 48) {
+        reason = 'expiry'
+      } else if (gain >= 0.15) {
+        reason = 'take_profit'
+      } else if (gain <= -0.20) {
+        reason = 'stop_loss'
+      }
+
+      if (!reason) continue
+
+      // Calculate P&L
+      const shares = pos.size_usdc / entryPrice
+      const pnl = shares * exitPrice - pos.size_usdc
+
+      // Build closed position record
+      const closed: Position = {
+        ...pos,
+        status: 'closed',
+        exit_price: exitPrice,
+        pnl,
+        closed_at: Date.now(),
+        reason,
+      }
+
+      // Track in closed_ids set
+      const posKey = `${pos.market_id}_${pos.outcome}_${pos.ts}`
+      await this.redis.sadd(`${this.prefix}:closed_ids`, posKey)
+
+      // Push to closed_positions history
+      await this.redis.lpush(`${this.prefix}:closed_positions`, JSON.stringify(closed))
+      await this.redis.ltrim(`${this.prefix}:closed_positions`, 0, 9999)
+
+      // Log entry
+      await this.redis.lpush(`${this.prefix}:log`, JSON.stringify({
+        type: 'position_closed',
+        data: closed,
+        ts: Date.now(),
+      }))
+      await this.redis.ltrim(`${this.prefix}:log`, 0, 9999)
+
+      counts[reason]++
+      closedCount++
+
+      console.log(
+        `[position-monitor] CLOSE ${reason.toUpperCase()} "${String(pos.market_question).slice(0, 50)}" ` +
+        `${pos.outcome} entry=${entryPrice.toFixed(3)} exit=${exitPrice.toFixed(3)} pnl=${pnl >= 0 ? '+' : ''}${pnl.toFixed(2)}`
+      )
+    }
+
+    console.log(
+      `[position-monitor] checked=${toCheck.length} closed=${closedCount} ` +
+      `(take_profit=${counts.take_profit} stop_loss=${counts.stop_loss} expiry=${counts.expiry})`
+    )
+  }
+
+  private async fetchCurrentPrice(marketId: string, outcome: string): Promise<MarketPrice | null> {
+    try {
+      const res = await fetch(`https://gamma-api.polymarket.com/markets/${marketId}`)
+      if (!res.ok) return null
+      const data = await res.json() as any
+
+      const outcomes: string[] = JSON.parse(data.outcomes || '[]')
+      const prices: string[] = JSON.parse(data.outcomePrices || '[]')
+      const endDate: string = data.endDateIso || data.endDate || ''
+
+      const priceMap: Record<string, number> = {}
+      outcomes.forEach((o, i) => {
+        priceMap[o] = parseFloat(prices[i]) || 0
+        priceMap[o.toLowerCase()] = parseFloat(prices[i]) || 0
+      })
+
+      // Normalize outcome lookup
+      const normalized = outcome.charAt(0).toUpperCase() + outcome.slice(1).toLowerCase()
+      const price = priceMap[outcome] ?? priceMap[normalized] ?? priceMap[outcome.toLowerCase()]
+      if (price === undefined) return null
+
+      return { price, endDate }
+    } catch {
+      return null
+    }
+  }
+
+  stop(): void {
+    this.redis.disconnect()
+  }
+}

package/src/signals/coinbase-ws.ts

@@ -0,0 +1,146 @@
+import { EventEmitter } from 'events';
+import WebSocket from 'ws';
+
+export interface PriceSignal {
+  asset: 'BTC' | 'ETH';
+  direction: 'up' | 'down';
+  pct_change: number;
+  price: number;
+  window_secs: number;
+  signal_ts: number;
+}
+
+interface PriceTick {
+  price: number;
+  ts: number;
+}
+
+const THRESHOLD = 0.005; // 0.5%
+const WINDOW_SECS = 60;
+const PRODUCTS = ['BTC-USD', 'ETH-USD'] as const;
+
+export class CoinbaseSignalDetector extends EventEmitter {
+  private ws: WebSocket | null = null;
+  private history: Map<string, PriceTick[]> = new Map();
+  private currentPrice: Map<string, number> = new Map();
+  private reconnectTimer: NodeJS.Timeout | null = null;
+
+  start(): void {
+    this.connect();
+  }
+
+  stop(): void {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+
+  private connect(): void {
+    const url = 'wss://ws-feed.exchange.coinbase.com';
+    console.log(`[coinbase-ws] Connecting to ${url}`);
+
+    const ws = new WebSocket(url);
+    this.ws = ws;
+
+    ws.on('open', () => {
+      console.log('[coinbase-ws] Connected');
+      const sub = {
+        type: 'subscribe',
+        product_ids: PRODUCTS,
+        channels: ['ticker'],
+      };
+      ws.send(JSON.stringify(sub));
+    });
+
+    ws.on('message', (data: Buffer) => {
+      try {
+        this.handleMessage(JSON.parse(data.toString()));
+      } catch (e) {
+        // ignore parse errors
+      }
+    });
+
+    ws.on('error', (err: Error) => {
+      console.error('[coinbase-ws] Error:', err.message);
+    });
+
+    ws.on('close', () => {
+      console.log('[coinbase-ws] Disconnected — reconnecting in 5s');
+      this.scheduleReconnect();
+    });
+  }
+
+  private scheduleReconnect(): void {
+    this.reconnectTimer = setTimeout(() => {
+      this.connect();
+    }, 5000);
+  }
+
+  private handleMessage(msg: any): void {
+    // Coinbase Exchange WS ticker format
+    if (msg.type !== 'ticker') return;
+
+    const { product_id, price } = msg;
+    if (!product_id || !price) return;
+
+    const priceNum = parseFloat(price);
+    if (isNaN(priceNum)) return;
+
+    this.currentPrice.set(product_id, priceNum);
+    this.recordTick(product_id, priceNum);
+    this.checkThreshold(product_id, priceNum);
+  }
+
+  private recordTick(productId: string, price: number): void {
+    if (!this.history.has(productId)) {
+      this.history.set(productId, []);
+    }
+    const ticks = this.history.get(productId)!;
+    const now = Date.now();
+    ticks.push({ price, ts: now });
+
+    // Trim ticks older than window
+    const cutoff = now - WINDOW_SECS * 1000;
+    while (ticks.length > 0 && ticks[0].ts < cutoff) {
+      ticks.shift();
+    }
+  }
+
+  private checkThreshold(productId: string, currentPrice: number): void {
+    const ticks = this.history.get(productId);
+    if (!ticks || ticks.length < 2) return;
+
+    const oldest = ticks[0];
+    const pctChange = (currentPrice - oldest.price) / oldest.price;
+
+    if (Math.abs(pctChange) >= THRESHOLD) {
+      const asset = productId.replace('-USD', '') as 'BTC' | 'ETH';
+      const signal: PriceSignal = {
+        asset,
+        direction: pctChange > 0 ? 'up' : 'down',
+        pct_change: pctChange,
+        price: currentPrice,
+        window_secs: Math.round((Date.now() - oldest.ts) / 1000),
+        signal_ts: Date.now(),
+      };
+
+      console.log(
+        `[signal] ${asset} ${signal.direction} ${(pctChange * 100).toFixed(2)}% ` +
+        `@ $${currentPrice.toLocaleString()} over ${signal.window_secs}s`
+      );
+      this.emit('signal', signal);
+
+      // Reset history to avoid re-triggering on same move
+      this.history.set(productId, [{ price: currentPrice, ts: Date.now() }]);
+    }
+  }
+
+  getCurrentPrice(asset: 'BTC' | 'ETH'): number | undefined {
+    return this.currentPrice.get(`${asset}-USD`);
+  }
+}

package/src/test/smoke.ts

@@ -0,0 +1,93 @@
+/**
+ * Smoke tests — verify the pipeline components work end-to-end.
+ * Hits live APIs in read-only mode. No auth required.
+ */
+import { fetchActiveMarkets, fetchMarket } from '../markets/gamma';
+import { getOrderbook, getPrice } from '../markets/clob';
+import { placeOrder } from '../markets/clob';
+
+let passed = 0;
+let failed = 0;
+
+async function test(name: string, fn: () => Promise<void>): Promise<void> {
+  process.stdout.write(`  ${name} ... `);
+  try {
+    await fn();
+    console.log('PASS');
+    passed++;
+  } catch (err: any) {
+    console.log(`FAIL: ${err.message}`);
+    failed++;
+  }
+}
+
+function assert(condition: boolean, msg: string): void {
+  if (!condition) throw new Error(msg);
+}
+
+async function main(): Promise<void> {
+  console.log('\n[smoke] Running smoke tests...\n');
+
+  await test('fetchActiveMarkets returns array', async () => {
+    const markets = await fetchActiveMarkets(10_000, 1_000);
+    assert(Array.isArray(markets), 'expected array');
+    assert(markets.length > 0, `expected markets, got ${markets.length}`);
+    const m = markets[0];
+    assert(typeof m.id === 'string', 'market.id should be string');
+    assert(typeof m.question === 'string', 'market.question should be string');
+    assert(typeof m.volume === 'number', 'market.volume should be number');
+    console.log(`\n    [info] Got ${markets.length} markets, first: "${m.question.substring(0, 60)}"`);
+  });
+
+  await test('fetchActiveMarkets has BTC/ETH/crypto markets', async () => {
+    const markets = await fetchActiveMarkets(10_000, 1_000);
+    const cryptoMarkets = markets.filter(m =>
+      /bitcoin|btc|ethereum|eth|crypto/i.test(m.question + m.description)
+    );
+    console.log(`\n    [info] Found ${cryptoMarkets.length} crypto-related markets`);
+    assert(cryptoMarkets.length > 0, 'expected some crypto markets');
+  });
+
+  await test('placeOrder dry-run works', async () => {
+    const result = await placeOrder({
+      token_id: 'test-token-id',
+      side: 'BUY',
+      size_usdc: 10,
+      price: 0.6,
+      dry_run: true,
+    });
+    assert(result.dry_run === true, 'expected dry_run=true');
+    assert(result.token_id === 'test-token-id', 'expected token_id');
+    assert(result.estimated_shares > 0, 'expected estimated_shares > 0');
+  });
+
+  // Optional CLOB tests — may fail if token IDs change
+  await test('getOrderbook (with real token — may skip)', async () => {
+    const markets = await fetchActiveMarkets(50_000, 5_000);
+    const withTokens = markets.find(m => m.tokens.length > 0 && m.tokens[0].token_id);
+    if (!withTokens) {
+      console.log('\n    [skip] No liquid markets with tokens found');
+      return;
+    }
+    const tokenId = withTokens.tokens[0].token_id;
+    try {
+      const book = await getOrderbook(tokenId);
+      assert(Array.isArray(book.bids), 'expected bids array');
+      assert(Array.isArray(book.asks), 'expected asks array');
+      console.log(`\n    [info] Orderbook: ${book.bids.length} bids, ${book.asks.length} asks, spread=${book.spread?.toFixed(4)}`);
+    } catch (e: any) {
+      console.log(`\n    [skip] CLOB unavailable: ${e.message}`);
+    }
+  });
+
+  console.log(`\n[smoke] Results: ${passed} passed, ${failed} failed\n`);
+
+  if (failed > 0) {
+    process.exit(1);
+  }
+}
+
+main().catch((err) => {
+  console.error('[smoke] Fatal:', err.message);
+  process.exit(1);
+});

package/tsconfig.json

@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "ignoreDeprecations": "6.0",
+    "rootDir": "src",
+    "outDir": "dist",
+    "strict": false,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "resolveJsonModule": true,
+    "sourceMap": true,
+    "declaration": true,
+    "skipLibCheck": true,
+    "lib": ["ES2022"],
+    "types": ["node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}