polly-gamba 1.0.1

package/src/markets/gamma.ts

@@ -0,0 +1,146 @@
+const GAMMA_BASE = 'https://gamma-api.polymarket.com';
+const CACHE_TTL_MS = 10 * 60 * 1000; // 10 minutes
+
+export interface MarketToken {
+  token_id: string;
+  outcome: string;
+  price: number;
+}
+
+export interface Market {
+  id: string;
+  conditionId: string;
+  question: string;
+  description: string;
+  volume: number;
+  volume24hr: number;
+  liquidity: number;
+  tokens: MarketToken[];
+  active: boolean;
+  closed: boolean;
+}
+
+interface CacheEntry {
+  markets: Market[];
+  ts: number;
+}
+
+let cache: CacheEntry | null = null;
+
+function parseNumber(val: any): number {
+  if (typeof val === 'number') return val;
+  if (typeof val === 'string') return parseFloat(val) || 0;
+  return 0;
+}
+
+function parseTokens(raw: any): MarketToken[] {
+  if (!Array.isArray(raw)) return [];
+  return raw.map((t: any) => ({
+    token_id: t.token_id ?? t.tokenId ?? '',
+    outcome: t.outcome ?? '',
+    price: parseNumber(t.price),
+  }));
+}
+
+function parseMarket(raw: any): Market {
+  // Gamma API returns outcomes/prices as JSON strings, not a tokens array
+  let tokens = parseTokens(raw.tokens)
+  if (tokens.length === 0 && raw.outcomes) {
+    try {
+      const outcomes: string[] = JSON.parse(raw.outcomes)
+      const prices: string[] = JSON.parse(raw.outcomePrices || '[]')
+      tokens = outcomes.map((outcome, i) => ({
+        token_id: '',
+        outcome,
+        price: parseFloat(prices[i]) || 0,
+      }))
+    } catch {}
+  }
+
+  return {
+    id: String(raw.id ?? ''),
+    conditionId: String(raw.conditionId ?? raw.condition_id ?? ''),
+    question: String(raw.question ?? ''),
+    description: String(raw.description ?? ''),
+    volume: parseNumber(raw.volume),
+    volume24hr: parseNumber(raw.volume24hr),
+    liquidity: parseNumber(raw.liquidity),
+    tokens,
+    active: Boolean(raw.active),
+    closed: Boolean(raw.closed),
+  };
+}
+
+export async function fetchActiveMarkets(minVolume = 10_000, minLiquidity = 1_000): Promise<Market[]> {
+  const now = Date.now();
+  if (cache && now - cache.ts < CACHE_TTL_MS) {
+    return cache.markets;
+  }
+
+  const url = `${GAMMA_BASE}/markets?active=true&closed=false&limit=500`;
+  console.log(`[gamma] Fetching active markets from ${url}`);
+
+  const res = await fetch(url);
+  if (!res.ok) {
+    throw new Error(`Gamma API error: ${res.status} ${res.statusText}`);
+  }
+
+  const raw = await res.json();
+  const data: any[] = Array.isArray(raw) ? raw : [];
+  const markets: Market[] = data
+    .map(parseMarket)
+    .filter(m => m.active && !m.closed && m.volume >= minVolume && m.liquidity >= minLiquidity);
+
+  console.log(`[gamma] Loaded ${markets.length} markets (filtered from ${data.length})`);
+
+  cache = { markets, ts: now };
+  return markets;
+}
+
+export async function fetchHighQualityMarkets(
+  minVolume24h = 50_000,
+  minLiquidity = 50_000,
+  minPrice = 0.10,
+  maxPrice = 0.90
+): Promise<Market[]> {
+  const all = await fetchActiveMarkets(1_000, 1_000)
+
+  return all
+    .filter(m => {
+      const vol24 = m.volume24hr ?? 0
+      const liq = m.liquidity ?? 0
+      const hasUncertainty = m.tokens?.some(t => t.price >= minPrice && t.price <= maxPrice)
+      return vol24 >= minVolume24h && liq >= minLiquidity && hasUncertainty
+    })
+    .sort((a, b) => (b.volume24hr ?? 0) - (a.volume24hr ?? 0))
+}
+
+export async function fetchMarket(id: string): Promise<Market | null> {
+  const url = `${GAMMA_BASE}/markets/${id}`;
+  const res = await fetch(url);
+  if (!res.ok) return null;
+  const data = await res.json();
+  return parseMarket(data);
+}
+
+export function clearCache(): void {
+  cache = null;
+}
+
+const KEYWORDS: Record<string, string[]> = {
+  BTC: ['bitcoin', 'btc', 'crypto', 'cryptocurrency'],
+  ETH: ['ethereum', 'eth', 'ether', 'defi'],
+}
+
+export function filterBySignal(asset: string, markets: Market[]): Market[] {
+  const kw = KEYWORDS[asset] || []
+  const scored = markets
+    .map(m => {
+      const text = `${m.question} ${m.description || ''}`.toLowerCase()
+      const score = kw.reduce((s, k) => s + (text.includes(k) ? 1 : 0), 0)
+      return { m, score }
+    })
+    .filter(x => x.score > 0)
+    .sort((a, b) => b.score - a.score || b.m.volume - a.m.volume)
+  return scored.slice(0, 20).map(x => x.m)
+}

package/src/mcp/server.ts

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from '@modelcontextprotocol/sdk/types.js';
+
+import { fetchActiveMarkets, fetchMarket, Market } from '../markets/gamma';
+import { getOrderbook, getPrice, placeOrder } from '../markets/clob';
+import { PriceSignal } from '../signals/coinbase-ws';
+
+// Keywords that link crypto assets to market questions
+const ASSET_KEYWORDS: Record<string, string[]> = {
+  BTC: ['bitcoin', 'btc', 'crypto', 'cryptocurrency', 'price', 'market'],
+  ETH: ['ethereum', 'eth', 'crypto', 'cryptocurrency', 'price', 'market'],
+};
+
+function matchesSignal(market: Market, signal: PriceSignal): boolean {
+  const keywords = ASSET_KEYWORDS[signal.asset] ?? [];
+  const haystack = `${market.question} ${market.description}`.toLowerCase();
+  return keywords.some(kw => haystack.includes(kw));
+}
+
+function simpleKeywordMatch(market: Market, query: string): boolean {
+  if (!query) return true;
+  const terms = query.toLowerCase().split(/\s+/).filter(Boolean);
+  const haystack = `${market.question} ${market.description}`.toLowerCase();
+  return terms.every(term => haystack.includes(term));
+}
+
+const server = new Server(
+  { name: 'polymarket', version: '1.0.0' },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'list_markets',
+      description: 'Fetch active Polymarket prediction markets with current prices',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Keyword filter for market question/description' },
+          min_volume: { type: 'number', description: 'Minimum USD volume (default: 10000)' },
+          limit: { type: 'number', description: 'Max results to return (default: 20)' },
+        },
+      },
+    },
+    {
+      name: 'get_orderbook',
+      description: 'Get CLOB orderbook for a specific market token',
+      inputSchema: {
+        type: 'object',
+        required: ['token_id'],
+        properties: {
+          token_id: { type: 'string', description: 'Polymarket token ID' },
+        },
+      },
+    },
+    {
+      name: 'get_market_price',
+      description: 'Get current buy/sell price for a market token (0-1 = probability)',
+      inputSchema: {
+        type: 'object',
+        required: ['token_id', 'side'],
+        properties: {
+          token_id: { type: 'string' },
+          side: { type: 'string', enum: ['buy', 'sell'] },
+        },
+      },
+    },
+    {
+      name: 'assess_signal',
+      description: 'Given a crypto price signal, find relevant Polymarket markets that might be affected',
+      inputSchema: {
+        type: 'object',
+        required: ['signal'],
+        properties: {
+          signal: {
+            type: 'object',
+            description: 'PriceSignal object',
+            required: ['asset', 'direction', 'pct_change', 'price', 'window_secs', 'signal_ts'],
+            properties: {
+              asset: { type: 'string', enum: ['BTC', 'ETH'] },
+              direction: { type: 'string', enum: ['up', 'down'] },
+              pct_change: { type: 'number' },
+              price: { type: 'number' },
+              window_secs: { type: 'number' },
+              signal_ts: { type: 'number' },
+            },
+          },
+        },
+      },
+    },
+    {
+      name: 'place_order',
+      description: 'Place a Polymarket CLOB order (dry_run=true by default — logs intent without executing)',
+      inputSchema: {
+        type: 'object',
+        required: ['token_id', 'side', 'size_usdc', 'price'],
+        properties: {
+          token_id: { type: 'string' },
+          side: { type: 'string', enum: ['BUY', 'SELL'] },
+          size_usdc: { type: 'number', description: 'Order size in USDC' },
+          price: { type: 'number', description: 'Limit price 0-1 (probability)' },
+          dry_run: { type: 'boolean', description: 'If true, log only — do not execute (default: true)' },
+        },
+      },
+    },
+  ],
+}));
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case 'list_markets': {
+        const { query, min_volume = 10_000, limit = 20 } = (args ?? {}) as any;
+        const markets = await fetchActiveMarkets(min_volume, 1_000);
+        const filtered = markets
+          .filter(m => simpleKeywordMatch(m, query ?? ''))
+          .slice(0, limit);
+        return {
+          content: [{ type: 'text', text: JSON.stringify(filtered, null, 2) }],
+        };
+      }
+
+      case 'get_orderbook': {
+        const { token_id } = args as { token_id: string };
+        const book = await getOrderbook(token_id);
+        return {
+          content: [{ type: 'text', text: JSON.stringify(book, null, 2) }],
+        };
+      }
+
+      case 'get_market_price': {
+        const { token_id, side } = args as { token_id: string; side: 'buy' | 'sell' };
+        const price = await getPrice(token_id, side);
+        return {
+          content: [{ type: 'text', text: JSON.stringify({ token_id, side, price }) }],
+        };
+      }
+
+      case 'assess_signal': {
+        const { signal } = args as { signal: PriceSignal };
+        const start = Date.now();
+        const markets = await fetchActiveMarkets(10_000, 1_000);
+        const matched = markets.filter(m => matchesSignal(m, signal));
+        const latency_ms = Date.now() - start;
+
+        const result = {
+          signal,
+          matched_count: matched.length,
+          latency_ms,
+          markets: matched.slice(0, 10).map(m => ({
+            id: m.id,
+            question: m.question,
+            volume: m.volume,
+            liquidity: m.liquidity,
+            tokens: m.tokens,
+          })),
+        };
+        return {
+          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+      }
+
+      case 'place_order': {
+        const { token_id, side, size_usdc, price, dry_run = true } = args as any;
+        const result = await placeOrder({ token_id, side, size_usdc, price, dry_run });
+        return {
+          content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+        };
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (err: any) {
+    return {
+      content: [{ type: 'text', text: `Error: ${err.message}` }],
+      isError: true,
+    };
+  }
+});
+
+async function main(): Promise<void> {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('[mcp] Polymarket MCP server started (stdio)');
+}
+
+main().catch((err) => {
+  console.error('[mcp] Fatal:', err);
+  process.exit(1);
+});

package/src/mcp-server.ts

@@ -0,0 +1,245 @@
+#!/usr/bin/env node
+import { Server } from '@modelcontextprotocol/sdk/server/index.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js'
+import Redis from 'ioredis'
+
+const REDIS_PREFIX = process.env.POLLY_REDIS_PREFIX || 'polly'
+
+const redis = new Redis(process.env.REDIS_URL || 'redis://localhost:6379', {
+  retryStrategy: (times) => Math.min(times * 500, 5000),
+  maxRetriesPerRequest: null,
+  enableReadyCheck: false,
+})
+redis.on('error', (e) => console.error('[redis]', e.message))
+
+const server = new Server(
+  { name: 'polly-gamba-paper', version: '1.0.0' },
+  { capabilities: { tools: {} } }
+)
+
+server.setRequestHandler(ListToolsRequestSchema, async () => ({
+  tools: [
+    {
+      name: 'place_order',
+      description: 'Place a paper trade on Polymarket. Logs the trade to Redis (no real execution).',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          market_id: { type: 'string', description: 'Polymarket market ID' },
+          market_question: { type: 'string', description: 'Market question for logging' },
+          token_id: { type: 'string', description: 'Token ID (YES or NO token)' },
+          outcome: { type: 'string', description: 'YES or NO' },
+          side: { type: 'string', enum: ['BUY', 'SELL'] },
+          size_usdc: { type: 'number', description: 'Size in USDC (virtual)' },
+          price: { type: 'number', description: 'Current price (0-1)' },
+          reasoning: { type: 'string', description: 'Why you are making this trade' }
+        },
+        required: ['market_id', 'market_question', 'outcome', 'side', 'size_usdc', 'price', 'reasoning']
+      }
+    },
+    {
+      name: 'skip_market',
+      description: 'Explicitly decide not to trade on a market, with reasoning.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          market_id: { type: 'string' },
+          market_question: { type: 'string' },
+          reasoning: { type: 'string', description: 'Why you are skipping' }
+        },
+        required: ['market_id', 'market_question', 'reasoning']
+      }
+    },
+    {
+      name: 'skip_all',
+      description: 'Skip all markets in the current scan — use only when you have zero opinion on any market.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          reasoning: { type: 'string', description: 'Why you are skipping all markets' }
+        },
+        required: ['reasoning']
+      }
+    },
+    {
+      name: 'get_positions',
+      description: 'Returns all open positions from Redis.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+        required: []
+      }
+    },
+    {
+      name: 'close_position',
+      description: 'Marks a position as closed with exit price and P&L.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          market_id: { type: 'string', description: 'Polymarket market ID' },
+          outcome: { type: 'string', description: 'YES or NO' },
+          exit_price: { type: 'number', description: 'Exit price (0-1)' },
+          reason: { type: 'string', enum: ['take_profit', 'stop_loss', 'expiry', 'manual'], description: 'Reason for closing' }
+        },
+        required: ['market_id', 'outcome', 'exit_price', 'reason']
+      }
+    },
+    {
+      name: 'get_pnl_summary',
+      description: 'Returns P&L summary across all open and closed positions.',
+      inputSchema: {
+        type: 'object',
+        properties: {},
+        required: []
+      }
+    }
+  ]
+}))
+
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  const { name, arguments: args } = req.params
+  const ts = Date.now()
+
+  if (name === 'place_order') {
+    const a = args as any
+    const position = { ...a, ts, status: 'open', pnl: null }
+    await redis.lpush(`${REDIS_PREFIX}:positions`, JSON.stringify(position))
+    await redis.ltrim(`${REDIS_PREFIX}:positions`, 0, 9999)
+    await redis.publish(`${REDIS_PREFIX}:events`, JSON.stringify({ type: 'trade', ...position }))
+    console.error(`[paper] TRADE ${a.side} ${a.outcome} "${String(a.market_question).slice(0, 50)}" @ ${a.price} $${a.size_usdc}`)
+    return {
+      content: [{
+        type: 'text',
+        text: `Paper trade logged: ${a.side} ${a.outcome} on "${a.market_question}" @ ${a.price} for $${a.size_usdc} USDC. Position recorded in Redis.`
+      }]
+    }
+  }
+
+  if (name === 'skip_market') {
+    const a = args as any
+    await redis.lpush(`${REDIS_PREFIX}:skips`, JSON.stringify({ ...a, ts }))
+    await redis.ltrim(`${REDIS_PREFIX}:skips`, 0, 9999)
+    console.error(`[paper] SKIP "${String(a.market_question).slice(0, 50)}"`)
+    return {
+      content: [{ type: 'text', text: `Skip recorded for "${a.market_question}": ${a.reasoning}` }]
+    }
+  }
+
+  if (name === 'skip_all') {
+    const a = args as any
+    await redis.lpush(`${REDIS_PREFIX}:skips`, JSON.stringify({ skip_all: true, reasoning: a.reasoning, ts }))
+    await redis.ltrim(`${REDIS_PREFIX}:skips`, 0, 9999)
+    console.error(`[paper] SKIP_ALL: ${String(a.reasoning).slice(0, 100)}`)
+    return {
+      content: [{ type: 'text', text: `Skip all recorded: ${a.reasoning}` }]
+    }
+  }
+
+  if (name === 'get_positions') {
+    const raw = await redis.lrange(`${REDIS_PREFIX}:positions`, 0, -1)
+    const closedIds = new Set(await redis.smembers(`${REDIS_PREFIX}:closed_ids`))
+    const positions = raw.map(r => {
+      try { return JSON.parse(r) } catch { return null }
+    }).filter(Boolean).filter((p: any) => {
+      if (p.status === 'closed') return false
+      const key = `${p.market_id}_${p.outcome}_${p.ts}`
+      return !closedIds.has(key)
+    })
+    return {
+      content: [{ type: 'text', text: JSON.stringify(positions, null, 2) }]
+    }
+  }
+
+  if (name === 'close_position') {
+    const a = args as any
+    const raw = await redis.lrange(`${REDIS_PREFIX}:positions`, 0, -1)
+    const positions = raw.map(r => {
+      try { return JSON.parse(r) } catch { return null }
+    }).filter(Boolean)
+
+    // Find matching open position
+    const match = positions.find((p: any) =>
+      p.market_id === a.market_id &&
+      p.outcome?.toLowerCase() === String(a.outcome).toLowerCase() &&
+      p.status !== 'closed'
+    )
+
+    if (!match) {
+      return { content: [{ type: 'text', text: `No open position found for market ${a.market_id} outcome ${a.outcome}` }] }
+    }
+
+    const shares = match.size_usdc / match.price
+    const pnl = shares * a.exit_price - match.size_usdc
+    const closed = {
+      ...match,
+      status: 'closed',
+      exit_price: a.exit_price,
+      pnl,
+      closed_at: Date.now(),
+      reason: a.reason,
+    }
+
+    const posKey = `${match.market_id}_${match.outcome}_${match.ts}`
+    await redis.sadd(`${REDIS_PREFIX}:closed_ids`, posKey)
+    await redis.lpush(`${REDIS_PREFIX}:closed_positions`, JSON.stringify(closed))
+    await redis.ltrim(`${REDIS_PREFIX}:closed_positions`, 0, 9999)
+    await redis.lpush(`${REDIS_PREFIX}:log`, JSON.stringify({ type: 'position_closed', data: closed, ts: Date.now() }))
+    await redis.ltrim(`${REDIS_PREFIX}:log`, 0, 9999)
+
+    console.error(`[paper] CLOSE ${a.reason.toUpperCase()} "${String(match.market_question).slice(0, 50)}" ${match.outcome} pnl=${pnl >= 0 ? '+' : ''}${pnl.toFixed(2)}`)
+    return {
+      content: [{ type: 'text', text: `Position closed: ${a.reason}. P&L: ${pnl >= 0 ? '+' : ''}$${pnl.toFixed(2)} USDC` }]
+    }
+  }
+
+  if (name === 'get_pnl_summary') {
+    const [openRaw, closedRaw] = await Promise.all([
+      redis.lrange(`${REDIS_PREFIX}:positions`, 0, -1),
+      redis.lrange(`${REDIS_PREFIX}:closed_positions`, 0, -1),
+    ])
+    const closedIds = new Set(await redis.smembers(`${REDIS_PREFIX}:closed_ids`))
+
+    const allPositions = openRaw.map(r => { try { return JSON.parse(r) } catch { return null } }).filter(Boolean)
+    const openPositions = allPositions.filter((p: any) => {
+      if (p.status === 'closed') return false
+      return !closedIds.has(`${p.market_id}_${p.outcome}_${p.ts}`)
+    })
+    const closedPositions = closedRaw.map(r => { try { return JSON.parse(r) } catch { return null } }).filter(Boolean)
+
+    const totalInvested = openPositions.reduce((s: number, p: any) => s + (p.size_usdc || 0), 0)
+    const totalRealized = closedPositions.reduce((s: number, p: any) => s + (p.pnl || 0), 0)
+    const wins = closedPositions.filter((p: any) => (p.pnl || 0) > 0).length
+    const winRate = closedPositions.length > 0 ? wins / closedPositions.length : 0
+
+    const byReason: Record<string, number> = {}
+    for (const p of closedPositions) {
+      const r = p.reason || 'unknown'
+      byReason[r] = (byReason[r] || 0) + 1
+    }
+
+    const summary = {
+      open_positions: openPositions.length,
+      closed_positions: closedPositions.length,
+      total_invested: Math.round(totalInvested * 100) / 100,
+      total_realized_pnl: Math.round(totalRealized * 100) / 100,
+      win_rate: Math.round(winRate * 100) / 100,
+      by_reason: byReason,
+    }
+
+    return { content: [{ type: 'text', text: JSON.stringify(summary, null, 2) }] }
+  }
+
+  throw new Error(`Unknown tool: ${name}`)
+})
+
+async function main() {
+  const transport = new StdioServerTransport()
+  await server.connect(transport)
+  console.error('[mcp] polly-gamba-paper MCP server started (stdio)')
+}
+
+main().catch((e) => {
+  console.error('[mcp] Fatal:', e)
+  process.exit(1)
+})