polly-gamba 1.0.1

package/README.md

@@ -0,0 +1,130 @@
+# polly-gamba
+
+**Signal propagation arbitrage:** Coinbase price move → Polymarket bet, before the humans do.
+
+```
+┌─────────────────┐    signal    ┌───────────────────┐    match    ┌──────────────────┐
+│  Coinbase WS    │ ──────────→  │   Signal Router   │ ─────────→  │  Polymarket CLOB │
+│  BTC/ETH ticker │              │   (Claude brain)  │             │  Order execution │
+└─────────────────┘              └───────────────────┘             └──────────────────┘
+       ↑                                  ↑                                 ↑
+  0.5% move in                    keyword + heuristic              dry-run by default
+    60s window                    market matching                  (set API key for live)
+```
+
+## Why this works
+
+Human reaction time from seeing a BTC pump on Coinbase to placing a Polymarket bet: **5–30 minutes**.
+
+That's the edge. We don't front-run algos — we front-run *people*. Crypto price signal → find correlated prediction markets → place before the crowd arrives.
+
+News doesn't matter. Price signal does.
+
+## Architecture
+
+| Component | File | Purpose |
+|---|---|---|
+| Coinbase WS | `src/signals/coinbase-ws.ts` | Real-time BTC/ETH ticker, threshold detection |
+| Gamma API | `src/markets/gamma.ts` | Fetch active Polymarket markets, 10-min cache |
+| CLOB API | `src/markets/clob.ts` | Orderbook reads, price queries, order placement |
+| MCP Server | `src/mcp/server.ts` | Polymarket tools for Claude Code integration |
+| Main loop | `src/index.ts` | Orchestration, latency tracking, dry-run |
+
+## Quick start
+
+```bash
+npm install
+
+# Run the signal → match → execute pipeline (dry-run mode)
+npx ts-node src/index.ts
+
+# Run as MCP server (for Claude Code)
+npx ts-node src/mcp/server.ts
+
+# Run smoke tests
+npm test
+```
+
+## Signal detection
+
+`coinbase-ws.ts` connects to Coinbase Advanced Trade WebSocket (no auth required):
+- Subscribes to `ticker` channel for `BTC-USD` and `ETH-USD`
+- Maintains a 60-second rolling price window
+- Fires a `PriceSignal` when price moves ≥ 0.5% within the window
+
+```typescript
+interface PriceSignal {
+  asset: 'BTC' | 'ETH'
+  direction: 'up' | 'down'
+  pct_change: number    // e.g. 0.0213 for +2.13%
+  price: number         // current USD price
+  window_secs: number   // actual window duration
+  signal_ts: number     // Date.now() at detection
+}
+```
+
+## Market matching
+
+On signal, the system:
+1. Fetches active Polymarket markets (Gamma API, cached 10 min)
+2. Filters for volume > $10k, liquidity > $1k
+3. Keyword-matches market questions against the signal asset
+4. Logs matched markets + latency breakdown
+
+## MCP Tools (Claude integration)
+
+Add to `~/.claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "polymarket": {
+      "command": "npx",
+      "args": ["ts-node", "/path/to/polly-gamba/src/mcp/server.ts"]
+    }
+  }
+}
+```
+
+Available tools:
+- **`list_markets`** — fetch active markets with optional keyword filter
+- **`get_orderbook`** — CLOB orderbook for a token
+- **`get_market_price`** — buy/sell price (0–1 = probability)
+- **`assess_signal`** — find markets affected by a price signal
+- **`place_order`** — place order (dry-run default)
+
+## Latency tracking
+
+Every signal logs:
+```
+signal_ts      → when the price move was detected
+match_ts       → when market matching completed
+execute_ts     → when dry-run/order was logged
+```
+
+Target: signal → execute in < 500ms.
+
+## Config
+
+| Env var | Required | Description |
+|---|---|---|
+| `POLYMARKET_API_KEY` | No (for now) | CLOB API key for live order placement |
+
+## Dry-run mode
+
+All order placement is dry-run by default — logs `WOULD PLACE ORDER: ...` without touching the CLOB. Set `dry_run: false` and `POLYMARKET_API_KEY` for live execution.
+
+## Next steps
+
+1. **CLOB auth** — implement EIP-712 L1 + L2 API key header signing
+2. **Position sizing** — Kelly criterion on signal strength × market liquidity
+3. **Redis signal bus** — decouple signal detection from execution
+4. **Backtesting** — replay historical Coinbase ticks against historical Polymarket prices
+5. **Claude reasoning** — pipe signals through Claude for semantic market scoring
+
+## Build
+
+```bash
+npm run build   # tsc → dist/
+npm test        # smoke tests (live API, read-only)
+```

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "polly-gamba",
+  "version": "1.0.1",
+  "description": "Coinbase price signal → Claude brain → Polymarket CLOB execution",
+  "main": "dist/index.js",
+  "scripts": {
+    "start": "ts-node src/index.ts",
+    "mcp": "ts-node src/mcp/server.ts",
+    "mcp-paper": "ts-node src/mcp-server.ts",
+    "build": "tsc",
+    "test": "ts-node src/test/smoke.ts"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gonzih/polly-gamba.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/gonzih/polly-gamba/issues"
+  },
+  "homepage": "https://github.com/gonzih/polly-gamba#readme",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.28.0",
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^25.5.0",
+    "@types/ws": "^8.18.1",
+    "better-sqlite3": "^12.8.0",
+    "ioredis": "^5.10.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^6.0.2",
+    "ws": "^8.20.0"
+  }
+}

package/src/claude-trader.ts

@@ -0,0 +1,237 @@
+import { spawn, ChildProcess, execSync } from 'child_process'
+import { existsSync } from 'fs'
+import { createInterface } from 'readline'
+import Redis from 'ioredis'
+import { PriceSignal } from './signals/coinbase-ws'
+import { Market } from './markets/gamma'
+
+function findClaudeBin(): string {
+  const candidates = [
+    process.env.CLAUDE_BIN,
+    '/Users/feral/.npm-global/bin/claude',
+    '/usr/local/bin/claude',
+    '/opt/homebrew/bin/claude',
+  ].filter(Boolean) as string[]
+
+  try {
+    const fromWhich = execSync('which claude 2>/dev/null', { encoding: 'utf8' }).trim()
+    if (fromWhich) candidates.unshift(fromWhich)
+  } catch {}
+
+  for (const p of candidates) {
+    if (existsSync(p)) return p
+  }
+  throw new Error(`claude binary not found. Tried: ${candidates.join(', ')}. Set CLAUDE_BIN env var.`)
+}
+
+const CLAUDE_BIN = findClaudeBin()
+const CLAUDE_TOKEN = process.env.CLAUDE_CODE_OAUTH_TOKEN || process.env.ANTHROPIC_API_KEY || ''
+
+export interface TraderConfig {
+  cwd: string
+  redisPrefix: string
+  model?: string
+  envOverrides?: Record<string, string>
+  label: string
+}
+
+export class ClaudeTrader {
+  private proc: ChildProcess | null = null
+  private redis: Redis
+  private ready = false
+  private queue: string[] = []
+  private config: TraderConfig
+
+  constructor(config: TraderConfig) {
+    this.config = config
+    this.redis = new Redis(process.env.REDIS_URL || 'redis://localhost:6379', {
+      retryStrategy: (times) => Math.min(times * 500, 5000),
+      maxRetriesPerRequest: null,
+      enableReadyCheck: false,
+    })
+    this.redis.on('error', (e) => console.error(`[redis:${config.label}]`, e.message))
+  }
+
+  start() {
+    const env: Record<string, string> = {
+      ...(process.env as Record<string, string>),
+    }
+
+    if (CLAUDE_TOKEN) {
+      if (CLAUDE_TOKEN.startsWith('sk-ant-oat')) {
+        env.CLAUDE_CODE_OAUTH_TOKEN = CLAUDE_TOKEN
+      } else {
+        env.ANTHROPIC_API_KEY = CLAUDE_TOKEN
+      }
+    }
+
+    if (this.config.envOverrides) {
+      Object.assign(env, this.config.envOverrides)
+    }
+
+    const args = [
+      '--continue',
+      '--output-format', 'stream-json',
+      '--input-format', 'stream-json',
+      '--print',
+      '--verbose',
+      '--dangerously-skip-permissions',
+    ]
+
+    if (this.config.model) {
+      args.push('--model', this.config.model)
+    }
+
+    this.proc = spawn(CLAUDE_BIN, args, { cwd: this.config.cwd, env })
+
+    const rl = createInterface({ input: this.proc.stdout! })
+    rl.on('line', (line) => this.handleOutputLine(line))
+
+    this.proc.stderr?.on('data', (d: Buffer) => {
+      const s = d.toString()
+      if (s.trim()) this.log('stderr', { text: s.trim() }).catch(() => {})
+    })
+
+    this.proc.on('close', (code: number | null) => {
+      console.error(`[claude-trader:${this.config.label}] process closed (code=${code}) — restarting in 5s`)
+      this.log('process', { event: 'closed', code }).catch(() => {})
+      this.proc = null
+      this.ready = false
+      setTimeout(() => this.start(), 5000)
+    })
+
+    this.proc.on('error', (err: Error) => {
+      console.error(`[claude-trader:${this.config.label}] spawn error:`, err.message)
+      this.log('process', { event: 'error', message: err.message }).catch(() => {})
+    })
+
+    // Send system context after brief startup delay
+    setTimeout(() => {
+      this.sendRaw(JSON.stringify({
+        type: 'user',
+        message: {
+          role: 'user',
+          content: `You are a Polymarket paper trader running a high-volume moneyball strategy. Your job is to place paper trades on EVERY market where you have ANY opinion on fair value — even slight.
+
+TOOLS: place_order, skip_all
+RULES:
+- Output ONLY tool calls. Zero prose.
+- For EVERY market in the list: if current price differs from your estimated fair probability by more than 5%, place a trade.
+- YES is underpriced → BUY YES. NO is underpriced (YES overpriced) → BUY NO.
+- $10 USDC per trade (small size, many bets).
+- NO cap on number of trades — bet every market where you see any edge.
+- Only skip_all if you genuinely have zero opinion on any market (rare).
+- Use your world knowledge: sports standings, political context, recent events, base rates.`
+        }
+      }))
+      this.ready = true
+      this.flushQueue()
+      console.log(`[claude-trader:${this.config.label}] ready`)
+    }, 2000)
+  }
+
+  private handleOutputLine(line: string) {
+    if (!line.trim()) return
+    try {
+      const msg = JSON.parse(line)
+      this.log('claude_output', msg).catch(() => {})
+    } catch {
+      this.log('claude_raw', { text: line }).catch(() => {})
+    }
+  }
+
+  private sendRaw(json: string) {
+    if (this.proc?.stdin?.writable) {
+      this.proc.stdin.write(json + '\n')
+    }
+  }
+
+  private flushQueue() {
+    while (this.queue.length && this.ready) {
+      this.sendRaw(this.queue.shift()!)
+    }
+  }
+
+  async onSignal(signal: PriceSignal, markets: Market[]) {
+    const signalId = (signal as any).id || Math.random().toString(36).slice(2)
+    const pct = signal.pct_change
+    const prefix = this.config.redisPrefix
+
+    // Log signal to Redis
+    await this.redis.lpush(`${prefix}:signals`, JSON.stringify({ ...signal, id: signalId, markets_count: markets.length }))
+    await this.redis.ltrim(`${prefix}:signals`, 0, 9999)
+    await this.redis.set(`${prefix}:signal:${signalId}`, JSON.stringify({ signal, markets }), 'EX', 86400)
+
+    const prompt = `## Signal ${signalId}
+
+**${signal.asset} ${signal.direction === 'up' ? '+' : '-'}${(Math.abs(pct) * 100).toFixed(2)}%** @ $${signal.price.toFixed(2)}
+Window: ${signal.window_secs}s | Time: ${new Date(signal.signal_ts).toISOString()}
+
+## Relevant Polymarket Markets (${markets.length} found)
+
+${markets.map((m, i) => `### ${i + 1}. ${m.question}
+- Volume: $${(m.volume || 0).toLocaleString()}
+- Liquidity: $${(m.liquidity || 0).toLocaleString()}
+- Market ID: ${m.id}
+- Tokens: ${m.tokens?.map(t => `${t.outcome}@${t.price}`).join(', ') || 'none'}
+${m.description ? `- Description: ${m.description.slice(0, 200)}` : ''}`).join('\n\n')}
+
+Call place_order on any market you have edge on. $10 per trade. No cap.`
+
+    const msg = JSON.stringify({
+      type: 'user',
+      message: { role: 'user', content: prompt }
+    })
+
+    if (this.ready) {
+      this.sendRaw(msg)
+    } else {
+      this.queue.push(msg)
+    }
+  }
+
+  async onAutonomousScan(markets: Market[]) {
+    const scanId = Math.random().toString(36).slice(2)
+    const prefix = this.config.redisPrefix
+
+    await this.redis.lpush(`${prefix}:scans`, JSON.stringify({ scanId, markets_count: markets.length, ts: Date.now() }))
+    await this.redis.ltrim(`${prefix}:scans`, 0, 9999)
+
+    const tradeable = markets.filter(m =>
+      m.tokens?.some(t => t.price > 0.02 && t.price < 0.98)
+    )
+
+    const prompt = `## Autonomous Scan ${scanId}
+
+Time: ${new Date().toISOString()}
+
+## High-Quality Markets (${tradeable.length} found — vol24h>$50k, liq>$50k, price 0.10-0.90)
+
+${tradeable.map((m, i) => `### ${i + 1}. ${m.question}
+- Volume 24h: $${(m.volume24hr || 0).toLocaleString()}
+- Liquidity: $${(m.liquidity || 0).toLocaleString()}
+- Market ID: ${m.id}
+- Tokens: ${m.tokens?.map(t => `${t.outcome}@${t.price}`).join(', ') || 'none'}
+${m.description ? `- Description: ${m.description.slice(0, 200)}` : ''}`).join('\n\n')}
+
+For EVERY market above: if price differs from your fair probability by >5%, place a trade ($10 USDC). Call skip_all only if you have zero opinion on all markets.`
+
+    const msg = JSON.stringify({
+      type: 'user',
+      message: { role: 'user', content: prompt }
+    })
+
+    if (this.ready) {
+      this.sendRaw(msg)
+    } else {
+      this.queue.push(msg)
+    }
+  }
+
+  private async log(type: string, data: any) {
+    const prefix = this.config.redisPrefix
+    const entry = JSON.stringify({ type, data, ts: Date.now(), model: this.config.label })
+    await this.redis.lpush(`${prefix}:log`, entry)
+    await this.redis.ltrim(`${prefix}:log`, 0, 9999)
+  }
+}

package/src/index.ts

@@ -0,0 +1,116 @@
+import { CoinbaseSignalDetector, PriceSignal } from './signals/coinbase-ws'
+import { fetchActiveMarkets, fetchHighQualityMarkets, filterBySignal } from './markets/gamma'
+import { ClaudeTrader } from './claude-trader'
+import { PositionMonitor } from './position-monitor'
+import * as path from 'path'
+import * as os from 'os'
+
+const CWD = process.env.POLLY_CWD || path.join(os.homedir(), 'polly-gamba')
+
+async function main(): Promise<void> {
+  console.log('[polly-gamba] Starting paper trading service')
+  console.log(`[polly-gamba] Claude cwd: ${CWD}`)
+
+  const anthropicTrader = new ClaudeTrader({ cwd: CWD, redisPrefix: 'polly', label: 'anthropic' })
+
+  const ollamaTrader = new ClaudeTrader({
+    cwd: CWD,
+    redisPrefix: 'polly:ollama',
+    label: 'ollama',
+    model: 'glm-4.7-flash',
+    envOverrides: {
+      ANTHROPIC_BASE_URL: 'http://localhost:11434',
+      ANTHROPIC_AUTH_TOKEN: 'ollama',
+      ANTHROPIC_API_KEY: 'ollama',
+      USER_TYPE: 'ant',
+    },
+  })
+
+  const signals = new CoinbaseSignalDetector()
+
+  const monitor = new PositionMonitor(
+    process.env.REDIS_URL || 'redis://localhost:6379',
+    'polly'
+  )
+
+  anthropicTrader.start()
+  ollamaTrader.start()
+
+  signals.on('signal', (signal: PriceSignal) => {
+    console.log(`[signal] ${signal.asset} ${signal.direction} ${(Math.abs(signal.pct_change) * 100).toFixed(2)}% @ $${signal.price.toLocaleString()}`)
+    handleSignal(signal, anthropicTrader, ollamaTrader).catch((e: Error) => {
+      console.error('[error] signal handling failed:', e.message)
+    })
+  })
+
+  signals.start()
+  console.log('[polly-gamba] Listening for BTC/ETH price signals (threshold: 0.5% in 60s)...')
+
+  // Position monitor: check every 15 minutes for exits
+  const SCAN_INTERVAL_MS = 15 * 60 * 1000 // 15 minutes
+  monitor.checkPositions().catch((e: Error) => console.error('[monitor]', e.message))
+  setInterval(() => {
+    monitor.checkPositions().catch((e: Error) => console.error('[monitor]', e.message))
+  }, SCAN_INTERVAL_MS)
+
+  // Autonomous scan on startup and every 15 minutes
+  autonomousScan(anthropicTrader, ollamaTrader).catch((e: Error) => {
+    console.error('[error] autonomous scan failed:', e.message)
+  })
+  setInterval(() => {
+    autonomousScan(anthropicTrader, ollamaTrader).catch((e: Error) => {
+      console.error('[error] autonomous scan failed:', e.message)
+    })
+  }, SCAN_INTERVAL_MS)
+
+  process.on('SIGINT', () => {
+    console.log('\n[polly-gamba] Shutting down...')
+    signals.stop()
+    monitor.stop()
+    process.exit(0)
+  })
+
+  process.on('SIGTERM', () => {
+    signals.stop()
+    monitor.stop()
+    process.exit(0)
+  })
+}
+
+async function autonomousScan(...traders: ClaudeTrader[]): Promise<void> {
+  console.log('[scan] fetching high-quality markets (vol24h>$50k, liq>$50k, price 0.10-0.90)')
+  let markets
+  try {
+    markets = await fetchHighQualityMarkets()
+  } catch (e: any) {
+    console.error('[scan] failed to fetch markets:', e.message)
+    return
+  }
+  console.log(`[scan] ${markets.length} high-quality markets for autonomous review`)
+  await Promise.all(traders.map(t => t.onAutonomousScan(markets)))
+}
+
+async function handleSignal(signal: PriceSignal, ...traders: ClaudeTrader[]): Promise<void> {
+  let markets
+  try {
+    markets = await fetchActiveMarkets(10_000, 1_000)
+  } catch (e: any) {
+    console.error('[error] failed to fetch markets:', e.message)
+    return
+  }
+
+  const relevant = filterBySignal(signal.asset, markets)
+  console.log(`[match] ${relevant.length} markets for ${signal.asset} signal`)
+
+  if (relevant.length === 0) {
+    console.log('[match] no relevant markets found')
+    return
+  }
+
+  await Promise.all(traders.map(t => t.onSignal(signal, relevant)))
+}
+
+main().catch((err) => {
+  console.error('[polly-gamba] Fatal:', err)
+  process.exit(1)
+})

package/src/markets/clob.ts

@@ -0,0 +1,127 @@
+const CLOB_BASE = 'https://clob.polymarket.com';
+
+export interface OrderbookLevel {
+  price: string;
+  size: string;
+}
+
+export interface Orderbook {
+  market: string;
+  asset_id: string;
+  bids: OrderbookLevel[];
+  asks: OrderbookLevel[];
+  spread?: number;
+}
+
+export interface PlaceOrderParams {
+  token_id: string;
+  side: 'BUY' | 'SELL';
+  size_usdc: number;
+  price: number; // 0-1 range
+  dry_run?: boolean;
+}
+
+export interface OrderResult {
+  dry_run: boolean;
+  token_id: string;
+  side: 'BUY' | 'SELL';
+  size_usdc: number;
+  price: number;
+  estimated_shares: number;
+  order_id?: string;
+  logged_at: number;
+}
+
+export async function getOrderbook(tokenId: string): Promise<Orderbook> {
+  const url = `${CLOB_BASE}/book?token_id=${encodeURIComponent(tokenId)}`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`CLOB getOrderbook error: ${res.status} ${res.statusText}`);
+  }
+  const data: any = await res.json();
+
+  const bids: OrderbookLevel[] = (data.bids ?? []).slice(0, 10);
+  const asks: OrderbookLevel[] = (data.asks ?? []).slice(0, 10);
+
+  let spread: number | undefined;
+  if (bids.length > 0 && asks.length > 0) {
+    spread = parseFloat(asks[0].price) - parseFloat(bids[0].price);
+  }
+
+  return {
+    market: data.market ?? '',
+    asset_id: data.asset_id ?? tokenId,
+    bids,
+    asks,
+    spread,
+  };
+}
+
+export async function getPrice(tokenId: string, side: 'buy' | 'sell'): Promise<number> {
+  const url = `${CLOB_BASE}/price?token_id=${encodeURIComponent(tokenId)}&side=${side}`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`CLOB getPrice error: ${res.status} ${res.statusText}`);
+  }
+  const data: any = await res.json();
+  return parseFloat(data.price ?? data) ?? 0;
+}
+
+export async function getPrices(tokenIds: string[]): Promise<Map<string, number>> {
+  const prices = new Map<string, number>();
+
+  // Batch with concurrency limit of 5
+  const chunks: string[][] = [];
+  for (let i = 0; i < tokenIds.length; i += 5) {
+    chunks.push(tokenIds.slice(i, i + 5));
+  }
+
+  for (const chunk of chunks) {
+    await Promise.all(
+      chunk.map(async (id) => {
+        try {
+          const price = await getPrice(id, 'buy');
+          prices.set(id, price);
+        } catch (e) {
+          // skip failed lookups
+        }
+      })
+    );
+  }
+
+  return prices;
+}
+
+export async function placeOrder(params: PlaceOrderParams): Promise<OrderResult> {
+  const { token_id, side, size_usdc, price, dry_run = true } = params;
+  const estimated_shares = price > 0 ? size_usdc / price : 0;
+
+  const result: OrderResult = {
+    dry_run,
+    token_id,
+    side,
+    size_usdc,
+    price,
+    estimated_shares,
+    logged_at: Date.now(),
+  };
+
+  if (dry_run) {
+    console.log(
+      `[clob/dry-run] WOULD PLACE ORDER: ${side} ${size_usdc} USDC @ ${price} ` +
+      `(~${estimated_shares.toFixed(2)} shares) token=${token_id}`
+    );
+    return result;
+  }
+
+  // Real order placement — requires CLOB auth (L1/L2 headers)
+  // Auth implementation deferred — set POLYMARKET_KEY env var when ready
+  const apiKey = process.env.POLYMARKET_API_KEY;
+  if (!apiKey) {
+    throw new Error('POLYMARKET_API_KEY not set — cannot place real orders');
+  }
+
+  // TODO: implement full CLOB auth (EIP-712 L1 + L2 API key headers)
+  // See: https://docs.polymarket.com/#authentication
+  throw new Error('Real order placement not yet implemented — use dry_run=true');
+}