Skip to main content

Settlement paradigms

A rollup's settlement paradigm decides how a settlement batch becomes final once it is anchored to the Main Chain. The RDK supports four, and enforces a compatibility matrix that ties each paradigm to the sequencer modes and proof systems it can use.

ParadigmFinalityProofsSequencerNotes
optimisticDelayed (challenge window)Interactive fraud proofsdedicated / sharedDefault 604,800 s window with a challenge bond (see below)
zkInstant on a valid proofSNARK (STARK paused)dedicated / shared, or based sequencingOn-chain verification gates finalization
based~2 blocksNonebased onlyHost-chain proposers sequence the rollup
sovereignThe rollup's own consensusNonededicated / sharedSelf-sequenced, settles off the Main Chain

optimistic​

A batch is accepted on submission without a proof and finalizes after a challenge window (default 604,800 s, nominally 7 days) unless a challenger proves it fraudulent.

How long that is in practice depends on when the batch was submitted. From chain v3.2.4 the window is measured in seconds of block time, so 604,800 s is 7 days. Batches submitted before it use the original rule of window / 6 blocks, which assumed 6-second blocks: on mainnet (about 3.2 s blocks) that is roughly 3.75 days, on the testnet (about 1 s) roughly 28 hours. See how the window is measured. Challenges and the operator's response are interactive fraud proofs, backed by a challenge bond. Optimistic settlement uses the fraud proof system.

What "fraudulent" means on chain. The chain does not run your rollup. It holds the operator to one rule: a batch's published stateRoot must equal the canonical transition root of the batch's own inputs (previous root, data hash, transaction count, and from chain v3.2.5 also the chain id, rollup id and withdrawals root). A challenge whose proof names that root is upheld whenever the batch published anything else, and from v3.2.5 any account can resolve it, paid from the rollup's escrow. Compute the root with batchTransitionRoot (see Watchtower): a placeholder or a root from your own scheme is provably fraudulent.

From chain v3.2.8: qledger-v1. A new optimistic rollup must be created with executionVm: "qledger-v1" and sequencing: "based" (the nft and custom presets set both). The chain then runs the qledger-v1 model: a uqor account ledger with signed transfers and withdrawals (ML-DSA-44 account keys). Its inputs are its inbox: user posts (postRollupData) and deposits (depositToRollup). Any account holding a submitter bond (bondRollupSubmitter, at least min_submitter_bond, default 1,000 QOR) may submit a batch of up to 64 inbox entries, setting inboxEnd and carrying the inbox range commitment as dataHash. A fraud proof makes the chain re-execute the batch; if its state or withdrawals root is wrong, the batch and every batch built on it are rejected and the submitter's bond is slashed: half is burned, the challenger receives the other half. Withdrawals are paid from finalized batches only, from the rollup's deposit pool. Optimistic rollups created before v3.2.8 keep working under the transition-root rule above.

Choose it when you want low submission overhead and can tolerate delayed finality: general-purpose app-chains, NFT platforms, anything not latency- critical.

zk​

Each batch carries a validity proof (a snark; stark is paused from chain v3.2.8). The proof is verified on-chain when the batch is submitted, and a valid proof finalizes the batch immediately, with no challenge window.

The chain verifies a zk batch against a verification key registered on the rollup. From chain v3.2.7 the creator registers it with setVerificationKey or verificationKey on createRollup; on a release without it every zk batch is refused (code 21). A SNARK is Groth16 over BLS12-381 in gnark's binary encoding, with public inputs prev_state_root, state_root, data_hash and (for batches from chain v3.2.5) withdrawals_root. From chain v3.2.8 each input the submitter chooses must already be below the scalar modulus; see Proof systems.

A zk (snark) rollup can be created with sequencing: "based": anyone posts data, the order is inclusion on the chain, and since the proof binds the roots, the inbox range and the withdrawals root, any account may submit its batches. With privacy: "encapsulated" it is a private rollup: every post is an ML-KEM-1024 envelope to its members (sealEnvelope / openEnvelope).

Choose it when you need fast, trust-minimized finality — high-value DeFi, exchanges, anything that benefits from cryptographic finality without a wait.

based​

Ordering and inclusion are inherited from host-chain proposers, giving roughly two-block finality with no separate proof. Based settlement requires the based sequencer mode (the rollup does not run its own sequencer).

Choose it when you want fast finality and tight coupling to the host chain's liveness, and are comfortable delegating sequencing — high-throughput gaming or enterprise rollups.

sovereign​

The rollup runs its own consensus and settles off the Main Chain; it anchors data but carries no proofs or challenges. Finality is whatever the rollup's own consensus provides.

Choose it when you want maximum autonomy over consensus and settlement and are using QoreChain primarily for anchoring and data availability.

Compatibility​

The paradigm constrains the proof system and (for based) the sequencer mode:

  • optimistic → fraud
  • zk → snark (stark is paused)
  • optimistic also needs executionVm: "qledger-v1" and sequencing: "based" for a new rollup
  • based → none (and based sequencer mode)
  • sovereign → none

The RDK validates these before anything is submitted. See Proof systems for the full matrix and Sequencer modes for the based constraint.