Stock-token research. Separate from the memecoin bot and its planned holder rewards.
Robinhood Chain · 4663 · hourly
It works the spread between pools — memecoins today, tokenized stocks next door.
Every block the bot moved a token in, and every leg of that hour’s biggest transaction — read off the chain by this page, in your browser. No wallet, and nothing here asks the bot to do anything.
The hour above — the blocks the bot acted in, and every leg of that one transaction — is read from its Transfer logs and that transaction’s own receipt. MEV NOW, further down, claims the share you already earned in an hour like this one. The claim caused none of it: the hour was over before the root existed.
The hour
Profit isn't modelled or quoted. It's the reserve balance now minus the reserve balance written into the last epoch's log, and the explorer will show you both sides of that subtraction. A trade the bot closed and a creator fee from someone else's trade both land in the same wallet, so that one subtraction counts either without needing to tell them apart. That second stream turns on once $MEVHOOD trades on its own launchpad: 0.7% of every trade there lands in the same wallet, on top of whatever the bot made.
The holders' half is not sent anywhere. It is funded into the distributor under one Merkle root for that hour, and each wallet over the threshold spends a proof against it whenever it likes — that is what MEV NOW does. Whatever nobody takes inside the window goes back to the reserve.
The stock board below is a field the bot does not work yet. It is here because you can check it yourself, the same way you check everything else on this page. Chainlink publishes the exchange price for each stock on-chain, the pool sets its own, and the gap between the two is what's worth watching: oracle from the chain RPC, pool from Dexscreener.
| Ticker | Oracle | Pool | Premium | Liquidity | 24H Vol | Oracle age | |
|---|---|---|---|---|---|---|---|
| reading the field… | |||||||
Dead pools (under $5k liquidity or a gap over 50 %) are listed without a premium. A pool with zero 24h volume is asleep — listed without a premium even if its liquidity looks real. An oracle older than six hours means the exchange is closed — that is when the gap grows.
State
Your browser talks to the public RPC directly — no API in between, so a number that's wrong here is wrong on the explorer too. The reserve is re-read every five seconds, the epoch logs every minute.
Three-tenths of each hour's income never leaves this wallet — that's the bot's bid for next hour, and the only reason one hour can get bigger than the last. The rest goes out: half behind a root holders claim from, a fifth spent buying $MEVHOOD back to burn.
Legs the bot moved through each token in this window, not what it made. Profit only shows up once there’s an epoch log to read it from.
Paired with HOOD. Robin Hood's cut, on Robinhood's chain, priced in Robinhood's stock. HOODon / USDG pool ↗
HOOD here is Ondo's token of Robinhood Markets stock; it has no Chainlink feed, so it never appears on the field.
Bots take the spread. This one gives it back.
Mechanics
Nothing here asks for an approval and nothing here holds your tokens. The only transaction you ever send is the claim itself, and it moves money in one direction: out of the distributor, into your wallet.
Pool against pool: the same memecoin prices against USDG in one venue and against WETH in another, and the two quotes drift from what the USDG/WETH rate says they should. The bot trades the triangle back into line.
Backrunning a swap: a large buy or sell knocks a pool off its own price for a block or two, and the bot trades into that window right after it lands.
Working thin books directly: PONS, CASHCAT and the smaller names in the bot's inventory don't need a second venue to drift — a single pool can sit lopsided on its own, and that's spread enough.
Reserve balance now, minus the reserve balance recorded in the previous epoch's log. Two numbers, one operation, both visible on Blockscout. Nothing about strategy or fill quality enters the calculation.
Half the hour's income becomes the pool, three-tenths stays in the reserve, and a fifth buys $MEVHOOD on the open market and sends it to the dead address — — basis points, always summing to 10000. The pool is divided pro-rata by snapshot balance among the wallets over the threshold, so a wallet holding 2% of the eligible supply gets 2% of that hour's pool and nothing more.
The operator publishes one Merkle root per hour and funds the distributor with exactly the pool it covers. A wallet holding at least — at the snapshot block is a leaf in that tree, and MEV NOW spends its proof against the root. One claim per wallet per epoch, enforced by the contract, not by the page.
An hour without profit closes as a zero epoch with an empty root. It shows up on the board like every other hour. Anything nobody claims within — goes back to the reserve and becomes the bot's working capital again.
Board
The last 24 epochs, each one an Epoch log pulled with eth_getLogs walking back from the head. PUBLISHED is what that hour's root covers; CLAIMED is what holders have taken out of it, read from epochs(id) on the contract rather than from the log, so the two numbers are independent. WINDOW counts down to the sweep that returns the rest to the reserve. Ticker touches are transaction counts, not per-ticker profit.
| Epoch | Profit | Published | Claimed | Burned | Holders | Reserve after | Window | Tx |
|---|---|---|---|---|---|---|---|---|
| before the first epoch | ||||||||
There is no sign-up step and no list to get onto. Connect a wallet and the page reads three things off the chain — your $MEVHOOD balance, whether you have already claimed this epoch, and the amount and proof the operator published for you. If all three line up, the button is live.
A wallet that cannot receive ETH reverts its own claim: the transaction fails, the epoch keeps the money, and nothing is marked as taken.
Lookup
Paste an address and the page replays its Claimed logs from the deploy block — every epoch that wallet has taken its share out of, and the transaction that did it. It doesn't have to be yours, and nothing is stored.
| Epoch | Claimed | Tx |
|---|---|---|
| nothing searched yet | ||
The full documentation lives at mevhood.xyz/docs: ten pages on the contract, the operator and what can go wrong, written so every number is either a protocol rule or a measurement with a date on it. Start with the hour, or go straight to MEV NOW, what can go wrong or the full FAQ.
— of those questions are answered here, because they are the ones asked most. The rest are over there rather than copied into both places.
One hour, closed at :00 UTC by the operator script. Income for that hour is the reserve's balance right now minus the balance recorded in the log of the epoch before it — one subtraction, checkable on the explorer, that doesn't care whether the money came from the bot's trades or from $MEVHOOD's own creator fee landing in the same wallet. Half is funded into the distributor under that hour's Merkle root, three-tenths stays as working capital for the next hour, and a fifth buys $MEVHOOD back and burns it.
An hour with nothing to distribute still closes, just with an empty root, nothing funded and nothing burned, and it still shows up on the board like any other row. The whole sequence, in the order the operator performs it, is the hour.
It does one thing: it calls claim() on the distributor with your epoch id, your amount and your proof, and the contract sends you that amount of ETH. That is a withdrawal of a share that was already earned, already computed and already funded before you pressed anything.
It does not start a trade, place an order, or make the bot do anything. The bot's hour is over by the time the root exists. The route the page draws while your transaction is in flight is the hour that already happened, rebuilt from the executor's own Transfer logs. Nothing about it was caused by the button. The threshold, the seven-day window and every revert a claim can hit are on MEV NOW.
Everything here comes straight from your browser, with no API reshaping it in between: the reserve balance from eth_getBalance on the public RPC at rpc.mainnet.chain.robinhood.com (and rpc.ordofi.network whenever that one will not answer), the epoch history from eth_getLogs against the distributor's Epoch event, every claim from its Claimed event, what each epoch still owes from epochs(id), oracle prices from latestRoundData() on the Chainlink feeds, and pool prices from Dexscreener. Pull up Blockscout, paste in the distributor address, and cross-check whatever looks off. It should match exactly, because both pages are reading the same chain.
The full list of what a reader can verify without trusting the operator — and the one thing that cannot be verified that way — is on the operator page.
Four addresses sit behind everything on this page. They come straight from the constants at the top of the script, so what's below can't drift from what's actually deployed. Every other address the site reads, with who created it and what trusting it exposes you to, is on the addresses page.