The Herfindahl–Hirschman Index: Measuring Market Concentration On-Chain
2026-10-15
The Herfindahl–Hirschman Index (HHI) measures market concentration and the level of competition within an industry. It was developed independently by economists Orris Herfindahl and Albert Hirschman in the 1940s and 1950s and has since become the standard tool used by antitrust regulators worldwide to evaluate whether a market is competitive, moderately concentrated, or approaching monopoly.
In traditional finance, the US Department of Justice uses HHI to screen mergers. In on-chain systems, HHI is an equally precise instrument for measuring whether block ordering, liquidity provision, or transaction sequencing is becoming dangerously concentrated among a small number of actors. This article covers how HHI is calculated, how to interpret it, and how it applies specifically to Priority Gas Auction (PGA) ordering analysis on Arbitrum One.
HHI is the sum of the squared market shares of all participants in a market:
HHI = Σ (s_i)²
where s_i is each participant's share as a value from 0 to 100Using shares expressed as percentages (0 to 100), HHI ranges from near 0 (perfect competition, infinitely many tiny players) to 10,000 (pure monopoly, one player holds 100% of the market).
If you express shares as fractions (0 to 1), HHI ranges from 0 to 1. Both are correct. Just be consistent. Most regulatory bodies and academic literature use the 0 to 10,000 scale.
Squaring amplifies large shares disproportionately. A player with 50% share contributes 2,500 to the index. A player with 5% share contributes only 25. This means the index is highly sensitive to dominant players and relatively insensitive to fragmentation at the tail. That is exactly what you want: a measure that raises the alarm when one entity is pulling away from the field, not just counting how many entities exist.
| HHI Range | Market Classification | Interpretation |
|---|---|---|
| 0 to 1,499 | Unconcentrated | Competitive. No single player dominates. Entry is viable. |
| 1,500 to 2,499 | Moderately Concentrated | Some consolidation. Regulators take notice above 1,800. |
| 2,500 to 10,000 | Highly Concentrated | One or a few players dominate. Competition is weak. |
| 10,000 | Pure Monopoly | Single entity holds 100% of market share. |
As a reference: the US smartphone OS market (iOS plus Android together holding close to 100%) produces an HHI well above 5,000. A commodities exchange with hundreds of active market makers might produce an HHI below 200.
Suppose a market has five firms with these market shares:
| Firm | Share (%) | Share² |
|---|---|---|
| A | 40 | 1,600 |
| B | 30 | 900 |
| C | 15 | 225 |
| D | 10 | 100 |
| E | 5 | 25 |
HHI = 1600 + 900 + 225 + 100 + 25 = 2,850At 2,850, this market is highly concentrated. Firms A and B together hold 70% and their squared contributions dominate the index. If Firm A acquires Firm B, the new HHI would be:
// After merger: A+B = 70%, C = 15%, D = 10%, E = 5%
HHI_post = 70² + 15² + 10² + 5²
= 4900 + 225 + 100 + 25
= 5,250
delta_HHI = 5250 - 2850 = 2,400A delta above 200 in a market already above 2,500 triggers automatic DOJ review. This merger would not pass without significant divestitures.
interface Participant {
entity: string;
share: number; // as percentage 0-100
}
function calculateHHI(participants: Participant[]): number {
const total = participants.reduce((sum, p) => sum + p.share, 0);
if (Math.abs(total - 100) > 0.01) {
throw new Error(`Shares must sum to 100, got ${total}`);
}
return participants.reduce((hhi, p) => hhi + p.share ** 2, 0);
}
function classifyHHI(hhi: number): string {
if (hhi < 1500) return 'Unconcentrated';
if (hhi < 2500) return 'Moderately Concentrated';
return 'Highly Concentrated';
}
// Example
const market: Participant[] = [
{ entity: 'Firm A', share: 40 },
{ entity: 'Firm B', share: 30 },
{ entity: 'Firm C', share: 15 },
{ entity: 'Firm D', share: 10 },
{ entity: 'Firm E', share: 5 },
];
const hhi = calculateHHI(market);
console.log(`HHI: ${hhi} (${classifyHHI(hhi)})`);
// HHI: 2850 (Highly Concentrated)On Arbitrum One, the Priority Gas Auction (PGA) determines how transactions are ordered within a block. Entities, typically automated searchers, arbitrageurs, and market makers, compete by paying priority fees to secure favorable ordering for their transactions. The entity willing to pay the highest priority fee gets placed first.
When a small number of well-capitalised searchers consistently win the ordering auction across many blocks, the sequencing power of the network concentrates. This is a measurable centralisation risk. HHI is the right tool to quantify it.
In priority-watch, we track each entity's share of ordered transactions (or priority fee capture) across a rolling window of blocks. The HHI of those shares tells us whether ordering power is broadly distributed or whether one or two entities have effectively captured the sequencer.
interface BlockEntity {
address: string;
txCount: number; // transactions ordered in priority positions
feePaid: bigint; // total priority fees paid (wei)
}
interface BlockWindow {
blockStart: number;
blockEnd: number;
entities: BlockEntity[];
}
function pgaOrderingHHI(window: BlockWindow): {
hhi: number;
classification: string;
topEntity: string;
topShare: number;
} {
const totalTx = window.entities.reduce((s, e) => s + e.txCount, 0);
if (totalTx === 0) throw new Error('No transactions in window');
const participants = window.entities.map((e) => ({
entity: e.address,
share: (e.txCount / totalTx) * 100,
}));
const hhi = participants.reduce((acc, p) => acc + p.share ** 2, 0);
const top = participants.sort((a, b) => b.share - a.share)[0];
return {
hhi: Math.round(hhi),
classification: classifyHHI(hhi),
topEntity: top.entity,
topShare: parseFloat(top.share.toFixed(2)),
};
}
// Example: blocks 250000 to 250099 on Arbitrum One
const window: BlockWindow = {
blockStart: 250000,
blockEnd: 250099,
entities: [
{ address: '0xSearcher1', txCount: 420, feePaid: 8400000000000000n },
{ address: '0xSearcher2', txCount: 310, feePaid: 6200000000000000n },
{ address: '0xArb1', txCount: 180, feePaid: 3600000000000000n },
{ address: '0xRetail', txCount: 90, feePaid: 450000000000000n },
],
};
const result = pgaOrderingHHI(window);
console.log(result);
// { hhi: 2918, classification: 'Highly Concentrated',
// topEntity: '0xSearcher1', topShare: 42 }A single-point HHI reading is useful. A time series is much more powerful. You can detect trends: is the market concentrating over time, or is a previously dominant searcher losing ground to new entrants?
interface HHISnapshot {
timestamp: Date;
blockRange: [number, number];
hhi: number;
topEntityShare: number;
}
async function buildHHITimeSeries(
windowSize: number,
stepSize: number,
latestBlock: number,
lookbackBlocks: number,
): Promise<HHISnapshot[]> {
const snapshots: HHISnapshot[] = [];
for (
let end = latestBlock;
end > latestBlock - lookbackBlocks;
end -= stepSize
) {
const start = end - windowSize;
const window = await fetchBlockWindow(start, end);
const result = pgaOrderingHHI(window);
snapshots.push({
timestamp: await getBlockTimestamp(end),
blockRange: [start, end],
hhi: result.hhi,
topEntityShare: result.topShare,
});
}
return snapshots.reverse(); // chronological order
}Plotting this series reveals regime changes: a new searcher entering the market drops HHI sharply, a searcher going offline spikes it, and algorithmic improvements by one entity that let it consistently outbid competitors will show a slow upward drift.
A simpler approach is the CR-N ratio: add up the shares of the top N players. CR-4, for example, is the combined share of the top four entities. Many dashboards report CR-4 because it is easy to explain.
The problem with CR-N is that it is insensitive to how the top-N share is distributed internally. A market where four entities each hold 15% (CR-4 = 60%) looks identical to one where a single entity holds 57% and three others hold 1% each (CR-4 still 60%). HHI distinguishes them immediately:
// Four equal players at 15% each (plus others)
const equal = [15, 15, 15, 15, 10, 10, 10, 10].map(s => s ** 2);
const hhiEqual = equal.reduce((a, b) => a + b, 0);
// HHI = 900 + 900 + 900 + 900 + 100 + 100 + 100 + 100 = 4000
// Wait — shares must sum to 100:
// Actually: [15,15,15,15,10,10,10,10] = 100. HHI = 4*225 + 4*100 = 1300
// Dominant player scenario: [57,1,1,1,40 others each ~1%]
// Roughly: 57² + many tiny = 3249 + small ≈ 3300+
// CR-4 is the same. HHI reveals the difference.For any system where you care about the concentration of power, not just the number of players, HHI is strictly more informative than CR-N.
When comparing markets with different numbers of participants, raw HHI can be misleading. A market with 3 equal players has an HHI of 3,333 even with perfect competition among those 3. To correct for this, use normalised HHI:
function normaliseHHI(hhi: number, n: number): number {
// Scales HHI to 0 (perfect equal distribution) to 1 (monopoly)
// n = number of participants
const minHHI = 10000 / n; // HHI if all shares were equal
return (hhi - minHHI) / (10000 - minHHI);
}
// 3 equal players: HHI = 3333, normalised = 0.0 (perfectly competitive given 3 players)
// 1 dominant player out of 3: HHI = 9800, normalised ≈ 0.98Normalised HHI is useful when the participant count in your blockchain window varies across time periods or chains, and you want a comparable concentration signal regardless of pool size.
In a PGA system, a rising HHI signals a few specific risks:
A decentralised network should target HHI well below 1,500 in its ordering layer. Persistent readings above 2,500 warrant protocol-level intervention, such as tighter sequencer rotation, ordering randomisation, or fair-ordering guarantees.