Abstract
We outline an OP Stack dispute game in which a proposer posts an output root without embedding proof material in the factory identity. At least one configured proof lane must support the root during the initial one-day challenge window. If nobody challenges and a proof was submitted, the game may resolve in favor of the proposer; without a proof it resolves against the proposer. A challenge may be submitted whether or not the initial proof already exists and raises the requirement to two independent proof lanes by seven days from game creation. The stock DisputeGameFactory, AnchorStateRegistry, and OptimismPortal2 remain responsible for game creation, claim validity, and withdrawals; a WIP-1006 ERC20StakingVault holds proposal and challenge bonds in a deployment-selected ERC-20 token. World Chain configures WLD as that bond token.
Motivation
The vanilla OP Stack fault-proof system inherits a multi-day challenge window for every proposal and routes every dispute through a single interactive fault-proof lane. Base’s Azul proof system reduces that window when two heterogeneous proofs (TEE and ZK) agree, but still requires a proof on the common path and still rests final resolution on at most two lanes.
World Chain targets two properties that neither model provides together:
- A stable factory identity. Proof bytes are submitted to the created game rather than included in
extraData, so the stock factory UUID remains predictable from the transition. - A cheap common path. Only one configured proof lane is required when no participant objects to a root.
- A diversified disputed path. When a root is challenged, the proposer must defend it, and no single prover, TEE vendor, or council action can finalize that defense. At least two independent lanes must agree.
The result is fast finality in the common case and n / m threshold security in the dispute case.
Specification
The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “NOT RECOMMENDED”, “MAY”, and “OPTIONAL” in this document are to be interpreted as described in RFC 2119 and RFC 8174.
Constants
Protocol constants are fixed by this WIP and MUST NOT be changed without a new WIP.
| Name | Value | Meaning |
|---|---|---|
PROOF_LANE_COUNT | 3 | Number of configured proof lanes. |
CHALLENGER_REWARD_BPS | 5,000 | Share of a forfeited proposer bond paid to the challenger after a challenged proof timeout, in basis points. |
Activation Parameters
Activation parameters are set at hardfork activation and held as immutable values on the proof system contracts. They MAY be retuned only by a subsequent activation. All implementations MUST commit to these values in their deployed configuration and MUST NOT permit per-call overrides.
Proof-system identities (aggregationVKey, rangeVKeyCommitment, and teeImageId) are also
immutable game-implementation configuration, but are not fixed protocol constants. Rotating one
requires activating a new game implementation; existing games retain their original identities.
| Name | Initial Value | Meaning |
|---|---|---|
PROOF_THRESHOLD | 2 | Number of distinct proof lanes that MUST support a challenged root before it finalizes. The implementation accepts values from 2 through PROOF_LANE_COUNT. |
BLOCK_INTERVAL | TBD | Exact distance each proposal MUST advance from its parent. |
CHALLENGE_PERIOD | 1 day | Duration after proposal creation during which any participant MAY challenge a root and any party MAY submit the initial proof. Per-proposal challengeDeadline = createdAt + CHALLENGE_PERIOD. |
PROOF_PERIOD | 7 days | Duration after proposal creation during which the proposer MAY defend a challenged root by accumulating lane submissions toward PROOF_THRESHOLD. Per-proposal proofDeadline = createdAt + PROOF_PERIOD. PROOF_PERIOD MUST be greater than CHALLENGE_PERIOD. A challenged root that the proposer has not defended to PROOF_THRESHOLD by proofDeadline MUST be invalidated. |
PROPOSER_BOND | TBD | Bond tokens locked from the creator’s available vault balance during factory creation. Paid to the proposer after DEFENDER_WINS, split between the challenger and protocol after a challenged proof timeout, paid to the protocol after an unchallenged proof timeout, or refunded if the registry invalidates the game. |
CHALLENGER_BOND | TBD | Bond tokens locked from the challenger’s available vault balance at challenge time. Split between the proposer and accepted proof-lane recipients after a successful defense, returned to the challenger after proof timeout, or refunded if the registry invalidates the game. |
PROTOCOL_FEE_RECIPIENT | TBD | Nonzero protocol-controlled recipient credited with the proposer bond after an unchallenged proof timeout and with the portion not paid to the challenger after a challenged proof timeout. |
Proof Lanes
A challenged root finalizes only when at least PROOF_THRESHOLD distinct lanes are accepted by the same game. Each lane counts at most once per game. The lanes do not need to authenticate byte-identical payloads: the validity and TEE lanes authenticate the transition, while the Security Council authenticates the proposal’s rootId. The game derives both statements from its own state.
| Lane | Source | Submission |
|---|---|---|
VALIDITY_PROOF | A configured validity proof verifier (zkVM or SNARK). | Permissionless. |
TEE_ATTESTATION | A registered TEE signer attesting to the transition. | Anyone MAY relay a valid signed attestation. |
SECURITY_COUNCIL | A Security Council threshold signature or multisig action. | Council-controlled attestation. |
Multiple proofs from the same lane MUST NOT increase the threshold count.
Identifiers and Authenticated Statements
The factory UUID identifies a game, while each proof lane authenticates a statement derived by that game. The implementation fixes the complete domain. Each proposal supplies that domain’s hash in extraData, allowing the game to reject cross-domain proposals and ensuring that the factory UUID changes when the proof-system domain changes.
Proposal (per-proposal)
| Field | Source | Meaning |
|---|---|---|
rootClaim | Proposer | Claimed L2 output root, computed as in the OP Stack output-root V1 encoding. |
domainHash | Proposer | Hash of the implementation’s immutable domain. The game MUST reject a value that differs from its configured domainHash. |
l2BlockNumber | Proposer | L2 block number for rootClaim, matching the l2BlockNumber field of an OP Stack L2 output proposal. |
parentRef | Proposer | Address of the parent — the AnchorStateRegistry for the first proposal, otherwise the parent proposal. Same convention as the OP Stack Fault Dispute Game extraData parent reference and the parent reference encoded in Base Azul’s AggregateVerifier extra-data layout (see Base Azul proof system). The parent’s rootClaim and l2BlockNumber are read from this reference rather than re-supplied. |
attempt | Proposer | Retry nonce for the same transition. Attempt zero is the initial game; later attempts are permitted only after an eligible predecessor fails or is made obsolete by activation. |
l1OriginHash | Factory | Previous L1 block hash captured at proposal creation. The proposer does not pass it as calldata. |
l1OriginNumber | Game | L1 block number paired with the factory-captured l1OriginHash. |
The proposer deposits the configured bond token into ERC20StakingVault and calls DisputeGameFactory.create(gameType, rootClaim, extraData), where:
extraData = abi.encode(domainHash, l2BlockNumber, parentRef, attempt)
Domain (game-immutable)
| Field | Meaning |
|---|---|
chainId | World Chain L2 chain ID. |
proofSystemVersion | Version of this proof system’s proof-domain encoding. |
rollupConfigHash | Hash of the rollup configuration and World Chain hardfork schedule. |
blockInterval | Exact distance in L2 blocks between a parent root and a proposed root. |
These values are set once on the game implementation (analogous to Base’s CONFIG_HASH and L2_CHAIN_ID immutables). Their hash is supplied in each game’s extraData and MUST equal the implementation’s immutable domainHash. The game implementation also pins the aggregation vkey, range vkey commitment, and TEE image ID. Lane verifier contracts are reusable: the game supplies its pinned identity to the selected verifier for every proof.
Identifiers and statements
The contracts use two related identifiers and one transition statement:
gameUUIDis the stockDisputeGameFactorylookup key and the unique identifier for a game creation. It commits togameType,rootClaim, and the completeextraData, but excludes the factory-captured L1 origin.rootIdis the Security Council’s proposal commitment. It includes the factory-captured L1 origin and is also used to correlate proof events and errors. It is not the factory UUID and does not includeattempt.transitionis the state-transition statement authenticated by the validity and TEE lanes. The game derives it from its L1 head, parent proposal, root claim, L2 block number, and immutable rollup configuration.
The contract computes:
domainHash = keccak256(abi.encode(
chainId,
proofSystemVersion,
rollupConfigHash,
blockInterval
))
extraData = abi.encode(
domainHash,
l2BlockNumber,
parentRef,
attempt
)
gameUUID = keccak256(abi.encode(
gameType,
rootClaim,
extraData
))
rootId = keccak256(abi.encode(
domainHash,
parentRef,
rootClaim,
l2BlockNumber,
l1OriginHash,
l1OriginNumber
))
transition = TransitionPublicValues({
l1Head: l1OriginHash,
l2PreRoot: parentRoot,
l2PreBlockNumber: parentL2BlockNumber,
l2PostRoot: rootClaim,
l2PostBlockNumber: l2BlockNumber,
rollupConfigHash: rollupConfigHash
})
The factory MUST reject duplicate games with the same gameUUID. The game MUST construct the expected lane statement from its own state; callers MUST NOT be able to override it. The validity lane MUST authenticate abi.encode(transition, rangeVKeyCommitment) under the game-pinned aggregation vkey. The TEE lane MUST authenticate abi.encode(transition) with a signer registered for the game-pinned TEE image ID. The Security Council lane MUST authenticate abi.encode(rootId) under a council-specific signature domain.
Proof reuse across games is permitted only when the authenticated transition and relevant verifier identities are identical. Such reuse proves the same state transition and MUST NOT allow a proof for one parent, root, block range, rollup configuration, aggregation program, range program, or TEE image to authorize another.
State Machine
The OP Stack lifecycle uses GameStatus for externally consumed resolution. The WIP-facing root states map onto it as follows:
stateDiagram-v2
[*] --> PROPOSED: factory.create(root)
PROPOSED --> FINALIZED: PROOF_THRESHOLD lanes
PROPOSED --> FINALIZED: one proof + unchallenged deadline
PROPOSED --> INVALIDATED: no proof at unchallenged deadline
PROPOSED --> CHALLENGED: bonded challenge before challenge deadline
CHALLENGED --> FINALIZED: resolve after PROOF_THRESHOLD lanes
CHALLENGED --> INVALIDATED: resolve after proof timeout
PROPOSED --> INVALIDATED: resolve after parent invalidation
CHALLENGED --> INVALIDATED: resolve after parent invalidation
FINALIZED --> [*]
INVALIDATED --> [*]
FINALIZED corresponds to GameStatus.DEFENDER_WINS; INVALIDATED corresponds to GameStatus.CHALLENGER_WINS. Game resolution alone does not make a claim withdrawable. The stock AnchorStateRegistry separately determines whether the game is proper, respected, beyond the finality delay, and claim-valid.
Proposal Lifecycle
A root enters the system in the PROPOSED state.
- The proposer deposits bond tokens into its available vault balance, then calls the stock
DisputeGameFactory.createwith zero ETH. The factory creates a clone, captures its caller asgameCreatorand the L1 head, and callsinitialize. - The game validates the domain, parent registration and eligibility, exact L2 block interval, and retry predecessor, then asks the vault to lock
PROPOSER_BOND. - The factory registers a game only after
initializereturns, so the vault authenticates the caller as the deterministic clone the factory deploys for the current implementation and the caller’s creation data, then debitsPROPOSER_BONDfromgameCreator’s available balance. Any failure reverts the entire creation. - The game records
createdAt = block.timestamp,challengeDeadline = createdAt + CHALLENGE_PERIOD, andproofDeadline = createdAt + PROOF_PERIOD. - The root remains open to challenge until
challengeDeadline.
The account calling create is both gameCreator and the bonded proposer. Once a game is registered, it remains authorized to settle through the same singleton vault even if the factory later registers a newer implementation. Game-implementation rotations MUST reuse that vault so settled balances remain available across versions.
The DisputeGameFactory owner and vault ProxyAdmin owner MUST remain the same governance authority. This is required because the factory owner selects the implementations on whose word the vault allocates participant balances, while the ProxyAdmin owner controls the vault implementation and break-glass custody. New bond locks MUST fail closed if those owners diverge, and deployment and activation tooling MUST validate the invariant.
Proof material MUST NOT be part of factory creation or extraData. After the game exists, any party MAY submit a valid configured proof lane before challengeDeadline. Offchain services MAY choose a preferred operational lane, but the onchain protocol MUST NOT privilege one lane for the initial proof.
An initial attempt = 0 identifies the first game for a transition. A later attempt keeps the same parentRef, increments attempt, and MUST be accepted only after the preceding attempt enters a protocol-defined recovery case, such as a proof timeout or a game created before WIP-1006 became respected.
Challenge Lifecycle
Any participant MAY challenge a proposed root before challengeDeadline, regardless of whether an initial proof lane already supports it. A challenge goes through optimistically: the challenger is not asked to prove that the root is invalid, and the challenge succeeds by default unless the proposer defends the root. The challenge raises the required support from one lane to PROOF_THRESHOLD.
The challenge transaction:
- MUST NOT require the caller to submit proof material.
- MUST atomically lock
CHALLENGER_BONDfrom the caller’s available vault balance; - MUST mark the root as
CHALLENGED. - MUST NOT change the
proofDeadlinederived from proposal creation.
If the challenged root resolves in favor of the proposer, the challenger bond is split equally between the proposer and each accepted proof-lane recipient; the proposer also recovers the proposer bond. If it times out below threshold, the challenger recovers the challenger bond plus CHALLENGER_REWARD_BPS of the proposer bond, and the protocol receives the remainder. A game accepts only one challenger.
A challenge submitted at or after challengeDeadline MUST revert.
Unchallenged Finality
An unchallenged root that reaches PROOF_THRESHOLD MAY resolve immediately with DEFENDER_WINS.
Otherwise, if no valid challenge has been submitted by challengeDeadline, anyone MAY call
resolve(). The game MUST resolve with DEFENDER_WINS when all of the following hold:
- the root is still
PROPOSED; - the parent is the anchor sentinel or has resolved with
DEFENDER_WINS; and - the parent is not blacklisted; and
- either at least
PROOF_THRESHOLDconfigured lanes have been accepted by the game, orblock.timestamp >= challengeDeadlineand at least one configured lane has been accepted by the game.
If no proof lane supports the root at challengeDeadline, the game MUST instead resolve with CHALLENGER_WINS, record proof timeout, and credit the proposer bond to the configured protocol recipient. This outcome MUST remain retryable even when no challenger exists.
A self-blacklisted, retired, unrespected, or otherwise improper game may still have DEFENDER_WINS status, but the registry MUST reject its claim and the game MUST use refund-mode bond settlement.
Proposer Defense and Challenged Finality
Once a root is challenged, the burden of proof rests with the proposer, who MUST defend the root by establishing its validity. A challenged root MUST NOT finalize merely because time has elapsed. It finalizes only when the proposer’s defense assembles support from at least PROOF_THRESHOLD distinct proof lanes for the root, and only if the threshold is met before proofDeadline.
Defending the root is the proposer’s responsibility because the proposer’s PROPOSER_BOND is forfeited if the root fails to reach the threshold. Lane submission itself remains permissionless — any party MAY relay a valid lane submission, and a proposer MAY coordinate independent provers, TEE signers, and the Security Council to do so — but the protocol assigns the economic responsibility for the defense to the proposer and to no other party.
Each root tracks a per-lane support set (the proof bitmap) with one bit per entry in Proof Lanes. Each lane’s bit is set at most once, and a duplicate submission MUST revert. Each submission also names the recipient of that lane’s share of a forfeited challenger bond.
For each lane submission, the contract MUST:
- Verify that the game is still in progress.
- Verify that
block.timestamp < challengeDeadlinewhen unchallenged, orblock.timestamp < proofDeadlinewhen challenged. - Decode the lane, reward recipient, and lane-specific proof from the compact payload.
- Construct the lane-specific statement and verifier identity from the game’s own state and immutable configuration.
- Verify the proof or attestation according to the lane-specific verifier.
- Set the lane’s bit, record its reward recipient, and emit
Provedwith the updated bitmap.
A lane submission at or after its applicable deadline MUST revert. Once threshold is met, anyone MAY call resolve(), which MUST resolve the game with DEFENDER_WINS whether or not it was challenged.
If block.timestamp >= proofDeadline and the proof bitmap contains fewer than PROOF_THRESHOLD distinct lanes, anyone MAY call resolve(). The game MUST resolve with CHALLENGER_WINS, record proof timeout as the invalidation reason, return the challenger bond, credit CHALLENGER_REWARD_BPS of the proposer bond to the challenger, and credit the remainder to PROTOCOL_FEE_RECIPIENT.
Invalidity and Conflicts
Invalidation occurs either when a challenged root times out below threshold or when its parent is blacklisted or resolves with CHALLENGER_WINS. Parent invalidation observed before descendant resolution MUST cascade. Because neither participant caused an ancestor failure, the descendant proposer and challenger MUST recover their full bonds.
A descendant MAY resolve after its parent resolves with DEFENDER_WINS but before the parent’s registry finality airgap elapses. This allows consecutive games’ finality windows to overlap. If a resolved parent is found invalid during that overlap, the guardian MUST pause the system and blacklist the parent and every already-resolved descendant before unpausing; descendants that have not resolved yet inherit the invalid parent automatically.
An invalidated root MUST NOT become claim-valid or update the anchor.
If invalidity of a finalized root is discovered after the fact — for example, via an offchain proof exhibiting a conflicting (parentRoot, l2BlockNumber) → rootClaim' — the protocol MUST NOT silently roll back finalized state. The configured safety process MUST be triggered: pausing the proof game type, blacklisting the game, or routing the incident to governance.
Lane-Specific Requirements
Validity Proof
The validity proof lane verifies that the transition from parentRoot at parentL2BlockNumber to rootClaim at l2BlockNumber is valid from l1OriginHash under rollupConfigHash. The verifier MAY be implemented with a zkVM, a SNARK, or another cryptographic proof system. For SP1, the proof MUST authenticate abi.encode(transition, rangeVKeyCommitment) under the aggregation vkey pinned by the game. It MUST be verified onchain or by an onchain verifier gateway.
TEE Attestation
The TEE lane accepts a signature from a registered TEE signer over abi.encode(transition). Signer admission MUST verify the hardware attestation, approved image measurements, and attestation freshness before deriving and activating the signer’s identity. For each proof, the lane verifier MUST recover the signer from the transition signature and require that the signer is registered for the TEE image ID pinned by the game. Revocation MUST prevent all subsequent proofs from that signer.
Security Council Attestation
The Security Council lane accepts a threshold signature, multisig transaction, or equivalent onchain action from the configured council. The attestation MUST bind to rootId and MUST be domain-separated from other council actions. A council attestation counts as one lane and MUST NOT finalize a challenged root by itself.
Anchor Updates
Only claim-valid games may update the canonical anchor. The stock anchor registry MUST enforce:
- factory registration;
- respected-at-creation status;
- the dispute-game finality delay;
DEFENDER_WINS;- monotonically increasing L2 block numbers;
- rejection of games that are blacklisted, retired, or paused.
Blacklist, retirement, pause, and respected-game-type controls MUST remain gated by the stock OP guardian role. Anchor updates SHOULD be permissionless and self-validating. Failure to advance the anchor MUST NOT prevent an otherwise finalized game from closing or a claim-valid game from supporting a withdrawal.
Bond Settlement
Resolution assigns normal-mode credits without releasing bond tokens. After the stock dispute-game finality delay, anyone MAY call closeGame() to fix the bond distribution mode:
NORMALwhenAnchorStateRegistry.isGameProper(game)is true;REFUNDwhen the game has been blacklisted, retired, or otherwise made improper.
Closing SHOULD attempt to advance the anchor but MUST treat an ineligible or stale anchor update as non-fatal. It MUST atomically settle the full game pot into the selected recipients’ available vault balances, making those balances immediately reusable for new bonds, reject duplicate settlement, and preserve exact payout conservation. External withdrawal is account-controlled and two-phase: the account requests an amount, waits the configured delay, and withdraws bond tokens. A new request resets the delay for the full pending amount.
The vault MUST maintain one-to-one bond-token-denominated liabilities and MUST NOT issue transferable shares or apply an exchange rate. Direct token donations MAY make assets exceed liabilities. Insolvency MUST NOT prevent internal game settlement, but an external transfer may fail until the vault is recapitalized. System pause blocks external withdrawal but does not block deposits, withdrawal requests, or challenges to existing games; game creation and closing retain their existing ASR pause checks.
For challenged DEFENDER_WINS, CHALLENGER_BOND MUST be split equally between the proposer and every accepted proof-lane recipient, with any integer-division remainder credited to the proposer. For challenged PROOF_TIMEOUT, the challenger receives its bond plus CHALLENGER_REWARD_BPS of PROPOSER_BOND; PROTOCOL_FEE_RECIPIENT receives the rest of PROPOSER_BOND. REFUND mode returns the full deposited bonds to their depositors instead of applying normal-mode rewards.
Portal Withdrawals
OptimismPortal2.proveWithdrawalTransaction selects a game by its stock factory index. The Portal MUST require the game to be proper and respected and MUST verify the output-root proof against the game’s rootClaim. Withdrawal finalization occurs only after the proof-maturity delay and AnchorStateRegistry.isGameClaimValid(game) returns true. A game does not need to be the current anchor to support a withdrawal.
Contract Interfaces
WIP-1006 is implemented as a new game type on the stock OP Stack dispute infrastructure. The game follows the canonical clone-with-immutable-args and IDisputeGame ABI while retaining World Chain-specific challenge and proof-lane behavior.
| Interface | Role | Reference |
|---|---|---|
IDisputeGameFactory | Stock OP factory; registers the WIP-1006 implementation, creates clones, indexes games by UUID and list index, and captures l1Head. | DisputeGameFactory |
IDisputeGame / IMultiProofGame | Per-proposal game; exposes the Portal-facing lifecycle and World Chain proof-lane extensions. | AggregateVerifier |
IAnchorStateRegistry | Stock OP registry; evaluates registration, respect, blacklist, retirement, finality, claim validity, and the current anchor. | AnchorStateRegistry |
IERC20StakingVault | Accepts participant deposits, locks WIP-1006 proposal and challenge bonds from available balances, settles finalized game payouts, and enforces delayed token withdrawal. | IERC20StakingVault |
IWorldChainProofVerifier | Common interface for verifying lane proofs against a game-supplied verifier identity and game-derived public values. | IWorldChainProofVerifier |
NitroEnclaveKeyRegistry | Maintains TEE signer identities admitted through Nitro attestation. | NitroEnclaveKeyRegistry |
SecurityCouncilVerifier | Verifies the council Safe’s ERC-1271 attestation over rootId. | SecurityCouncilVerifier |
Backwards Compatibility
This proposal is implemented as a new World Chain game type registered on the existing OP Stack DisputeGameFactory. Existing output roots and Cannon-style games do not need to be reinterpreted. Activating the type consists of deploying the vault, registering the game implementation, setting the factory’s type-1006 ETH initialization bond to zero, and switching the stock AnchorStateRegistry respected game type after operational readiness.
The proposal data remains aligned with the OP Stack:
rootClaimfollows the OP Stack output-root V1 encoding.l2BlockNumbermatches thel2BlockNumberfield of an L2 output proposal.parentReffollows the Fault Dispute GameextraDataparent reference convention — theAnchorStateRegistryfor the first proposal, otherwise the parent proposal address.l1OriginHashis factory-captured at proposal creation, matching the L1 head snapshot taken byDisputeGameFactoryat clone creation.- factory identity uses the canonical
(gameType, rootClaim, extraData)UUID; domainHash,l2BlockNumber,parentRef, andattemptare encoded inextraData.
Proposers and challengers deposit enough bond tokens into their available vault balances before using the stock factory and game APIs. deposit(account, amount) transfers the caller’s tokens and credits the selected account, and no standing allowance is required after a deposit. Offchain services do not require a custom factory or anchor registry. Proposers and defenders MAY reconstruct a selected lineage by looking up the expected transition from the current anchor; challengers use the factory index to inspect all games. A deployment MAY have its defender submit the TEE lane as the initial operational policy, but challenged games MUST still be escalated with an independent lane.
Test Cases
Before this WIP can move beyond Draft, implementations SHOULD cover at least:
- a newly created game has no proof support and a factory UUID independent of later proof bytes;
- the proposer bond is locked from
gameCreatoratomically with factory creation, and creation reverts without sufficient available balance; - the vault rejects a proposer-bond lock from any caller that is not the deterministic clone the canonical factory deploys;
- an already registered game can settle after the factory implementation is replaced;
- an unchallenged root with any one valid configured lane finalizes after exactly
CHALLENGE_PERIOD; - an unchallenged root with
PROOF_THRESHOLDdistinct lanes finalizes beforeCHALLENGE_PERIOD; - an unchallenged proofless root invalidates after exactly
CHALLENGE_PERIOD, forfeits its proposer bond to the configured protocol recipient, and can be retried; - factory creation rejects an incorrect domain hash or malformed
extraData; - factory UUID lookup and
findLatestGamespreserve the complete WIP-1006extraData; - any account can challenge without proof by posting
CHALLENGER_BONDbefore the deadline; - an account can challenge after an initial proof, and the game then requires
PROOF_THRESHOLDlanes; - a proposer that challenges its own game and lets it time out loses the protocol share of
PROPOSER_BOND; - challenged
DEFENDER_WINSsplitsCHALLENGER_BONDbetween the proposer and accepted proof-lane recipients; - a challenge at or after the deadline reverts;
- a configuration where
proofDeadline <= challengeDeadlineis rejected; - a challenged root with one supporting lane does not finalize;
- a proposer defends a challenged root to finalization with two distinct supporting lanes;
- a challenged root the proposer fails to defend to
PROOF_THRESHOLDlanes byproofDeadlineinvalidates and forfeitsPROPOSER_BOND; - a lane submission at or after
proofDeadlinereverts and does not affect the proof bitmap; - challenging a root does not change its creation-time
proofDeadline; - duplicate submissions from the same lane revert without changing the threshold count or reward recipient;
- the validity and TEE lanes reject a proof for a different transition or verifier identity, and the Security Council lane rejects an attestation for a different
rootId; - parent invalidation cascades and refunds both descendant participants;
- retry attempts reject an ineligible predecessor and accept each specified recovery case;
- close atomically settles normal mode for proper games and refund mode for blacklisted or retired games;
- vault liabilities remain exact across deposits, bond locks, settlement, delayed withdrawals, and participant-address overlap;
- Portal withdrawal proof and finalization accept a claim-valid WIP-1006 game and reject blacklisted, retired, unrespected, challenger-winning, or insufficiently mature games.
Security Considerations
Unchallenged-path safety relies on one proof lane. Any single configured lane may support the common path. An invalid root can therefore finalize if one lane is compromised and no honest participant challenges it before challengeDeadline. A timely challenge escalates the game to the independent-lane threshold.
Disputed-path safety depends on lane independence. A false challenged finality requires two lanes to accept the same invalid root. Implementations MUST avoid shared signing keys, shared verifier keys, shared operator control, and shared offchain infrastructure across lanes, because any such sharing collapses the effective threshold below two.
TEE trust assumptions live in one lane. The TEE lane rests on the hardware vendor, attestation verification, the owner-managed PCR allowlist, the game-pinned PCR0 image ID, and enclave signer-key security. Registration is permissionless, but only an attestation for an approved PCR tuple can add a signer. A weakened PCR policy, compromised signer key, or vulnerable approved image can turn this lane unsafe without affecting the other two. The TEE lane is counted exactly once, and a challenge MUST require an additional independent lane.
Security Council is a safety valve, not a finality mechanism. Council signing keys, quorum rules, and action domains MUST be isolated from unrelated governance actions. A council attestation alone MUST NOT finalize a challenged root.
Lane statement binding is critical. The validity and TEE lanes MUST authenticate the exact transition reconstructed by the game. rollupConfigHash MUST commit to every derivation-affecting configuration value, including chain IDs and the World Chain hardfork schedule, and MUST change when any such value changes. A validity-program change MUST rotate the applicable vkey, and a TEE-program change MUST rotate the image ID. The Security Council attestation MUST bind to rootId, whose domainHash commits to chainId, proofSystemVersion, rollupConfigHash, and blockInterval. Missing any of these bindings can permit a proof or attestation to be accepted outside the context in which it was produced.
gameUUID is not a proof target. It exists for factory duplicate prevention, deterministic deployment, and discovery. The validity and TEE lanes authenticate the game-derived transition instead; the Security Council authenticates rootId. The game, rather than the proof submitter, MUST construct each expected statement.
Proof-lane rewards are exposed to public-mempool MEV. The lane proof does not authenticate the compact payload’s reward recipient. A public-mempool observer can copy a valid proof, replace the recipient, and front-run the original submission to capture that lane’s share of a forfeited challenger bond. This does not change proof validity or prevent the game from progressing, but proof submissions that claim a lane reward SHOULD use a trusted private transaction path. Private submission is an operational mitigation, not a cryptographic binding to the recipient.
Self-challenge can amplify proof work. A proposer can challenge its own valid game through another account and force defenders to produce another lane. If the game times out, the shared owner loses the protocol share of PROPOSER_BOND; if it is defended, accepted proof-lane recipients share CHALLENGER_BOND. A proposer that also controls those recipients can still recycle the successful-defense payout, so the economics limit but do not prevent proof-amplification griefing.
The vault ProxyAdmin is a custody trust assumption. The deployed implementation exposes no administrative path for moving participant balances or extracting backing tokens directly. However, the ProxyAdmin owner can upgrade the singleton vault, so its compromise can still affect uncommitted balances and backing for active games. Production deployment MUST protect this role accordingly.
Bond-lock authentication is part of factory integrity. The factory registers a game only after initialize returns, so the vault MUST authenticate a proposer bond lock by recomputing the deterministic clone address the canonical factory deploys for the current implementation and the caller’s creation data. Because locks allocate deposited balances on the word of factory-selected code, they MUST fail closed unless the factory owner and the vault ProxyAdmin owner are the same authority. Participant exposure is bounded by the bond tokens deliberately deposited into the vault.
Bond calibration is security-critical. If CHALLENGER_BOND is too cheap, attackers can force valid roots into the slow path or create repeated proof work. If it is too expensive, honest watchers may fail to challenge invalid roots. PROPOSER_BOND must make invalid proposals expensive while keeping proposal participation viable. Exact economic parameters are out of scope for this WIP but MUST be tuned before mainnet deployment.
Copyright
Copyright and related rights waived via CC0.