Passa al contenuto principale

Perché QoreChain RDK

La maggior parte dei kit di sviluppo per rollup sono variazioni sullo stesso tema: ti aiutano a lanciare una app-chain che regola i propri stati su un layer di base. Il QoreChain RDK fa anche questo, e aggiunge tre funzionalità specifiche di QoreChain, costruite attorno al Layer 1 di QoreChain piuttosto che agli strumenti:

  • un layer di regolamento post-quantistico,
  • primitive consultive di AI/RL on-chain (QCAI), e
  • un runtime a tripla VM con chiamate cross-VM.
Fase iniziale: leggi la colonna Stato

Nessun rollup è ancora stato creato su nessuna delle due reti (verificato il 27 ottobre 2026). La tabella qui sotto indica cosa funziona oggi; ciò che i client 0.6.x pubblicati hanno cambiato e i limiti che restano sono raccolti in RDK 0.8.0: modifiche e limiti. Se ti serve solo un generico rollup optimistic/zk, qualunque kit va bene; le funzionalità descritte qui sono ciò che l'RDK aggiunge in più, in TypeScript, Python, Go, Rust e Java.

FunzionalitàStatoSu cosa si basa
Ricevute di regolamento🟡 Fase inizialeGli ancoraggi sono firmati con ML-DSA-87, lo schema post-quantistico della Main Chain; non esiste ancora nessun ancoraggio, quindi il verificatore attuale (che verifica rispetto alla chain) non è mai stato eseguito su un ancoraggio reale
QCAI Rollup Copilot🟡 Non ancora disponibile sugli endpoint pubbliciServizi consultivi di AI/RL on-chain che gli endpoint pubblici oggi non espongono
Chiamate cross-VM multi-VM🟡 Non ancora utilizzabile sulle reti liveUn precompile cross-VM che non è attivato sulla mainnet, attivo con una allowlist sulla testnet (l'encoder dalla 0.6.0 corrisponde al layout della chain), e il caricamento di QoreChain Native è chiuso

1. Ricevute di regolamento​

🟡 Progetto costruito sul layer di base post-quantistico di QoreChain. Gli ancoraggi di regolamento sono firmati con ML-DSA-87 (Dilithium-5, FIPS-204), lo stesso schema usato dalla Main Chain. Fase iniziale: non esiste ancora nessun ancoraggio su nessuna delle due reti.

Quando il creatore del tuo rollup ancora un batch di regolamento, l'ancoraggio è firmato con una chiave post-quantistica registrata on-chain. L'RDK può impacchettare quell'ancoraggio come una ricevuta portabile, e un verificatore rilegge l'affermazione da un nodo QoreChain per confermare che il rollup, il batch, l'ancoraggio e la chiave del creatore corrispondano tutti a ciò che la chain detiene.

import { createRdkClient, buildSettlementReceipt, verifySettlementReceipt } from "@qorechain/rdk";

const rdk = createRdkClient({ network: "testnet" });
const receipt = await buildSettlementReceipt(rdk, "my-rollup", 42);
const result = await verifySettlementReceipt(receipt, { client: rdk });
console.log(result.valid);

verifySettlementReceipt verifica rispetto alla chain e si rifiuta di dire valid senza un client. Nella 0.5.0 il suo controllo sulla chain non riusciva a completarsi sulle reti live (falliva in modo chiuso invece di segnalare come valida una ricevuta genuina); la 0.6.0 ha risolto il problema e la 0.6.1 (e ogni release successiva) confronta ogni campo della ricevuta, ma non esiste ancora alcun ancoraggio, quindi nessuna delle due è stata eseguita su uno reale. Vedi Ricevute di regolamento per ciò che una ricevuta dimostra e ciò che non dimostra e per i limiti esatti.


2. QCAI Rollup Copilot​

🟡 Non ancora disponibile sugli endpoint pubblici.

Il Copilot è pensato per aggregare i servizi consultivi della rete (un agente per la politica delle fee, raccomandazioni, indagini antifrode) in un'unica vista in sola lettura e in linguaggio semplice per un rollup. È best-effort: se un servizio è irraggiungibile, degrada a un avviso invece di fallire. Quei servizi oggi non sono esposti sugli endpoint pubblici, quindi ogni sezione ritorna come avviso.

import { createRdkClient, getRollupAdvice } from "@qorechain/rdk";

const rdk = createRdkClient({ network: "testnet" });
const advice = await getRollupAdvice(rdk, "my-rollup");
console.log(advice.warnings); // services that could not be reached

Dalla CLI: qorollup advise my-rollup. Vedi QCAI Copilot.


3. Chiamate cross-VM multi-VM​

🟡 Non ancora utilizzabile sulla mainnet — il precompile non è attivato lì e il caricamento di QoreChain Native è chiuso. Sulla testnet il precompile è attivo con una allowlist (testato con eth_call il 7 novembre 2026). Vedi Multi-VM.

L'RDK include helper che codificano una chiamata da un contratto EVM (Solidity) a un contratto QoreChain Native attraverso un precompile fisso all'indirizzo 0x…0901. Quel precompile non è attivo sulla mainnet ed è attivo sulla testnet (con una allowlist di contratti verificati; testato il 7 novembre 2026) (vedi Precompile EVM: stato della rete): eth_getCode per 0x…0901 restituisce 0x (un precompile non ha bytecode), una chiamata di contratto verso di esso ha successo senza alcun effetto sulla mainnet; sulla testnet un target nella allowlist raggiunge il suo contratto e ogni altro viene rifiutato con "is not allowlisted".

L'helper encodeCrossVmCalldata (dalla 0.6.0) costruisce il calldata per executeCrossVMCall(uint8 targetVM, string targetContract, bytes payload), il layout che il nodo decodifica (la 0.5.0 e le precedenti codificavano una forma a due argomenti con un selettore diverso, che non avrebbe mai potuto raggiungere il precompile). Puoi codificare tu stesso la stessa chiamata, mostrata qui con viem (targetVM 1 è QoreChain Native, l'unico target supportato):

import { encodeFunctionData, parseAbi, toHex } from "viem";

const abi = parseAbi([
"function executeCrossVMCall(uint8 targetVM, string targetContract, bytes payload)",
]);

const calldata = encodeFunctionData({
abi,
functionName: "executeCrossVMCall",
args: [
1, // 1 = QoreChain Native
"qor1examplecontract…", // target contract
toHex(new TextEncoder().encode(JSON.stringify({ increment: {} }))), // its execute message
],
});

// Send an EVM transaction: to = 0x0000000000000000000000000000000000000901, data = calldata

Oppure direttamente da Solidity sul tuo rollup:

address constant CROSS_VM_PRECOMPILE = 0x0000000000000000000000000000000000000901;

function callCosmWasm(string calldata contractAddr, bytes calldata msg_)
external returns (bytes memory)
{
bytes memory data =
abi.encodeWithSignature("executeCrossVMCall(uint8,string,bytes)", uint8(1), contractAddr, msg_);
(bool ok, bytes memory ret) = CROSS_VM_PRECOMPILE.call(data);
require(ok, "cross-VM call failed");
return ret;
}

ok da solo oggi non dimostra nulla: finché il precompile non ha codice, la chiamata restituisce successo con dati vuoti e non esegue nulla, quindi conferma l'effetto sul contratto di destinazione.

Crea uno scheletro di partenza con npm create qorechain-rollup my-app -- --template multivm-rollup. (Solo EVM↔QoreChain Native; le chiamate cross-VM verso SVM sono separate.)


Tutto il resto che ti aspetteresti​

Oltre a queste funzionalità, l'RDK include anche le dotazioni di base: cinque client di linguaggio pubblicati e verificati contro golden vector condivisi, i cinque profili preset e la matrice di compatibilità completa, la gestione dei batch di regolamento e del ciclo di vita, lo storage nativo per la disponibilità dei dati (vedi la sua nota di stato), un auto-challenger watchtower per i rollup optimistic, e la CLI operativa qorollup.

Prossimi passi​