Learn how to build a Solana wallet scoring system that combines wallet age, PnL, win rate, token diversity, transaction frequency, and holding patterns into a single composite score for copy-trading, sybil detection, and alpha wallet discovery.
Disclosure: This article contains affiliate links. If you sign up through them, MadeOnSol may earn a commission at no extra cost to you. This never affects our rankings, ratings, or reviews.
Not all wallets are created equal. A wallet that has traded profitably for six months across hundreds of tokens is fundamentally different from one that got lucky on a single memecoin. But most trading tools treat them the same — a buy signal is a buy signal, regardless of who is behind it.
A wallet scoring system fixes this. By combining multiple on-chain metrics into a single composite score, you can rank any Solana wallet on a spectrum from low-quality noise to high-conviction alpha. This guide walks through the architecture, metrics, data sources, and code needed to build one from scratch.
Raw wallet tracking gives you a firehose of data. Thousands of wallets are making trades every minute on Solana. Without scoring, you cannot separate the signal from the noise.
A well-designed scoring system lets you:
If you are already tracking smart money on Solana, scoring is the natural next step to make that data actionable.
A robust Solana wallet scoring system combines at least six on-chain dimensions. Each captures a different aspect of wallet quality.
Older wallets with long transaction histories are more trustworthy than fresh wallets. A wallet that has survived multiple market cycles has a track record you can evaluate. New wallets might be sybils, bots, or one-trade wonders.
Data source: Use Helius getSignaturesForAddress to pull the full transaction history. The timestamp of the earliest transaction gives you wallet age.
Profit and loss is the most obvious metric, but it needs careful calculation. You must track buy cost basis per token, match sells against buys (FIFO or average cost), and account for partial exits.
Data source: Cielo Finance provides pre-calculated PnL for Solana wallets. Alternatively, reconstruct it from raw swap transactions via Helius parsed transaction history.
Win rate measures what percentage of a wallet's token trades ended in profit. A wallet with 45% win rate across 200 trades is far more reliable than one with 80% win rate across 5 trades. Always consider win rate alongside sample size.
Building a product on Solana data?
Skip the Geyser pipeline — embed KOL flow, deployer reputation, and the all-DEX firehose over REST, WebSocket, or webhooks. The Business tier (€400/mo) is the self-serve embed license at 500k calls/day — Enterprise adds white-label & redistribution.
Tools mentioned
Live health scores, average ratings, and direct links on MadeOnSol.
MCP server powered by Solana Agent Kit for on-chain actions
Telegram trading bot for Solana — snipe new tokens, set limit orders, auto-sell, and copy trade with built-in MEV protection
Unity SDK for building Solana games
Browser-based IDE for developing and deploying Solana programs
Native Solana support inside the MetaMask browser wallet
Get this data via API
Stream real-time KOL trades, PnL rankings, and coordination signals programmatically.
New customers try Pro free for 5 days — card, cancel anytime.
import { MadeOnSol } from "madeonsol";
const client = new MadeOnSol({ apiKey: "msk_your_key" });
// Real-time KOL trades
const { trades } = await client.kol.feed({ limit: 10, action: "buy" });
// KOL convergence signals
const { tokens } = await client.kol.coordination({ min_kols: 3 });Building a product on Solana data?
MadeOnSol isn't an RPC or another generic token API — it's Solana memecoin intelligence that's painful to build in-house, pulled from dual-region gRPC shred streams: sub-second from the on-chain event to your app.
Signals you'd otherwise build
KOL & smart-money flow from 1,000+ labeled wallets, deployer reputation, coordination clusters, linked-wallet entity resolution, and an all-DEX firehose.
Embed it in your product
The Business tier (€400/mo, self-serve) licenses you to display MadeOnSol data inside your own product — 500k calls/day, 10 WS + 5 firehose connections. Enterprise above adds white-label & redistribution rights and custom endpoints.
Evaluate first, commit later
Test everything on a free ULTRA key — no commitment. If it fits, we scope volume or white-label pricing.
Keep reading
Developer Tools
Watch live smart-money trades on Solana and paper-trade them in real time: open a virtual position when a tracked KOL buys, close when they sell, and track PnL from the market-cap multiple. This tutorial walks the open-source kol-copytrade-bot-starter — ~300 lines, one dependency, free API key — and shows how to filter by KOL win rate, deployer tier, and multi-KOL confirmation before risking anything real.
Education
KOL stands for Key Opinion Leader — a trader or personality whose calls move markets. Here's what KOLs actually are, how they make money, whether their calls are profitable (we measured 757,000 trades), and how wallet tracking separates real traders from paid promoters.
Reviews
Bullpen pulls Solana memecoins, Hyperliquid perps, and Polymarket prediction markets into one non-custodial terminal — with smart-money tracking and copy trading on top. Here's an honest 2026 review.
Guides
GMGN, free Cielo, and Solscan cover a lot of ground at no cost. But there are specific points where the free tier becomes the bottleneck — here's exactly when that happens and what upgrading actually gets you.
Guides
By the time a KOL tweets a pump.fun token, the best entry is already gone. The real edge is on-chain, before the announcement. Here's what the data shows about KOL timing — and how to use it.
Guides
Copying bots disguised as smart money is one of the most common and costly mistakes in Solana copy trading. Here's how to spot them on-chain, why popular trackers miss them, and how to clean your KOL list before it costs you.
Enjoyed this article?
Real-time KOL trades, Pump.fun deployer intel, and 1,200+ ranked Solana tools — free to explore.
Open the KOL TrackerData source: Derive from the same PnL data. A "win" is any token position that was closed with positive realized PnL.
Wallets that profit across many different tokens demonstrate repeatable skill rather than luck. A wallet that made money on 50 different tokens is more impressive than one that made the same amount on a single 100x play.
Data source: Count unique token mints traded from the wallet's swap history. Weight diversity by the number of profitable unique tokens versus total unique tokens traded.
Active wallets generate more data points, which makes their other metrics more statistically significant. A wallet averaging 10+ trades per week over months gives you high confidence. A wallet with 3 trades total does not.
Data source: Count transactions over rolling time windows (7d, 30d, 90d) from Helius transaction signatures.
How long a wallet holds positions reveals its strategy. Diamond-hands wallets that hold through drawdowns behave differently from quick-flip scalpers. Neither is inherently better, but understanding the pattern helps you match wallets to your own strategy.
Data source: Calculate average hold time per token by measuring the time between first buy and last sell for each position.
The foundation of any wallet scoring system is reliable on-chain data. Here is how to fetch a wallet's complete trading history using the Helius API.
const HELIUS_API_KEY = process.env.HELIUS_API_KEY;
const BASE_URL = `https://api.helius.xyz/v0`;
interface WalletTransaction {
signature: string;
timestamp: number;
type: string;
tokenTransfers: TokenTransfer[];
}
interface TokenTransfer {
mint: string;
fromUserAccount: string;
toUserAccount: string;
tokenAmount: number;
}
async function getWalletHistory(
walletAddress: string,
limit = 1000
): Promise<WalletTransaction[]> {
const transactions: WalletTransaction[] = [];
let beforeSignature: string | undefined;
while (transactions.length < limit) {
const url = new URL(
`${BASE_URL}/addresses/${walletAddress}/transactions`
);
url.searchParams.set("api-key", HELIUS_API_KEY);
url.searchParams.set("limit", "100");
if (beforeSignature) {
url.searchParams.set("before", beforeSignature);
}
const response = await fetch(url.toString());
const batch = await response.json();
if (!batch.length) break;
transactions.push(...batch);
beforeSignature = batch[batch.length - 1].signature;
}
return transactions;
}
This gives you the raw transaction data. From here, filter for swap transactions (type SWAP) and extract the token transfers to build a per-token trade ledger.
Once you have the raw transactions, group them by token mint and calculate realized PnL per position.
interface TokenPosition {
mint: string;
buys: { amount: number; costSol: number; timestamp: number }[];
sells: { amount: number; receivedSol: number; timestamp: number }[];
}
function calculateWinRate(positions: TokenPosition[]): {
winRate: number;
totalTrades: number;
wins: number;
} {
let wins = 0;
let closed = 0;
for (const position of positions) {
const totalCost = position.buys.reduce((s, b) => s + b.costSol, 0);
const totalReceived = position.sells.reduce(
(s, s2) => s + s2.receivedSol, 0
);
// Only count positions that have been at least partially sold
if (position.sells.length === 0) continue;
closed++;
if (totalReceived > totalCost) {
wins++;
}
}
return {
winRate: closed > 0 ? wins / closed : 0,
totalTrades: closed,
wins,
};
}
A common mistake is counting open positions (tokens bought but never sold) as losses. Exclude them entirely or score them separately based on current unrealized PnL.
With individual metrics calculated, combine them into a single score using weighted normalization.
interface WalletMetrics {
walletAgeInDays: number;
realizedPnlSol: number;
winRate: number; // 0 to 1
uniqueTokensTraded: number;
weeklyTxFrequency: number;
avgHoldTimeHours: number;
totalClosedTrades: number;
}
interface ScoringWeights {
age: number;
pnl: number;
winRate: number;
diversity: number;
frequency: number;
holdPattern: number;
}
const DEFAULT_WEIGHTS: ScoringWeights = {
age: 0.10,
pnl: 0.25,
winRate: 0.25,
diversity: 0.15,
frequency: 0.10,
holdPattern: 0.15,
};
function normalize(value: number, min: number, max: number): number {
return Math.max(0, Math.min(1, (value - min) / (max - min)));
}
function computeWalletScore(
metrics: WalletMetrics,
weights: ScoringWeights = DEFAULT_WEIGHTS
): number {
// Require minimum sample size for statistical confidence
const sampleMultiplier = Math.min(1, metrics.totalClosedTrades / 30);
const scores = {
age: normalize(metrics.walletAgeInDays, 0, 365),
pnl: normalize(metrics.realizedPnlSol, -10, 500),
winRate: normalize(metrics.winRate, 0.15, 0.60),
diversity: normalize(metrics.uniqueTokensTraded, 1, 100),
frequency: normalize(metrics.weeklyTxFrequency, 0, 50),
holdPattern: normalize(metrics.avgHoldTimeHours, 0.5, 168),
};
const raw =
scores.age * weights.age +
scores.pnl * weights.pnl +
scores.winRate * weights.winRate +
scores.diversity * weights.diversity +
scores.frequency * weights.frequency +
scores.holdPattern * weights.holdPattern;
// Scale by sample confidence and convert to 0-100
return Math.round(raw * sampleMultiplier * 100);
}
The sampleMultiplier is critical. Without it, a wallet with 2 trades and a 100% win rate would score higher than a wallet with 200 trades and a 45% win rate. The multiplier penalizes wallets with insufficient data, requiring at least 30 closed trades for full scoring confidence.
The default weights above are a starting point. You should adjust them based on your use case:
pnl and winRate weights. You care about profitability above all.age and diversity weights. Sybils tend to be new wallets with narrow activity.frequency and diversity weights. Alpha wallets are actively exploring new tokens.Test your weights against known wallets. Pick 10 wallets you consider high-quality and 10 you consider low-quality. A good scoring system should cleanly separate the two groups.
The most immediate application of wallet scoring is improving copy-trading systems. Instead of copying every trade from a followed wallet, gate the copy-trade execution on the wallet's score.
Implementation approach:
The MadeOnSol KOL Tracker already surfaces wallet performance data that feeds directly into scoring. Combining KOL tracker data with your own scoring layer gives you a filtered view of only the highest-quality signals from top-performing KOL wallets.
Sybil wallets created for airdrop farming share common patterns that scoring exposes:
A wallet scoring system flags these automatically. Wallets scoring below 20 out of 100 that suddenly interact with a new protocol are almost certainly sybils. This is valuable both for protocol teams running airdrops and for traders who want to estimate real user counts.
The most powerful use of wallet scoring is discovering new alpha wallets before they appear on public leaderboards. The approach is to monitor whale wallets on Solana and score every wallet that interacts with trending tokens early.
Discovery pipeline:
Nansen provides pre-built smart money labels that can serve as ground truth for validating your scoring model against established alpha wallets.
Scoring tells you who to watch; the next layer is reading what they're doing in aggregate. Our guide to on-chain order flow analysis covers how to read buy/sell pressure across these wallets before a move plays out.
Real-world wallet scoring requires handling several edge cases:
Multi-wallet users: Sophisticated traders split activity across multiple wallets. Your scoring system sees each wallet independently. This is actually fine — if a wallet scores well on its own, the signal is valid regardless of whether the owner has other wallets.
Bot wallets: MEV bots and arbitrage bots will score high on frequency and win rate but low on diversity and hold time. Decide whether to include or exclude them based on your use case. For copy-trading, bot wallets are usually not useful to follow.
Dormant wallets: A wallet that was highly active and profitable six months ago but has not traded since presents a challenge. Apply a time decay factor — reduce scores for wallets with no activity in the last 30 days.
function applyTimeDecay(score: number, lastActivityDays: number): number {
if (lastActivityDays <= 30) return score;
const decayFactor = Math.max(0.3, 1 - (lastActivityDays - 30) / 180);
return Math.round(score * decayFactor);
}
A complete wallet scoring pipeline runs as a scheduled job:
The entire system can run on a single server with the Helius free tier handling most data needs. As you scale to thousands of wallets, consider caching transaction data locally and only fetching incremental updates.
If you'd rather skip building this pipeline yourself, MadeOnSol's free Solana wallet tracker and PnL analyzer already outputs a comparable trust score, win rate, and bot-detection read for any wallet with a single paste.
The Helius free tier provides 100,000 credits per day, and each getSignaturesForAddress call costs a small number of credits. In practice you can score 200 to 500 wallets daily on the free tier if you cache transaction history and only fetch new data incrementally. For larger-scale scoring, Helius paid plans or a combination of Helius and Birdeye data provides enough throughput for thousands of wallets.
A wallet needs at least 30 closed token positions over a period of at least 60 days for the score to be statistically meaningful. Below that threshold, apply the sample size multiplier discussed above to discount the score. Wallets with fewer than 10 closed trades should not be used for copy-trading decisions regardless of their apparent win rate, because the variance is too high to distinguish skill from luck.
Yes, in most cases. Wallet behavior changes over time, and a wallet that was profitable six months ago may have shifted strategy. A practical approach is to calculate metrics over two windows — the full history and the last 90 days — then weight the recent window at 60% and the full history at 40%. This captures both long-term track record and current form.
Run a backtest. Take a snapshot of wallet scores from 30 days ago, then measure the actual trading performance of those wallets over the following 30 days. Group wallets into score quartiles (0-25, 26-50, 51-75, 76-100) and compare average PnL across groups. A working scoring system should show a clear positive correlation between score quartile and subsequent profitability. If it does not, revisit your weights and normalization ranges.
The weighting approach above mirrors the sample-size and consistency filters covered in how to identify smart money wallets on Solana — both require a minimum trade count before treating win rate as signal, and both score wallets across multiple time periods rather than a single hot streak.