@catalyst-team/poly-sdk 0.1.0 → 0.2.0

package/examples/13-arbitrage-service.ts

@@ -0,0 +1,211 @@
+#!/usr/bin/env npx tsx
+/**
+ * Example 13: ArbitrageService - Complete Workflow
+ *
+ * Demonstrates the full arbitrage workflow:
+ * 1. Scan markets for opportunities
+ * 2. Start real-time monitoring
+ * 3. Auto-execute arbitrage
+ * 4. Stop and clear positions
+ *
+ * Environment variables:
+ *   POLY_PRIVKEY - Private key for trading (optional for scan-only mode)
+ *
+ * Run with:
+ *   pnpm example:arb-service
+ *
+ * Or scan-only (no trading):
+ *   npx tsx examples/13-arbitrage-service.ts --scan-only
+ */
+
+import { ArbitrageService } from '../src/index.js';
+
+// Parse arguments
+const args = process.argv.slice(2);
+const SCAN_ONLY = args.includes('--scan-only');
+const RUN_DURATION = parseInt(args.find(a => a.startsWith('--duration='))?.split('=')[1] || '60') * 1000; // default 60s
+
+async function main() {
+  console.log('╔════════════════════════════════════════════════════════════════╗');
+  console.log('║              ArbitrageService - Complete Workflow              ║');
+  console.log('╚════════════════════════════════════════════════════════════════╝');
+  console.log();
+
+  const privateKey = process.env.POLY_PRIVKEY;
+
+  if (!privateKey && !SCAN_ONLY) {
+    console.log('No POLY_PRIVKEY provided. Running in scan-only mode.\n');
+  }
+
+  // ========== Initialize ArbitrageService ==========
+  const arbService = new ArbitrageService({
+    privateKey: SCAN_ONLY ? undefined : privateKey,
+    profitThreshold: 0.005,  // 0.5% minimum profit
+    minTradeSize: 5,         // $5 minimum
+    maxTradeSize: 100,       // $100 maximum
+    autoExecute: !SCAN_ONLY && !!privateKey,
+    enableLogging: true,
+
+    // Rebalancer config
+    enableRebalancer: !SCAN_ONLY && !!privateKey,
+    minUsdcRatio: 0.2,
+    maxUsdcRatio: 0.8,
+    targetUsdcRatio: 0.5,
+    imbalanceThreshold: 5,
+    rebalanceInterval: 10000,
+    rebalanceCooldown: 30000,
+
+    // Execution safety
+    sizeSafetyFactor: 0.8,
+    autoFixImbalance: true,
+  });
+
+  // ========== Set up event listeners ==========
+  arbService.on('opportunity', (opp) => {
+    console.log(`\n🎯 ${opp.type.toUpperCase()} ARB: ${opp.profitPercent.toFixed(2)}%`);
+    console.log(`   ${opp.description}`);
+    console.log(`   Recommended size: ${opp.recommendedSize.toFixed(2)}, Est profit: $${opp.estimatedProfit.toFixed(2)}`);
+  });
+
+  arbService.on('execution', (result) => {
+    if (result.success) {
+      console.log(`\n✅ Execution succeeded!`);
+      console.log(`   Type: ${result.type}, Size: ${result.size.toFixed(2)}`);
+      console.log(`   Profit: $${result.profit.toFixed(2)}`);
+      console.log(`   Time: ${result.executionTimeMs}ms`);
+    } else {
+      console.log(`\n❌ Execution failed: ${result.error}`);
+    }
+  });
+
+  arbService.on('rebalance', (result) => {
+    if (result.success) {
+      console.log(`\n🔄 Rebalance: ${result.action.type} ${result.action.amount.toFixed(2)}`);
+      console.log(`   Reason: ${result.action.reason}`);
+    } else {
+      console.log(`\n⚠️ Rebalance failed: ${result.error}`);
+    }
+  });
+
+  arbService.on('balanceUpdate', (balance) => {
+    console.log(`\n💰 Balance: USDC=${balance.usdc.toFixed(2)}, YES=${balance.yesTokens.toFixed(2)}, NO=${balance.noTokens.toFixed(2)}`);
+  });
+
+  arbService.on('error', (error) => {
+    console.error(`\n🚨 Error: ${error.message}`);
+  });
+
+  // ========== Step 1: Scan Markets ==========
+  console.log('═══════════════════════════════════════════════════════════════');
+  console.log('Step 1: Scanning markets for arbitrage opportunities...');
+  console.log('═══════════════════════════════════════════════════════════════\n');
+
+  const scanResults = await arbService.scanMarkets(
+    { minVolume24h: 5000, limit: 50 },
+    0.003  // 0.3% min profit for scanning
+  );
+
+  const opportunities = scanResults.filter(r => r.arbType !== 'none');
+
+  console.log(`\nFound ${opportunities.length} opportunities out of ${scanResults.length} markets scanned\n`);
+
+  if (opportunities.length > 0) {
+    console.log('Top 5 opportunities:');
+    console.log('┌──────────────────────────────────────────────────────────────────┐');
+    for (const r of opportunities.slice(0, 5)) {
+      console.log(`│ ${r.market.name.slice(0, 50).padEnd(50)} │`);
+      console.log(`│   ${r.arbType.toUpperCase()} +${r.profitPercent.toFixed(2)}%  Size: ${r.availableSize.toFixed(0)}  Vol: $${r.volume24h.toLocaleString().padEnd(10)} │`);
+      console.log(`├──────────────────────────────────────────────────────────────────┤`);
+    }
+    console.log('└──────────────────────────────────────────────────────────────────┘');
+  }
+
+  if (SCAN_ONLY || opportunities.length === 0) {
+    console.log('\n✅ Scan complete.');
+    if (SCAN_ONLY) {
+      console.log('   (Running in scan-only mode, not starting arbitrage)');
+    }
+    if (opportunities.length === 0) {
+      console.log('   (No profitable opportunities found)');
+    }
+    return;
+  }
+
+  // ========== Step 2: Start Arbitrage ==========
+  console.log('\n═══════════════════════════════════════════════════════════════');
+  console.log('Step 2: Starting arbitrage on best market...');
+  console.log('═══════════════════════════════════════════════════════════════\n');
+
+  const best = opportunities[0];
+  console.log(`Selected: ${best.market.name}`);
+  console.log(`Type: ${best.arbType.toUpperCase()}, Profit: +${best.profitPercent.toFixed(2)}%\n`);
+
+  await arbService.start(best.market);
+
+  // ========== Step 3: Run for duration ==========
+  console.log('\n═══════════════════════════════════════════════════════════════');
+  console.log(`Step 3: Running for ${RUN_DURATION / 1000} seconds...`);
+  console.log('═══════════════════════════════════════════════════════════════\n');
+  console.log('Monitoring for arbitrage opportunities...');
+  console.log('(Press Ctrl+C to stop early)\n');
+
+  // Handle graceful shutdown
+  let stopped = false;
+  const shutdown = async () => {
+    if (stopped) return;
+    stopped = true;
+    console.log('\n\nShutting down...');
+    await cleanup();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+
+  // Wait for duration
+  await new Promise(resolve => setTimeout(resolve, RUN_DURATION));
+
+  // ========== Step 4: Stop and Clear ==========
+  async function cleanup() {
+    console.log('\n═══════════════════════════════════════════════════════════════');
+    console.log('Step 4: Stopping and clearing positions...');
+    console.log('═══════════════════════════════════════════════════════════════\n');
+
+    await arbService.stop();
+
+    // Print stats
+    const stats = arbService.getStats();
+    console.log('Session Statistics:');
+    console.log(`  Opportunities detected: ${stats.opportunitiesDetected}`);
+    console.log(`  Executions attempted: ${stats.executionsAttempted}`);
+    console.log(`  Executions succeeded: ${stats.executionsSucceeded}`);
+    console.log(`  Total profit: $${stats.totalProfit.toFixed(2)}`);
+    console.log(`  Running time: ${(stats.runningTimeMs / 1000).toFixed(0)}s`);
+
+    // Clear positions
+    if (privateKey) {
+      console.log('\nClearing positions...');
+      const clearResult = await arbService.clearPositions(best.market, false);
+
+      console.log(`\nPosition status:`);
+      console.log(`  Market status: ${clearResult.marketStatus}`);
+      console.log(`  YES balance: ${clearResult.yesBalance.toFixed(4)}`);
+      console.log(`  NO balance: ${clearResult.noBalance.toFixed(4)}`);
+      console.log(`  Expected recovery: $${clearResult.totalUsdcRecovered.toFixed(2)}`);
+
+      if (clearResult.actions.length > 0) {
+        console.log(`\nPlanned actions:`);
+        for (const action of clearResult.actions) {
+          console.log(`  - ${action.type}: ${action.amount.toFixed(4)} → ~$${action.usdcResult.toFixed(2)}`);
+        }
+        console.log('\n(Run with --execute-clear to actually clear positions)');
+      }
+    }
+
+    console.log('\n✅ Done!');
+  }
+
+  await cleanup();
+}
+
+main().catch(console.error);

package/examples/README.md

@@ -41,7 +41,7 @@ pnpm example:smart-money # 02-smart-money.ts
 Get started with the SDK. Fetches trending markets and orderbook data.
 
 ```typescript
-import { PolymarketSDK } from '@prediction-router/poly-sdk';
+import { PolymarketSDK } from '@catalyst-team/poly-sdk';
 const sdk = new PolymarketSDK();
 const trending = await sdk.gammaApi.getTrendingMarkets(5);
 ```

package/package.json

@@ -1,36 +1,38 @@
 {
   "name": "@catalyst-team/poly-sdk",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "private": false,
+  "description": "TypeScript SDK for Polymarket - prediction markets trading, smart money analysis, and market data",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
-  "bin": {
-    "poly-mcp": "./dist/mcp/server.js"
-  },
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js"
-    },
-    "./mcp": {
-      "types": "./dist/mcp/index.d.ts",
-      "import": "./dist/mcp/index.js"
-    },
-    "./mcp/server": {
-      "types": "./dist/mcp/server.d.ts",
-      "import": "./dist/mcp/server.js"
     }
   },
+  "keywords": [
+    "polymarket",
+    "prediction-markets",
+    "trading",
+    "crypto",
+    "defi",
+    "smart-money"
+  ],
+  "author": "Catalyst Team",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.25.1",
     "@nevuamarkets/poly-websockets": "^0.3.0",
     "@polymarket/clob-client": "4.22.8",
     "@types/ws": "^8.18.1",
     "bottleneck": "^2.19.5",
     "ethers": "5",
     "ws": "^8.18.3",
-    "@prediction-router/cache": "0.1.0"
+    "@catalyst-team/cache": "0.1.0"
   },
   "devDependencies": {
     "tsx": "^4.7.0",
@@ -39,8 +41,6 @@
   },
   "scripts": {
     "build": "tsc",
-    "mcp": "node dist/mcp/server.js",
-    "mcp:dev": "tsx src/mcp/server.ts",
     "dev": "tsc --watch",
     "test": "vitest run",
     "test:watch": "vitest",
@@ -55,8 +55,8 @@
     "example:trading": "tsx examples/08-trading-orders.ts",
     "example:rewards": "tsx examples/09-rewards-tracking.ts",
     "example:ctf": "tsx examples/10-ctf-operations.ts",
-    "example:arbitrage": "tsx examples/11-arbitrage-service.ts",
-    "example:live-arb": "tsx examples/12-live-arbitrage-scan.ts",
-    "example:trending-arb": "tsx examples/13-trending-arb-monitor.ts"
+    "example:live-arb": "tsx examples/11-live-arbitrage-scan.ts",
+    "example:trending-arb": "tsx examples/12-trending-arb-monitor.ts",
+    "example:arb-service": "tsx examples/13-arbitrage-service.ts"
   }
 }

package/scripts/arb/faze-bo3-arb.ts

@@ -0,0 +1,385 @@
+#!/usr/bin/env npx tsx
+/**
+ * FaZe vs Passion UA - BO3 Match Winner Arbitrage Monitor (V2 - Instant Merge)
+ *
+ * V2 策略：配合 token-rebalancer.ts 使用
+ * - Long Arb: Buy YES + NO → 立即 Merge（因为账户预存了 tokens）
+ * - Short Arb: 直接卖出预存的 tokens
+ * - Rebalancer 自动补充 tokens，确保随时有流动性
+ *
+ * Usage:
+ *   POLY_PRIVKEY=0x... npx tsx scripts/v2/faze-bo3-arb.ts
+ *   POLY_PRIVKEY=0x... npx tsx scripts/v2/faze-bo3-arb.ts --auto-execute
+ *   POLY_PRIVKEY=0x... npx tsx scripts/v2/faze-bo3-arb.ts --auto-execute --threshold 0.003
+ */
+
+import {
+    WebSocketManager,
+    CTFClient,
+    TradingClient,
+    RateLimiter,
+    type BookUpdate,
+    type TokenIds,
+  } from '../../src/index.js';
+  
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // MARKET CONFIGURATION - FaZe vs Passion UA BO3 Match Winner
+  // ═══════════════════════════════════════════════════════════════════════════════
+  
+  const MARKET_CONFIG = {
+    name: 'CS2: FaZe vs Passion UA (BO3)',
+    conditionId: '0x5ac2e92a82ea41ec3a4d9332d323d8d198a8c9acc732b7e6373bd61f45e1df49',
+    outcomes: ['FaZe', 'Passion UA'],
+    yesTokenId: '89062136554637645106569570664838812035010963361832797298254486917225439629146',
+    noTokenId: '54956090965819006918015199317329813503156478664679332459223691084797135448319',
+  };
+  
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // CONFIGURATION
+  // ═══════════════════════════════════════════════════════════════════════════════
+  
+  const PRIVATE_KEY = process.env.POLY_PRIVKEY || process.env.POLYMARKET_PRIVATE_KEY || '';
+  const RPC_URL = process.env.POLYGON_RPC_URL || 'https://polygon-rpc.com';
+  
+  const args = process.argv.slice(2);
+  const AUTO_EXECUTE = args.includes('--auto-execute');
+  const thresholdIdx = args.indexOf('--threshold');
+  const PROFIT_THRESHOLD = thresholdIdx !== -1 ? parseFloat(args[thresholdIdx + 1]) : 0.005;
+  const MIN_SIZE = 5;
+  const MAX_SINGLE_TRADE = 100;
+  const MIN_TOKEN_RESERVE = 10;
+  
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // STATE
+  // ═══════════════════════════════════════════════════════════════════════════════
+  
+  interface OrderbookState {
+    yesBids: Array<{ price: number; size: number }>;
+    yesAsks: Array<{ price: number; size: number }>;
+    noBids: Array<{ price: number; size: number }>;
+    noAsks: Array<{ price: number; size: number }>;
+    lastUpdate: number;
+  }
+  
+  interface BalanceState {
+    usdc: number;
+    yesTokens: number;
+    noTokens: number;
+    lastUpdate: number;
+  }
+  
+  let orderbook: OrderbookState = {
+    yesBids: [],
+    yesAsks: [],
+    noBids: [],
+    noAsks: [],
+    lastUpdate: 0,
+  };
+  
+  let balance: BalanceState = {
+    usdc: 0,
+    yesTokens: 0,
+    noTokens: 0,
+    lastUpdate: 0,
+  };
+  
+  let wsManager: WebSocketManager;
+  let ctf: CTFClient | null = null;
+  let tradingClient: TradingClient | null = null;
+  
+  let isExecuting = false;
+  let lastArbCheck = 0;
+  let totalOpportunities = 0;
+  let totalExecuted = 0;
+  let totalProfit = 0;
+  
+  const tokenIds: TokenIds = {
+    yesTokenId: MARKET_CONFIG.yesTokenId,
+    noTokenId: MARKET_CONFIG.noTokenId,
+  };
+  
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // MAIN
+  // ═══════════════════════════════════════════════════════════════════════════════
+  
+  async function main() {
+    console.log('╔════════════════════════════════════════════════════════════════╗');
+    console.log('║       FAZE vs PASSION UA - BO3 ARBITRAGE (V2 INSTANT)          ║');
+    console.log('╚════════════════════════════════════════════════════════════════╝');
+    console.log('');
+    console.log(`Market: ${MARKET_CONFIG.name}`);
+    console.log(`Outcomes: ${MARKET_CONFIG.outcomes[0]} (YES) vs ${MARKET_CONFIG.outcomes[1]} (NO)`);
+    console.log(`Condition ID: ${MARKET_CONFIG.conditionId.slice(0, 20)}...`);
+    console.log(`Profit Threshold: ${(PROFIT_THRESHOLD * 100).toFixed(2)}%`);
+    console.log(`Auto Execute: ${AUTO_EXECUTE ? 'YES' : 'NO'}`);
+    console.log(`Strategy: INSTANT MERGE (with Rebalancer support)`);
+    console.log('');
+  
+    const rateLimiter = new RateLimiter();
+  
+    if (PRIVATE_KEY) {
+      ctf = new CTFClient({ privateKey: PRIVATE_KEY, rpcUrl: RPC_URL });
+      console.log(`Wallet: ${ctf.getAddress()}`);
+  
+      tradingClient = new TradingClient(rateLimiter, { privateKey: PRIVATE_KEY, chainId: 137 });
+      await tradingClient.initialize();
+      console.log('Trading client initialized');
+  
+      await updateBalance();
+      console.log(`USDC.e Balance: ${balance.usdc.toFixed(2)}`);
+      console.log(`YES Tokens: ${balance.yesTokens.toFixed(2)}`);
+      console.log(`NO Tokens: ${balance.noTokens.toFixed(2)}`);
+  
+      const heldPairs = Math.min(balance.yesTokens, balance.noTokens);
+      if (heldPairs < MIN_TOKEN_RESERVE) {
+        console.log(`\n⚠️  Token reserve low (${heldPairs.toFixed(0)} < ${MIN_TOKEN_RESERVE})`);
+        console.log(`   Run token-rebalancer.ts to auto-split tokens`);
+      }
+    } else {
+      console.log('No wallet configured - monitoring only');
+    }
+  
+    console.log('');
+    console.log('═══════════════════════════════════════════════════════════════');
+    console.log('Connecting to WebSocket...');
+    console.log('');
+  
+    wsManager = new WebSocketManager({ enableLogging: false });
+    wsManager.on('bookUpdate', handleBookUpdate);
+    wsManager.on('connected', ({ assetIds }) => console.log(`WebSocket connected for ${assetIds.length} assets`));
+    wsManager.on('error', (error) => console.error('WebSocket error:', error.message));
+  
+    await wsManager.subscribe([MARKET_CONFIG.yesTokenId, MARKET_CONFIG.noTokenId]);
+    setInterval(updateBalance, 30000);
+  
+    process.on('SIGINT', async () => {
+      console.log('\n\nShutting down...');
+      console.log(`Total opportunities: ${totalOpportunities}, Executed: ${totalExecuted}, Profit: $${totalProfit.toFixed(2)}`);
+      await wsManager.unsubscribeAll();
+      process.exit(0);
+    });
+  
+    console.log('Monitoring for arbitrage opportunities...\n');
+  }
+  
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // BALANCE & ORDERBOOK
+  // ═══════════════════════════════════════════════════════════════════════════════
+  
+  async function updateBalance() {
+    if (!ctf) return;
+    try {
+      const [usdcBalance, positions] = await Promise.all([
+        ctf.getUsdcBalance(),
+        ctf.getPositionBalanceByTokenIds(MARKET_CONFIG.conditionId, tokenIds),
+      ]);
+      balance.usdc = parseFloat(usdcBalance);
+      balance.yesTokens = parseFloat(positions.yesBalance);
+      balance.noTokens = parseFloat(positions.noBalance);
+      balance.lastUpdate = Date.now();
+    } catch (error) {
+      console.error('Failed to update balance:', (error as Error).message);
+    }
+  }
+  
+  function handleBookUpdate(update: BookUpdate) {
+    const { assetId, bids, asks } = update;
+    if (assetId === MARKET_CONFIG.yesTokenId) {
+      orderbook.yesBids = bids.sort((a, b) => b.price - a.price);
+      orderbook.yesAsks = asks.sort((a, b) => a.price - b.price);
+    } else if (assetId === MARKET_CONFIG.noTokenId) {
+      orderbook.noBids = bids.sort((a, b) => b.price - a.price);
+      orderbook.noAsks = asks.sort((a, b) => a.price - b.price);
+    }
+    orderbook.lastUpdate = Date.now();
+    checkArbitrage();
+  }
+  
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // ARBITRAGE DETECTION
+  // ═══════════════════════════════════════════════════════════════════════════════
+  
+  function checkArbitrage() {
+    const now = Date.now();
+    if (now - lastArbCheck < 10) return;
+    lastArbCheck = now;
+  
+    if (orderbook.yesBids.length === 0 || orderbook.noAsks.length === 0) return;
+  
+    const yesBestBid = orderbook.yesBids[0]?.price || 0;
+    const yesBestAsk = orderbook.yesAsks[0]?.price || 1;
+    const noBestBid = orderbook.noBids[0]?.price || 0;
+    const noBestAsk = orderbook.noAsks[0]?.price || 1;
+  
+    const effectiveBuyYes = Math.min(yesBestAsk, 1 - noBestBid);
+    const effectiveBuyNo = Math.min(noBestAsk, 1 - yesBestBid);
+    const effectiveSellYes = Math.max(yesBestBid, 1 - noBestAsk);
+    const effectiveSellNo = Math.max(noBestBid, 1 - yesBestAsk);
+  
+    const longCost = effectiveBuyYes + effectiveBuyNo;
+    const longProfit = 1 - longCost;
+    const shortRevenue = effectiveSellYes + effectiveSellNo;
+    const shortProfit = shortRevenue - 1;
+  
+    const orderbookLongSize = Math.min(orderbook.yesAsks[0]?.size || 0, orderbook.noAsks[0]?.size || 0);
+    const orderbookShortSize = Math.min(orderbook.yesBids[0]?.size || 0, orderbook.noBids[0]?.size || 0);
+  
+    const heldPairs = Math.min(balance.yesTokens, balance.noTokens);
+    const balanceLongSize = longCost > 0 ? balance.usdc / longCost : 0;
+    const longSize = Math.min(orderbookLongSize, balanceLongSize, MAX_SINGLE_TRADE);
+    const shortSize = Math.min(orderbookShortSize, heldPairs, MAX_SINGLE_TRADE);
+  
+    const timestamp = new Date().toISOString().split('T')[1].split('.')[0];
+    const status = [
+      `[${timestamp}]`,
+      `${MARKET_CONFIG.outcomes[0]}: ${yesBestBid.toFixed(2)}/${yesBestAsk.toFixed(2)}`,
+      `${MARKET_CONFIG.outcomes[1]}: ${noBestBid.toFixed(2)}/${noBestAsk.toFixed(2)}`,
+      `Long: ${(longProfit * 100).toFixed(2)}%`,
+      `Short: ${(shortProfit * 100).toFixed(2)}%`,
+      `Bal: $${balance.usdc.toFixed(0)}`,
+      `Pairs: ${heldPairs.toFixed(0)}`,
+    ].join(' | ');
+  
+    const hasLongArb = longProfit > PROFIT_THRESHOLD && longSize >= MIN_SIZE && balance.usdc >= MIN_SIZE;
+    const hasShortArb = shortProfit > PROFIT_THRESHOLD && shortSize >= MIN_SIZE && heldPairs >= MIN_TOKEN_RESERVE;
+  
+    if (hasLongArb || hasShortArb) {
+      console.log('\n' + '!'.repeat(75));
+      console.log(status);
+  
+      if (hasLongArb) {
+        totalOpportunities++;
+        console.log(`\n🎯 LONG ARB: Buy ${MARKET_CONFIG.outcomes[0]} @ ${effectiveBuyYes.toFixed(4)} + ${MARKET_CONFIG.outcomes[1]} @ ${effectiveBuyNo.toFixed(4)}`);
+        console.log(`   Cost: ${longCost.toFixed(4)}, Profit: ${(longProfit * 100).toFixed(2)}%, Size: ${longSize.toFixed(2)}, Est: $${(longProfit * longSize).toFixed(2)}`);
+        if (AUTO_EXECUTE && !isExecuting) executeLongArb(effectiveBuyYes, effectiveBuyNo, longSize, longProfit);
+      }
+  
+      if (hasShortArb) {
+        totalOpportunities++;
+        console.log(`\n🎯 SHORT ARB: Sell ${MARKET_CONFIG.outcomes[0]} @ ${effectiveSellYes.toFixed(4)} + ${MARKET_CONFIG.outcomes[1]} @ ${effectiveSellNo.toFixed(4)}`);
+        console.log(`   Revenue: ${shortRevenue.toFixed(4)}, Profit: ${(shortProfit * 100).toFixed(2)}%, Size: ${shortSize.toFixed(2)}, Est: $${(shortProfit * shortSize).toFixed(2)}`);
+        if (AUTO_EXECUTE && !isExecuting) executeShortArb(shortSize, shortProfit * shortSize);
+      }
+  
+      console.log('!'.repeat(75) + '\n');
+    } else {
+      process.stdout.write('\r' + status + '    ');
+    }
+  }
+  
+  // ═══════════════════════════════════════════════════════════════════════════════
+  // EXECUTION
+  // ═══════════════════════════════════════════════════════════════════════════════
+  
+  async function executeLongArb(buyYesPrice: number, buyNoPrice: number, size: number, profitRate: number) {
+    if (!ctf || !tradingClient || isExecuting) return;
+    isExecuting = true;
+    const startTime = Date.now();
+    console.log('\n🔄 Executing Long Arb (Buy → Instant Merge)...');
+  
+    try {
+      const requiredUsdc = (buyYesPrice + buyNoPrice) * size;
+      if (balance.usdc < requiredUsdc) {
+        console.log(`❌ Insufficient USDC.e: have ${balance.usdc.toFixed(2)}, need ${requiredUsdc.toFixed(2)}`);
+        isExecuting = false;
+        return;
+      }
+  
+      console.log(`   1. Buying tokens in parallel...`);
+      const orderStartTime = Date.now();
+      const [buyYesResult, buyNoResult] = await Promise.all([
+        tradingClient.createMarketOrder({ tokenId: MARKET_CONFIG.yesTokenId, side: 'BUY', amount: size * buyYesPrice, orderType: 'FOK' }),
+        tradingClient.createMarketOrder({ tokenId: MARKET_CONFIG.noTokenId, side: 'BUY', amount: size * buyNoPrice, orderType: 'FOK' }),
+      ]);
+      console.log(`      ${MARKET_CONFIG.outcomes[0]}: ${buyYesResult.success ? '✓' : '✗'}, ${MARKET_CONFIG.outcomes[1]}: ${buyNoResult.success ? '✓' : '✗'} (${Date.now() - orderStartTime}ms)`);
+  
+      if (!buyYesResult.success || !buyNoResult.success) {
+        console.log(`❌ Order(s) failed - will retry on next opportunity`);
+        if (buyYesResult.errorMsg) console.log(`   YES Error: ${buyYesResult.errorMsg}`);
+        if (buyNoResult.errorMsg) console.log(`   NO Error: ${buyNoResult.errorMsg}`);
+        isExecuting = false;
+        return;
+      }
+  
+      // Immediate merge using pre-held tokens
+      const heldPairs = Math.min(balance.yesTokens, balance.noTokens);
+      const mergeSize = Math.floor(Math.min(size, heldPairs) * 1e6) / 1e6;
+  
+      if (mergeSize >= MIN_SIZE) {
+        console.log(`   2. Merging ${mergeSize.toFixed(2)} pairs from pre-held tokens...`);
+        try {
+          const mergeResult = await ctf.merge(MARKET_CONFIG.conditionId, mergeSize.toString());
+          console.log(`      TX: ${mergeResult.txHash}`);
+  
+          const estProfit = profitRate * mergeSize;
+          totalProfit += estProfit;
+          console.log(`✅ Long Arb completed! Profit: ~$${estProfit.toFixed(2)}. Total: ${Date.now() - startTime}ms`);
+        } catch (mergeError: any) {
+          console.log(`   ⚠️ Merge failed: ${mergeError.message}`);
+          console.log(`   Tokens will be held for later merge by rebalancer`);
+        }
+      } else {
+        console.log(`   2. Skipping merge (held pairs ${heldPairs.toFixed(2)} < ${MIN_SIZE})`);
+        console.log(`   Tokens held - rebalancer will merge later`);
+      }
+  
+      totalExecuted++;
+      await new Promise(r => setTimeout(r, 2000));
+      await updateBalance();
+      console.log(`   New balance: USDC=${balance.usdc.toFixed(2)}, YES=${balance.yesTokens.toFixed(2)}, NO=${balance.noTokens.toFixed(2)}`);
+    } catch (error) {
+      console.log(`❌ Long Arb failed: ${(error as Error).message}`);
+    }
+    isExecuting = false;
+  }
+  
+  async function executeShortArb(size: number, estProfit: number) {
+    if (!ctf || !tradingClient || isExecuting) return;
+    isExecuting = true;
+    const startTime = Date.now();
+    console.log('\n🔄 Executing Short Arb (Sell Pre-held Tokens)...');
+  
+    try {
+      const heldPairs = Math.min(balance.yesTokens, balance.noTokens);
+      if (heldPairs < size) {
+        console.log(`❌ Insufficient held tokens: have ${heldPairs.toFixed(2)}, need ${size.toFixed(2)}`);
+        console.log(`   Run token-rebalancer.ts to auto-split more tokens`);
+        isExecuting = false;
+        return;
+      }
+  
+      console.log(`   1. Selling pre-held tokens in parallel...`);
+      const orderStartTime = Date.now();
+      const [sellYesResult, sellNoResult] = await Promise.all([
+        tradingClient.createMarketOrder({ tokenId: MARKET_CONFIG.yesTokenId, side: 'SELL', amount: size, orderType: 'FOK' }),
+        tradingClient.createMarketOrder({ tokenId: MARKET_CONFIG.noTokenId, side: 'SELL', amount: size, orderType: 'FOK' }),
+      ]);
+      console.log(`      ${MARKET_CONFIG.outcomes[0]}: ${sellYesResult.success ? '✓' : '✗'}, ${MARKET_CONFIG.outcomes[1]}: ${sellNoResult.success ? '✓' : '✗'} (${Date.now() - orderStartTime}ms)`);
+  
+      if (!sellYesResult.success || !sellNoResult.success) {
+        console.log(`❌ Order(s) failed`);
+        if (sellYesResult.errorMsg) console.log(`   YES Error: ${sellYesResult.errorMsg}`);
+        if (sellNoResult.errorMsg) console.log(`   NO Error: ${sellNoResult.errorMsg}`);
+        isExecuting = false;
+        return;
+      }
+  
+      console.log(`✅ Short Arb completed! Profit: ~$${estProfit.toFixed(2)}. Total: ${Date.now() - startTime}ms`);
+      totalExecuted++;
+      totalProfit += estProfit;
+  
+      await new Promise(r => setTimeout(r, 2000));
+      await updateBalance();
+      console.log(`   New balance: USDC=${balance.usdc.toFixed(2)}, YES=${balance.yesTokens.toFixed(2)}, NO=${balance.noTokens.toFixed(2)}`);
+  
+      const newHeldPairs = Math.min(balance.yesTokens, balance.noTokens);
+      if (newHeldPairs < MIN_TOKEN_RESERVE) {
+        console.log(`   ⚠️ Token reserve low (${newHeldPairs.toFixed(0)}) - rebalancer should split more`);
+      }
+    } catch (error) {
+      console.log(`❌ Short Arb failed: ${(error as Error).message}`);
+    }
+    isExecuting = false;
+  }
+  
+  main().catch(console.error);