The Game Cycle

IndexPVP operates in a repeating cycle of three phases: Countdown, Voting, and Execution (the Delisting). Understanding this cycle is critical to playing effectively.

Phase 1: Countdown (4 Hours)

The game begins with a 4-hour countdown. During this phase:

• Trading is fully open — Buy and sell any listed index's tokens
• Standard fees apply — 1-5% dynamic fee based on volatility
• Market caps shift — Prices move based on buying and selling pressure
• Coalitions form — Players coordinate to pump specific indexes

The goal during this phase is to position yourself advantageously before voting begins. You want to either:

• Become the top holder of any listed index — that's how you earn a seat at the voting roundtable
• Hold tokens in indexes unlikely to be delisted (safe havens)
• Accumulate tokens in indexes you think will receive buyback ETH after the delisting

What Determines Market Cap?

Market cap = token price x total supply (1 billion per index). Since supply is fixed, market cap is purely a function of the Uniswap pool price. More buying pressure = higher price = higher market cap.

The index with the highest market cap when the countdown expires becomes the blue chip for the round — it gets a seat at the roundtable and cannot be targeted for delisting.

Phase 2: Voting (5 Minutes, Secret Roundtable)

When the countdown hits zero, anyone can call triggerVote(). This:

1. Snapshots the highest market cap index as the blue-chip (immune) index
2. Activates the Trading Halt — a 20% sell fee on ALL index tokens
3. Starts a new GovernanceVotingV2 round; the keeper computes a ranking of every listed index by market cap, looks up each index's top holder, and publishes the Merkle root of Poseidon(indexCode, rank, topHolder) leaves on-chain
4. Opens a 5-minute voting period

Who Can Vote?

Only the top holder of each listed index. One seat per listed index — the roundtable starts full (every index in the game gets a seat) and shrinks by one every time an index is delisted.

Each seat's weight is its market-cap rank:

Rank	Weight (with listedCount listed indexes)
#1 (blue chip)	listedCount — most powerful seat, can't be delisted
#2	listedCount - 1
...	...
Last	1

Formula: weight = listedCount - rank + 1.

How the Vote Stays Secret

Each leader submits a zero-knowledge proof (built from a Noir circuit in the browser, ~3–5s) that they are a legitimate top holder of some listed index, without revealing which one. Alongside the proof, the actual target is NaCl-box-encrypted to the keeper's on-chain public key. The contract stores a keccak binding commitment so the keeper cannot later forge or substitute votes.

Until the voting window ends, no one — not even the keeper — knows who voted for whom. No bandwagoning, no last-second tactical switching, no public kingmaker coercion.

Reveal

When the window closes, the keeper decrypts every ciphertext off-chain and submits a single revealAndFinalize transaction. The contract:

1. Verifies each reveal's keccak commitment matches what was posted at vote time
2. Rejects any reveal targeting the blue-chip index
3. Tallies weighted votes and emits the final target

What If Nobody Votes?

If no votes are cast during the window, a random listed index (excluding the blue-chip #1) is selected for elimination during the randomness-driven delisting phase.

The Trading Halt

During voting, a 20% sell fee applies to ALL token sales across every index. This mechanic:

• Prevents panic selling during the vote
• Makes it expensive to dump tokens of the likely-delisted index
• Incentivizes holding through the vote
• Creates a temporary liquidity lock effect

Phase 3: Execution (The Delisting)

After the 5-minute voting period ends, anyone can call executeDelisting(). Execution happens in two on-chain steps using Quiver VRF for tamper-resistant randomness.

Why not Chainlink VRF?

Chainlink VRF (and other randomness oracles like Pyth Entropy or Gelato VRF) does not exist on Robinhood Chain. IndexPVP instead uses Quiver VRF, provided by the Quiver Foundation — a verifiable two-party commit–reveal randomness coordinator that is live on Robinhood Chain. It sits behind the game's provider-agnostic async randomness interface (IRandomnessProvider), fulfilled by a thin adapter, QuiverRandomnessProvider, so the game's request/callback shape is unchanged.

Step 1: Request Randomness (Phase 1)

When executeDelisting() is called:

• The governance vote is finalized — the delisting target is determined (or marked as needing random selection if nobody voted)
• A randomness request is sent to the Quiver coordinator via QuiverRandomnessProvider, which maps Quiver's seq (sequence number) to the game's requestId
• The game enters a brief "randomness pending" state

Step 2: Reveal Callback (Phase 2)

Shortly after, Quiver's own keeper — called "Fletcher" — delivers the reveal callback, and the game receives the resulting random word via rawFulfillRandomness:

• If no votes were cast, the random word selects the delisting target
• ALL 7 liquidity positions in the target index's Uniswap pool are removed
• The recovered ETH is redistributed via buyback swaps

The final value is computed as randomNumber = keccak256(userRandom ‖ providerRevelation) — a two-party scheme combining the consumer's own randomness with Quiver's revelation. It is fair and unbiasable as long as either party (the game or Quiver) is honest: neither side can grind the outcome without the other's cooperation. The IndexPVP keeper is not involved in randomness at all.

Step 3: Redistribute ETH

The recovered ETH is distributed via three buyback swaps, with targets chosen using the random seed:

Recipient	Share	Mechanism
Blue-Chip (#1) Index	40%	ETH swapped into the blue-chip index's tokens
Random Index #1	40%	ETH swapped into a random surviving index (not the winner)
Random Index #2	10%	ETH swapped into another random surviving index (distinct from winner and #1)
Treasury	10%	Sent directly to protocol treasury

Each buyback swap immediately increases the receiving index's token price. This is one of the primary ways players profit. All random selections use the Quiver VRF randomness so no one — not validators, not the protocol — can predict or manipulate which indexes receive buyback ETH.

Step 4: Circuit Breaker

After each buyback swap, a 5-minute circuit breaker activates on the receiving pool. During this window, selling fees start at 90% and decay linearly back to normal over 5 minutes.

This prevents bots and frontrunners from immediately dumping after the buyback pump, ensuring organic price discovery.

Step 5: Mark and Reset

The delisted index is permanently marked as delisted. Its token still exists as an ERC20 but can no longer be traded through the router. A new 4-hour countdown begins.

Randomness Timeout Fallback

If the randomness callback fails to arrive within 1 hour (RANDOMNESS_TIMEOUT), the contract owner can call cancelPendingDelisting(), which completes the delisting using fallback entropy derived from keccak256(blockhash(block.number - 1), block.timestamp, ...). This liveness safety net applies regardless of which randomness provider is active, and ensures finalized governance votes are never discarded — the delisting always completes.

(Note: block.prevrandao is deliberately not used — on Arbitrum-stack chains like Robinhood Chain it is the constant 1 and provides no entropy.)

The Endgame

As indexes are delisted, the dynamics change dramatically:

• Fewer indexes = larger share of buyback ETH per survivor
• Concentrated liquidity = more ETH flowing into fewer pools
• Higher stakes = each vote becomes more consequential
• Coalition shifts = previously allied indexes may turn on each other

The game continues until only one index remains.

Market Close & The Prize Pot

When the final delisting reduces the listed indexes to 1, the game ends automatically:

1. gameOver is set to true — no more countdowns or votes
2. The surviving index is recorded as the winningIndex
3. The Prize Pot is finalized — its ETH balance and the winning token's supply are snapshotted

The winning index's token holders can then forfeit their tokens to redeem proportional ETH from the prize pot — a redemption at NAV. This is the RFV (Risk-Free Value) — a guaranteed payout for every token held.

Throughout the game, 30% of all trading fees across every index flow into the Prize Pot. The more trading volume the game generates, the larger the pot grows. See Prize Pot & RFV for full details on how redemption works.

Cycle Timing Summary

Phase	Duration	Key Action
Countdown	4 hours	Trade freely, build market cap
Voting	5 minutes	Top holders cast secret, ZK-proved votes
Reveal	1 tx	Keeper decrypts and submits revealAndFinalize
Execution (Phase 1)	Instant	Request randomness from Quiver via QuiverRandomnessProvider
Randomness Pending	~seconds	Waiting for Quiver's Fletcher keeper to deliver the reveal callback
Execution (Phase 2)	Instant	Delist target, redistribute ETH
Circuit Breaker	5 minutes	High sell fees decay on buyback recipients
New Countdown	4 hours	Cycle repeats