Robinhood Chain data: what five weeks of mainnet look like onchain

1. The money on the chain

When we profiled Robinhood Chain's tokenized stocks in early July 2026, the chain's entire financial history fit in a glance: an $18.4 million stablecoin float, 313 stock-token transfers, a tokenized float worth about 36 shares. Five weeks of public mainnet later, the same queries return something much larger. Here is the July snapshot against the August 7 pin, re-measured from the same logs:

A note on method before the first chart. SQD's Portal serves this chain's raw history: headers, transactions, logs, traces. It does not serve reconstructed state, so there is no balanceOf to call and no TVL endpoint to read. Everything financial in this guide is therefore built from arithmetic on events: supplies netted from mints and burns, protocol balances netted from transfers in and out, volumes summed from swap events, and prices taken from the pools themselves, volume-weighted by hour for ETH and by day for each stock token. Every number here is therefore a sum over a fixed list of log events in a fixed block range, which anyone with access to the dataset can recompute.

2. DEX volume, priced by the chain itself

The hardest number to get right here is dollar volume, because swap events carry amounts, not prices. The standard shortcut is an external price feed; this guide does not use one. Instead, the pricing comes from inside the chain. The anchor is the 154 native ETH/USDG and WETH/USDG pools on the Uniswap v4 singleton, which clear $529M of lifetime volume between them; the singleton is one contract and carries the pool id in the first indexed topic, so the whole set is a single cheap filter. It is not the chain's deepest ETH market: 14 Uniswap v3 pools on the same pair carry $3.20B. Deriving the price from those instead moves the hourly figure by 0.04% on average and never by more than 2.4%, so the choice of anchor is not doing any work here. Divide the USDG that flowed through the anchor pools by the ETH that flowed the other way, hour by hour, and you get a volume-weighted ETH price for every hour from 19:00 UTC on July 1 onward; each swap elsewhere is then valued at the ETH price of its own hour, not a whole-day average. A swap against USDG or USDe is worth its dollar amount at face value. Between the two, 96% of all swaps get a dollar value with zero external inputs.

Why hourly, and not one price per day. A daily average is the easy version and it is what the first pass of this guide used, but it charges every trade in a day the same price for ETH. That is a poor fit here: across the five hours of July 1 that carry a price, the chain's own ETH quote ran from $1,910.84 at 19:00 UTC down to $1,617.50 at 23:00, a spread of 18.1%, and because the daily figure is itself volume-weighted it tracks the busiest hours and misprices the rest: it lands within 0.3% of the 20:00 hour that carried the most volume that day, and 15.0% away from 19:00, the first hour in the series. Repricing the whole history hour by hour moved the lifetime total by 0.07%. The largest single-day change is July 1 at 12.3%, and almost none of that is the reprice: the hours before 19:00 that day have no ETH price, so 1,371 ETH of volume the daily method did value drops out, worth 15.0 points, while repricing the five hours that do carry a price adds 2.7 points back. Away from that boundary day no day moves by more than 1.5%. The small total is not an accident either: the daily figure was already volume-weighted, so it was never a flat average of the day's quotes. The case for hourly is the method rather than the size of the correction, since no trade is charged a price from a different part of the day. Finer still would be better, and the exact answer prices every swap at its own execution ratio, but the ETH/USDG pools do not trade in every minute; an hour is the smallest slice where they reliably clear enough to set a price. That floor, not the chain's opening, is what sets the start of the series: the anchor pools first traded on June 24, but across 59 hours before 19:00 UTC on July 1 they cleared only $5,036 between them, and the series begins at the first hour that did more than $5,000 on its own. Inside the series exactly one hour, 03:00 UTC on July 6, saw those pools trade less than $5,000, and it inherits the last price that did clear the bar. Hours before the series starts carry no ETH price at all, so the 60,712 ETH-side swaps in them are left unpriced rather than valued at a stale rate; swaps against a dollar token in those hours still count at face value, $51,976 in total.

The split in the first chart matters as much as the total. Of the $19.42B, only $4.14B moved between assets with a registry identity: the tokenized equities, the two dollar tokens, and ETH. The other $15.28B sits in pairs involving tokens the registry does not list, led by memecoins launched on the chain itself; on the heaviest July days a handful of anonymous WETH pairs cleared $75M to $90M each on a few thousand swaps apiece. On the largest of them, the WETH bought and the WETH sold over the day matched to within a single unit out of 24,456, which is round-tripping rather than accumulation. Both bands are real swap events in canonically-created pools, and separating them by token identity keeps speculative churn from inflating the size of the market, and the market from lending credibility to the churn. It bears on the second chart too, though only in direction: across July this guide's series runs $2.72B above the published one, which is 20% of the non-registry band over the same days rather than all of it. Count every event and July comes out higher; once that activity faded, the two measurements converged.

The raw material is three topic filters, one per pool design. Uniswap v4 concentrates everything in one contract, so its filter is a single address and the pool appears as the first indexed topic; v3 and v2 pools each emit from their own address, mapped back to token pairs through PoolCreated and PairCreated events. This is the v4 sweep; amounts are signed 128-bit integers in the first two data words:

Where that volume happens is lopsided: native and wrapped ETH against USDG carry $3.74B of lifetime volume between them, 19% of everything priced, spread over 9.98 million swaps at a mean of $375 each. Tokenized stocks are real but smaller: NVDA cleared $147.1M of lifetime volume, GME $85.4M, SPCX $65.8M, AAPL $17.3M, and the 96 registry tokens together $391.0M.

The table also shows something the tokenized-equity framing can obscure: this chain grew a memecoin economy within weeks. The largest non-ETH pairs are tokens outside the official registry: CASHCAT cleared $1.10 billion across its pools, VIRTUAL $341 million, PONS $216 million, PIPEDOG $125 million. And buried in the long tail is a warning about canonical addresses: a token calling itself GME, at an address the registry does not list for its GameStop equity token, cleared $65 million on its own, $32 million of it against USDG. On a chain with an official contract registry, supply and volume math is only as good as the address list it starts from.

Method notes. Volume counts each swap once, whichever way it traded, at the dollar value of whichever of its two tokens is a dollar token or ETH, across every pool the canonical factories ever created; pools pairing two unpriced tokens are excluded rather than guessed at (4,931,473 swaps, 4% of the total, sit in pools pairing two tokens this method cannot price). The pool census is itself a finding: 806,101 pools and pairs created since genesis across the three designs, 299,183 of them on the v4 singleton and 63,747 of those against USDG.

3. The dollar tokens: USDG, USDe, and Morpho

A dollar-pegged token's supply is its dollar float, valued at $1 a unit. Mints are transfers out of the zero address and burns are transfers into it, so one filtered query per token, cumulated by day, is a supply curve; as a check on the method, running it back to the July guide's snapshot returns $17,919,400 of USDG, matching what that guide reported from a different query five weeks earlier. For a protocol contract, the same arithmetic gives holdings: sum transfers whose recipient topic is the contract, subtract those whose sender topic is it. Topic filters take arrays and the logs field takes multiple selectors, so a single request streams both directions for five protocol contracts at once:

The composition is the part worth noting. The chain's two dollar tokens are close in size but doing different jobs: $239.6M of the USDe, 99% of every unit on the chain, sits inside Morpho Blue as a lending-market balance, while USDG circulates through trading, transfers, and the 63,747 USDG pools from the previous section. The largest balance among the contracts measured here is not equity-related at all; it is a synthetic-dollar lending market that went from $934,055 on July 1 to $270.9M five weeks later, with the logs giving its exact composition every day in between. The float moves in both directions: over August 6 and the morning of August 7 the USDG supply contracted by $27.4M, burn by burn, all of it visible at the end of the chart.

Two limits, and one double-counting risk. The limits: the Uniswap v4 singleton's own balance is excluded because flash accounting makes its settlement traffic enormous (64,000 to 155,000 transfers per fifty-minute window across three samples), and contracts holding native ETH rather than WETH need traces, not transfer logs. The risk: much of what sits inside Morpho arrived through curator vaults, so a tally that counts the curator's assets and Morpho's assets as separate line items restates the same dollars twice. Netting per contract makes the double count impossible: each unit sits in exactly one balance, because the transfer that moved it went in exactly one direction.

4. The equity ledger: 96 tokens, priced by their own pools

Robinhood's official contract registry lists 96 stock and ETF tokens, from AAOI to ZS, plus canonical WETH and USDG. All 96 show issuance activity in the logs within this guide's window: 13,916 mint and burn events on the equity tokens, against 73,420,659 transfer events moving them around, counted across the 97 tokens on the chain that emit the scaled-UI transfer event (the registry's 96, plus one fund token). Supply is the same arithmetic as the stablecoins, netted per token from its issuance events, with one extra step: ERC-8056 tokens carry a UI multiplier for corporate actions, so raw units are scaled by each token's multiplier at the relevant timestamp (CRWD's is 4.0 since its July 2 split; six others have moved off 1.0).

Shares are quantities; the pools supply the prices. For each token with a USDG pool that cleared at least $10,000 in a day, dividing the USDG that moved through the pool by the shares that moved through it gives a volume-weighted daily price, and 33 of the 96 tokens clear that bar. Marking each token's outstanding shares at its most recent liquid-day price values the whole tokenized-equity float:

The same arithmetic, read per token, shows what holders actually own, token by token. NVDA is the most valuable float and the busiest ledger, 55,300 distinct wallets have touched it. GME has the most shares outstanding, 63,563 of them. And single shares run expensive at the top of the price board: ASML marks at $1,674.07 (its last liquid day was August 4) and SNDK at $1,255.92:

Issuance is not uniform, either. GME alone accounts for 3,729 of the 13,916 issuance events, more than a quarter of all mint and redemption traffic on the registry, against 422 for NVDA and 39 for MSFT: the meme stock's holders cycle in and out of the tokenized wrapper at a pace nothing else approaches.

One chart is worth separating out, because it answers a common question about tokenized stocks: what price do the onchain markets actually clear at? Here is NVDA priced purely by its own pools, one volume-weighted point per day, no oracle anywhere in the pipeline:

The issuance sweep is one filtered query, the same shape as a stablecoin supply query but on the scaled-transfer signature (its topic0 is TransferWithScaledUI). Net supply needs both directions, so the request carries three selectors: mints pin topic1 to the zero address, and redemptions pin topic2 to the zero address or to 0xdEaD…dEaD. Mints alone give gross issuance, not the float:

Two details from the ledger worth knowing. The equity tokens never stop. Bucket every wallet-to-wallet move through August 5 by weekday and hour of the New York day and all 168 buckets are busy: the quietest of them, 6 AM on Tuesdays, still holds 135,725 of the 71.2 million moves, so the tokens keep changing hands through nights and weekends when the US market is closed. And the burn conventions matter: supply math must treat transfers to 0xdEaD…dEaD as retirements alongside true burns to the zero address. Both routes appear here, though the dead-address one is rare: two events in the whole window, and both on a fund token rather than one of the 96 registry equities. A pipeline that nets only the zero address already misses those two retirements and nets that fund token 23% too high, and it will miss more the first time a registry equity uses the address.

5. Corporate actions went routine

The ERC-8056 guide read the first four multiplier updates ever recorded, all on one T-bill fund, and called the pattern: corporate actions as scheduled log events. Five weeks on, the same one-topic query returns 12 events across 7 contracts, and the pattern is now routine market plumbing; the newest, an ASML adjustment, landed on August 6 at 15:01 UTC with its effective time nine minutes later in the payload:

Three things stand out. First, the CRWD token's multiplier quadrupled, announced twice on July 2 and effective at 13:30 UTC, which is 9:30 AM in New York: a 4-for-1 adjustment landing exactly at the market open, and the first split-sized action on one of the 96 registry equities (the WEEK fund had already doubled at the June 29 open, three days earlier). Second, the supply ledger shows the split took effect against an almost empty book: CRWD's first mint came four days after its multiplier moved, so the corporate-action machinery was live before the float was. Third, the small adjustments (MU, ORCL, DELL, SGOV, ASML, each a fraction of a percent) land in a fixed slot, four of the five taking effect at exactly 15:10 UTC, and read like income distributions paid by scaling positions rather than sending cash; SGOV's multiplier stepped up +0.096% in a single move on July 8 and has not moved since. Every one was announced before it took effect, with the effective timestamp in the event payload.

This changes the arithmetic for anyone summing stock-token amounts. In late June every equity token's multiplier read exactly 1.0 and raw sums were safe; today seven tokens have moved theirs, and CRWD's raw amounts understate effective shares by a factor of four: its raw net supply of 0.365 tokens is 1.459 effective shares. Scale raw sums by each token's multiplier at the relevant timestamp, or index the uiValue field of TransferWithScaledUI, where the contract has already applied it. The equity ledger in section 4 does the former.

6. Block production: one every 100ms

Everything above runs on a chain that produces a block every 100 milliseconds, around the clock. That cadence, and the transaction load it carries, is measured from every one of the 30,166,661 block headers in the pinned window, fetched in a single includeAllBlocks stream:

7. Reproduce it: one Pipes SDK script

The curls above show the raw protocol; production pipelines use the Pipes SDK, which handles decoding, cursors, and typed events. This script reproduces the guide's headline stablecoin figure, the USDG float, from genesis. It is the exact file we ran, unedited:

It walks all 30.2 million blocks in a little over twelve minutes on a laptop (the run behind this guide logged 735 seconds end to end, an average of about 41,000 blocks per second), because the two indexed-parameter filters travel to the Portal and only the few thousand matching events come back. The tail of its output, verbatim:

The final line is the guide's USDG float to the cent, from an independent implementation. One real gotcha, which the comment in the script encodes: the decoder matches logs by event signature, and both filters share the Transfer signature. Put the two filters in a single decoder and the SDK logs a duplicate-topics error while the second entry silently misses events; split them into two outputs, as here, and each output receives the merged mint-and-burn stream. Classify by the decoded from field instead of trusting the output name, or the mints and burns cancel to zero. We know because our drafts hit both failure modes before this version.

Every other number in this guide is the same pattern with a different filter. The full inventory:

All nine run against one endpoint. Every query in this guide is the same POST against portal.sqd.dev/datasets/robinhood-mainnet/stream with a different body, served from genesis and streaming at the head, in the standard evm shape that any EVM pipeline already uses. The testnet (chain ID 46630) is served the same way and listed alongside mainnet on the Robinhood Chain page.

8. Indexing notes at 30 million blocks

Lessons from building the numbers above, for anyone pointing an indexer at this chain:

• Filter before you stream. The single TransferWithScaledUI topic family alone is 73.4 million events, about 35 GB of raw JSON as the Portal streams it; the full log stream, on a chain now clearing 14 million transactions a day, is far larger. Put the address list or topic filter in the request, not in your client. Downloading everything and filtering client-side worked in July; today it means moving tens of gigabytes for a single topic.
• Aggregate in the stream when raw events do not fit. The volume series in section 2 covers 110,863,045 swap events without storing one of them: the sweep folds each page into per-hour, per-pool sums as it streams. Jobs that need the individual events keep them; jobs that only need totals usually should not.
• Model the multiplier from day one. With seven tokens off a 1.0 multiplier inside this guide's pinned window and one of them at 4.0, raw-amount pipelines are silently wrong in a way they were not in July. The fix is one state table keyed on UIMultiplierUpdated, described in the ERC-8056 guide.
• Balances are arithmetic; prices can be too. Netting transfers reproduces holdings to the wei with no state access. Valuation usually stops there, but on a chain whose only observable markets are its own pools, volume-weighted prices derived from the swaps themselves price ETH and 33 equities without any feed. The discipline is a liquidity floor at each timescale: a stock token is priced only from a pool-day that cleared $10,000, ETH only from an hour in which its benchmark pools cleared $5,000, and thinner periods inherit the last price that qualified.
• Mind the burn addresses. Supply math on this chain must treat transfers to 0xdEaD…dEaD as retirements alongside true burns to the zero address. Both appear in the scaled-transfer stream, so a query that filters for only one of them nets the wrong supply.
• RPC log pagination does not survive this volume. An eth_getLogs loop capped at a few thousand logs per response needs hundreds of round trips per day of stock-token activity alone; the caps and failure modes are the subject of our eth_getLogs guide. A streaming endpoint with server-side filters returns the same data in one request.

9. Robinhood Chain data with SQD

Every number in this guide came out of the robinhood-mainnet dataset: headers for the cadence, topic filters for supplies and corporate actions, one address for the whole v4 DEX, swap amounts for every price. The dataset serves the chain from genesis and keeps streaming at the head, using the standard evm query type, so pipelines built for any EVM chain (with the Pipes SDK or the Squid SDK) run against Robinhood Chain unchanged.

Robinhood Chain is currently a private SQD dataset, provisioned with an API key rather than through the free public Portal, for both mainnet and testnet. Access is by request: contact the team for a key. Dataset details are on the Robinhood Chain page.