@exagent/agent 0.3.6 → 0.3.8

package/src/prediction/client.ts

@@ -1,288 +0,0 @@
-/**
- * Polymarket Client
- *
- * CLOB API (authenticated, Polygon) for orders and fills.
- * Gamma API (public) for market discovery, search, trending.
- *
- * Uses @polymarket/clob-client for L2 auth and order signing.
- * API key derived once per session from wallet signature.
- */
-
-import { ClobClient, Side } from '@polymarket/clob-client';
-import { createWalletClient, http, type WalletClient } from 'viem';
-import { privateKeyToAccount } from 'viem/accounts';
-import { polygon } from 'viem/chains';
-import type {
-  PredictionConfig,
-  PredictionMarket,
-  PredictionFill,
-} from './types.js';
-import { DEFAULT_PREDICTION_CONFIG, POLYGON_CHAIN_ID } from './types.js';
-
-interface ApiKeyCreds {
-  key: string;
-  secret: string;
-  passphrase: string;
-}
-
-interface OrderBookLevel {
-  price: number;
-  size: number;
-}
-
-export class PolymarketClient {
-  private readonly config: PredictionConfig;
-  private clobClient: ClobClient | null = null;
-  private apiCreds: ApiKeyCreds | null = null;
-  private readonly signer: WalletClient;
-  private readonly walletAddress: string;
-
-  private marketCache: Map<string, { market: PredictionMarket; cachedAt: number }> = new Map();
-  private readonly CACHE_TTL_MS = 60_000;
-
-  constructor(privateKey: string, config?: Partial<PredictionConfig>) {
-    this.config = { ...DEFAULT_PREDICTION_CONFIG, ...config } as PredictionConfig;
-    const account = privateKeyToAccount(privateKey as `0x${string}`);
-    this.signer = createWalletClient({
-      account,
-      chain: polygon,
-      transport: http(),
-    });
-    this.walletAddress = account.address;
-  }
-
-  // ── INITIALIZATION ─────────────────────────────────────────
-
-  async initialize(): Promise<void> {
-    const initClient = new ClobClient(
-      this.config.clobApiUrl,
-      POLYGON_CHAIN_ID,
-      this.signer,
-    );
-
-    this.apiCreds = (await initClient.createOrDeriveApiKey()) as ApiKeyCreds;
-
-    // EOA signature type (0)
-    this.clobClient = new ClobClient(
-      this.config.clobApiUrl,
-      POLYGON_CHAIN_ID,
-      this.signer,
-      this.apiCreds,
-      0,
-    );
-
-    console.log(`[prediction] CLOB initialized for ${this.walletAddress}`);
-  }
-
-  get isInitialized(): boolean {
-    return this.clobClient !== null && this.apiCreds !== null;
-  }
-
-  // ── CLOB API — ORDER BOOK & PRICES ─────────────────────────
-
-  async getOrderBook(tokenId: string): Promise<{ bids: OrderBookLevel[]; asks: OrderBookLevel[] }> {
-    this.ensureInitialized();
-    const book = await this.clobClient!.getOrderBook(tokenId);
-    return {
-      bids: (book.bids || []).map((b: any) => ({ price: parseFloat(b.price), size: parseFloat(b.size) })),
-      asks: (book.asks || []).map((a: any) => ({ price: parseFloat(a.price), size: parseFloat(a.size) })),
-    };
-  }
-
-  async getMidpointPrice(tokenId: string): Promise<number> {
-    const book = await this.getOrderBook(tokenId);
-    if (book.bids.length === 0 || book.asks.length === 0) return 0;
-    return (book.bids[0].price + book.asks[0].price) / 2;
-  }
-
-  async getLastTradePrice(tokenId: string): Promise<number> {
-    this.ensureInitialized();
-    const resp = await this.clobClient!.getLastTradePrice(tokenId);
-    return parseFloat(resp?.price || '0');
-  }
-
-  // ── CLOB API — ORDERS ──────────────────────────────────────
-
-  async placeLimitOrder(params: {
-    tokenId: string;
-    price: number;
-    size: number;
-    side: 'BUY' | 'SELL';
-  }): Promise<{ orderId: string; success: boolean }> {
-    this.ensureInitialized();
-    const order = await this.clobClient!.createAndPostOrder({
-      tokenID: params.tokenId,
-      price: params.price,
-      side: params.side as Side,
-      size: params.size,
-    });
-    return {
-      orderId: order?.orderID || '',
-      success: !!order?.orderID,
-    };
-  }
-
-  async placeMarketOrder(params: {
-    tokenId: string;
-    amount: number;
-    side: 'BUY' | 'SELL';
-  }): Promise<{ orderId: string; success: boolean }> {
-    this.ensureInitialized();
-    const order = await this.clobClient!.createMarketOrder({
-      tokenID: params.tokenId,
-      amount: params.amount,
-      side: params.side as Side,
-    });
-    const result = await this.clobClient!.postOrder(order);
-    return {
-      orderId: result?.orderID || '',
-      success: !!result?.orderID,
-    };
-  }
-
-  async cancelOrder(orderId: string): Promise<boolean> {
-    this.ensureInitialized();
-    try {
-      await this.clobClient!.cancelOrder({ orderID: orderId });
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async cancelAllOrders(): Promise<boolean> {
-    this.ensureInitialized();
-    try {
-      await this.clobClient!.cancelAll();
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  async getOpenOrders(): Promise<any[]> {
-    this.ensureInitialized();
-    return this.clobClient!.getOpenOrders();
-  }
-
-  async getTradeHistory(): Promise<PredictionFill[]> {
-    this.ensureInitialized();
-    const trades = await this.clobClient!.getTrades();
-    return (trades || []).map((t: any) => this.parseRawFill(t));
-  }
-
-  // ── GAMMA API — MARKET DISCOVERY (public) ──────────────────
-
-  async getMarkets(params?: {
-    limit?: number;
-    offset?: number;
-    category?: string;
-    active?: boolean;
-  }): Promise<PredictionMarket[]> {
-    const query = new URLSearchParams();
-    if (params?.limit) query.set('limit', String(params.limit));
-    if (params?.offset) query.set('offset', String(params.offset));
-    if (params?.active !== undefined) query.set('active', String(params.active));
-    if (params?.category) query.set('tag', params.category);
-
-    const url = `${this.config.gammaApiUrl}/markets?${query.toString()}`;
-    const resp = await fetch(url);
-    if (!resp.ok) throw new Error(`Gamma API error: ${resp.status} ${await resp.text()}`);
-
-    const raw = await resp.json();
-    return (raw || []).map((m: any) => this.parseGammaMarket(m));
-  }
-
-  async getMarketByConditionId(conditionId: string): Promise<PredictionMarket | null> {
-    const cached = this.marketCache.get(conditionId);
-    if (cached && Date.now() - cached.cachedAt < this.CACHE_TTL_MS) {
-      return cached.market;
-    }
-
-    const url = `${this.config.gammaApiUrl}/markets?condition_id=${conditionId}`;
-    const resp = await fetch(url);
-    if (!resp.ok) return null;
-
-    const raw = await resp.json();
-    if (!raw || raw.length === 0) return null;
-
-    const market = this.parseGammaMarket(raw[0]);
-    this.marketCache.set(conditionId, { market, cachedAt: Date.now() });
-    return market;
-  }
-
-  async searchMarkets(query: string, limit = 20): Promise<PredictionMarket[]> {
-    const url = `${this.config.gammaApiUrl}/markets?_q=${encodeURIComponent(query)}&limit=${limit}&active=true`;
-    const resp = await fetch(url);
-    if (!resp.ok) return [];
-
-    const raw = await resp.json();
-    return (raw || []).map((m: any) => this.parseGammaMarket(m));
-  }
-
-  async getTrendingMarkets(limit = 10): Promise<PredictionMarket[]> {
-    const url = `${this.config.gammaApiUrl}/markets?active=true&limit=${limit}&order=volume24hr&ascending=false`;
-    const resp = await fetch(url);
-    if (!resp.ok) return [];
-
-    const raw = await resp.json();
-    return (raw || []).map((m: any) => this.parseGammaMarket(m));
-  }
-
-  // ── WALLET ─────────────────────────────────────────────────
-
-  getWalletAddress(): string {
-    return this.walletAddress;
-  }
-
-  // ── PRIVATE ────────────────────────────────────────────────
-
-  private ensureInitialized(): void {
-    if (!this.clobClient) {
-      throw new Error('PolymarketClient not initialized. Call initialize() first.');
-    }
-  }
-
-  private parseGammaMarket(raw: any): PredictionMarket {
-    const outcomes = raw.outcomes ? JSON.parse(raw.outcomes) : ['Yes', 'No'];
-    const outcomePrices = raw.outcomePrices ? JSON.parse(raw.outcomePrices) : [0, 0];
-    const outcomeTokenIds = raw.clobTokenIds ? JSON.parse(raw.clobTokenIds) : [];
-
-    return {
-      conditionId: raw.conditionId || raw.condition_id || '',
-      question: raw.question || '',
-      description: raw.description || '',
-      category: raw.groupItemTitle || raw.category || 'Other',
-      outcomes,
-      outcomeTokenIds,
-      outcomePrices: outcomePrices.map((p: any) => parseFloat(p) || 0),
-      volume24h: parseFloat(raw.volume24hr || raw.volume24h || '0'),
-      liquidity: parseFloat(raw.liquidity || '0'),
-      endDate: raw.endDate ? new Date(raw.endDate).getTime() / 1000 : 0,
-      active: raw.active !== false && raw.closed !== true,
-      resolved: raw.resolved === true,
-      winningOutcome: raw.winningOutcome,
-      resolutionSource: raw.resolutionSource || undefined,
-      uniqueTraders: raw.uniqueTraders || undefined,
-    };
-  }
-
-  private parseRawFill(raw: any): PredictionFill {
-    const tokenId = raw.asset_id || undefined;
-    const marketConditionId = raw.market || raw.asset_id || '';
-
-    return {
-      orderId: raw.orderId || raw.order_id || '',
-      tradeId: raw.id || raw.tradeId || '',
-      marketConditionId,
-      outcomeIndex: raw.outcome_index ?? (raw.side === 'BUY' ? 0 : 1),
-      side: raw.side === 'BUY' || raw.side === 'buy' ? 'BUY' : 'SELL',
-      price: String(raw.price || '0'),
-      size: String(raw.size || '0'),
-      fee: String(raw.fee || '0'),
-      timestamp: raw.timestamp || raw.created_at ? new Date(raw.created_at).getTime() : Date.now(),
-      isMaker: raw.maker_order || raw.is_maker || false,
-      tokenId,
-    };
-  }
-}

package/src/prediction/index.ts

@@ -1,3 +0,0 @@
-export * from './types.js';
-export { PolymarketClient } from './client.js';
-export { PolymarketOrderManager } from './order-manager.js';

package/src/prediction/order-manager.ts

@@ -1,297 +0,0 @@
-/**
- * Polymarket Order Manager
- *
- * Executes prediction trade signals, polls for new fills,
- * and tracks local position state.
- */
-
-import type {
-  PredictionConfig,
-  PredictionTradeSignal,
-  PredictionOrderResult,
-  PredictionFill,
-  PredictionPosition,
-  PredictionAccountSummary,
-} from './types.js';
-import { PolymarketClient } from './client.js';
-
-// ── LOCAL POSITION TRACKING ──────────────────────────────────
-
-interface LocalPosition {
-  marketConditionId: string;
-  outcomeIndex: number;
-  marketQuestion: string;
-  tokenId: string;
-  balance: number;
-  totalCostBasis: number;
-  totalProceeds: number;
-  averageEntryPrice: number;
-  currentPrice: number;
-  category?: string;
-  endDate?: number;
-}
-
-export class PolymarketOrderManager {
-  private readonly client: PolymarketClient;
-  private readonly config: PredictionConfig;
-
-  private seenFillIds: Set<string> = new Set();
-  private recentFills: PredictionFill[] = [];
-  private positions: Map<string, LocalPosition> = new Map();
-
-  private lastPriceRefresh: number = 0;
-  private readonly PRICE_REFRESH_MS = 10_000;
-
-  constructor(client: PolymarketClient, config: PredictionConfig) {
-    this.client = client;
-    this.config = config;
-  }
-
-  // ── SIGNAL EXECUTION ───────────────────────────────────────
-
-  async executeSignal(signal: PredictionTradeSignal): Promise<PredictionOrderResult> {
-    if (signal.action === 'hold') {
-      return { success: true, status: 'cancelled', error: 'Hold signal — no action' };
-    }
-
-    // Risk checks
-    const violation = this.checkRiskLimits(signal);
-    if (violation) {
-      return { success: false, status: 'error', error: violation };
-    }
-
-    try {
-      const market = await this.client.getMarketByConditionId(signal.marketConditionId);
-      if (!market) {
-        return { success: false, status: 'error', error: `Market not found: ${signal.marketConditionId}` };
-      }
-
-      if (!market.active) {
-        return { success: false, status: 'error', error: `Market is closed: ${market.question}` };
-      }
-
-      const tokenId = market.outcomeTokenIds[signal.outcomeIndex];
-      if (!tokenId) {
-        return { success: false, status: 'error', error: `Invalid outcome index: ${signal.outcomeIndex}` };
-      }
-
-      const isBuy = signal.action === 'buy_yes' || signal.action === 'buy_no';
-      const side = isBuy ? 'BUY' as const : 'SELL' as const;
-
-      let result: { orderId: string; success: boolean };
-
-      if (signal.orderType === 'market') {
-        result = await this.client.placeMarketOrder({
-          tokenId,
-          amount: signal.amount,
-          side,
-        });
-      } else {
-        result = await this.client.placeLimitOrder({
-          tokenId,
-          price: signal.limitPrice,
-          size: signal.amount,
-          side,
-        });
-      }
-
-      if (result.success) {
-        console.log(`[prediction] Order placed: ${signal.action} ${signal.amount} on "${market.question}" @ ${signal.limitPrice}`);
-        return { success: true, orderId: result.orderId, status: 'resting' };
-      }
-
-      return { success: false, status: 'error', error: 'Order placement failed' };
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.error('[prediction] Order execution error:', message);
-      return { success: false, status: 'error', error: message };
-    }
-  }
-
-  // ── FILL POLLING ───────────────────────────────────────────
-
-  async pollNewFills(): Promise<PredictionFill[]> {
-    try {
-      const allFills = await this.client.getTradeHistory();
-      const newFills: PredictionFill[] = [];
-
-      for (const fill of allFills) {
-        if (!this.seenFillIds.has(fill.tradeId)) {
-          this.seenFillIds.add(fill.tradeId);
-          newFills.push(fill);
-          this.processFill(fill);
-          this.recentFills.push(fill);
-        }
-      }
-
-      // Cap recent fills
-      if (this.recentFills.length > 100) {
-        this.recentFills = this.recentFills.slice(-100);
-      }
-
-      return newFills;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      console.warn('[prediction] Fill polling error:', message);
-      return [];
-    }
-  }
-
-  getRecentFills(): PredictionFill[] {
-    return this.recentFills;
-  }
-
-  // ── POSITION QUERIES ───────────────────────────────────────
-
-  async getPositions(forceRefresh = false): Promise<PredictionPosition[]> {
-    if (forceRefresh || Date.now() - this.lastPriceRefresh > this.PRICE_REFRESH_MS) {
-      await this.refreshPrices();
-    }
-
-    return Array.from(this.positions.values())
-      .filter((p) => p.balance > 0)
-      .map((p) => this.toExternalPosition(p));
-  }
-
-  async getAccountSummary(): Promise<PredictionAccountSummary> {
-    const positions = await this.getPositions();
-    const totalExposure = positions.reduce((sum, p) => sum + p.costBasis, 0);
-    const totalUnrealizedPnl = positions.reduce((sum, p) => sum + p.unrealizedPnl, 0);
-    const openMarkets = new Set(positions.map((p) => p.marketConditionId));
-
-    return {
-      totalExposure,
-      totalUnrealizedPnl,
-      openMarketCount: openMarkets.size,
-      openPositionCount: positions.length,
-    };
-  }
-
-  getTotalExposure(): number {
-    let total = 0;
-    for (const pos of this.positions.values()) {
-      if (pos.balance > 0) total += pos.totalCostBasis;
-    }
-    return total;
-  }
-
-  // ── CANCELLATION ───────────────────────────────────────────
-
-  async cancelOrder(orderId: string): Promise<boolean> {
-    return this.client.cancelOrder(orderId);
-  }
-
-  async cancelAllOrders(): Promise<boolean> {
-    return this.client.cancelAllOrders();
-  }
-
-  // ── PRIVATE ────────────────────────────────────────────────
-
-  private checkRiskLimits(signal: PredictionTradeSignal): string | null {
-    if (signal.amount > this.config.maxNotionalUSD) {
-      return `Trade exceeds max notional: $${signal.amount} > $${this.config.maxNotionalUSD}`;
-    }
-
-    if (signal.limitPrice <= 0 || signal.limitPrice >= 1) {
-      return `Invalid price: ${signal.limitPrice} (must be 0.01-0.99)`;
-    }
-
-    if (signal.confidence < 0.3) {
-      return `Low confidence: ${signal.confidence} < 0.3`;
-    }
-
-    const isBuy = signal.action === 'buy_yes' || signal.action === 'buy_no';
-    if (isBuy) {
-      const currentExposure = this.getTotalExposure();
-      if (currentExposure + signal.amount > this.config.maxTotalExposureUSD) {
-        return `Total exposure exceeded: $${currentExposure + signal.amount} > $${this.config.maxTotalExposureUSD}`;
-      }
-    }
-
-    return null;
-  }
-
-  private processFill(fill: PredictionFill): void {
-    const key = `${fill.marketConditionId}:${fill.outcomeIndex}`;
-    let pos = this.positions.get(key);
-
-    const price = parseFloat(fill.price);
-    const size = parseFloat(fill.size);
-
-    if (!pos) {
-      pos = {
-        marketConditionId: fill.marketConditionId,
-        outcomeIndex: fill.outcomeIndex,
-        marketQuestion: fill.marketQuestion || '',
-        tokenId: fill.tokenId || '',
-        balance: 0,
-        totalCostBasis: 0,
-        totalProceeds: 0,
-        averageEntryPrice: 0,
-        currentPrice: price,
-        category: undefined,
-        endDate: undefined,
-      };
-      this.positions.set(key, pos);
-    } else if (!pos.tokenId && fill.tokenId) {
-      pos.tokenId = fill.tokenId;
-    }
-
-    if (fill.side === 'BUY') {
-      const oldCost = pos.averageEntryPrice * pos.balance;
-      const newCost = price * size;
-      pos.balance += size;
-      pos.totalCostBasis += newCost;
-      pos.averageEntryPrice = pos.balance > 0 ? (oldCost + newCost) / pos.balance : 0;
-    } else {
-      pos.balance -= size;
-      pos.totalProceeds += price * size;
-      if (pos.balance < 0) pos.balance = 0;
-    }
-  }
-
-  private async refreshPrices(): Promise<void> {
-    const openPositions = Array.from(this.positions.values()).filter((p) => p.balance > 0);
-
-    await Promise.all(
-      openPositions.map(async (pos) => {
-        try {
-          if (!pos.tokenId) {
-            const market = await this.client.getMarketByConditionId(pos.marketConditionId);
-            if (market && market.outcomeTokenIds[pos.outcomeIndex]) {
-              pos.tokenId = market.outcomeTokenIds[pos.outcomeIndex];
-            }
-          }
-          if (pos.tokenId) {
-            const price = await this.client.getMidpointPrice(pos.tokenId);
-            if (price > 0) pos.currentPrice = price;
-          }
-        } catch {
-          // Keep stale price on error
-        }
-      }),
-    );
-
-    this.lastPriceRefresh = Date.now();
-  }
-
-  private toExternalPosition(pos: LocalPosition): PredictionPosition {
-    const unrealizedPnl =
-      pos.balance > 0 ? (pos.currentPrice - pos.averageEntryPrice) * pos.balance : 0;
-
-    return {
-      marketConditionId: pos.marketConditionId,
-      marketQuestion: pos.marketQuestion,
-      outcomeIndex: pos.outcomeIndex,
-      outcomeLabel: pos.outcomeIndex === 0 ? 'Yes' : 'No',
-      tokenId: pos.tokenId,
-      balance: pos.balance,
-      averageEntryPrice: pos.averageEntryPrice,
-      currentPrice: pos.currentPrice,
-      unrealizedPnl,
-      costBasis: pos.totalCostBasis - pos.totalProceeds,
-      endDate: pos.endDate,
-      category: pos.category,
-    };
-  }
-}