A thirty-second market on Robinhood Chain. Every fee it earns buys real stock for $ROLLA holders.
npm start) for the real thing, where the seed never leaves the backend until settlement.Provide ETH liquidity to back the game and earn the house edge, or deposit ETH to play for real. Balances are held by an on-chain vault you can verify; withdraw anytime. Unaudited beta — only deposit what you can afford to lose.
RollaCoasta is a leveraged trading game played on synthetic tickers that live for thirty seconds. Every fee the game and the token generate is used to buy real equities, which go to $ROLLA holders. All of it.
A ticker lists at 100.00 and has half a minute to live. You go long or short at up to 100×, and you get out before it gets you — or you don’t. Then it delists and a new one lists two seconds later.
The price is not a random number generator with a chart drawn on top. It is driven by the order flow of the people trading it. Longs push it up, shorts push it down, liquidations shove it further, and funding drags it back. Squeezes and cascades are not animations — they are what the equation does when a crowd leans one way. That is what makes the tape worth reading, and it is what makes reading it an actual edge.
Underneath the game is a single, unusually short pipe. Fees go in one end, tokenised stock comes out the other, and $ROLLA holders own it. There is no cut taken along the way.
$GUH is not a company. It is a price, generated live, that exists for thirty seconds and then stops existing.
You enter at any moment. You close whenever you want, or the clock closes you at 0:00, or the price reaches your liquidation level and closes you the hard way. There is no overnight, no thesis, no waiting for earnings. There is a bar under the chart that says your live P&L, and it is also the button that gets you out.
The name is not decoration. It is the sound a Robinhood trader made in 2019 on discovering what a box spread does, and it is the only appropriate name for the first instrument in this series.
It launches alone, deliberately: one price path to tune, one order book, and everybody concentrated in the same thirty seconds. A thin market split six ways is six dead markets. The rest of the series unlocks later — see Ride 05.
Most games like this roll dice and draw the result. RollaCoasta does something else: the order flow is an input to the price. Every open position pushes the price in its own direction. The crowd is not betting on the chart. The crowd is the chart.
Each instrument runs this same engine with its own parameters. Below is the general form; $GUH’s specific numbers are in Ride 04. This is the exact equation running in the chart above.
| Term | Name | What it does to the chart |
|---|---|---|
| μ(s)·dt | Regime drift | A hidden state machine flips between calm, pump, dump and euphoria on its own clock. You never see which regime you are in — you infer it, late, from the tape. |
| σ(s)·dW | Fair noise | The provably-fair component. Seeded and committed before the round opens (Ride 08). This is the only part an operator could theoretically rig, which is exactly why it is the part that gets published. |
| λ·sign(I)·|I/L|^1.4 | Flow impact | Net imbalance moves the price. The 1.4 exponent makes impact superlinear, so pushing the price is possible but gets brutally expensive — whales can try, and the attempt taxes them in public. |
| κ±·J·dN± | Jumps | Poisson wicks. Rare, violent, and asymmetric — this is where an instrument gets its personality. |
| −φ·F(I/L) | Funding drag | When the crowd stacks one way, funding pulls against it. Without this, a one-sided round walks the price to infinity and the game ends. |
Because liquidations force positions closed, and closing a position changes I, liquidations feed the same term that caused them. Nobody scripts a squeeze. The squeeze is what the equation does on its own.
This only works peer-to-peer. Traders are counterparty to each other. If the house took the other side of a price it also influences, flow-driven pricing would be a printing press pointed at the house. It is not, and it must never be.
Every order arriving inside a 100 ms window fills at the same price. Because flow moves price, unbatched fills would hand a decisive edge to whoever sits closest to the matching engine, and the game would become a latency auction no human can enter. Batching kills that outright — and it is why the agent API in Ride 07 is a fair fight.
Pool depth L is the denominator of the impact term, so it is not a yield sticker — it sets how violent the chart is. A thin pool means every order swings it. A deep pool smooths it out.
Which creates a trap worth naming: liquidity providers want a calm chart, traders want a violent one, and growing the pool would quietly kill the game. So as L grows, λ scales down and σ scales up to hold total volatility constant. The chart stays exactly as wild, while LP risk shifts from directional and ruinous to symmetric and survivable.
$GUH’s defining parameter choice is jump asymmetry: downside jumps are 2.6× larger than upside jumps and arrive more than twice as often, offset by a positive baseline drift.
The result is a chart that climbs in small, reassuring increments and then falls off a cliff without warning. It rewards patience and then punishes it. It is a machine for manufacturing the exact noise the ticker is named after.
| Parameter | Value | Notes |
|---|---|---|
| σ — calm | 0.9 %/√s | Baseline noise floor. |
| σ — feral | 3.4 %/√s | Reached when open interest overwhelms pool depth. |
| λ — impact | 0.85 | How hard a unit of imbalance pushes. |
| Impact exponent | 1.4 | Superlinear. The anti-whale. |
| κ⁺ — up jump | 1.0× | Upside wick scale — the baseline. |
| κ⁻ — down jump | 2.6× | The signature. Down jumps hit 2.6× harder. |
| dN⁺ rate | 0.05 /s | Roughly 1.5 upside wicks per round. |
| dN⁻ rate | 0.11 /s | Roughly 3.3 downside wicks per round. |
| φ — funding | 0.30 | Mild. $GUH lets the crowd get away with it for a while. |
| Regimes | 4 | Markov switching, mean dwell 6.5 s. |
| Round length | 30 s | Plus 2 s settlement. |
The rest of the series unlocks at vault milestones — which means the fees in Ride 06 are not only buying stock, they are buying the next instrument for everyone in the room. And each one changes a different term of the equation, so each is a genuinely different trading problem, not a reskin.
| Ticker | Status | Formula change | How it plays |
|---|---|---|---|
| $GUH | ● OPEN | κ⁻ = 2.6 κ⁺ | Grinds up, knifes down. |
| $COPIUM | ● $250K vault | φ = 0.90 | Funding cranked to violent. It always comes back — until the round ends first. |
| $TENDIES | ● $1M vault | μeuphoria ×3 | Fat upside tails and long air pockets. Vertical or nothing. |
| $WIFESBF | ● $2.5M vault | μ < 0, κ⁺ = 2.6 κ⁻ | $GUH inverted. Bleeds down all round, then rips your shorts off. |
| $0DTE | ● $5M vault | σ ∝ 1/(T−t) | Volatility explodes as the clock runs out. The last five seconds are the game. |
| $MARGIN.CALL | ● $10M vault | λ × 2 | The crowd moves it twice as hard. Pure reflexivity, no shelter. |
Every instrument publishes a disclosure page exactly like this one before it opens — full parameter set, committed seeds, no exceptions. An instrument whose numbers are not public does not list.
A market charges 0.25% of traded notional — 0.35% with the protocol layer on — and it is split per market, so every party earns only on the volume they actually serve.
The baseline 0.25% pays the people doing the work: 0.20% to liquidity providers (of the market they back) and 0.05% to the oracle-node runners (of the market they run the oracle for). Turning the protocol layer on adds two more 0.05% slices — one buys real stock for $ROLLA holders, one buys back and burns $ROLLA. Team: 0%. Nothing is discretionary; every slice has an address.
| Slice | Rate | Destination | When |
|---|---|---|---|
| Liquidity providers | 0.20% | The market's LP pool — pro rata by shares | always |
| Oracle nodes | 0.05% | The runners of that market's oracle — pro rata | always |
| Stock → holders | 0.05% | Buys real equities for $ROLLA holders | protocol on |
| $ROLLA buyback & burn | 0.05% | Buys $ROLLA on-market and burns it | protocol on |
| Team | 0% | No allocation | — |
| Total | 0.25% / 0.35% | off / on | — |
Incentives are local. A liquidity provider earns the 0.20% only on the market they actually back, and an oracle-node runner earns the 0.05% only on the market they actually run the oracle for — so capital and honest data flow to where they are needed, market by market, instead of a single pooled fee everyone splits regardless of contribution.
Liquidity providers now earn two ways: this fee slice and the house edge — being the counterparty to net imbalance, keeping the difference when the crowd leans wrong. Depositing into a market's pool is both renting its fee stream and taking a position against its consensus.
The protocol layer (the two 0.05% slices) is a toggle: off, the fee is a lean 0.25% that goes entirely to the people running the market; on, it adds the flywheel that buys stock for holders and burns $ROLLA. Either way, the team takes nothing.
The vault accumulates fees continuously and executes on a schedule into tokenised equities. Every purchase is announced on the tape mid-round — the chart dims, a ticker tape crosses the screen, and the whole park watches the buy land. Losing money is one thing. Watching it become someone’s share of NVDA in real time is a different product.
The trader made money and still paid into the vault. That is the point: winners fund it too. A player’s headline profile stat is not their P&L, it is lifetime fees contributed — which turns the losing half of the park from marks into patrons, and happens to be true.
RollaCoasta is open to automated traders on the same terms as humans: same batched fills, same fee schedule, same tape. Agents are not tolerated, they are wanted — they are the reason there is a market at four in the morning, and they pay the same 0.10% into the same vault.
1. Set up a wallet, securely. Auth is a signed message (SIWE) — it proves you own an address and authorises no transaction. Still, use a dedicated bot key with only what you're willing to trade, never your main wallet. Generate one and keep it in an env var, never in code or git:
2. Run the reference bot in one command. It signs in, streams the live tape, and trades the order-flow imbalance — the whole thing is ~30 lines (examples/agent.mjs). No SDK.
Under the hood — sign in (copy-paste, tested live). Nonce → sign the returned message → get a session token:
Trade over the WebSocket (same host, wss://). Authenticate with the token, then open/close — fills batch every 100ms. Public reads are plain HTTP.
Auto-compound & farm. Trade the reflex, then recycle winnings into the house side so profits earn the edge as LP yield. Farming is on-chain (the FarmPool contract), so you compound with a plain addLiquidity tx:
Run an entropy + verifier node — earn governance points. Anyone can help decentralise the randomness and independently police the tape in one command. The node posts entropy that gets folded into each round's seed (it can only add unpredictability), and re-hashes every revealed seed against its commitment; each accepted contribution and verified round earns governance points.
The full reference bot is in the repo (examples/agent.mjs) and this whole flow is tested against the live endpoint. Every round is replayable: pull /v1/round/:id for the revealed seed + order log and re-run the open-source engine to check the tape yourself.
Machine and human leaderboards are kept separate, permanently. Agents will outperform people at a thirty-second reflexive market, and ranking them together would tell every human in the park to leave. Two divisions, two boards, one order book.
Before each round opens, the server publishes hash(serverSeed) — that is the Commit line in the panel beside the chart, and it is fixed before you can place a single order. After settlement it reveals serverSeed. The noise and jump terms — σ(s)·dW and κ±·J·dN± — are a pure function of (serverSeed, clientSeed, nonce), so anyone can replay the round and confirm the dice were cast before the first order arrived.
The Verify button does exactly that, in your own browser: it takes the revealed seed, re-computes SHA-256, and checks it against the commit you were shown thirty seconds earlier. If they ever disagree, the round was tampered with and you should never trade here again.
The flow term cannot be committed in advance, because it does not exist in advance. It is produced by the people trading, in the moment, and it is unknown to the operator for exactly as long as it is unknown to you. That is not a gap in the fairness proof — it is the product.
$GUH is the first market, not the only shape. The same settlement stack now runs oracle markets too — a 30-second (or any-duration) market on a real asset whose settlement price is a proven aggregation of many feeds, not a trusted oracle.
Two market kinds share one verifier and one settlement, behind a single 5-slot proof layout [init, final, commit, id, dataHash]:
final = AGG(the committed set); a wrong number has no valid proof.A market is kind × duration × oracle × payout. Register a spec (discoverable at /v1/markets); each oracle names its own sources/APIs at creation ({api, symbol}), so a custom oracle can pull whatever venues it needs. The aggregation is configurable per market. Full guide + template: ORACLE-SDK.md ↗.
Anyone can help run a market's oracle. A market has a set of nodes (e.g. 5 nodes, quorum 3): each independently pulls the sources, computes the same integer aggregation, and signs the observationsHash. On-chain, OracleFeed verifies a quorum of node signatures before the hash is committed — no single node can move the number. Node runners earn the 0.05% oracle-fee slice of the market they serve. One line to start:
A full STARK verify is ~44M gas — over some chains' per-transaction limit (Robinhood testnet caps a tx near 32M). So the verifier is chunked: begin → step → finish carries the constraint accumulator across three transactions (~24M / 16M / 18M), each under the cap, reproducing the monolithic verify exactly. On testnet the full trustless loop runs end to end: feed → 5-node quorum → observationsHash → STARK proof (3 chunked txs) → disprove slashes a lie, and an honest round finalizes. Addresses below; details in DEPLOYMENTS.md ↗.
Three contracts on Robinhood Chain do the real work. All are source-verified — click any address to read them.
RollaInstruments is an ERC-721 where each token’s genome is the full parameter set of the price engine (drift, volatility, jump sizes, funding, pool depth), packed into one 256-bit number. It borrows the CryptoKitties idea — on-chain genes, breeding, cooldowns — but the genes aren’t cosmetic: they are the market. Breed two instruments and each gene is inherited from one parent with a small mutation, clamped to a safe envelope, producing a genuinely new market. Children are born as Eggs and only go live after an off-chain simulation gate replays the genome through thousands of headless rounds and proves it’s playable — a lying validator is caught because the gate is deterministic and reproducible. Token #0 is $GUH, the genesis genome every instrument descends from.
RollaFarmPoolETH holds the real ETH behind the game. Liquidity providers deposit ETH and receive shares in house equity; players deposit a withdrawable ETH balance to play. When players lose, house equity rises and every share is worth more; when they win, it falls. LPs aren’t renting a fee stream — they are the counterparty. A solvency invariant guarantees player balances are always fully backed by ETH in the contract, and both sides can withdraw at any time, even if the owner pauses new play.
Deposit ETH, pick a side (long or short) and leverage up to 100×, and ride a synthetic ticker that lives for 30 seconds. Cash out any time, or the round settles you at the buzzer — or your liquidation price gets hit first. Every round is provably fair: the server publishes hash(seed) before the round and reveals the seed after, so you can replay the exact price path yourself (the Verify button does it in your browser). Position size is capped at a small fraction of pool depth, so no whale can shove the price with their own order.
Provide ETH liquidity to the pool and you take the other side of every bet. When players lose, your share of the pool grows; when they win, it shrinks — you earn the house edge, not a fee sticker. Deposit and withdraw whenever you like; a solvency invariant in the contract keeps player balances fully backed at all times, and an incident pause can never touch your right to withdraw.
You don’t have to trust us to settle honestly. The engine is pure deterministic math, so each round is settled behind a zero-knowledge proof: an SP1 proof attests that the round’s results were computed correctly from its committed inputs, and an on-chain verifier checks that proof before a single token moves. A wrong settlement can’t produce a valid proof, so it’s simply rejected — no trusted operator, ever. Wins and losses settle in one atomic, per-round-capped transaction against the pool.
0x191aEAA4D097fe778aD274217102305c09DdB4C20xdB6C7619De1964fD6d3D8F1EBB67f6E0B64866CF0xe36f596f05db7f52bf216a403cb06ae865a7e2c40x8b1EF83dbd4608423bDb4EbF54D897147413757E0xae50b117397c54398c86ed3f9fa6caab936337b70xa8318B3F05A5289A0c52139fe67E92E499f2D97b0xe2Ef21156B39af8df3C74065140fbEc0251Aa27D0xbb349f428142D24af132182088bedC34B4c127740x977ff648a16f10463E53c036222294C89a60Fe780x018b1742345290117f289B6f307341ee955068eF0x1F8eEF54D294B80d7FFe9aff1f7C9Ce79e80AD4E0x92C4E7a56230Dc70666934f3991EBee10Bf07C520x70775b480d380D2Cd9D23D767ee46c2Ea4d7419f0xed5942861D2054091b122DacF1480281a23f378B0x4d6E4Ab45200ccBe541e1d5DCa77E041f0a621520x1dEc2512712a53d033FBAaA886578A62ff69B6b40xb3D1f81C8A9bAC7fEa4bECad3179cb7C6198Ee8e0x73b64FD9B2B16F87c3bAc052a25Bf9199A58b8dDEach verifier entry also links 415 auto-generated constraint-library contracts (the AIR constraint evaluator, split to fit the 24KB contract limit) — full list in DEPLOYMENTS.md. Internal libraries (StarkProofCodec, GoldilocksField, KeccakTranscript, MerkleVerifier, FriVerifier, FriDeep, ConstraintEval, Poseidon2Goldilocks) are inlined into the deployed contracts above, so they have no separate address.
Token economy on mainnet: $ROLLA ↗ RollaInstruments ($GUH) ↗ GME ↗ Pons V2 ↗ Source on GitHub ↗
loading…
loading…
Created markets go live immediately in the picker (oracle markets start streaming). They reuse the deployed shared verifier + settlement; the registry is in-memory on the server.
Every oracle must be robust and have independent nodes running it, so new oracles are reviewed internally before approval. Only approved oracles can back a market.