Skip to main content

Here is a fairness feature I genuinely like. A game contract on Base works out the most it can afford to pay you, writes that number to the chain, and only then asks Chainlink VRF for a random word. The ceiling is fixed in storage before anybody knows the outcome, so the operator cannot look at the result and decide afterwards that a big win was too big. The event that records it is called PrizeCapCommitted, and the comment above it in the verified source says exactly what it is for: “the ceiling is on-chain in an earlier block than the fulfillment that uses it.”

I pulled every one of those commitments from the contract that runs the most games on the subscription I wrote about last month. There are 1,058 of them. Not one of the 1,058 left the full prize table available. And from 14:36:43 UTC on 31 August 2026 onwards, the committed ceiling was zero on every spin, 34 in a row across 64 days. Every one of those 34 paid back exactly half the stake. The random word changed every time. The payout never did.

TL;DR

  • A Base game contract (VRFR at 0xb14df0cfe63e83968136ec1c8080051cb500670f) commits a solvency-based prize ceiling on chain before each Chainlink VRF request. It is a good design, and it worked exactly as written.
  • Across all 1,058 spins from 26 July to 3 November 2026 (43 wallets, 54,295 USDC staked), the ceiling never once covered the full prize table. 983 spins had the top band removed from the draw entirely.
  • After a 799 USDC withdrawal from the prize pool on 31 August, the ceiling read zero for 34 consecutive spins. Each paid exactly 0.5x, whatever the VRF word: 475 USDC staked, 237.50 returned.
  • The commitment is honest but late. It lands in the same transaction that takes your stake, so nothing lets a player refuse a spin whose ceiling has collapsed. A one-line minimum-ceiling parameter would fix that.
  • Separately, 45 of the 49 game contracts on that subscription carry an operator-only function that runs the payout logic on caller-supplied “random” words. No operator code has ever been able to call it. And yesterday, 19 November, the subscription itself was cancelled.

What the contract actually commits

The game is a stake-and-multiplier spin. You pick a tier (the source names them shrimp, dolphin, shark and whale, at 10, 25, 50 and 100 USDC) and two random words decide your result. The first word picks a band from a cumulative odds table out of 10,000: diamond, platinum, gold, silver or bronze. The second picks a multiplier inside that band. In the configuration live today, diamond pays between 12x and 50x, platinum 4x to 12x, gold 2x to 4x, silver 1x to 2x, and bronze 0.5x to 1x. Bronze is the floor and covers 80% of rolls on the shrimp tier.

Before requesting randomness, the contract asks what it can afford:

uint256 balance = IERC20(iOperator.USDC()).balanceOf(iOperator.POOL());
uint256 owed = totalReserved + nftLiability;
uint256 available = balance > owed ? balance - owed : 0;
uint256 capAmount = (available * capBps) / 10_000;
return (capAmount * 10_000) / stake;

That is a respectable piece of accounting. It takes the pool’s real USDC balance, subtracts prizes already promised to unsettled spins and money owed to holders of premium NFTs the game mints, and lets a single spin promise at most 80% of what is left (capBps is 8,000 on chain). The result is a maximum multiplier in basis points, and it is written to storage, keyed by request ID, and emitted as PrizeCapCommitted in the same transaction as the VRF request.

Then the clever bit. The contract does not just clamp a big win after the fact. A function called _rollOffsetFor removes unaffordable bands from the draw before the word arrives. Because a low roll means a high band, skipping the first N values of the roll deletes diamond, then platinum, and so on, until only bands the pool can honour remain. If the ceiling lands in the middle of a band, _capBand trims that band’s upper limit to the ceiling. The comment explains the intent: stepping down “keeps label == payout“, so a result labelled gold always pays a gold amount.

The point of all this is sound. A game that sizes its prizes against a pool it might not be able to pay is lying to somebody. Fixing the ceiling before the outcome exists means the operator cannot discover a 50x winner and quietly downgrade it. It is the solvency half of fairness that we argued in July most provably fair games skip entirely, implemented in about forty lines.

Every commitment, July to November

The contract has emitted 1,058 PrizeCapCommitted events, the first at 06:23 UTC on 26 July 2026 and the last at 12:01 UTC on 3 November. They come from 43 distinct wallets, and the stakes add up to 54,295 USDC: 182 shrimp spins, 229 dolphin, 359 shark and 288 whale. The pool settles in Circle’s canonical USDC on Base (0x8335…2913), so this is real money, not a test token.

The odds and multipliers were not constant. The operator reconfigured them repeatedly, and reading the configuration back at the block before each spin finds at least 37 distinct versions across the four tiers in those 101 days. So each commitment has to be scored against the table that was live when it was made, not today’s. Done that way:

What the committed ceiling left in the draw Spins Share
Every band, but diamond’s top clamped 75 7.1%
Diamond removed 396 37.4%
Diamond and platinum removed 466 44.0%
Only silver and bronze left 87 8.2%
Bronze only 34 3.2%
Full prize table available 0 0.0%

The highest ceiling the contract ever committed was 424,051 basis points, a little over 42x. The top of the diamond band has been at least 50x in every configuration on record. So the jackpot at the top of the published table was never reachable on any of the 1,058 spins, and on 983 of them, 92.9%, the diamond band was not in the draw at all.

That is the cap doing its job, and I want to be fair about it: a pool holding a few hundred or a few thousand USDC cannot honour a 50x win on a 100 USDC stake, and a contract that admits that is better than one that pretends. But it does change what the odds table means. A table that says “diamond: 4 in 10,000” is describing a game that, on this contract, never took place.

14:36:43 UTC, 31 August

On the morning of 31 August the ceiling was healthy by this contract’s standards. The last spin before lunch, at 12:10 UTC, committed 290,989 basis points, about 29x, with every band in the draw.

At 14:36:43 UTC, in block 50,698,828, the address that owns both the game contract and its operator, 0x9ea7740579511fb1148d99c93230c4b1f79fde12, called withdraw(address,uint256) on the prize pool and moved 799 USDC out to 0x7459ed656b8668293996d6b19587439b3bfe1d04. Reading state on either side of that block:

Block Pool USDC NFT liability Reserved Ceiling (shrimp)
50,698,827 944.43 587.30 0 positive
50,698,828 145.43 587.30 0 0
Today 332.25 607.30 0 0

With the pool holding less than the NFT book it owes, available is zero, the ceiling is zero for every stake size, and the offset logic falls all the way through to the floor. The source is explicit about what happens next:

if (upper > maxMul) upper = maxMul;
// ponytail: pool below even the bronze floor. Pay the floor rather than emit a
// multiplier outside every band; FluxBox already reverts if it truly cannot pay.
if (upper < lower) upper = lower;

With a ceiling of zero, the upper limit is cut to zero and then raised back to the bronze floor of 5,000 basis points. The band collapses to a single value. The first spin after the withdrawal came at 16:41 UTC and committed a ceiling of 0. So did the next 33.

Thirty-four spins, one outcome

From 31 August to 3 November, eight wallets made 34 spins on this contract: 30 at 10 USDC, three at 25 and one at 100, for 475 USDC staked. I matched every one of them to its result event in the game’s result store. All 34 paid a multiplier of exactly 5,000 basis points. That is 237.50 USDC back on 475.

Chainlink delivered fresh, verifiable randomness to every one of those requests, and the contract used it. The band roll moved around normally: 2,628 on one spin, 6,981 on the next, 9,816 on another, all above the 2,000 offset the empty ceiling imposed. None of it mattered. When the only reachable band has a width of one, the second word has nothing to choose between. The draw was provably fair and entirely decided before it happened.

The raw receipt for the last spin, transaction 0x872f…4055 on 3 November, shows the whole sequence in five logs: the 10 USDC stake moving into the prize pool, the VRF request to the coordinator, PrizeCapCommitted with a stake of 10,000,000 and a ceiling of 0, and the game’s own bookkeeping events. Everything a player needed to know was public. It just arrived in the same transaction as the money.

The commitment arrives one step too late

This is the design point I think matters beyond one contract. A commitment protects you against the party who makes it only if it binds them before you act. Here, the ceiling is fixed before the random word, which protects players from an operator who might shrink a prize after seeing the outcome. It is not fixed before the stake. The function that computes it is a public view, maxMultiplierFor(uint256), so a careful player could call it first. But nothing ties the spin to what they saw. The pool can move between the read and the bet, and the bet goes through whatever the ceiling turns out to be.

Decentralised exchanges solved the identical problem years ago. A swap carries a minimum output, and if the price moves past it the transaction reverts instead of filling at a worse rate. The spin equivalent is a single argument: the lowest ceiling the player will accept. If maxMultiplierFor(stake) comes in below it, revert and keep the stake where it was. Thirty-four spins at a ceiling of zero would have been 34 reverted transactions and nobody would have been paid half for the privilege.

The surrounding arithmetic shows why this is not a footnote. Using each spin’s live configuration, the published schedule with every band open has an expected return of between 102.0% and 119.4% of stake, depending on tier and version. It is, on paper, a game the house loses. Applying the ceilings actually committed, the stake-weighted expected return across all 1,058 spins falls to 99.5%, against 107.9% uncapped. The cap is not an edge case of the house edge. It is the house edge, and it moves with a pool balance the player is never asked to look at.

One trap for anyone auditing this from events alone: the result store emits TierRaffled and MultiplierRaffled with their arguments crossed over. The event named for the tier carries the multiplier paid, which is why every one of the 34 shows ticketId 5000. A dashboard built from event names will read this game backwards.

The function next to the commitment

Reading the same source for the cap turns up something else, directly below the fulfilment logic:

function s_ChooseWinner(uint256 requestId, uint256[] calldata randomWords) public onlyOperator {
    fulfillRandomWords(requestId, randomWords);
}

That runs the full payout path with “random” words supplied by whoever is the operator. Chainlink is not involved. This is the exact thing VRF exists to rule out, sitting one function away from a commitment scheme designed to make the game more honest.

It is not in one contract. Of the 49 consumers on the subscription, 45 have the s_ChooseWinner selector, 0x96167b31, in their dispatch table. The other four are three addresses with no bytecode at all and one of the operator proxies, registered as a consumer itself. So the question is whether any operator can actually call it.

The 45 sit behind eight operator contracts, every one an upgradeable proxy. I reconstructed the implementation history of each by reading the proxy’s implementation slot through time: 48 distinct implementation versions and 40 upgrades between 16 October 2025 and 26 July 2026. None of the 48 contains the s_ChooseWinner selector. On the evidence of the bytecode, no operator has ever been able to reach it, and the current FluxBox source confirms its only low-level call goes to a fixed campaign module that does not reach it either.

That is the reassuring half. The other half is that the operators are upgradeable by four admin keys with no timelock in front of them, and one upgrade by any of those keys would make the bypass live on every game behind that operator. One of those four keys is 0x33c828f9a334f871456ab0a7fd7c8bf76fe7767c, which administers two of the operators. That is the address the subscription had a standing ownership offer to for 178 days when I last looked. I described it then as somebody other than the operator. On this evidence it is more accurate to call it another key inside the same operation. The broader issue of game contracts whose randomness source can be swapped is the subject of our census of 59 consumer configurations; this is the same weakness reached by a different door.

Yesterday the subscription closed

That subscription no longer exists. At 18:51:54 UTC on 19 November 2026, in block 59,619,693, the owner 0xdb1820620365984b096ced6f1a124ddf531c4119 cancelled it. The coordinator refunded 0.0952102 ETH and no LINK to 0x3dd6f2ce3ec90a455d27d03d40cc24a2f05d2a23, an address that has never sent a transaction. The ownership offer was still pending at the block before; it was never accepted. Between my reading on 24 October and the cancellation, the subscription’s request counter moved from 5,669 to 5,677. Eight draws in 26 days, four of them on the contract measured here.

Every one of the 49 consumers is still wired to that subscription ID, which now reverts as invalid, so none of them can get a Chainlink word. The only routes left for any of these games to produce a result are routes that do not go through VRF: re-pointing the coordinator, which is the owner’s prerogative on any standard consumer, or an upgrade that makes s_ChooseWinner reachable. I am not saying either will happen. I am saying that is the complete list. The pool still holds 332.25 USDC, against 607.30 owed to NFT holders.

What this means if you play

The lesson is not that solvency caps are bad. A game without one is either massively overcollateralised or making promises it cannot keep, and you should prefer the game that tells you. The lesson is that a commitment only protects you if it binds before you pay, and that a provably fair random word can be attached to a draw with nothing left to decide.

That is the standard we hold Satoshie to, and the one you should hold us to. Our raffles and coinflip draw from Chainlink VRF on Base, our subscription is public, and every question in this post can be asked of our contracts with the same free RPC calls: what is the most a draw can pay, is that fixed before you enter, can anything other than the coordinator deliver a result, and who can change that. If any answer is worse than you expected, that is a fair thing to hold against us. A fairness claim you can only check after you have paid is half a claim.

Honest limits

  • Configuration history is a floor. I found config changes by comparing reads at spin blocks and bisecting where they differed. A change that was made and then reversed between two spins would not show up, so 37 versions is a minimum, and the band scoring could be off for spins inside such a window. The 34 bronze-only spins do not depend on configuration: a ceiling of zero pays the floor in every version, and I confirmed each payout from its result event.
  • Expected return is schedule arithmetic. The 102.0% to 119.4% figures take the midpoint of each band at the live odds. They ignore the game’s NFT and coupon mechanics, which move money outside the multiplier, so they describe the spin, not a player’s whole experience.
  • I do not know what the interface showed. A front end could have displayed the ceiling before each spin. Nothing on chain enforces that, which is the point, but players may have known more than the contract required them to.
  • I cannot say why 799 USDC left the pool. If it settled an NFT redemption, the matching liability was never released: nftLiability was 587.30 USDC before and after. In that case the ceiling sat at zero for 64 days because of a bookkeeping line nobody cleared, which would be worse, not better.
  • Selector searches are not proofs. I looked for the s_ChooseWinner selector pushed as a constant in each implementation’s bytecode. A generic call-forwarding function or a selector built at runtime would evade that. I read full source only for the current FluxBox implementation, and implementation history was sampled at 120 points per proxy before bisecting, so a version live for a very short window could be missing.
  • Spin records come from one indexer. The 1,058 commitments were pulled from Blockscout’s decoded logs. I cross-checked the last spin’s receipt and the cancellation against raw RPC, not every event.

Three questions for any game you play

  1. What is the most this draw can pay, and is that fixed before I pay or only before the random word?
  2. If the pool cannot cover the top prize, does my transaction revert, or does it quietly take a smaller game?
  3. Is there any function, live or one upgrade away, that delivers a result without the randomness provider?

Everything above is re-checkable on Base. Call maxMultiplierFor(10000000) on 0xb14df0cfe63e83968136ec1c8080051cb500670f and it returns 0. The pool withdrawal is transaction 0xa998011ebb23ba1ce321975d88bd5864f1f68c0eb9503a24bae360b5da8e322d, the cancellation is 0xe0893b5a6b5a6b20657f45655d860843cf1ea1a7549c86b2a61371cab8df4166, and PrizeCapCommitted has topic 0x973dd31f…. The ceiling was committed first every time. For 34 spins, it was zero.

📷 Photo by Carl Raw on Unsplash

Valentina Ní Críonna

Author Valentina Ní Críonna

More posts by Valentina Ní Críonna