What the chain proves, and what it does not.

The chain orders, timestamps and proves

Every move you make is a transaction to the Arena contract. It records the move and the order it arrived in, and it refuses a move from anyone who is not playing. Your session key signs it and the sequencer executes it before the call returns, which is why the arcade can show you the round trip as a number rather than a spinner.

Mini-blocks are sealed at a 10 ms scheduling target and Ethereum-shaped blocks at a 250 ms scheduling target. Neither is a latency guarantee, and neither is a claim about throughput. The figure on the arena page is what your own browser measured, including both proxy hops.

The arena: played for PKL, and bounded by the chain

A run costs a stake of 100, 500 or 2,500 PKL, taken from the PKL side of your vault on the bank's PKL ledger when you join. Nine tenths of it becomes the bag your snake carries, 7% goes to the sea that pays for pellets, combos and objectives, and 3% is the house fee. Everything you eat is PKL, a kill hands you part of the victim's bag as a bounty, and cashing out alive pays what your snake is holding back into your vault. Cashing out needs at least one kill in the run: leaving before your first kill forfeits the bag.

The chain proves the money side of a run. The stake moves into the arena in the join itself, and the contract accrues the 3% fee right there, so the fee is the chain's number and not the server's word. A payout is never more than 100 times the stake, and never more than the pool can pay without touching the unskimmed fee or the stake of any other open session, so one run can never spend another player's refund. No payout is ever recorded against a run the server reported as killing nobody: such a run settles at zero. Every session is settled, cancelled or expired exactly once, so nobody is paid twice. A session the server cancels, which it does on a restart for every run whose world no longer exists, or one nobody settles within 7,200 EVM blocks, about thirty minutes, which anybody may then expire, returns the stake in full and unwinds its fee. And the fee is the only thing skim can take out of the arena: the sea, the bags and every open stake are out of its reach.

The server computes the physics and splits the room

Where your snake is, how long it is and what it collided with are computed by the arcade server from the ordered stream of confirmed moves. The chain does not simulate the game, and this page will not pretend otherwise. So the split of the room is the server's too: what each pellet is worth, who ate it, the combo and the objectives it paid, who killed whom, the bounty and the loot a death scattered, and how big your bag was when you left. When a run ends, the server reports it to the Arena contract with the payout and the kills.

Inside the bounds above, you are trusting the server with that split. A compromised server could pay one player the whole sea within them, or pay a winner nothing, and the kill count the chain pairs with a payout is its report as well. What it cannot do is pay an account that holds no open session, pay a session twice, reach another player's stake, or take the house fee as a payout.

What you can check for yourself is the input stream: every move is a public transaction, and the order they arrived in is fixed by the chain. What you cannot check is the simulation that turns those moves into a game. That part is the server's, and you are trusting it.

This page will not tell you the game is reproducible, because it is not. The server places the four hundred pellets, every respawn after a bite, every pellet's kind, every power-up, every crate a kill or the map drops, every spawn point and every starting heading from an unseeded random source, so nobody replaying the public transactions can rebuild a round, and neither can the server itself after a restart. Ticks run on wall-clock time rather than on chain time as well, so even a seeded generator would leave a replayer unable to say which tick an input landed on. Nothing here promises that is coming.

Arena skins: crates, and a roll nobody steers

Skins are never sold. They come only out of crates looted in a run: a kill can drop one, a few appear on the map at random, and a crate is kept only by cashing out alive with it. A skin changes how your snake looks and never how it plays; no rule in the room reads rarity.

Which crates you carried out is the server's word, and the server grants them after your cash-out. What a crate rolls is not. The operator publishes the head of a hash chain before anybody opens anything, each opening is revealed with the next link down, oldest first, and the contract accepts only a link that hashes to the one it holds, so the server cannot choose the link that rolls your crate and you cannot predict it. The roll is recomputable by anybody from the reveal's log. The operator knows its own chain, so it can stall the line, which blocks every opening behind it, and it can time crates of its own; it cannot hand a chosen roll to anybody else's opening. And you never lose a crate to a missing reveal: an opening left unrevealed for 300 EVM blocks, about seventy-five seconds, can be reclaimed by anybody, and the crate goes back to you unopened.

The claw machine: what is proved, and what is not

A pull costs 500 PKL and buys an ATTEMPT, not a piece. A miss forfeits it and spends one of the ten attempts an address ever gets. There are 500 pieces, every one different from every other, and one taken is gone for everyone.

The chain proves which piece. The operator publishes the hash of a secret before anybody pulls, the contract refuses a secret whose hash is not that commitment, and the piece is computed from that secret, the 32 random bytes your own browser drew, and the pull id, over the pieces still unclaimed. That last condition is load-bearing. Whoever holds the hash chain knows the link a given pull will be fulfilled with, so a seed somebody handed you is a seed that could have been ground against that link until it named a chosen piece. For a seed this page drew for you, and never reuses, nobody can NAME the piece your catch will yield, and nobody can pick it after the fact. Being unable to name it is not the same as being unable to move it. The piece comes from that hash modulo the pieces still in the machine, and every pull resolved in front of yours reshuffles what is left, so the operator can still change which piece you get by how and when it resolves those pulls. Your piece is fixed only once every pull older than yours is resolved.

The server judges the grab, and you are trusting it for that. Whether the jaws closed on anything is computed by the arcade server from the inputs you sent, exactly as it computes the arena's collisions. It can grant a catch and it can deny one, and because it holds the link before it decides, it can work out what each waiting pull would yield and report only the catches it likes. What limits that is that a miss reveals its link too, so anybody holding the log can recompute the piece a denied catch would have produced, and a pattern of denials is a public fact rather than a suspicion. That is the whole of the mitigation. This game is not trustless and this page will not say that it is.

What stays trusted: the operator sees your seed before it reveals, and could stall a pull it dislikes. Stalling blocks every player rather than one, is publicly visible, and a pull left unfulfilled past 300 EVM blocks is refundable by anybody at all, which at the chain's 250 ms EVM block scheduling target is about seventy-five seconds. The refund always pays the account rather than whoever asked, and it hands the attempt back with the stake. Past that deadline the stall turns into a choice: refunding the pull at the head resolves it without spending its link, so the operator can pass that link to whoever is next. It costs the skipped player nothing but the wait, since the stake and the attempt both come back, and it leaves one public refund naming them. Before the deadline, pulls are fulfilled oldest first and nobody can deal the links out to suit themselves; when the contract's own cursor falls behind, anybody can move it forward.

Ten attempts are counted per ADDRESS. Addresses cost nothing and the stake is faucet PKL with no monetary value, so one person with FIFTY funded addresses can take the whole collection, and a short script is all that takes. Fifty, because 500 pieces divided by ten attempts an address is fifty addresses: the limit was two until 2026-09-15 and the figure here was two hundred and fifty, so raising it made this admission five times stronger rather than weaker. Nothing in the contract can stop that on a public testnet and none of it pretends to. Ten per wallet is true. Everyone gets a fair shot at the collection is not, and this page will not say it.

Your money, and what a stolen key can do

The vault contract credits your Pickle account in two assets: ether, which Crash, Patch, Trellis, Stack, Derby and Glide stake, and PKL, which the arena and the claw machine take. Which one a cabinet spends is fixed in the cabinet itself and is not something a transaction can choose. The key this device holds can spend either inside the arcade and can send either back to your account, because a withdrawal always pays the account and never whoever asked for it.

Every cabinet here now takes a stake, the arena included, so a stolen key can lose what you have deposited by playing as you: an arena run that dies or leaves before its first kill, a bet it does not cash out, a spin that pays nothing, a square whose column closes under it, or a pull that misses. It cannot take your ether or your PKL anywhere else, sign on any other Pickle site, or touch the rest of your wallet, because a withdrawal always pays your account and never whoever asked, and an arena cash-out and a skin both land on your account, never on the key.

Revoking the key costs one transaction, on the wallet page.

Patch: the grid is fixed before the reels move

A spin costs between $0.10 and $10 in ether, on a fixed ladder rather than a typed amount, because the stake is three line bets and it has to divide into whole wei. Four reels, three rows, three straight lines, paying left to right.

The chain proves the grid. Before you have chosen anything, the operator publishes the hash of the seed your next spin will use, and the contract refuses a seed whose hash is not that commitment. Your own browser draws 32 random bytes and publishes their hash in the spin itself, and the twelve symbols come from BOTH halves and the spin id. Neither side alone can name the grid, and the operator cannot choose your commitment knowing your half, because your half does not exist when it chooses. It could grind its own seed against many candidates, which is worth saying plainly rather than calling impossible; it buys nothing, because there is nothing yet to grind against.

You can recompute it. Read the seed off the Revealed log, read your own half off your own transaction, check the commitment was published in a block BEFORE your spin, then call gridOf and quote, which are pure functions on the contract. If the reels showed you something else, the chain is right and this site is wrong.

What is still trusted is one thing, and this page will not bury it. One process holds the operator key and the secret the seeds come from, so it knows every future commitment before anybody has paid. It cannot change a published commitment, take anything out of the vault, alter a grid once both halves are fixed, or learn your half before choosing yours. What it can do is DECLINE TO SETTLE. A declined spin refunds the stake rather than paying the win, so declining costs the house nothing and saves it a payout: the operator can decline a win, but it cannot decline a win and keep your stake. Three things narrow that and none removes it. Settling is permissionless once the seed is public, so a stall has to be a refusal to publish at all rather than a refusal to pay. The refund is permissionless too, so nobody has to ask for it. And the count of unsettled spins is published, so a pattern is visible from outside rather than only to the people it happened to.

The machine returns about 98.5% of what is staked over a long run. Two parts of that figure are exact arithmetic and two are measured from simulation, so it is quoted to one decimal rather than four: a spin is a spin, and a long run is longer than an evening.

Trellis: the chain decides where the line went

A square is one ten-second slot and one price band, and it costs between $0.10 and $100 in ether. Backing a square is a bet that the ETH/USD line passes through it. You can back as many as you like, and the same one more than once.

The outcome is not the operator's to report. When a slot ends, sealing it reads the chain's own price registry for the prints inside that slot, and the square wins when the range those prints covered overlaps its band. Settling is permissionless: once a slot is sealed, anybody can call it, and the contract pays from what it already holds.

The multiplier is the one thing the operator signs. A price this small cannot be computed on-chain, so each cell carries a quote signed for that exact square, and the signature stands only for a short window because the board moves every second. The multiplier your bet locks is the one it was signed at, and nothing can lower it afterwards.

What is still trusted is narrower here than anywhere else in the arcade: there is no seed and no commitment, so there is nothing for an operator to know in advance. It can only DECLINE TO QUOTE, which is visible immediately - a board with no prices on it is a board nobody can bet on. If the feed stops, nobody loses: a slot the chain published no price inside is void and every stake on it comes back, and a slot nobody seals at all becomes refundable by anybody ten minutes after it ends.

Stack: the mini-block decides where the slab stopped

A run costs about one dollar in ether, fixed by the contract, and it goes into the pot of its UTC day. Two hours after the day ends, the three tallest towers of that day share 90% of the pot, half, 30% and 10%, and the house keeps the rest. With fewer than three players the shares present are scaled up to the same 90%, so one player alone gets 90% back. Ties go to the tower that finished first.

The house is never on the other side of a run. A pot is paid out of that day's own entries and never out of the arcade's float, so the best a perfect player can do is win the other players' entries.

Where the slab stopped is the chain's number. Every tap is a transaction, and the rules are a pure function of the timestamp of the mini-block that carried it: the slab slides on a fixed triangle wave that starts where the previous tap was judged and speeds up with the height. Anybody holding a run's mini-blocks can recompute every floor of it, and the arcade serves each run whole, every tap with its mini-block, at /api/stack/run/ and the run's number.

A tap also carries the instant it was pressed, as the page's clock read it, in the last eight bytes of its calldata. A tap that a stall held on its way to the chain is judged at that instant instead of at its mini-block, but never more than three quarters of a second earlier and never before the floor began. So a short stall no longer moves the slab past where the player stopped it. The window is the one choice a player could make on purpose, by sending late and naming an earlier instant, which is why it is no longer than a short stall.

What is still trusted is the height the operator reports when a run ends. The contract counts the taps and refuses a height taller than the taps it saw, so the operator can report less than the rules give and never more. A run the operator never reports is refundable by anybody an hour after it began, and a run the arcade server could not judge, because it restarted in the middle of one, is handed back at once.

Derby: the chain's own price feeds are the runners

A race runs every minute. A bet is a stake of 0.25, 1, 5 or 25 dollars in ether on one of eight runners, taken until three seconds before the gate. It is pari-mutuel: every stake on a race goes into one pot, 8% is taken, and the rest is shared by the stakes on the winner in proportion to their size. When runners tie, the pot is split evenly between them. The house backs every runner with a small seed of about five dollars so that a player alone in a race still has real odds; the seed is never paid out, so the most a race can ever cost the house is its eight seeds.

The finish is the chain's. A runner's score is how far its price moved between the gate and the line, divided by its handicap, and both prices are proven against rounds the chain printed: anybody may seal the gate and the line, and the contract accepts only the last round printed before each instant, with the next one printed at or after it. A runner whose feed was not fresh at either end, or whose market was not open when that end was sealed, voids the race and every stake is refunded, so a closed market is never raced against a flat line. A fresh price alone is not enough: a closed market's last price is printed every block too, marked closed. Anybody may settle a bet, and a race nobody sealed within ten minutes is refundable by anybody.

What is still trusted is the lineup and the handicaps. The operator chooses the eight runners and posts each one's handicap, in public, before anybody bets. It cannot choose a winner: the gate and the line are proven against rounds the chain printed, and anybody may seal and settle. The arcade serves every race whole, with the rounds both proofs named, at /api/derby/race/ and the race's number.

Glide: the canyon is a price feed, and the mini-block judges every wing beat

A run costs about one dollar in ether, fixed by the contract, and it goes into the pot of its UTC day, one pot for every canyon. Two hours after the day ends, the three longest flights of that day share 90% of the pot, half, 30% and 10%, and the house keeps the rest; fewer than three are scaled up to the same 90%, and ties go to the flight that finished first. The house is never on the other side of a run.

The canyon is fixed by the chain. The contract records the feed's latest round when the run starts, and the canyon's points are the rounds from twelve before it onward, one per block, scaled by how far that feed moved in the 240 rounds before the start. A run starts only on a feed that printed in the last five seconds and whose market the chain reports open, because a closed market's last price is printed every block too and would draw a flat canyon. The glider's flight is a pure function of those rounds and of the timestamps of the mini-blocks that carried the start and each wing beat, so anybody holding them can recompute the whole flight to the hundredth of a second. A wing beat carries the instant it was pressed in its calldata, as a Stack tap does, and one a stall held on its way is judged at that instant, at most three quarters of a second before its mini-block and never before the beat before it. The arcade serves every run whole, the rounds and every wing beat with its mini-block, at /api/glide/run/ and the run's number, and the rounds stay in the chain's own logs for good.

What is still trusted is the time the operator reports when a run ends. The contract refuses one longer than the run has lasted, and one longer than four seconds per wing beat the chain counted, so the operator can report less than the rules give and never more. A run the operator never reports is refundable by anybody an hour after it began, and a run the arcade server could not judge, because it did not see it start, the feed stopped printing under it, or its market was already closed when it began, is handed back at once.

Test tokens

Pickle Chain Testnet, chain ID 78270. Test PKL and test ETH have no monetary value and are not redeemable for anything. Chain state may be reset without notice, and a reset takes the vault's balances with it.