Why QoreChain RDK
Most rollup development kits are variations on the same theme: they help you launch an app-chain that settles to a base layer. The QoreChain RDK does that too — but it also exposes three things no other rollup kit can, because they depend on capabilities that live in QoreChain's Layer 1, not in the tooling:
- a post-quantum settlement layer,
- on-chain AI/RL advisory primitives (QCAI), and
- a triple-VM runtime with cross-VM calls.
If you only need a generic optimistic/zk rollup, any kit will do. If you want your rollup's settlement to be verifiable, quantum-safe, and AI-aware, this is the only kit that can express it — in TypeScript, Python, Go, Rust, and Java.
| Differentiator | Status | Why it's only possible here |
|---|---|---|
| Quantum-safe settlement receipts | 🟢 Unique (first-mover) | Needs a post-quantum L1 — impossible on a non-PQC base layer |
| QCAI Rollup Copilot | 🟢 Unique through the chain | Wraps QoreChain-only on-chain AI/RL endpoints |
| Multi-VM cross-VM calls | 🟡 Distinctive | QoreChain runs EVM + QoreChain Native + SVM under one chain (bridge not yet active on the public networks) |
1. Quantum-safe settlement receipts
🟢 Unique. No rollup kit built on a non-post-quantum L1 can offer this.
When your rollup anchors a settlement batch, QoreChain commits its state root to the Main Chain under a post-quantum (ML-DSA-87 / Dilithium-5, FIPS-204) signature. The RDK turns that anchor into a portable receipt you can hand to an auditor, an exchange, or a counterparty.
From chain v3.2.2 the anchored message is bound to one network and to one batch: it carries the chain id and length-prefixed fields, and for a rollup batch its height is the batch index. So a signature from one network cannot be replayed on another, and one batch's anchor cannot be passed off as another's. The RDK signs this for you when your operator submits a batch (see Settlement receipts).
A receipt is a claim, not evidence — every field in it comes from whoever handed it to you. So verification re-reads the claim from the chain: that the rollup really belongs to that layer, that the batch really carries that state root, that an anchor matching the receipt actually exists on chain, that the receipt names the network you are asking, and that the creator's key is the one the chain has registered. Only then is it valid.
import {
createRdkClient,
buildSettlementReceipt,
verifySettlementReceipt,
} from "@qorechain/rdk";
const rdk = createRdkClient({ network: "mainnet" }); // public mainnet endpoints
// Build a portable receipt for batch #42 of "my-rollup".
const receipt = await buildSettlementReceipt(rdk, "my-rollup", 42);
// → { version: 2, chainId: "qorechain-vladi", stateRoot, pqcSignature, creator, ... }
// Verify it against the chain.
const result = await verifySettlementReceipt(receipt, { client: rdk });
console.log(result.valid); // true only if the chain reproduces it
console.log(result.checks.anchorOnChain); // a matching anchor exists on chain
console.log(result.checks.chainBinding); // the receipt is for this network
console.log(result.signBytesVersion); // "v2" for anchors from v3.2.2 on
There is also a signature-only mode, for when you only want to check the
post-quantum signature against a key you already hold. It is deliberately never
valid — a signature proves someone signed those bytes, it cannot prove the
anchor exists:
const result = await verifySettlementReceipt(receipt, {
creatorPublicKey: "a1b2…", // a key you obtained out-of-band
});
// result.mode === "signature-only"
// result.valid === false ← by design: nothing was checked against the chain
The same receipt verifies byte-for-byte across all five languages (the
non-TypeScript clients use the chain's own qorechain-pqc library), so a receipt
produced by a TypeScript service verifies identically in a Go auditor or a Java
backend. See Quantum-safe settlement receipts.
2. QCAI Rollup Copilot
🟢 Unique through the chain. Built on on-chain AI/RL endpoints that other networks simply don't have.
QoreChain runs network-level AI/RL services on-chain — a fee-policy agent, network recommendations, fraud investigations, circuit breakers. The Copilot aggregates them into a single, reviewable, plain-language view for one rollup. It's read-only and best-effort: if an advisory service is unreachable, it degrades to a warning instead of failing.
import { createRdkClient, getRollupAdvice } from "@qorechain/rdk";
const rdk = createRdkClient({ network: "mainnet", endpoints: { rest, evmRpc } });
const advice = await getRollupAdvice(rdk, "my-rollup");
for (const s of advice.suggestions) {
console.log(`[${s.level}] ${s.message}`);
// [action] 2 open fraud investigation(s) reference this rollup …
// [warn] QCAI reports network congestion — consider raising the fee …
// [info] A live QCAI fee estimate is available …
}
console.log(advice.feeEstimate); // live QCAI fee estimate
console.log(advice.fraudInvestigations); // investigations touching this rollup
console.log(advice.rlAgentStatus); // the RL fee/routing agent's state
From the CLI:
qorollup advise my-rollup
Other kits have nothing to wrap — the advisory data is a QoreChain primitive. See QCAI Copilot.
3. Multi-VM cross-VM calls
🟡 Distinctive. QoreChain runs EVM, QoreChain Native, and SVM under one chain, with a precompile that bridges EVM → QoreChain Native.
Status: not yet active on mainnet or testnet. The precompile is built into the validators' binary but runs only once governance lists its address in the EVM parameter
active_static_precompiles(which lists it on neither network today), and it reaches only targets governance has allowlisted. The tooling below is ready for it, decodes the chain v3.2.5 result and refusal formats, and tells you whether a call would reach its target.
Your EVM (Solidity) rollup contract can call an existing QoreChain Native (Wasm) contract
through a fixed precompile at 0x…0901. The RDK builds the calldata — byte-for-byte what the
chain's decoder reads — and checks whether the precompile is live first:
import {
encodeCrossVmCalldata,
isCrossVmPrecompileActive,
CROSS_VM_PRECOMPILE,
} from "@qorechain/rdk";
const status = await isCrossVmPrecompileActive("https://api.qore.host");
if (!status.active) throw new Error(status.reason);
const calldata = encodeCrossVmCalldata({
contract: "qor1examplecontract…", // target QoreChain Native (Wasm) contract
msg: JSON.stringify({ increment: {} }), // its execute message
});
// Send an EVM transaction: to = CROSS_VM_PRECOMPILE, data = calldata
Or directly from Solidity on your rollup. Note the chain's signature takes a leading
targetVM (1 for QoreChain Native):
address constant CROSS_VM_PRECOMPILE = 0x0000000000000000000000000000000000000901;
uint8 constant TARGET_NATIVE = 1;
function callNative(string calldata contractAddr, bytes calldata msg_)
external returns (bytes memory)
{
bytes memory data = abi.encodeWithSignature(
"executeCrossVMCall(uint8,string,bytes)", TARGET_NATIVE, contractAddr, msg_
);
(bool ok, bytes memory ret) = CROSS_VM_PRECOMPILE.call(data);
require(ok, "cross-VM call failed");
// An inactive precompile is an address with no code: the call "succeeds" with
// empty data. Have your target return a non-empty acknowledgement and require it.
require(ret.length > 0, "cross-VM precompile inactive, or no acknowledgement");
return ret;
}
Scaffold a starter with npm create qorechain-rollup my-app -- --template multivm-rollup.
(EVM↔QoreChain Native only; SVM cross-calls are separate.) See Multi-VM.
Everything else you'd expect
Beyond the differentiators, the RDK ships the table-stakes too: five published
language clients verified against shared golden vectors, the five preset profiles
and the full compatibility matrix, settlement-batch and lifecycle management,
native data availability, a watchtower auto-challenger for optimistic
rollups, and the qorollup operator CLI.
Next
- Install — per-language install.
- Quickstart — from zero to a live testnet rollup.
- Quantum-safe settlement receipts · QCAI Copilot · Multi-VM — the deep dives.