A rip is two transactions. You pay in the first and reveal in the second. That split is not an inconvenience bolted on afterwards — it is the reason the odds can be trusted, and it is explained in full below.

1. 1

   Pick a series and a count

   Each series publishes its own odds. You can draw between 1 and 10 at a time; the cap keeps the settle transaction inside a predictable gas budget.

2. 2

   Pay

   The engine quotes a price, takes your ETH, and splits it immediately — nothing is held in escrow. Your outcome is bound to a block three ahead that does not exist yet. Overpay and the difference is credited back to you, not kept.

3. 3

   Wait three blocks

   Roughly half a minute on Robinhood Chain. The counter the contract reads advances with Ethereum underneath, not with this chain's own 100ms blocks, so the wait is longer than the block count suggests. During that window nobody — not you, not us, not a bot watching the mempool — can know what you drew, because the block that decides it has not been produced.

4. 4

   Reveal

   A second transaction reads that block and mints what you drew as an ERC-1155 token. Anyone can send this transaction, which means you hold no veto over your own result, and a keeper can clear your draw if you close the tab.

5. 5

   Hold or redeem

   Keep the position, sell it on any marketplace, or burn it back to the pool for its weighted share. Redemption works even while the protocol is paused.

Draws are grouped into baskets — a new one opens every hour. A basket is a label for reading the activity feed, nothing more; it does not affect odds, price, or what you can redeem.

Each series publishes five tiers with fixed probabilities. Those numbers go into the contract when the series is listed and there is no function to edit them afterwards. A series can be closed, never re-weighted. Mutable odds would make every figure on this site meaningless.

Weight is separate from odds, and it is the part that matters. A position’s claim on the pool is its weight divided by all outstanding weight. A Legendary is 60 times a Common, so the ladder is steep by design — that is what makes a rare draw worth chasing rather than just a different colour of label.

Multiply each tier’s odds by its weight and add them up and you get the expected weight of a single draw — currently 2.74 for TSLA. That number is what the price is built from.

The price of one draw is built in three steps:

1. Take the pool’s value of one weight unit — 0.00082 ETH right now. That is the pool divided by all outstanding weight, floored at 0.0008 ETH so it can never open at zero.
2. Multiply by the expected weight of a draw (2.74). This is what the draw is worth in backing, before any margin.
3. Add a 10% surcharge. This is the house edge, and it is the entire source of the protocol’s revenue.

So the price moves with the pool. As the pool deepens, one weight unit is worth more, and rips cost more. Nobody sets the price by hand and there is no admin function that can.

The contract refuses any configuration where those shares would leave the pool with nothing. That invariant is checked on every parameter change, not just at deployment.

The pool holds ETH. One weight unit is worth the pool divided by all outstanding weight, and a position redeems for its weight times that, minus a 1% redemption fee that stays in the pool. The money never leaves the contract until a holder takes it.

Because a draw’s expected weight is priced in exactly, the backing portion of a ticket leaves the per-weight value unchanged. It is the surcharge that lifts it. Every rip pays existing holders a little.

Part of the pool is locked and can never be withdrawn. Bootstrap liquidity was deposited together with weight that belongs to nobody — no position corresponds to it, so no code path can pay it out, not to a holder and not to the owner. Today that is 3.2% of the backing. Verify it yourself with lockedWeight() against totalWeight().

It exists because of a specific failure: without it, the first Legendary drawn on a freshly seeded pool would own nearly all of it off a single ticket. Locked weight puts a permanent floor under the pool, which bounds a jackpot to a sane multiple and means the last holder to leave still has something to leave against.

Redeeming burns the token, so the engine needs a one-time ERC-1155 operator approval from your wallet. You can revoke it whenever you like. Redemption is credited for withdrawal rather than pushed to you directly — a contract that refuses ETH cannot block anyone else’s exit that way.

Part of every surcharge comes back to the buyer as $SBIT credit. The share slides with how deep the pool is: 60% of the surcharge when the pool is empty, falling linearly to 20% once it reaches the target depth. Right now it is 20%.

The logic is plain enough: a thin book has to pay people to show up, and a deep one does not. Credit accrues in ETH terms and converts to $SBIT at a published rate when you claim it, from a reserve held by the engine. If that reserve runs dry the claim reverts rather than silently paying nothing.

A single wallet at a time holds the crown and earns 10% of every surcharge paid on the protocol. Taking it costs 10% more than the deposit already standing.

The holder you replace gets their full deposit back, credited immediately. It is not a bid you lose — it is a deposit you park, and you can step down and take it with you at any time. Refunds are credited rather than pushed, so a contract that refuses ETH cannot wedge itself onto the throne permanently.

Crown deposits are tracked separately from the backing pool. They are never part of what positions redeem against, and redemptions can never touch them.

If a draw resolved in the same transaction that paid for it, a contract could read its own result and revert on anything below Legendary — paying only gas to re-roll until it won. Every naive on-chain lootbox dies this way. It is not a theoretical attack.

So paying and revealing are separate. Paying fixes your outcome to a block three ahead: a block that does not exist yet and whose hash no party to the draw — not you, not the engine, not any contract either of you controls — can predict. Revealing reads that block. Anyone can send the reveal, which means you hold no veto over your own result — and also that a keeper can settle your draw if you disappear.

The remaining weakness, stated plainly: this chain has one sequencer, it decides block contents, and Robinhood documents its block hashes as unsuitable for cryptographic randomness. So the operator of the chain could in principle bias a pending draw in a way you could not detect. That is a materially weaker guarantee than a dedicated randomness oracle, and it is the honest description of what secures your outcome today. Chainlink runs on Robinhood Chain, but VRF is not among the services live here; the engine reads randomness through an interface, so it can be repointed at one the day it ships, without redeploying anything else.

One more edge: blockhash only reaches back 256 blocks. A draw left unsettled past that window is unreadable forever, so the contract settles it at the floor tier rather than stranding your ETH. Stalling never benefits anyone, because it only ever lowers the outcome.

Check these on Blockscout before sending anything. $SBIT has no owner, no mint function, no transfer tax and no blacklist — you can confirm all of that from the verified source, which is the point of building it that way.

Network

Robinhood Chain

RipEngine

StockPositions

$SBIT token

Two reads worth knowing: surplus() returns the ETH the contract holds beyond every liability it has recorded, and should never be negative. lockedBackingBps() returns the share of the pool nobody can withdraw. Both are public views — you do not need us to check solvency.