Real-Time Base Whale Tracking Using GoldRush Streaming API- Part 1
Picture this: one wallet accumulates a token position steadily over eight hours. Twenty-four hours later, they sell during a price spike, netting $50,000. This pattern repeats daily, and on-chain data makes it visible to those who know where to look.
We’ve all been there. You see a token’s price suddenly rocket upwards, a green candle stretching towards infinity. Everyone is calling it the "next big thing." You finally buy in, only to watch the price immediately reverse and plummet, leaving you with rapidly depreciating assets.
This is a three-part series, and in this part, we’ll look at what on-chain data actually gives you, who the whales are, and the specific signals you should monitor to begin turning raw blockchain events into actionable insight.
The Traditional Crypto Analysis
Before we go any further, let’s understand the limitations of the old (traditional crypto analysis). The tools most traders rely on are, by their very nature, steps behind the real action.
Technical Analysis (TA)
For many, trading is synonymous with Technical Analysis. This involves studying price charts, drawing trend lines, identifying patterns like head-and-shoulders or cup-and-handles, and watching trading volume in market conditions. The core belief is that history tends to repeat itself, and these patterns can forecast future price movements for informed decisions.
There’s a place for TA. It helps define market structure and identify key levels of support and resistance. But its critical limitation is that it is a lagging indicator. Every single data point on a price chart candle and every volume bar is a record of a transaction that has already been completed. TA is brilliant at documenting the past.
Social Sentiment & News
If charts are lagging, what about news and social sentiment? Surely, being plugged into Twitter, Telegram, and news feeds gives you an edge.
The reality is more complex. The crypto information space is a load of misinformation and coordinated campaigns. "Influencers" are often paid to promote tokens. Because news articles are published after a major price move, they can only provide hindsight analysis.
The Need for a New Lens
So if price charts show us the past, and social media is a manipulated present, where can we find a reliable view of the future? We must look deeper. We must look at the foundational layer of it all: the blockchain itself.
The blockchain is the immutable ledger that records every transaction, every transfer, and every interaction. It doesn't care about hype or patterns; it only records truth. This truth, when interpreted correctly, provides a direct line of sight into the actions of the market's most influential players.
The Power of On-Chain Data
So, what exactly is this "on-chain data," and why is it so transformative?
What is On-Chain Data?
At its simplest, on-chain data is the permanent and public record of everything that happens on a blockchain. Think of it as a global, unchangeable financial journal that anyone can read.
This records three critical types of information:
Transactions: Every time a token is sent from one wallet to another, it’s recorded. This tells us about capital movement.
Wallet Balances: At any given moment, you can see exactly how much of any asset a specific wallet holds. This tells us about the long term wallet accumulation and distribution.
Smart Contract Interactions: When a user provides liquidity to a decentralized exchange, borrows funds from a lending protocol, or stakes tokens, they are interacting with a smart contract. Each of these actions is recorded on-chain as a type of liquidity event, e.g., addLiquidity(), borrow(), or stake().
Hence, this data is transparent, verifiable, and created in near real-time. It is the ultimate source of truth. While a news outlet can publish a false narrative and a chart pattern can fail, a transaction on the blockchain either happened or it didn't. It is this incorruptible nature that makes it so powerful.
Crypto Whales
Now that we understand the ledger, let's look at the whales.
Who Are the Whales?
In crypto, a whale is an individual or entity that controls a wallet containing a sufficiently large amount of a specific cryptocurrency that their trading activity can single-handedly influence its price and liquidity.
They are not a monolithic group. Understanding the different types of whales is key to interpreting their actions:
Early Investors & Team Wallets: These are often the project's founders, early backers, or venture capital funds. They typically hold tokens that are subject to vesting schedules, meaning they can't sell all their tokens at once. When these wallets move funds, it's a monumental event. A transfer from a team wallet to an exchange is often a strong precursor to selling pressure.
Market Makers & Institutions: These are professional firms that provide liquidity and manage enormous portfolios. Their movements are often more nuanced than simple buying and selling. They might be engaging in complex strategies involving derivatives or arbitrage. Tracking them requires understanding not just that they moved funds, but why.
DeFi Degens: This is a more recent class of whale, often anonymous individuals who operate primarily in the world of decentralized finance (DeFi). They are massive participants in governance (voting on protocol changes), lending, and yield farming. Their movements can signal shifting confidence in a particular protocol or a broader sector of the market.
How Whales Move Markets
A whale's impact is both mechanical and psychological.
Liquidity Impact: The most direct effect. If a whale places a market buy order for $500,000 of a token with a modest market cap, that order will "sweep" the order book, buying all the tokens available at the lowest prices and rapidly pushing the price upwards. The reverse is true for a large sell order. It can instantly erase layers of buy support, causing a price crash.
Sentiment Catalyst: The psychological effect can be even more powerful. When a known smart-money wallet makes a large, public purchase, it creates a wave of FOMO (Fear Of Missing Out). Retail traders pile in, amplifying the whale's initial move. Conversely, a large sell-off from a respected entity can trigger FUD (Fear, Uncertainty, and Doubt), leading to panic selling.
The building blocks for real-time whale tracking
Not all on-chain data is equally useful for predicting large moves. Focus on the events that reveal intent and scale.
Wallet balances over time: Track token balances for suspect wallets. A sudden increase, or a steady upward trend, is a direct sign of accumulation.
Transaction flows to and from exchanges: Money moving to exchanges often precedes selling. Money moving off exchanges into private wallets can mean accumulation. Watch deposit and withdrawal addresses tied to major exchanges.
Liquidity events: Creation of a liquidity pair, large additions of liquidity, and temporary imbalances in pools are critical. An addition of significant liquidity by one wallet, followed by small buys from other wallets, is a clue.
Contract interactions: When wallets call specific smart contracts for staking, vesting, or locking, they reveal intent. Locking tokens for a protocol is different from routing them to a DEX.
Clustered wallet behaviour: Multiple wallets controlled by the same actor will often show coordinated timing. Identifying clusters helps differentiate organic volume from orchestrated accumulation.
On-chain timing and order: Because the chain timestamps events, the relative order of transactions across different wallets matters. Detecting a pattern where multiple wallets seed liquidity, and a final larger wallet completes a sweep, is the kind of pattern that leads to actionable signals.
The Critical Infrastructure for Real-Time Analysis
Here’s the catch: raw blockchain data is not a user-friendly dataset, and it is technically complex. Querying it directly is like trying to drink from a firehose.
To make it actionable, we need a powerful infrastructure that can index, structure, and stream this data in a way we can consume. This is where our core technology stack comes in.
The tools and infrastructure you need
Raw blockchain data is massive, verbose, and not organised for straightforward analysis. To detect whales in real time, you need a stack that takes raw events and turns them into normalized, queryable streams.
Components of a practical stack
A data engine that streams parsed events. This engine must normalize token standards, map addresses, and emit structured records for transfers, contract calls, and liquidity changes.
A fast indexer to make historical and recent data searchable. Detection often blends real-time watches with recent history to confirm patterns.
A rules engine to detect patterns and triage signals. Not every large transfer matters. Your rules identify what does.
An observability layer to review logs and replay events for rule refinement.
Here is where the Covalent Goldrush Streaming API comes in as the data engine and Base as a fast execution chain.
Covalent Goldrush Streaming API
Covalent Goldrush is presented here as a service that continuously streams normalized, cross-chain data. It converts raw transactions into structured events like “liquidity_added”, “token_transfer”, and “contract_call”. For real-time monitoring, this removes the heavy lifting of parsing and chaining logs and lets you focus on what matters.
Here's a conceptual walkthrough of getting wallet transaction activity using the Goldrush Streaming API.
You’ll need an API key from the Goldrush platform to run it, which you can obtain from here.
Next, create a new project folder and initialize it with npm init -y. Then, install the Covalent SDK, dotenv, and the development dependencies:
npm install @covalenthq/client-sdk ws dotenv
npm install typescript ts-node @types/node --save-devAfter that, create a file named wallet.ts and paste in the following code. Also, create a .env file to store your Goldrush API key.
import { GoldRushClient, StreamingChain } from "@covalenthq/client-sdk";
import * as dotenv from "dotenv";
import WebSocket from 'ws';
dotenv.config();
(global as any).WebSocket = WebSocket;
const API_KEY = process.env.COVALENT_API_KEY;
if (!API_KEY) {
console.error("ERROR: COVALENT_API_KEY not found in .env file");
process.exit(1);
}
// Use addresses from the documentation examples
const WALLET_ADDRESSES = [“Your wallet Address];
const client = new GoldRushClient(API_KEY, {}, {
onConnecting: () => console.log("Connecting..."),
onOpened: () => console.log("Connected!"),
onClosed: () => console.log("Disconnected"),
onError: (error) => console.error("Error:", error.message),
});
let unsubscribe: (() => void) | null = null;
function startMonitoring() {
console.log("Starting Base Whale Monitor");
console.log(`Monitoring ${WALLET_ADDRESSES.length} wallet(s) on Base`);
try {
unsubscribe = client.StreamingService.subscribeToWalletActivity(
{
chain_name: StreamingChain.BASE_MAINNET,
wallet_addresses: WALLET_ADDRESSES,
},
{
next: (data: any) => {
console.log("Raw data received, checking structure...");
console.log("Data keys:", Object.keys(data));
if (data?.data?.walletTxs) {
console.log(`Found ${data.data.walletTxs.length} transaction(s) in data.data.walletTxs`);
data.data.walletTxs.forEach((tx: any) => handleWalletTransaction(tx));
} else {
console.log("Unexpected data structure:", JSON.stringify(data, null, 2));
}
},
error: (error) => console.error("Stream error:", error),
complete: () => console.log("Stream completed"),
}
);
console.log("Subscribed successfully");
} catch (error: any) {
console.error("Failed to start:", error.message);
}
}
function handleWalletTransaction(tx: any) {
if (!tx?.tx_hash) return;
console.log('\n=== NEW TRANSACTION ===');
console.log('Hash:', tx.tx_hash);
console.log('From:', shortAddress(tx.from_address));
console.log('To:', shortAddress(tx.to_address));
console.log('Type:', tx.decoded_type);
console.log('Block:', tx.block_height);
console.log('Time:', tx.block_signed_at);
if (tx.decoded) {
console.log('Decoded Data:', JSON.stringify(tx.decoded, null, 2));
if (tx.decoded_type === 'TRANSFER' && tx.decoded.quote_usd) {
console.log('USD Value: $' + tx.decoded.quote_usd);
if (tx.decoded.quote_usd > 1000) {
console.log('*** WHALE ALERT: $' + tx.decoded.quote_usd + ' ***');
}
}
}
if (tx.logs && tx.logs.length > 0) {
console.log('Logs:', tx.logs.length, 'events');
}
console.log('=====================\n');
}
function shortAddress(address: string): string {
return address ? `${address.slice(0, 6)}...${address.slice(-4)}` : 'N/A';
}
startMonitoring();
process.on('SIGINT', async () => {
console.log('Shutting down...');
if (unsubscribe) unsubscribe();
await client.StreamingService.disconnect();
process.exit(0);
});Execute npx ts-node wallet.ts to begin receiving real-time wallet activity updates in your terminal.
Base: the execution layer
Base's faster block production means you see whale transactions sooner in Covalent's streams. When tracking large wallets, this reduced latency between their action and your observation is crucial for a timely response.
Conclusion
In this first part, we've established that traditional analysis, while useful, is inherently limited because it reacts to market effects. On-chain data, by contrast, provides a unique, leading-indicator view by allowing us to track the capital flows of the market's most influential participants, whales.
In Part 2, we will set up our first real-time data pipeline using Covalent to stream live wallet activity from the Base blockchain. We will learn how to classify and cluster wallets to separate the true signal from the noise. See you next time!
Resources:
Read more
Support
