clodds 1.1.0

package/dist/feeds/polymarket/whale-tracker.js

@@ -0,0 +1,709 @@
+"use strict";
+/**
+ * Polymarket Whale Tracker
+ *
+ * Monitors large trades and positions on Polymarket to identify whale activity.
+ * Uses a combination of:
+ * - CLOB WebSocket for real-time order flow
+ * - REST API for position snapshots
+ * - Subgraph for historical analysis
+ *
+ * Use cases:
+ * - Copy trading whale positions
+ * - Early signal detection for market moves
+ * - Liquidity analysis
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KNOWN_WHALES = exports.GAMMA_API_URL = exports.CLOB_REST_URL = exports.CLOB_WS_URL = void 0;
+exports.detectMarketCategory = detectMarketCategory;
+exports.createWhaleTracker = createWhaleTracker;
+exports.isWhaleAddress = isWhaleAddress;
+exports.getMarketWhaleActivity = getMarketWhaleActivity;
+const eventemitter3_1 = require("eventemitter3");
+const ws_1 = __importDefault(require("ws"));
+const logger_1 = require("../../utils/logger");
+async function fetchWithRetry(url, options = {}, config = {}) {
+    const { maxRetries = 3, baseDelayMs = 1000, maxDelayMs = 10000, timeoutMs = 30000, } = config;
+    let lastError = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            // Add timeout using AbortController
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+            const response = await fetch(url, {
+                ...options,
+                signal: controller.signal,
+            });
+            clearTimeout(timeoutId);
+            // Retry on 5xx errors or rate limits (429)
+            if (response.status >= 500 || response.status === 429) {
+                const retryAfter = response.headers.get('Retry-After');
+                const waitMs = retryAfter
+                    ? parseInt(retryAfter, 10) * 1000
+                    : Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
+                if (attempt < maxRetries) {
+                    logger_1.logger.debug({ url, status: response.status, waitMs, attempt }, 'Retrying request');
+                    await new Promise(resolve => setTimeout(resolve, waitMs));
+                    continue;
+                }
+            }
+            return response;
+        }
+        catch (error) {
+            lastError = error;
+            // Don't retry on abort (timeout)
+            if (error.name === 'AbortError') {
+                logger_1.logger.warn({ url, timeoutMs }, 'Request timed out');
+                if (attempt < maxRetries) {
+                    const waitMs = Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
+                    await new Promise(resolve => setTimeout(resolve, waitMs));
+                    continue;
+                }
+                throw new Error(`Request timed out after ${maxRetries + 1} attempts: ${url}`);
+            }
+            // Retry on network errors
+            if (attempt < maxRetries) {
+                const waitMs = Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
+                logger_1.logger.debug({ url, error: error.message, waitMs, attempt }, 'Retrying after error');
+                await new Promise(resolve => setTimeout(resolve, waitMs));
+                continue;
+            }
+        }
+    }
+    throw lastError || new Error(`Failed to fetch after ${maxRetries + 1} attempts: ${url}`);
+}
+// =============================================================================
+// CONSTANTS
+// =============================================================================
+const CLOB_WS_URL = 'wss://ws-subscriptions-clob.polymarket.com/ws/market';
+exports.CLOB_WS_URL = CLOB_WS_URL;
+const CLOB_REST_URL = 'https://clob.polymarket.com';
+exports.CLOB_REST_URL = CLOB_REST_URL;
+const GAMMA_API_URL = 'https://gamma-api.polymarket.com';
+exports.GAMMA_API_URL = GAMMA_API_URL;
+const DEFAULT_CONFIG = {
+    minTradeSize: 10000,
+    minPositionSize: 50000,
+    marketIds: [],
+    pollIntervalMs: 60000,
+    enableRealtime: true,
+};
+// =============================================================================
+// CATEGORY DETECTION
+// =============================================================================
+const CATEGORY_KEYWORDS = {
+    politics: ['trump', 'biden', 'election', 'president', 'congress', 'senate', 'republican', 'democrat', 'vote', 'poll', 'governor', 'mayor', 'political', 'party', 'cabinet', 'impeach'],
+    crypto: ['bitcoin', 'btc', 'ethereum', 'eth', 'solana', 'sol', 'crypto', 'token', 'coin', 'blockchain', 'defi', 'nft', 'altcoin', 'memecoin', 'doge', 'xrp'],
+    sports: ['nfl', 'nba', 'mlb', 'nhl', 'soccer', 'football', 'basketball', 'baseball', 'hockey', 'tennis', 'golf', 'ufc', 'boxing', 'championship', 'super bowl', 'world cup', 'playoffs', 'finals'],
+    entertainment: ['movie', 'film', 'oscar', 'grammy', 'emmy', 'celebrity', 'actor', 'actress', 'album', 'music', 'netflix', 'disney', 'tv show', 'streaming'],
+    science: ['nasa', 'spacex', 'climate', 'weather', 'hurricane', 'earthquake', 'pandemic', 'vaccine', 'fda', 'research', 'study', 'discovery', 'ai', 'artificial intelligence'],
+    economics: ['fed', 'interest rate', 'inflation', 'gdp', 'unemployment', 'recession', 'stock', 'market', 'dow', 's&p', 'nasdaq', 'earnings', 'ipo', 'merger'],
+    other: [],
+};
+/**
+ * Detect market category from question text
+ */
+function detectMarketCategory(question) {
+    const lowerQuestion = question.toLowerCase();
+    for (const [category, keywords] of Object.entries(CATEGORY_KEYWORDS)) {
+        if (category === 'other')
+            continue;
+        for (const keyword of keywords) {
+            if (lowerQuestion.includes(keyword)) {
+                return category;
+            }
+        }
+    }
+    return 'other';
+}
+// Known whale addresses (notable Polymarket traders)
+const KNOWN_WHALES = new Set((process.env.POLYMARKET_WHALE_ADDRESSES || '').split(',').filter(Boolean));
+exports.KNOWN_WHALES = KNOWN_WHALES;
+// =============================================================================
+// IMPLEMENTATION
+// =============================================================================
+function createWhaleTracker(config = {}) {
+    const emitter = new eventemitter3_1.EventEmitter();
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    let running = false;
+    let ws = null;
+    let pollInterval = null;
+    let reconnectTimeout = null;
+    let pingInterval = null;
+    let reconnectAttempts = 0;
+    let connectionState = 'disconnected';
+    // State
+    const whaleProfiles = new Map();
+    const activePositions = new Map();
+    const recentTrades = [];
+    const trackedAddresses = new Set(KNOWN_WHALES);
+    const closedPositionsByWhale = new Map();
+    // ==========================================================================
+    // REST API HELPERS
+    // ==========================================================================
+    async function fetchMarketTrades(marketId, maxPages = 5) {
+        const allTrades = [];
+        let nextCursor;
+        try {
+            for (let page = 0; page < maxPages; page++) {
+                const url = nextCursor
+                    ? `${CLOB_REST_URL}/trades?market=${marketId}&limit=100&cursor=${nextCursor}`
+                    : `${CLOB_REST_URL}/trades?market=${marketId}&limit=100`;
+                const response = await fetchWithRetry(url, {}, { maxRetries: 3, baseDelayMs: 1000, timeoutMs: 15000 });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}`);
+                }
+                const json = await response.json();
+                // Handle both array response and paginated response
+                const data = Array.isArray(json) ? json : (json.data || []);
+                nextCursor = Array.isArray(json) ? undefined : json.next_cursor;
+                const trades = data
+                    .filter((t) => {
+                    const usdValue = parseFloat(t.price) * parseFloat(t.size);
+                    return usdValue >= cfg.minTradeSize;
+                })
+                    .map((t) => ({
+                    id: t.id || `${t.market}_${t.timestamp}`,
+                    timestamp: new Date(t.timestamp || t.match_time),
+                    marketId: t.market || marketId,
+                    tokenId: t.asset_id,
+                    outcome: t.outcome || (t.side === 'BUY' ? 'Yes' : 'No'),
+                    side: t.side?.toUpperCase() || 'BUY',
+                    price: parseFloat(t.price),
+                    size: parseFloat(t.size),
+                    usdValue: parseFloat(t.price) * parseFloat(t.size),
+                    maker: t.maker_address || t.maker,
+                    taker: t.taker_address || t.taker,
+                    transactionHash: t.transaction_hash,
+                }));
+                allTrades.push(...trades);
+                // Stop if no more pages
+                if (!nextCursor || data.length < 100)
+                    break;
+            }
+            return allTrades;
+        }
+        catch (error) {
+            logger_1.logger.error({ marketId, error }, 'Failed to fetch market trades after retries');
+            return allTrades; // Return what we got so far
+        }
+    }
+    async function fetchAddressPositions(address, maxPages = 3) {
+        const allPositions = [];
+        let offset = 0;
+        const limit = 100;
+        try {
+            for (let page = 0; page < maxPages; page++) {
+                const response = await fetchWithRetry(`${GAMMA_API_URL}/positions?address=${address}&limit=${limit}&offset=${offset}`, {}, { maxRetries: 3, baseDelayMs: 1000, timeoutMs: 15000 });
+                if (!response.ok) {
+                    throw new Error(`HTTP ${response.status}`);
+                }
+                const data = await response.json();
+                const positions = data
+                    .filter((p) => {
+                    const usdValue = parseFloat(p.currentValue || p.size * p.price || 0);
+                    return usdValue >= cfg.minPositionSize;
+                })
+                    .map((p) => ({
+                    id: `${address}_${p.market}_${p.outcome}`,
+                    address,
+                    marketId: p.market || p.conditionId,
+                    marketQuestion: p.title || p.question,
+                    tokenId: p.asset_id || p.tokenId,
+                    outcome: p.outcome || 'Yes',
+                    size: parseFloat(p.size || p.amount || 0),
+                    avgEntryPrice: parseFloat(p.avgPrice || p.averageBuyPrice || 0),
+                    usdValue: parseFloat(p.currentValue || p.size * p.price || 0),
+                    unrealizedPnl: parseFloat(p.pnl || p.unrealizedPnl || 0),
+                    lastUpdated: new Date(p.updatedAt || Date.now()),
+                }));
+                allPositions.push(...positions);
+                // Stop if no more data
+                if (data.length < limit)
+                    break;
+                offset += limit;
+            }
+            return allPositions;
+        }
+        catch (error) {
+            logger_1.logger.error({ address, error }, 'Failed to fetch positions after retries');
+            return allPositions; // Return what we got so far
+        }
+    }
+    async function fetchTopTraders() {
+        try {
+            const response = await fetchWithRetry(`${GAMMA_API_URL}/leaderboard?limit=100&sortBy=volume`, {}, { maxRetries: 2, baseDelayMs: 1000, timeoutMs: 10000 });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            const data = await response.json();
+            return data.map((t) => t.address || t.user);
+        }
+        catch (error) {
+            logger_1.logger.error({ error }, 'Failed to fetch top traders');
+            return [];
+        }
+    }
+    // ==========================================================================
+    // WEBSOCKET HANDLING
+    // ==========================================================================
+    function connectWebSocket() {
+        if (ws) {
+            ws.close();
+        }
+        connectionState = 'reconnecting';
+        emitter.emit('connectionState', connectionState);
+        ws = new ws_1.default(CLOB_WS_URL);
+        ws.on('open', () => {
+            logger_1.logger.info('Whale tracker WebSocket connected');
+            connectionState = 'connected';
+            reconnectAttempts = 0;
+            emitter.emit('connectionState', connectionState);
+            // Subscribe to trade events for tracked markets
+            const markets = cfg.marketIds.length > 0 ? cfg.marketIds : ['*'];
+            for (const marketId of markets) {
+                ws?.send(JSON.stringify({
+                    type: 'subscribe',
+                    channel: 'trades',
+                    market: marketId,
+                }));
+            }
+            // Start JSON heartbeat ping (Polymarket requires JSON ping every 10s)
+            if (pingInterval)
+                clearInterval(pingInterval);
+            pingInterval = setInterval(() => {
+                if (ws?.readyState === ws_1.default.OPEN) {
+                    ws.send(JSON.stringify({ type: 'ping' }));
+                }
+            }, 10000); // Ping every 10 seconds per Polymarket docs
+        });
+        ws.on('message', (data) => {
+            try {
+                const message = JSON.parse(data.toString());
+                // Handle pong response (JSON pong, not WebSocket pong)
+                if (message.type === 'pong') {
+                    logger_1.logger.debug('WebSocket JSON pong received');
+                    return;
+                }
+                if (message.type === 'trade' || message.event_type === 'trade') {
+                    handleTradeMessage(message);
+                }
+            }
+            catch (error) {
+                logger_1.logger.error({ error, data: data.toString().slice(0, 200) }, 'Failed to parse WS message');
+            }
+        });
+        ws.on('close', (code, reason) => {
+            logger_1.logger.info({ code, reason: reason.toString() }, 'Whale tracker WebSocket disconnected');
+            connectionState = 'disconnected';
+            emitter.emit('connectionState', connectionState);
+            if (pingInterval) {
+                clearInterval(pingInterval);
+                pingInterval = null;
+            }
+            if (running) {
+                // Exponential backoff: 1s, 2s, 4s, 8s, 16s, max 60s
+                const delay = Math.min(1000 * Math.pow(2, reconnectAttempts), 60000);
+                reconnectAttempts++;
+                logger_1.logger.info({ delay, attempt: reconnectAttempts }, 'Scheduling WebSocket reconnect');
+                reconnectTimeout = setTimeout(() => {
+                    logger_1.logger.info('Reconnecting whale tracker WebSocket');
+                    connectWebSocket();
+                }, delay);
+            }
+        });
+        ws.on('error', (error) => {
+            logger_1.logger.error({ error }, 'Whale tracker WebSocket error');
+            emitter.emit('error', error);
+        });
+    }
+    function handleTradeMessage(message) {
+        const price = parseFloat(message.price || 0);
+        const size = parseFloat(message.size || message.amount || 0);
+        const usdValue = price * size;
+        // Filter by minimum size
+        if (usdValue < cfg.minTradeSize) {
+            return;
+        }
+        const trade = {
+            id: message.id || `${message.market}_${Date.now()}`,
+            timestamp: new Date(message.timestamp || message.match_time || Date.now()),
+            marketId: message.market || message.condition_id,
+            marketQuestion: message.question || message.title,
+            tokenId: message.asset_id || message.token_id,
+            outcome: message.outcome || (message.side === 'BUY' ? 'Yes' : 'No'),
+            side: (message.side || 'BUY').toUpperCase(),
+            price,
+            size,
+            usdValue,
+            maker: message.maker_address || message.maker || 'unknown',
+            taker: message.taker_address || message.taker || 'unknown',
+            transactionHash: message.transaction_hash,
+        };
+        // Track the trade
+        recentTrades.unshift(trade);
+        if (recentTrades.length > 1000) {
+            recentTrades.pop();
+        }
+        // Check if it's from a tracked whale
+        const isKnownWhale = trackedAddresses.has(trade.maker) || trackedAddresses.has(trade.taker);
+        logger_1.logger.info({
+            marketId: trade.marketId,
+            side: trade.side,
+            size: trade.size,
+            usdValue: trade.usdValue,
+            isKnownWhale,
+        }, 'Whale trade detected');
+        emitter.emit('trade', trade);
+        // Add unknown whales to tracking
+        if (!trackedAddresses.has(trade.maker) && trade.usdValue >= cfg.minTradeSize * 5) {
+            trackedAddresses.add(trade.maker);
+            logger_1.logger.info({ address: trade.maker }, 'New whale discovered');
+        }
+        if (!trackedAddresses.has(trade.taker) && trade.usdValue >= cfg.minTradeSize * 5) {
+            trackedAddresses.add(trade.taker);
+            logger_1.logger.info({ address: trade.taker }, 'New whale discovered');
+        }
+        // Emit copy trading signal if from a profitable whale
+        emitCopySignalIfProfitable(trade);
+    }
+    function emitCopySignalIfProfitable(trade) {
+        // Check both maker and taker
+        const addresses = [trade.maker, trade.taker].filter((a) => a && a !== 'unknown');
+        for (const address of addresses) {
+            const profile = whaleProfiles.get(address);
+            if (!profile)
+                continue;
+            // Only emit signals for whales with good track records
+            const signalStrength = calculateSignalStrengthInternal(profile);
+            if (signalStrength < 0.5)
+                continue; // Need at least 50% signal strength
+            const stats = closedPositionsByWhale.get(address);
+            const totalTrades = stats ? stats.wins + stats.losses : 0;
+            if (totalTrades < 5)
+                continue; // Need at least 5 trades for reliability
+            const winRate = stats ? stats.wins / totalTrades : 0;
+            const minWinRate = parseFloat(process.env.WHALE_MIN_WIN_RATE || '0.55');
+            if (winRate < minWinRate)
+                continue;
+            // Determine if this is a buy or sell for copy trading
+            const isBuyer = trade.taker === address && trade.side === 'BUY';
+            const isSeller = trade.taker === address && trade.side === 'SELL';
+            if (!isBuyer && !isSeller)
+                continue; // Taker is the one initiating
+            const signal = {
+                whaleAddress: address,
+                whaleProfile: profile,
+                trade,
+                suggestedSizePct: Math.min(50, signalStrength * 100), // Cap at 50% of whale's size
+                signalStrength,
+                action: isBuyer ? 'buy' : 'sell',
+                reason: `Whale ${address.slice(0, 8)}... (${(winRate * 100).toFixed(0)}% WR, ${totalTrades} trades) ${isBuyer ? 'bought' : 'sold'} $${trade.usdValue.toFixed(0)}`,
+            };
+            logger_1.logger.info({
+                whale: address.slice(0, 8),
+                action: signal.action,
+                size: trade.usdValue,
+                winRate: winRate * 100,
+                signalStrength,
+            }, 'Copy trading signal');
+            emitter.emit('copySignal', signal);
+        }
+    }
+    function calculateSignalStrengthInternal(profile) {
+        const stats = closedPositionsByWhale.get(profile.address);
+        if (!stats)
+            return 0;
+        const totalTrades = stats.wins + stats.losses;
+        if (totalTrades < 3)
+            return 0;
+        const winRate = stats.wins / totalTrades;
+        const avgPnl = stats.totalPnl / totalTrades;
+        // Signal strength based on:
+        // - Win rate (40% weight)
+        // - Number of trades / confidence (30% weight)
+        // - Average PnL (30% weight)
+        const winRateScore = Math.max(0, (winRate - 0.5) * 2); // 0 at 50%, 1 at 100%
+        const tradeCountScore = Math.min(1, totalTrades / 20); // 1 at 20+ trades
+        const pnlScore = avgPnl > 0 ? Math.min(1, avgPnl / 1000) : 0; // 1 at $1000 avg PnL
+        return winRateScore * 0.4 + tradeCountScore * 0.3 + pnlScore * 0.3;
+    }
+    // ==========================================================================
+    // POLLING
+    // ==========================================================================
+    async function pollPositions() {
+        logger_1.logger.debug({ whaleCount: trackedAddresses.size }, 'Polling whale positions');
+        for (const address of trackedAddresses) {
+            try {
+                const positions = await fetchAddressPositions(address);
+                for (const position of positions) {
+                    const key = position.id;
+                    const existing = activePositions.get(key);
+                    if (!existing) {
+                        // New position
+                        activePositions.set(key, position);
+                        emitter.emit('positionOpened', position);
+                    }
+                    else if (Math.abs(position.size - existing.size) > 0.01) {
+                        // Position changed
+                        const change = position.size - existing.size;
+                        activePositions.set(key, position);
+                        if (position.size === 0) {
+                            const pnl = position.unrealizedPnl || 0;
+                            activePositions.delete(key);
+                            // Record for win rate tracking
+                            const recordFn = emitter.recordClosedPosition;
+                            if (recordFn) {
+                                recordFn(address, pnl);
+                            }
+                            emitter.emit('positionClosed', position, pnl);
+                        }
+                        else {
+                            emitter.emit('positionChanged', position, change);
+                        }
+                    }
+                }
+                // Update profile
+                updateWhaleProfile(address, positions);
+            }
+            catch (error) {
+                logger_1.logger.error({ address, error }, 'Failed to poll positions');
+            }
+        }
+    }
+    function updateWhaleProfile(address, positions) {
+        const existing = whaleProfiles.get(address);
+        const totalValue = positions.reduce((sum, p) => sum + p.usdValue, 0);
+        const profile = {
+            address,
+            totalValue,
+            winRate: existing?.winRate || 0,
+            avgReturn: existing?.avgReturn || 0,
+            positions,
+            recentTrades: recentTrades.filter((t) => t.maker === address || t.taker === address).slice(0, 50),
+            firstSeen: existing?.firstSeen || new Date(),
+            lastActive: new Date(),
+        };
+        const isNew = !existing;
+        whaleProfiles.set(address, profile);
+        if (isNew && totalValue >= cfg.minPositionSize) {
+            emitter.emit('newWhale', profile);
+        }
+    }
+    // ==========================================================================
+    // PUBLIC API
+    // ==========================================================================
+    Object.assign(emitter, {
+        async start() {
+            if (running)
+                return;
+            running = true;
+            logger_1.logger.info({ config: cfg }, 'Starting whale tracker');
+            // Fetch initial top traders
+            const topTraders = await fetchTopTraders();
+            for (const address of topTraders) {
+                trackedAddresses.add(address);
+            }
+            // Connect WebSocket for real-time trades
+            if (cfg.enableRealtime) {
+                connectWebSocket();
+            }
+            // Start position polling
+            await pollPositions();
+            pollInterval = setInterval(pollPositions, cfg.pollIntervalMs);
+            logger_1.logger.info({ whaleCount: trackedAddresses.size }, 'Whale tracker started');
+        },
+        stop() {
+            if (!running)
+                return;
+            running = false;
+            if (ws) {
+                ws.close(1000, 'Stopping');
+                ws = null;
+            }
+            if (pollInterval) {
+                clearInterval(pollInterval);
+                pollInterval = null;
+            }
+            if (reconnectTimeout) {
+                clearTimeout(reconnectTimeout);
+                reconnectTimeout = null;
+            }
+            logger_1.logger.info('Whale tracker stopped');
+        },
+        isRunning() {
+            return running;
+        },
+        getKnownWhales() {
+            return Array.from(whaleProfiles.values());
+        },
+        getWhaleProfile(address) {
+            return whaleProfiles.get(address);
+        },
+        getTopWhales(limit = 10) {
+            return Array.from(whaleProfiles.values())
+                .sort((a, b) => b.totalValue - a.totalValue)
+                .slice(0, limit);
+        },
+        getRecentTrades(limit = 100) {
+            return recentTrades.slice(0, limit);
+        },
+        getActivePositions(marketId) {
+            const positions = Array.from(activePositions.values());
+            if (marketId) {
+                return positions.filter((p) => p.marketId === marketId);
+            }
+            return positions;
+        },
+        trackAddress(address) {
+            trackedAddresses.add(address);
+            logger_1.logger.info({ address }, 'Now tracking address');
+        },
+        untrackAddress(address) {
+            trackedAddresses.delete(address);
+            logger_1.logger.info({ address }, 'Stopped tracking address');
+        },
+        getConnectionState() {
+            return connectionState;
+        },
+        getProfitableWhales(minWinRate = 0.55, minTrades = 5) {
+            const profitable = [];
+            for (const [address, profile] of whaleProfiles) {
+                const stats = closedPositionsByWhale.get(address);
+                if (!stats)
+                    continue;
+                const totalTrades = stats.wins + stats.losses;
+                if (totalTrades < minTrades)
+                    continue;
+                const winRate = stats.wins / totalTrades;
+                if (winRate < minWinRate)
+                    continue;
+                // Update profile with calculated stats
+                profile.winRate = winRate * 100;
+                profile.avgReturn = totalTrades > 0 ? stats.totalPnl / totalTrades : 0;
+                profitable.push(profile);
+            }
+            // Sort by win rate, then by total value
+            return profitable.sort((a, b) => {
+                if (Math.abs(a.winRate - b.winRate) > 1) {
+                    return b.winRate - a.winRate;
+                }
+                return b.totalValue - a.totalValue;
+            });
+        },
+        recordClosedPosition(address, pnl) {
+            const stats = closedPositionsByWhale.get(address) || {
+                wins: 0,
+                losses: 0,
+                totalPnl: 0,
+            };
+            if (pnl > 0) {
+                stats.wins++;
+            }
+            else {
+                stats.losses++;
+            }
+            stats.totalPnl += pnl;
+            closedPositionsByWhale.set(address, stats);
+            // Update profile win rate
+            const profile = whaleProfiles.get(address);
+            if (profile) {
+                const totalTrades = stats.wins + stats.losses;
+                profile.winRate = totalTrades > 0 ? (stats.wins / totalTrades) * 100 : 0;
+                profile.avgReturn = totalTrades > 0 ? stats.totalPnl / totalTrades : 0;
+            }
+            logger_1.logger.debug({
+                address: address.slice(0, 8),
+                pnl,
+                wins: stats.wins,
+                losses: stats.losses,
+                winRate: ((stats.wins / (stats.wins + stats.losses)) * 100).toFixed(1),
+            }, 'Recorded closed position');
+        },
+        calculateSignalStrength(profile) {
+            return calculateSignalStrengthInternal(profile);
+        },
+    });
+    return emitter;
+}
+// =============================================================================
+// HELPER FUNCTIONS
+// =============================================================================
+/**
+ * Check if an address is likely a whale based on trade history
+ */
+async function isWhaleAddress(address, minVolume = 100000) {
+    try {
+        const response = await fetch(`${GAMMA_API_URL}/user-stats?address=${address}`);
+        if (!response.ok) {
+            return false;
+        }
+        const stats = await response.json();
+        const volume = parseFloat(stats.totalVolume || stats.volume || 0);
+        return volume >= minVolume;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get whale activity summary for a market
+ */
+async function getMarketWhaleActivity(marketId, minSize = 10000) {
+    try {
+        const response = await fetch(`${CLOB_REST_URL}/trades?market=${marketId}&limit=500`);
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const trades = await response.json();
+        let buyVolume = 0;
+        let sellVolume = 0;
+        const buyerVolumes = new Map();
+        const sellerVolumes = new Map();
+        for (const trade of trades) {
+            const usdValue = parseFloat(trade.price) * parseFloat(trade.size);
+            if (usdValue < minSize)
+                continue;
+            const maker = trade.maker_address || trade.maker;
+            const taker = trade.taker_address || trade.taker;
+            const side = trade.side?.toUpperCase();
+            if (side === 'BUY') {
+                buyVolume += usdValue;
+                buyerVolumes.set(taker, (buyerVolumes.get(taker) || 0) + usdValue);
+            }
+            else {
+                sellVolume += usdValue;
+                sellerVolumes.set(taker, (sellerVolumes.get(taker) || 0) + usdValue);
+            }
+        }
+        const topBuyers = Array.from(buyerVolumes.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([addr]) => addr);
+        const topSellers = Array.from(sellerVolumes.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 10)
+            .map(([addr]) => addr);
+        return {
+            totalWhaleVolume: buyVolume + sellVolume,
+            buyVolume,
+            sellVolume,
+            topBuyers,
+            topSellers,
+        };
+    }
+    catch (error) {
+        logger_1.logger.error({ marketId, error }, 'Failed to get market whale activity');
+        return {
+            totalWhaleVolume: 0,
+            buyVolume: 0,
+            sellVolume: 0,
+            topBuyers: [],
+            topSellers: [],
+        };
+    }
+}
+//# sourceMappingURL=whale-tracker.js.map