Rollups Overview
The QoreChain Rollup Development Kit (RDK) is a set of client libraries (TypeScript, Python, Go, Rust and Java), an operator command-line tool and starter templates for building application-specific rollups that settle on QoreChain through the on-chain x/rdk module. With it you configure a rollup, build and sign its transactions, read its state, follow its challenge windows, issue and verify settlement receipts, and assemble cross-VM calls and withdrawal proofs. Each rollup is an independent execution environment with its own block time, virtual machine, fee model and sequencing, while it inherits QoreChain's security, post-quantum cryptography and data availability. This page is for developers who want to launch or operate a rollup, and for anyone deciding whether the RDK fits their application.
The RDK is deployed on both networks, but no rollup has been created on either one yet (checked 27 October 2026), so the flows described in this section have not been exercised by third parties. ZK settlement (the defi profile, the defi-rollup template and every zk rollup) has not been tried on either network: the verification-key messages are enabled on mainnet since chain v3.2.7 (12 November 2026) and on the testnet since 6 November 2026 (see ZK / STARK & Withdrawals), but no ZK rollup has been created. Use optimistic settlement until a ZK rollup has been run end to end.
Mainnet (qorechain-vladi, EVM chain ID 9801, live since 7 June 2026) runs chain version v3.2.7 (governance proposal 16 applied it at height 4,164,600 on 12 November 2026; v3.2.6 had been applied at height 4,020,000 on 4 November 2026 by proposal 15; v3.2.5 had been applied at height 3,906,833 on 29 October 2026 by proposal 14, and v3.2.4 at height 3,742,566 on 23 October 2026, proposal 13); the testnet (qorechain-diana, EVM chain ID 9800) runs v3.2.8 since 12 November 2026 (height 9,929,500; v3.2.4 reached it on 19 October 2026, v3.2.5 on 26 October, v3.2.6 on 27 October, v3.2.7 on 6 November). Mainnet is one release behind the testnet: it has not applied v3.2.8. What v3.2.5 changes for rollups is listed under chain v3.2.5 behaviour; it applies on both networks. Where behaviour changed between v3.2.3 and v3.2.4, this section says which release applies. Validate every deployment on the testnet first, and read the status notes on each page: several capabilities (ZK verification, Celestia data availability, the QCAI Copilot, cross-VM calls, settlement receipts) are not usable end to end today.
Innovations
- Post-quantum settlement receipts. A batch's state anchor is signed with ML-DSA-87 by the rollup creator's registered key.
verifySettlementReceiptre-reads every field of the receipt from the chain (rollup, layer, batch root, and the anchor: state root, layer height, Main Chain height, anchor time, validator-set hash, transaction count, proof, signature). The verifying key comes from the chain and never from the receipt; the receipt must name the network you query; an unknown receipt version or an algorithm other than ML-DSA-87 is refused before any read; and a signature-only check is never reported as valid. The anchor message has a first form below the height of chain v3.2.2 and a second form, which also binds the chain id, from it; the version is chosen by the anchor's height. See Settlement receipts. - Hybrid signing with two key derivations. Transactions are signed with secp256k1 plus ML-DSA-87. The post-quantum key is derived from the mnemonic both in the canonical way (SHAKE-256 over
qorechain:pqc:v1|, the address and the mnemonic) and in the legacy way, and the client uses whichever key the chain has registered for the account. The Python, Go, Rust and Java clients sign hybrid from 0.8.0 and the CLI from 0.7.1; before that only the TypeScript client did. - Withdrawal proofs built as the chain builds them.
withdrawalsTree(0.7.0, all five languages) builds a batch's withdrawals root and every proof exactly as the chain does: leaf position is the withdrawal index, nodes are hashed with SHAKE-256, and batches from chain v3.2.5 use second-form leaves that also name the chain id. It is tested against vectors produced by the chain's own code, and every proof in those vectors is accepted by the chain's verifier.qorollup withdrawrefuses before paying a fee when its result is not the batch's on-chainwithdrawals_root. - Canonical transition root.
batchTransitionRootcomputes the exact state root the chain judges an optimistic batch by (the form mainnet applies today is a SHAKE-256 commitment of the previous state root, the data hash and the transaction count;transitionRootVersionForselects the form the connected network applies), andfraudProofbuilds the 64-byte proof from it. Both were tested against vectors generated by the chain's own code. - Chain-exact challenge windows.
batchChallengeWindowcomputes a batch's window the way the chain does (time-based: open while block time is below the submission time plus the window; for older batches, the window divided by six in blocks from the submission height) and judges it against the chain tip read from RPC/status, not the local clock. The Watchtower and the health monitor use it. From 0.7.0,getRollupHealthalso reportsheldBackBywhen the chain's in-order finality (v3.2.5, both networks, see chain v3.2.5 behaviour) is holding a batch back, andqorollup watchtower --canonicalreports the batches a challenge would win. - Checks before any fee is paid. The kit refuses a rollup id outside
^[a-z0-9][a-z0-9._-]{2,63}$; a withdrawal that is not inuqor, has a zero amount, carries a proof deeper than 64 levels of 32 bytes or names an invalid bech32 address; a withdrawals root that is not empty or exactly 32 bytes; a rollup stop the chain will refuse (v3.2.5 and later); and, when it can read the rollup, a batch that names a data hash on anativeorbothdata-availability rollup. Each of these would otherwise be refused by the chain after the fee is spent. - Cross-VM calldata and a live check.
encodeCrossVmCalldatabuilds calldata forexecuteCrossVMCall(uint8,string,bytes)(selector0x3c11078c, precompile0x...0901), andisCrossVmPrecompileActivereads whether the precompile is active on the network. From 0.7.0,getCrossVmParams,crossVmTargetReady,decodeCrossVmResultanddecodeRevertReasoncover the chain v3.2.5 allowlist and reply formats (both networks). See Multi-VM. - One set of test vectors for five languages. The TypeScript, Python, Go, Rust and Java packages are checked against the same golden fixture (the Go package has 100 unit tests, Rust 77 and Java 75).
How to use
Reads need no key and no funds. The snippets below read the live rdk module parameters and the list of rollups on the public testnet (qorechain-diana) and were run on 27 October 2026 from the published packages (these runs used 0.7.0; the current version is 0.9.0; 0.8.0 added hybrid signing to the Python, Go, Rust and Java clients and leaves the read calls shown here unchanged, but the snippets were not re-run with it). Each printed the testnet parameters (max rollups 200, minimum stake 10,000 QOR, creation burn rate 0.01, default challenge window 3,600 seconds, maximum DA blob size 2,097,152 bytes, blob retention 432,000 blocks, maximum 10 batches per block) and 0 rollups.
TypeScript (tested)
npm install @qorechain/rdk
import { createRdkClient } from "@qorechain/rdk";
// Public testnet (chain id qorechain-diana).
const rdk = createRdkClient({
network: "testnet",
endpoints: { rest: "https://api-testnet.qore.host" },
});
// Read the live rdk module parameters and the registered rollups.
const params = await rdk.params();
const rollups = await rdk.rest.listRollups();
console.log(rdk.network.chainId, params, `${rollups.length} rollups`);
The mainnet and testnet presets already carry the public qore.host endpoints, so createRdkClient({ network: "testnet" }) works without the endpoints field; it is shown above because the tested snippet passed it. Run with Node 20 or later (the test used Node 26).
Python (tested)
pip install qorechain-rdk
from qorrdk import create_rdk_client
# Public testnet (chain id qorechain-diana).
rdk = create_rdk_client(network="testnet", endpoints={"rest": "https://api-testnet.qore.host"})
# Read the live rdk module parameters and the registered rollups.
params = rdk.params()
rollups = rdk.rest.list_rollups()
print(rdk.network.chain_id, params, f"{len(rollups)} rollups")
Python 3.10 or later. qorechain-rdk depends on qorechain-pqc, which pulls liboqs-python and needs the liboqs library; on a machine without it, the first import builds it (git, CMake and a C compiler are needed). Tested in a fresh virtual environment on Python 3.12.
Go (tested)
go get github.com/qorechain/qorechain-rdk/packages/go@v0.9.0
package main
import (
"context"
"fmt"
rdk "github.com/qorechain/qorechain-rdk/packages/go"
)
func main() {
// Public testnet (chain id qorechain-diana).
client := rdk.NewRdkClient(rdk.RdkClientOptions{
Network: "testnet",
Endpoints: &rdk.Endpoints{Rest: "https://api-testnet.qore.host"},
})
ctx := context.Background()
// Read the live rdk module parameters and the registered rollups.
params, err := client.Params(ctx)
if err != nil {
panic(err)
}
rollups, _ := client.Rest.ListRollups(ctx)
fmt.Printf("%s %+v %d rollups\n", client.Network.ChainID, params, len(rollups))
}
Tested with Go 1.26, with the module fetched from the Go proxy.
Rust (tested)
cargo add qorechain-rdk
use qorechain_rdk::client::{RdkClient, RdkClientOptions};
fn main() -> Result<(), Box<dyn std::error::Error>> {
// Public testnet (chain id qorechain-diana).
let rdk = RdkClient::new(RdkClientOptions {
rest_url: Some("https://api-testnet.qore.host".into()),
..Default::default()
});
// Read the live rdk module parameters and the registered rollups.
let params = rdk.params()?;
let rollups = rdk.rest.list_rollups()?;
println!("{} {:?} {} rollups", rdk.network.chain_id, params, rollups.len());
Ok(())
}
The library is qorechain_rdk. Tested with Rust 1.95, built against crates.io.
Java (tested)
// build.gradle.kts
implementation("io.github.qorechain:qorechain-rdk:0.9.0")
import io.github.qorechain.rdk.client.RdkClient;
import io.github.qorechain.rdk.client.Views.ParamsView;
import io.github.qorechain.rdk.config.Networks;
public class RdkQuickstart {
public static void main(String[] args) {
// Public testnet (chain id qorechain-diana).
RdkClient.Options options = new RdkClient.Options();
options.network = "testnet";
options.endpoints = new Networks.Endpoints();
options.endpoints.rest = "https://api-testnet.qore.host";
RdkClient rdk = new RdkClient(options);
// Read the live rdk module parameters and the registered rollups.
ParamsView params = rdk.params();
int rollups = rdk.rest.listRollups().size();
System.out.println(rdk.network.chainId + " maxRollups=" + params.maxRollups
+ " minStakeForRollup=" + params.minStakeForRollup + " " + rollups + " rollups");
}
}
Java 21 or later from 0.8.0 (0.7.1 and earlier ran on JDK 17); tested with JDK 21 and Gradle 9.6 resolving from Maven Central. The file must be named RdkQuickstart.java. Maven Central serves 0.7.0, 0.7.1 and 0.8.0 (checked 31 October 2026).
Command line (tested)
npm install -g @qorechain/rdk-cli
qorollup --version
qorollup params --network testnet
qorollup --version prints the installed version (0.7.0 in the test run) and qorollup params --network testnet prints the live module parameters. This works from 0.6.2. Releases 0.6.1 and earlier exited with code 0 and printed nothing when installed from npm. The test installed @qorechain/rdk-cli@0.7.0 in an empty project and ran it through node_modules/.bin/qorollup; a global install and npx use the same bin link. Node 20 or later is required.
Scaffold a project (tested)
npx create-qorechain-rollup my-rollup --template nft-rollup --network testnet --yes
cd my-rollup && npm run doctor
Templates are defi-rollup, gaming-rollup, nft-rollup, enterprise-rollup, custom-rollup and multivm-rollup. The scaffolded project depends on @qorechain/rdk ^0.9.0 (^0.8.0 in 0.8.0, ^0.7.0 before). Scaffolding nft-rollup with the 0.6.1 scaffolder produced a project whose npm run doctor passed against the testnet (REST reachable, parameters readable, network qorechain-diana; it warns about Celestia data availability and a missing signer); scaffolding defi-rollup and running npm run typecheck passed again on 27 October 2026 with the current release. Do not use defi-rollup to launch a rollup yet (see Limits). To create a rollup and submit batches, follow Deploying a Rollup; transactions need a registered post-quantum key and, in the RDK, the TypeScript client given a pqcKeypair.
How to access
Networks and endpoints. The RDK talks to the public endpoints of the two networks; the mainnet and testnet presets already carry them.
| Network | Chain id | EVM chain ID | REST endpoint | Chain version |
|---|---|---|---|---|
| Mainnet | qorechain-vladi | 9801 | https://api.qore.host | v3.2.7 |
| Testnet | qorechain-diana | 9800 | https://api-testnet.qore.host | v3.2.8 |
Both networks serve the RDK queries (/qorechain/rdk/v1/...) over REST, gRPC and the CLI, so reads such as rdk.params() work against either. The testnet is a staging network with its own parameters: the default challenge window is 3,600 seconds on the testnet and 604,800 on mainnet, at most 200 rollups can exist on the testnet and 100 on mainnet, and the multilayer module allows 64 sidechain layers on the testnet and 10 on mainnet (checked 27 October 2026). Read GET /qorechain/rdk/v1/params on the network you target.
Prerequisites for creating a rollup.
| Requirement | Details |
|---|---|
| Funded account | An account with enough QOR for the stake, the layer stake and fees. |
| Escrowed stake | Creating a rollup escrows min_stake_for_rollup, 10,000 QOR on both networks. 1 % of the stake (100 QOR) is burned on creation; the rest stays in escrow and is returned when the rollup is stopped. |
| Layer stake | Creation also registers the rollup's layer in the multilayer module (minimum stake 1,000 QOR). If the layer cannot be registered, the rollup is still created but has no real layer, so its batches cannot be anchored and no receipts can be issued. |
| Registered post-quantum key | An ML-DSA-87 key registered for the account. Native-lane transactions signed only with the classical key are refused. A new account must register its post-quantum key in a transaction of its own before anything else; the RDK clients 0.9.0 do that registration for you. |
| Fees | The fee floor is 0.1 uqor per unit of gas; set the gas limit and the fee together. |
| Tooling | Node 20 or later for the CLI and the scaffolder; Python 3.10 or later (with liboqs, see above) for the Python client; Java 21 or later for Java (from RDK 0.8.0); the Go module github.com/qorechain/qorechain-rdk/packages/go. |
Reading state needs none of these. You can also request a rollup through the Dashboard (a request form, not an on-chain transaction) or create one with the chain CLI; see Deploying a Rollup for the full flow, the CLI commands and the TypeScript signing path.
Chain v3.2.5 behaviour: live on both networks
Chain v3.2.5 is live on mainnet (applied at height 3,906,833 on 29 October 2026, governance proposal 14) and on the testnet (since 26 October 2026). Mainnet runs v3.2.7 and the testnet v3.2.8, and both include it. RDK 0.7.0 and later support both. These rules apply on both networks; no rollup has been created on mainnet yet (GET /qorechain/rdk/v1/rollups returned an empty list on 4 November 2026), so the rules below are the release's rules and have not yet been exercised by a live mainnet rollup. For a rollup developer:
| Behaviour | Both networks (v3.2.5 and later) |
|---|---|
| Who can resolve a challenge | Any account |
| After an upheld fraud | The batch and every later unfinalized batch are rejected; the sequencer resubmits from the last good root under the same indexes |
| Finality order | Batches finalize in index order |
| Pending optimistic batches | At most 4,096 per rollup |
| Stopping a rollup | Refused while the latest batch is submitted or challenged; a stopped rollup frees its slot |
withdrawals_root | Empty or exactly 32 bytes; second-form withdrawal leaves name the chain id |
| Cross-VM bridge | GET /qorechain/crossvm/v1/params serves the allowlist (bridge_allowed_targets: empty on mainnet, checked again on 4 November 2026; on the testnet it was empty on 30 October and held three CosmWasm targets on 4 November); the precompile returns abi.encode(bytes) and refuses with Error(string) |
Cross-VM precompile 0x...0901 | Active on the testnet, with an allowlist of reviewed CosmWasm contracts (a call was tested on 7 November 2026 with eth_call); not active on mainnet |
Chain v3.2.6 is live on both networks (mainnet since 4 November 2026, height 4,020,000, proposal 15). For rollups the release adds withdrawals_bound to the batch view (whether a batch's withdrawals are bound to it); it also adds IBC and observability changes that do not change how a rollup settles. No mainnet rollup exists to show the new field, so it is stated from the release notes, not observed.
Chain v3.2.7: both networks
The testnet ran chain v3.2.7 from 6 November 2026 (height 9,594,600, applied by governance) and moved to v3.2.8 on 12 November. Mainnet has run v3.2.7 since 12 November 2026 (height 4,164,600, governance proposal 16). The checks below were made on the testnet on 7 November 2026; they were not repeated on mainnet, where only the release's switches are known. For rollups:
- ZK verification key messages. The testnet accepted
MsgSetVerificationKeyandMsgUpdateVerificationKey(a simulated transaction with an empty message got past message-type resolution and failed on the empty address field; mainnet answered "unable to resolve type URL" for the same message on 7 November, before it applied v3.2.7). The verification-key messages are enabled on mainnet from 12 November 2026. The release notes say a ZK batch without a registered key is refused before the fee is paid. No rollup exists on the testnet (GET /qorechain/rdk/v1/rollupsreturned an empty list), andGET /qorechain/rdk/v1/rollupsalso returned an empty list on mainnet on 12 November 2026, so no key has been registered and no ZK batch verified. RDK 0.8.0 has no builder for these messages. - Cross-VM precompile
0x...0901. Active on the testnet with an allowlist of three reviewed CosmWasm contracts; a read-onlyeth_callreached an allowlisted contract and was refused for any other target (details in Multi-VM). On mainnet the precompile and cross-VM calls stay off, including after v3.2.7 (the cross-VM call message is paused).
What exists today
| Status | |
|---|---|
| Rollups registered (mainnet and testnet) | None |
x/rdk module and its parameters | Deployed on both networks; read them with qorechaind query rdk config |
| RDK queries | Served on both networks over the CLI, gRPC and REST (/qorechain/rdk/v1/...), so REST-based reads such as the TypeScript rdk.params() work against mainnet |
| Settlement anchors written by the RDK | None. Since v3.2.2 a batch can carry an anchor_signature and is then anchored in x/multilayer in the same transaction; without it the batch settles unanchored. No rollup, layer or anchor exists yet. The TypeScript RDK (0.6.0 and later) sends the field when its client signs hybrid and is the rollup's creator (untested live); the Python, Go, Rust and Java clients sign hybrid from 0.8.0 but do not send it (checked for Python) |
Rollup layers registered in x/multilayer | None |
| ZK settlement | Verification key messages are enabled on mainnet (v3.2.7, 12 November 2026) and accepted on the testnet; no ZK rollup tried yet on either |
| Withdrawals | Paid from a per-rollup escrow ledger since v3.2.3 (see ZK / STARK & Withdrawals); none has been made, because no rollup exists |
For the lower-level module reference (module parameters, lifecycle internals, burn integration and multilayer anchoring) see the Rollup Development Kit page in the Architecture section. This Rollups section is the developer-facing how-to.
Where it is published
Versions checked on the registries on 12 November 2026. All packages are Apache-2.0.
RDK 0.9.0 (12 November 2026) supports chain v3.2.8 (the testnet runs it since 12 November 2026): rollup data posting, based sequencing, qledger-v1 optimistic rollups with fraud proofs, private rollups, canonical ZK inputs; STARK settlement is paused. See the release notes on GitHub.
| Registry | Package | Current version | Link |
|---|---|---|---|
| npm | @qorechain/rdk (TypeScript client) | 0.9.0 | npmjs.com |
| npm | @qorechain/rdk-cli (qorollup) | 0.9.0 | npmjs.com |
| npm | create-qorechain-rollup (scaffolder) | 0.9.0 | npmjs.com |
| PyPI | qorechain-rdk (import qorrdk) | 0.9.0 | pypi.org |
| crates.io | qorechain-rdk (library qorechain_rdk) | 0.9.0 | crates.io |
| Go module proxy | github.com/qorechain/qorechain-rdk/packages/go | v0.9.0 | pkg.go.dev |
| Maven Central | io.github.qorechain:qorechain-rdk | 0.9.0 | central.sonatype.com |
Maven Central serves 0.7.0, 0.7.1, 0.8.0 and 0.9.0 as well as earlier versions, and the Go proxy's @latest can lag a new tag, so pin the Go version. The source is public at github.com/qorechain/qorechain-rdk, the release notes are at v0.9.0 (and v0.8.0, v0.7.1), and the kit's own documentation is at qorechain.github.io/qorechain-rdk. The TypeScript package depends on @qorechain/sdk ^0.10.0 (from 0.7.0; 0.6.x used ^0.9.0; the Python, Go, Rust and Java packages use the matching QoreChain SDK 0.10.x from 0.8.0) and @qorechain/evm ^0.8.0, and the Python package on qorechain-pqc 0.2.x. The chain's x/rdk module logic itself is not part of the public kit.
Limits and known issues
- ZK settlement has not been tried on either network. This covers the
defiprofile, thedefi-rolluptemplate and every rollup created withzksettlement. The verification-key messages are enabled on mainnet since chain v3.2.7 (12 November 2026) and on the testnet since 6 November 2026, but no ZK rollup has been created, RDK 0.8.0 has no builder for the messages, and a ZK batch without a registered key is refused. Useoptimisticsettlement for now (see ZK / STARK & Withdrawals). - No rollup has been created on either network. The create, batch, challenge, receipt and withdrawal paths are covered by unit tests and shared vectors, but have not been exercised on chain.
- Hybrid signing needs your post-quantum key. From RDK 0.8.0 all five clients sign hybrid when given a post-quantum keypair, and the
qorolluptransaction commands (create,pause,resume,stop,withdraw) do from 0.7.1; without a key, or on earlier versions, a transaction is classical-only and both networks refuse it. No hybrid transaction from any client has been sent through a live rollup. Anchored batches are sent by the TypeScript client only. - (a) The
qorollupCLI printed nothing when installed from npm in 0.6.1 and earlier. This is fixed in 0.6.2: afternpm i -g @qorechain/rdk-cli,qorollup ...works andqorollup --versionprints 0.6.2. - (b) Withdrawal Merkle helpers defaulted to SHA-256 in 0.6.2 and earlier, while the chain uses SHAKE-256. A proof built with those defaults never verified on chain. Fixed in 0.7.0:
withdrawalsTreebuilds the chain's exact tree and was checked against the chain's own verifier (see Leaf and node encoding). Upgrade; code that relied on the SHA-256 defaults must now passhashexplicitly. - (c)
buildDaBlobhashed with SHA-256 in 0.6.2 and earlier, while the chain's blob commitment is SHAKE-256. Fixed in 0.7.0, where its commitment is the chain's. It never had a practical effect, because no transaction posts a blob; leavedataHashempty onnativeandbothdata availability (see Data Availability). - (d) The
defitemplate's demo circuit cannot verify. It is asnarkjsmultiplier, and the chain checks Groth16 over BLS12-381 with the previous state root, the state root and the data hash as public inputs, which that circuit does not expose. Even after key registration ships, you need your own circuit. - Any account can resolve a challenge (v3.2.5 and later, both networks). The chain checks the fraud proof itself; before v3.2.5 only the rollup's creator could submit the resolution (see chain v3.2.5 behaviour and Optimistic).
- Not usable on the live networks: Celestia data availability (not implemented), the QCAI Rollup Copilot (its advisory services are not on the public endpoints), cross-VM calls (the precompile at
0x...0901is not active on mainnet; on the testnet it is active with an allowlist, tested witheth_callon 7 November 2026), shared and based sequencers (the chain admits only the configured sequencer or, when none is set, the creator), andsuggest-profile(it returnsdefias a fixed fallback). - Version notes. Use 0.9.0 for everything (0.7.0 and earlier cannot send
qorolluptransactions the networks accept, and before 0.8.0 the Python, Go, Rust and Java clients cannot send any transaction): 0.6.2 and earlier build withdrawal proofs that never verify on chain, and 0.6.1 and earlier print nothing fromqorollupwhen installed from npm. 0.5.0 and earlier should not be used for receipts, the Watchtower or cross-VM calldata. The full list of what each release changed is in RDK 0.8.0: changes and limits.
Reference: what a rollup is made of
What the RDK gives you
A rollup created through the RDK bundles four configurable concerns:
| Concern | What it controls | Options |
|---|---|---|
| Settlement mode | How the rollup's state transitions are verified and finalized on QoreChain | optimistic, zk, based, sovereign |
| Proof system | The cryptographic or economic mechanism backing settlement | fraud, snark, stark, none |
| Sequencer mode | Who orders transactions before they are settled | dedicated, shared, based |
| Data availability | Where transaction data is published so anyone can reconstruct state | native, celestia, both |
Each rollup is registered with a unique rollup-id, backed by a stake bond in QOR, and assigned a lifecycle status (pending, active, paused, stopped). See Deploying a Rollup for the full create and lifecycle flow.
QoreChain-specific capabilities and their status
Beyond the table-stakes of any rollup kit, the RDK includes three capabilities built around QoreChain's Layer 1, plus a watchtower auto-challenger. Their status differs; the table says what works today.
| Capability | What it does |
|---|---|
| Settlement receipts | Package a settlement anchor as a portable receipt that carries a post-quantum (ML-DSA-87 / Dilithium-5) signature. Early stage: no anchors exist yet, so nothing has been verified against a real anchor; a receipt is a claim that must be checked against chain state, which the 0.7.0 verifier does, field by field. |
| QCAI Rollup Copilot | A read-only advisory helper for one rollup (fee estimate, recommendations, fraud investigations). The advisory services it reads are not exposed on the public endpoints yet. |
| Multi-VM cross-VM calls | Tooling to encode an EVM to QoreChain Native call through the cross-VM precompile (0x...0901). The precompile is not active on mainnet (a call does nothing there) and is active on the testnet with an allowlist (tested with eth_call on 7 November 2026); the encoder since 0.6.0 matches the layout the chain decodes. |
| Watchtower | An auto-challenger framework for optimistic rollups that surfaces new batches and challenge-window deadlines and challenges invalid batches against your validity predicate. It reads over REST, which both networks serve; since 0.6.0 it judges each batch's window the way the chain does (later releases keep that). |
See Why QoreChain RDK for the full rationale and code samples.
The four settlement paradigms
QoreChain RDK supports four settlement modes, each with different trust assumptions, finality characteristics and proof requirements. The combination of settlement mode and proof system is validated on-chain, and an incompatible pairing is rejected at creation. The diagram maps each settlement mode to its valid proof system.
Optimistic
Optimistic rollups assume submitted batches are valid by default and rely on fraud proofs for dispute resolution.
- Proof system:
fraud(interactive fraud proofs). - Sequencer:
dedicatedorshared. - Finality: Delayed until a configurable challenge window expires with no successful challenge.
- Disputes: Anyone may challenge a submitted batch within the window by posting a bond and a fraud proof. A challenge freezes the batch; from v3.2.5 (both networks) any account can then resolve it, where before v3.2.5 only the rollup creator could. The chain checks the proof itself: upheld fraud rejects the batch and pays the challenger, a dismissed challenge returns the batch to
submitted. From v3.2.5 an upheld fraud also rejects every later unfinalized batch, which the sequencer resubmits from the last good root under the same indexes (see chain v3.2.5 behaviour). See Deploying a Rollup. - Window length: the default window is 604,800 "seconds" on mainnet (the module's
default_challenge_window; the testnet's default is 3,600 seconds, read on 27 October 2026, and a rollup can set its own). Before v3.2.4 (on mainnet, before height 3,742,566) the chain converts this to blocks at a fixed 6 seconds per block, which is 100,800 blocks, so real elapsed time follows actual block time (about 3.7 days at mainnet's current ≈3.1 s blocks); plan in blocks, not days. From v3.2.4, a batch submitted from the upgrade height on gets a window measured in seconds of block time (a full 7 days); earlier batches keep the block-count rule. The upgrade height is 8,337,253 on the testnet (since 19 October 2026) and 3,742,566 on mainnet (23 October 2026).
ZK (zero-knowledge)
ZK rollups attach a cryptographic validity proof to each batch, proving state-transition correctness without re-execution.
- Proof system:
snark(succinct proofs) orstark(transparent proofs, no trusted setup). - Sequencer:
dedicatedorshared. - Finality: On valid proof verification, with no challenge window.
- Maturity: ZK settlement has not been tried on either network. SNARK batches are meant to be verified on-chain (Groth16 over BLS12-381) against a verification key stored with the rollup; the verification-key messages are enabled on mainnet since chain v3.2.7 (12 November 2026) and on the testnet since 6 November 2026, with no ZK rollup tried yet. STARK verification is experimental: it is opt-in and checks a demonstration circuit, not your rollup's own state transition. See ZK / STARK & Withdrawals.
Based
Based rollups delegate transaction sequencing to QoreChain (L1) proposers, inheriting the host chain's liveness and censorship resistance.
- Proof system:
none(L1 proposers are the source of ordering truth). - Sequencer:
based(required, enforced by on-chain validation). - Finality: Follows host-chain confirmation.
- Trade-off: The simplest operational model, since QoreChain validators handle sequencing, at the cost of dedicated-sequencer latency control.
- Status today:
basedis recorded in the rollup configuration, but QoreChain does not yet admit L1 proposers as batch submitters; the rollup creator submits (see Sequencer modes).
Sovereign
Sovereign rollups run their own consensus and self-sequence. They anchor state to QoreChain for verifiability but do not depend on the host chain for finality.
- Proof system:
none. - Sequencer: self-managed by the rollup.
- Finality: Independent, determined by the rollup's own consensus.
- State anchoring: State roots are posted to QoreChain for transparency, but the host chain does not enforce them.
Proof-system compatibility
The settlement mode constrains which proof systems are valid. These pairings are enforced when a rollup is created.
| Settlement mode | fraud | snark | stark | none |
|---|---|---|---|---|
| optimistic | Required | - | - | - |
| zk | - | Supported | Supported | - |
| based | - | - | - | Required |
| sovereign | - | - | - | Required |
Sequencer modes
The sequencer determines who orders transactions within a rollup block before settlement.
| Mode | Who sequences | Notes |
|---|---|---|
dedicated | A single designated operator address | Lowest latency; requires trust in the operator for liveness and fair ordering |
shared | A shared sequencer set | Ordering distributed across the set; slightly higher coordination overhead |
based | QoreChain L1 proposers | Inherits host-chain validator security and censorship resistance; required for based settlement |
On-chain, a batch may be submitted only by the rollup's configured sequencer address or, when none is set (every preset), by its creator. The shared and based modes are recorded in the rollup configuration, but QoreChain does not yet admit a shared sequencer roster or L1 proposers as batch submitters; those modes describe the intended design.
Choosing a paradigm
| If you want... | Consider |
|---|---|
| The simplest operational setup, with QoreChain validators sequencing | based |
| Fast finality with cryptographic guarantees (not usable yet) | zk (snark / stark) |
| A well-understood model with economic dispute resolution | optimistic (fraud) |
| Full independence with your own consensus, anchored for verifiability | sovereign |
Not sure where to start? The RDK ships preset profiles that bundle these choices for common application categories; see Preset Profiles. A suggest-profile helper exists, but it currently returns a fixed defi fallback (and defi cannot be used yet), so choose from the profile table.
Related
- Deploying a Rollup: launch a rollup from the CLI or the TypeScript RDK.
- Preset Profiles: bundles for common application categories.
- Data Availability: the native DA router and blob storage.
- ZK / STARK Withdrawals: proof-backed withdrawal flows.
- Settlement receipts, Watchtower, Multi-VM and Why QoreChain RDK.