RollMarkets

The price is made of you

Most games like this roll dice and draw the result. Synthetics do 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.

dP/P =  μ(s)·dt                     regime drift (hidden CALM·PUMP·DUMP·EUPHORIA)
      + σ(s)·dW                     committed, provably-fair noise
      + λ·sign(I)·|I/L|^1.4·dt      order-flow impact (superlinear, anti-whale)
      + κ±·J·dN±                    asymmetric Poisson jumps (wicks)
      − φ·F(I/L)·dt                 funding drag

I = net OI imbalance (long − short notional)   L = farm-pool depth

Liquidations feed the same term that caused them: a forced close re-enters the imbalance and pushes price further. Nobody scripts a squeeze — the squeeze is what the equation does on its own. Pool depth L is the denominator of the impact term, so it's a physics constant: as the pool grows, impact scales down and noise 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.

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.

Fills are batched on purpose

Every order in a 100ms window fills at the same price. Batching kills the latency-auction edge — it is why the agent API is a fair fight for humans and machines.

What we can prove, and what we can't

Before each round opens, the server publishes hash(serverSeed) — the Commit. After settlement it reveals serverSeed. The noise and jump terms 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 step re-computes SHA-256 in your own browser and checks it against the commit you were shown thirty seconds earlier.

The flow term cannot be committed in advance, because it does not exist in advance — it is made of the orders. That is not a gap in the fairness proof; it is the product.

Markets about anything

$GUH is the first market, not the only shape. The same settlement stack 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.

SYNTHETIC

Price path is a unique deterministic function of a committed seed. Truth is cryptographic — no oracle.

ORACLE

Settles to a mean / median / trimmed-mean of authenticated feeds. A STARK proves only that final = AGG(the committed set).

Run an oracle node — secure & proven

A market has a set of nodes (e.g. 5 nodes, quorum 3). Each pulls its sources, computes the same integer aggregation, and signs the observationsHash; OracleFeed verifies a quorum before commit. Node runners earn the 0.05% oracle slice — see the docs.

The proof fits on-chain

A full STARK verify is ~44M gas — over some chains' per-tx limit (Robinhood testnet ~32M). So the verify is chunked across three txs — begin → step → finish (~24M / 16M / 18M). The full trustless loop runs on testnet today: feed → 5-node quorum → observationsHash → STARK proof (3 chunked txs) → a disprove slashes a lie.