Verderer

Independent watchtower on Robinhood Chain. Verified state, faster access.

[Verderer @VerdererNode]

Three independent nodes run our verification separately.

All three have to land on identical output before anything gets signed.

That part gets said often enough to sound routine.

Here's the part that doesn't: Robinhood, the operator whose state we're checking, controls none of those three nodes, and gets no vote on its own case.

Sounds obvious, until you look at how most "independent" verification actually gets built.

Plenty of setups let the entity being checked run one of the checking nodes too, quietly, because standing up infrastructure is expensive and nobody's watching closely enough to ask who operates what.

We separated it on purpose, and the split is checkable.

Node operators, infrastructure providers, and the contract addresses doing the signing all sit in the open.

Not because we expect anyone to audit them line by line, but because the option has to exist.

[Verderer @VerdererNode]

Launch radar doesn't wait for a deploy to confirm.

It fires the moment a createPair call shows in the feed, before that call has executed anywhere, which is the only version of early that still means anything.

[Verderer @VerdererNode]

Locking tokens to unlock a feed tier sounds like every other staking mechanism until you check what happens on exit: you get the full amount back, whenever you ask.

We're not selling a token that appreciates because people are trapped in it.

We're renting access, and the deposit happens to be denominated in the token instead of cash.

Because that's the mechanism that lets the same tier also sell for a flat monthly fee at identical limits.

If holding the token isn't required to use the product, staking has to behave like a deposit, not a bet.

[Verderer @VerdererNode]

Testing the escape hatch isn't free.

Each monthly drill costs real ETH, gas on Ethereum to submit through the delayed inbox, gas again when inclusion lands roughly a day later.

We could skip it.

Nobody would notice for months, maybe longer, since an untested emergency exit looks identical to a working one until the day it isn't.

We run it anyway and publish the invoice alongside the transaction hashes.

Not because the number is impressive, it's small, but because a claim with a receipt attached is a different kind of claim than one without.

[Verderer @VerdererNode]

"Is this chain safe" usually gets asked of the operator, who answers yes, being the operator.

Better question, askable of raw data: has any state this chain posted to Ethereum ever failed independent recomputation?

Today the answer is no, across 399 assertions, verifiable without trusting us or them.

The difference between those two questions is the entire reason this project exists.

[Verderer @VerdererNode]

Sequencer lives somewhere physical.

Every millisecond of distance from that somewhere is latency no software removes.

Our reference client in Chicago sees the feed 1,802ms before the public RPC catches up, median across 5,000 samples.

From Frankfurt or Singapore those numbers change, and nobody publishes the map.

We're building it: same measurement, multiple regions, claimed versus observed.

Speed on this chain has a geography, and it deserves cartography.

[Verderer @VerdererNode]

Plasma died partly because it asked users to run watchtowers themselves - everyone responsible for monitoring their own exit, which meant in practice nobody monitored anything.

Rollups fixed the data problem but kept the assumption: someone, somewhere, is watching.

The role got professionalized on paper and left unfilled in production on chain after chain.

Every scaling design for eight years has quietly depended on a job almost nobody does.

[Verderer @VerdererNode]

Update: building the challenge we can't send.

/limits already says it plainly - we can prove a discrepancy, we can't dispute one. Validator list is closed, two addresses, both the operator's.

So we're building the dispute machinery anyway, all of it. Assemble a real challenge transaction against a discrepancy, sign it, publish it, and show the chain rejecting it for one reason: not on the list.

Two things at once. We become the only party ready to dispute the day that list opens. And "nobody outside can challenge this chain" stops being a claim and becomes a transaction anyone can read.

Most projects write that sentence. We'd rather show the receipt.

https://t.co/cYE7resQik

[Verderer @VerdererNode]

Since EIP-4844, rollups post transaction data in blobs - cheap, temporary storage on Ethereum that expires after roughly 18 days.

Our verifier rebuilds chain state from those blobs before they're gone.

Miss the window and reconstruction gets harder for everyone who wasn't archiving.

Part of running a watchtower nobody mentions: you're also the librarian.

Archive tier exists because we already had to keep everything anyway.

[Verderer @VerdererNode]

Chains with priority fees hold auctions: pay more, get sequenced earlier.
This chain doesn't - eth_maxPriorityFeePerGas returns zero, ordering is strictly first-come.

That doesn't make racing disappear. It moves the race from wallets to wires.

When you can't buy position, you buy proximity, and the contest becomes network engineering instead of gas bidding.

Cleaner in one way, more opaque in another: a gas auction is public, a latency race is invisible unless somebody measures and publishes it.

We measure and publish it.

[Verderer @VerdererNode]

Every trade on this chain executes against a soft confirmation - the sequencer's word that your transaction landed, given in milliseconds, backed by nothing yet.

Ethereum finds out hours later, when the batch posts. Finality arrives days after that.

Traders live entirely inside that first layer.

It's the fastest and least guaranteed data on the chain, which is exactly why measuring it, timing it, and comparing it against what eventually settles is a full-time job. Ours.

[Verderer @VerdererNode]

L2BEAT sorts rollups into stages. Stage 0 means training wheels: operator can do most things, users trust process. Stage 2 means the protocol defends itself.

Moving up requires, among other things, permissionless validation - anyone able to challenge a bad state.

Robinhood Chain sits at Stage 0 partly because its validator list holds two addresses.

Every piece of machinery we build, verifier, dispute transaction, bond reserve, is the checklist for that climb, built by an outsider before being asked.

[Verderer @VerdererNode]

Update: chain probing becomes a permanent process.

Found today, by accident, in ten minutes: sequencer silently ignores blockNumberMax while honoring the other three conditions.

Nobody documents how a chain actually behaves, only how it's supposed to. Which methods work, which conditions get honored, real inclusion order, latency by geography, what breaks under load.

We're probing continuously now and publishing it as a living spec - claimed behavior next to measured.

Only asset here nobody can copy. It accumulates by running.

https://t.co/gWevBJFYFp

[Verderer @VerdererNode]

Every assertion we check lands as one of four things: affirmed, denied, pending, or unreachable. Unreachable means our own node fell behind, not the chain. We publish that one too.

[Verderer @VerdererNode]

Nothing to install and nothing to buy.
Ledger at https://t.co/bGXoM5Q98A is open to everyone, showing every assertion we've checked, its verdict, and how long verification took.

Public tier gives you a working feed with 2,000ms delay and 5 reads per second.

That covers most people, whoever needs feed without delay moves up, and the rest of you never have to.

[Verderer @VerdererNode]

Update: we compare both statements the sequencer makes.

Every block gets announced twice. Once on the feed in real time, which is what traders act on instantly. Once in a batch posted to Ethereum, hours later, which is what actually settles.

Same block, two separate claims, and until now nobody was checking whether they say the same thing.

We hold both and compare them. If a block that traders acted on ever differs from the block that reaches Ethereum, that's the discrepancy that matters most, and it shows up in the ledger.

https://t.co/uQoHQxOY7f

[Verderer @VerdererNode]

@onlyzhynx Thanks, appreciate it. Integrations are exactly what we're pushing right now - API's open, docs are up, and we just published three reference clients so anyone building can lift working sample code.

Actively looking for partnerships with bots and protocols on 4663. DMs open.

[Verderer @VerdererNode]

Update: three reference clients are live.

They're ours, and the site says so. They prove the pipeline works end to end and give external bots working sample code. Not demand, not counted as users.

Separate machine in Chicago, public API over network, no database access. Own wallets, 250,000 VERD staked each, visible on-chain.

feed-watcher - measures what a client sees, not what our clock says. Polls the operator's RPC until it recognizes a block from our feed, network path included. Median 1,802ms, p90 2,758ms, 5,000 samples, zero cases where public RPC won.

radar-sniper - keeps intent and confirmation separate, lead measured against block time. Unconfirmed signals stay in the denominator. 347 observations.

conditional-mm - every second bundle is built to fail on purpose. State moved, bundle drops before inclusion at zero gas instead of reverting on-chain at full price.

https://t.co/GfBYcZca5I

[Verderer @VerdererNode]

Fair question, and the answer isn't a promise - it's on the timeline.

Two proof videos, both unedited, no cuts:

https://t.co/odRdhY4GY5

https://t.co/eOIgLezySy

Hardware on camera, config proven live against Ethereum, our block hash compared against an independent operator, and a signature broken on purpose so the contract rejects it on our own screen.

Everything else is queryable without us: contracts verified on Blockscout, verdicts signed to two chains, ledger open at https://t.co/bGXoM5PBj2

Run the checks yourself, get the same answers.

[Verderer @VerdererNode]

Robinhood Chain reports its state to Ethereum every ~32 minutes. Almost nobody checks whether that report is true.

We ran the check live, in a terminal, no editing between steps.

Step 0: asked Ethereum if Robinhood's core contract lives there. Yes. Asked Arbitrum the same. No. Built with Arbitrum's stack, answers to Ethereum.

Step 1: a full day of our checks compresses into one fingerprint, written on-chain. Pulled it back: 45 checks that day, zero problems.

Step 2: same fingerprint, written twice, once on Robinhood Chain and once on Ethereum, somewhere Robinhood can't touch. Read both. Identical.

Step 3: one verification, isolated. What Robinhood claimed next to what our machine worked out independently. They match.

Step 4: handed our signature to the contract and asked two questions, did they sign this, was it part of that day. Yes, and yes.

Step 5: changed one character in the signature on purpose. Contract's answer: that's not them. Without this step, everything above is just text on a screen.

Step 6: asked how many days without a problem. The chain counted it from its own records, not from us.

Server hands over raw data, nothing else. Every yes or no comes from a public chain anyone can query directly. Run it yourself, get the same answers.

[Verderer @VerdererNode]

Wrote about what happens when verification and speed run on the same machine.

Told through one desk, one trading day, one pool that landed in the feed before it existed anywhere else. https://t.co/EwREYeJavA