# How CloddsBot's Multi-Chain Whale Tracking Monitors Solana and EVM Wallets

> Discover how CloddsBot's multi-chain whale tracking monitors Solana and EVM wallets by normalizing trade events into a unified schema for efficient copy-trading.

- Repository: [AL/CloddsBot](https://github.com/alsk1992/CloddsBot)
- Tags: deep-dive
- Published: 2026-09-11

---

**TLDR:** CloddsBot tracks high-value "whale" wallets across Solana and EVM chains through a unified architecture comprising two specialized feed modules—one for Polymarket CLOB data and one for generic on-chain monitoring—that normalize all trade events into a common `WhaleTrade` schema and emit standardized signals for copy-trading.

CloddsBot (`alsk1992/CloddsBot`) implements a sophisticated **multi-chain whale tracking** system that treats Solana and Ethereum-compatible (EVM) addresses as interchangeable entities within a single copy-trading pipeline. The system aggregates real-time trade data from disparate sources—ranging from Polymarket's centralized limit order book (CLOB) to native Solana and EVM RPC endpoints—into unified whale profiles that track performance metrics, win rates, and position changes.

## Unified Architecture for Cross-Chain Monitoring

The whale tracking system splits responsibilities across two specialized modules that share a common interface. Both modules maintain an internal `whaleProfiles` Map and emit identical event types through an `EventEmitter`, allowing downstream components to consume cross-chain data without chain-specific logic.

### Polymarket Whale-Tracker Module

Located in [`src/feeds/polymarket/whale-tracker.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/feeds/polymarket/whale-tracker.ts), this module connects to Polymarket's CLOB WebSocket at `wss://ws-subscriptions-clob.polymarket.com/ws/market` and the Gamma REST API. It streams real-time trade events and polls position snapshots every configurable interval. The tracker filters trades by configurable USD thresholds (`minTradeSize`, `minPositionSize`) and maintains per-address profiles storing total value, win-rate, and category performance.

### Crypto Whale-Tracker Module for Solana and EVM

Located in [`src/feeds/crypto/whale-tracker.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/feeds/crypto/whale-tracker.ts), this module provides chain-agnostic on-chain tracking for Solana and EVM wallets. It connects to Solana RPC/WebSocket endpoints and EVM providers (Alchemy/Infura), listening for large token transfers or swaps exceeding the configured threshold. This module normalizes all incoming events into the same `WhaleTrade` shape used by the Polymarket tracker, enabling the bot to treat Solana and EVM addresses as interchangeable "whales."

## Real-Time Data Pipeline and Event Flow

The tracking pipeline follows a six-step process from configuration to signal generation:

1. **Configuration** - On startup, each tracker receives a `WhaleConfig` object with defaults of `$10,000` minimum trade size, `$50,000` minimum position size, and 60-second poll intervals.

2. **Whale Discovery** - The Polymarket tracker pulls top traders from the Gamma leaderboard API (`/leaderboard?limit=100&sortBy=volume`), while the crypto tracker auto-adds addresses executing trades above `minTradeSize * 5` on Solana or EVM chains.

3. **Real-Time Streaming** - Polymarket uses the CLOB WebSocket; Solana connects to `wss://api.mainnet-beta.solana.com`; EVM chains subscribe via provider WebSockets (e.g., Alchemy). All JSON payloads normalize into `WhaleTrade` objects containing fields like `usdValue`, `maker`, `taker`, `side`, and `marketId`.

4. **Position Polling** - Every `pollIntervalMs`, the system queries Gamma API positions for Polymarket and chain-specific RPC methods (`getTokenAccountsByOwner` for Solana, `eth_getLogs` for EVM) to detect `positionOpened`, `positionChanged`, or `positionClosed` events.

5. **Performance Tracking** - Closed positions trigger `recordClosedPosition` to update win/loss counts and total PnL per whale in the shared profiles map.

6. **Signal Generation** - The `calculateSignalStrength` function evaluates win-rate, trade-count confidence, and average PnL. When signal strength ≥ 0.5, closed trades ≥ 5, and win-rate ≥ `WHALE_MIN_WIN_RATE` (default 55%), the tracker emits a `copySignal` event via the `EventEmitter`.

## Configuration and Performance Thresholds

The system uses strict defaults to filter noise while remaining configurable:

- **Minimum Trade Size**: $10,000 USD (`minTradeSize`)
- **Minimum Position Size**: $50,000 USD (`minPositionSize`)
- **Win Rate Threshold**: 55% (`WHALE_MIN_WIN_RATE`)
- **Recent Trade Buffer**: Maximum 1,000 items in the `recentTrades` array
- **Signal Strength Threshold**: 0.5 (scale 0-1) for copy-trading eligibility

## Implementation Examples

### Initializing Multi-Chain Trackers

```typescript
import { createWhaleTracker as createPolymarketTracker } from './feeds/polymarket/whale-tracker';
import { createWhaleTracker as createCryptoTracker } from './feeds/crypto/whale-tracker';

const polyConfig = { minTradeSize: 15000 };
const cryptoConfig = { minTradeSize: 20000, enableRealtime: true };

const polyTracker = createPolymarketTracker(polyConfig);
const cryptoTracker = createCryptoTracker(cryptoConfig);

await Promise.all([polyTracker.start(), cryptoTracker.start()]);

```

### Subscribing to Cross-Chain Whale Events

```typescript
cryptoTracker.on('trade', (trade: WhaleTrade) => {
  console.log(
    `[Whale] ${trade.maker.slice(0, 8)} → ${trade.taker.slice(0, 8)} ` +
    `${trade.side} $${trade.usdValue.toLocaleString()} on ${trade.marketId}`
  );
});

```

### Aggregating Profitable Whales Across Chains

```typescript
const allProfiles = [
  ...polyTracker.getProfitableWhales(),
  ...cryptoTracker.getProfitableWhales(),
];

allProfiles.sort((a, b) => b.winRate - a.winRate || b.totalValue - a.totalValue);

allProfiles.slice(0, 10).forEach((p, i) => {
  console.log(`${i + 1}. ${p.address.slice(0, 10)} – WR: ${p.winRate.toFixed(1)}% – $${p.totalValue.toLocaleString()}`);
});

```

### Handling Copy-Trading Signals

The [`src/trading/copy-trading.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/trading/copy-trading.ts) module consumes normalized signals regardless of source chain:

```typescript
cryptoTracker.on('copySignal', (signal) => {
  copyTradeExecutor.handleSignal(signal);
});

```

## Unified API Interface

Both trackers expose identical public methods, enabling chain-agnostic interactions:

- `start()` and `stop()` for lifecycle management
- `trackAddress(address)` and `untrackAddress(address)` for manual whale curation
- `getKnownWhales()` and `getWhaleProfile(address)` for profile retrieval
- `getRecentTrades()` for accessing the bounded trade history
- `getProfitableWhales()` for filtering by performance metrics

## Summary

- CloddsBot implements multi-chain whale tracking through two specialized modules in [`src/feeds/polymarket/whale-tracker.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/feeds/polymarket/whale-tracker.ts) and [`src/feeds/crypto/whale-tracker.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/feeds/crypto/whale-tracker.ts).
- The architecture normalizes disparate data sources—Polymarket CLOB, Solana RPC, and EVM providers—into a unified `WhaleTrade` schema.
- Real-time WebSocket streams and periodic RPC polling maintain updated position data for both prediction markets and on-chain token transfers.
- A signal generation algorithm (`calculateSignalStrength`) filters whales by win-rate (≥55%), trade count (≥5), and signal strength (≥0.5) before emitting copy-trading events.
- The system treats Solana and EVM wallets as interchangeable entities, allowing [`src/trading/copy-trading.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/trading/copy-trading.ts) to execute mirrored trades without chain-specific logic.

## Frequently Asked Questions

### How does CloddsBot normalize data between Polymarket and on-chain Solana/EVM sources?

The **Crypto Whale-Tracker** module in [`src/feeds/crypto/whale-tracker.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/feeds/crypto/whale-tracker.ts) transforms incoming Solana and EVM transaction payloads into the same `WhaleTrade` interface used by the Polymarket tracker. This normalization includes mapping fields like `usdValue`, `maker`, `taker`, and `marketId` to a consistent schema, enabling the `EventEmitter` to broadcast identical event types (`trade`, `positionOpened`, `copySignal`) regardless of the underlying blockchain.

### What are the default thresholds for automatic whale detection?

CloddsBot uses conservative defaults defined in the `WhaleConfig` interface: a **$10,000 USD minimum trade size** (`minTradeSize`), **$50,000 minimum position size** (`minPositionSize`), and a **55% minimum win rate** (`WHALE_MIN_WIN_RATE`). For automatic discovery, the crypto tracker adds addresses that execute trades exceeding `minTradeSize * 5` (effectively $50,000) to the `trackedAddresses` Set.

### How is copy-trading signal strength calculated?

The `calculateSignalStrength` function in the whale tracker modules computes a 0-to-1 score based on three weighted factors: historical win-rate, statistical confidence derived from total trade count (requiring minimum 5 closed trades), and average realized profit/loss (PnL). A whale only emits a `copySignal` event when its signal strength reaches **0.5 or higher**, combined with meeting the minimum win-rate threshold.

### Can developers manually track specific wallet addresses outside the auto-discovery?

Yes. Both tracker instances expose the `trackAddress(address: string)` method, which adds the specified Solana or EVM address to the internal `trackedAddresses` Set and initializes a new entry in the `whaleProfiles` Map. Conversely, `untrackAddress(address)` removes monitoring for specific wallets. These methods are exposed through the user-facing slash commands defined in [`src/skills/bundled/whale-tracking/index.ts`](https://github.com/alsk1992/CloddsBot/blob/main/src/skills/bundled/whale-tracking/index.ts).