Precompilate EVM
QoreChain extinde motorul QoreChain EVM Engine cu șase contracte precompilate personalizate care expun funcționalități la nivel de protocol direct în Solidity. Aceste precompilate oferă acces on-chain la criptografie post-cuantică, scoring de risc bazat pe AI, mesagerie cross-VM și parametrii de consens PRISM.
Cele șase precompilate QoreChain de mai jos sunt compilate în nod, dar EVM-ul execută doar adresele din parametrul active_static_precompiles. Pe mainnet-ul qorechain-vladi (ID chain EVM 9801) această listă este goală la momentul redactării, deci niciunul nu este activ acolo. Pe testnet-ul qorechain-diana (ID chain EVM 9800) sunt active PQC Verify, PQC Key Status și PRISM Consensus Params, activate prin propunerea de guvernanță 21 a testnet-ului (aprobată la 27 octombrie 2026), iar adresa CrossVM Bridge se afla în listă când a fost citită la 7 noiembrie 2026. Cele două precompilate AI nu sunt active pe nicio rețea. Un apel către o adresă care nu se află în listă reușește și întoarce date goale (0x); nu face revert și nu întoarce o eroare. Vezi Starea rețelei înainte de a te baza pe oricare dintre ele.
Starea rețelei
| Precompilat | Adresă | qorechain-vladi (mainnet) | qorechain-diana (testnet) |
|---|---|---|---|
| CrossVM Bridge | 0x…0901 | Neactiv | Activ cu o listă de permisiuni (lista citită la 7 noiembrie 2026; un eth_call după upgrade-ul v3.2.7 a ajuns la un contract din listă și a fost refuzat pentru unul din afara listei; vezi Multi-VM) |
| PQC Verify | 0x…0A01 | Neactiv | Activ (din 27 octombrie 2026) |
| PQC Key Status | 0x…0A02 | Neactiv | Activ (din 27 octombrie 2026) |
| AI Risk Score | 0x…0B01 | Neactiv | Neactiv |
| AI Anomaly Check | 0x…0B02 | Neactiv | Neactiv |
| PRISM Consensus Params | 0x…0C01 | Neactiv | Activ (din 27 octombrie 2026) |
Starea este cea citită din parametrul live active_static_precompiles la 27 octombrie 2026 (mainnet recitit la 4 noiembrie 2026, după v3.2.6: tot goală; ambele rețele recitite la 7 noiembrie 2026: mainnet goală, testnet cu 0x…0901, 0x…0A01, 0x…0A02 și 0x…0C01). Este un parametru de lanț modificat prin guvernanță, deci lista fiecărei rețele se schimbă doar atunci când trece o propunere de guvernanță; lista testnet-ului a fost stabilită de propunerea 21, iar la momentul redactării nicio propunere de pe mainnet nu o modifică. Versiunea v3.2.3 (mainnet, 20 octombrie 2026) a introdus în binar, în spatele unei funcționalități de protocol, versiunile întărite ale punții CrossVM și ale precompilatului AI de anomalii, dar nu a activat niciun precompilat, iar nici v3.2.4 (mainnet din 23 octombrie 2026, testnet din 19 octombrie 2026), nici v3.2.6 (mainnet din 4 noiembrie 2026), nici v3.2.7 (testnet din 6 noiembrie 2026, mainnet din 12 noiembrie 2026) nu schimbă acest lucru: lista mainnet-ului a fost recitită la 12 noiembrie 2026 și este tot goală. Precompilatele PQC și de consens, doar pentru citire, vin primele, perechea AI odată ce calea lor de citire, în virgulă fixă, este pusă la punct, iar puntea CrossVM la final. Acest tabel listează doar ce este aplicat: o propunere aflată încă în perioada de vot nu reprezintă o stare.
Verifică singur lista curentă (goală înseamnă că niciunul nu e activ):
curl -s https://api.qore.host/cosmos/evm/vm/v1/params | jq .params.active_static_precompiles
curl -s https://api-testnet.qore.host/cosmos/evm/vm/v1/params | jq .params.active_static_precompiles
Protecție împotriva datelor returnate goale
Deoarece o adresă inactivă (sau care nu aparține QoreChain) întoarce succes fără date, nu citi niciodată octeții bruți returnați de un apel de nivel jos fără a-le verifica lungimea. abi.decode și apelurile prin interfețe tipate fac revert pe date goale, ceea ce este rezultatul sigur; un apel de nivel jos scris de mână trebuie să verifice explicit acest lucru:
(bool ok, bytes memory ret) = address(0x0000000000000000000000000000000000000a02)
.staticcall(abi.encodeWithSignature("pqcKeyStatus(address)", account));
require(ok && ret.length >= 96, "precompile not active");
(bool registered, uint8 algorithmId, bytes memory pubkey) = abi.decode(ret, (bool, uint8, bytes));
Nu trimite valoare către aceste adrese. Nu sunt payable, iar valoarea trimisă către o adresă de precompilat inactivă rămâne acolo, fără nicio posibilitate de recuperare.
Pe testnet, o verificare rapidă că cele trei precompilate active răspund (cu cast din Foundry; pe mainnet aceste adrese întorc în schimb date goale):
RPC=https://evm-testnet.qore.host
cast call 0x0000000000000000000000000000000000000c01 "rlConsensusParams()(uint256,uint256,uint256,uint256)" --rpc-url $RPC
cast call 0x0000000000000000000000000000000000000a02 "pqcKeyStatus(address)(bool,uint8,bytes,bool)" 0x0000000000000000000000000000000000000001 --rpc-url $RPC
Precompilate standard
Pe lângă cele șase precompilate QoreChain, nodul include precompilatele standard cosmos/evm. Ele urmează aceeași regulă: rulează doar acolo unde guvernanța a listat adresa lor în active_static_precompiles, iar build-ul comunitar al nodului nu le include.
| Adresă | Precompilat |
|---|---|
0x…0100 | P-256 (fără stare) |
0x…0400 | Bech32 (fără stare) |
0x…0800 | Staking |
0x…0801 | Distribution |
0x…0802 | Transfer IBC (ICS-20) |
0x…0804 | Bank (doar citire) |
0x…0805 | Governance |
0x…0806 | Slashing |
0x…0803 (vesting) este rezervat în upstream și neimplementat: la acea adresă nu există nimic. Operațiunile de staking, delegare și validator pe QoreChain se fac doar pe lane-ul nativ (vezi Staking și validatori), așa că nu construiți fluxuri de staking pe precompilatul de staking. Sursa: docs/EVM_PRECOMPILES.md din depozitul public core, la tagul v3.2.6.
Harta adreselor precompilatelor
Cifrele de gaz sunt cele pe care nodul le taxează după ce un precompilat este activ (per octet înseamnă per octet de date de intrare ale apelului).
| Precompilat | Adresă | Gaz de bază | Descriere |
|---|---|---|---|
| CrossVM Bridge | 0x0000000000000000000000000000000000000901 | 50.000 + 4/octet | Apeluri sincrone cross-VM (de la EVM la QoreChain Native) |
| PQC Verify | 0x0000000000000000000000000000000000000a01 | 25.000 + 8/octet | Verifică semnături post-cuantice ML-DSA-87 |
| PQC Key Status | 0x0000000000000000000000000000000000000a02 | 2.500 | Verifică dacă un cont are o cheie PQC înregistrată |
| AI Risk Score | 0x0000000000000000000000000000000000000b01 | 50.000 | Obține scorul de risc generat de AI pentru date de tranzacție |
| AI Anomaly Check | 0x0000000000000000000000000000000000000b02 | 40.000 | Verifică dacă un transfer este marcat drept anormal |
| PRISM Consensus Params | 0x0000000000000000000000000000000000000c01 | 1.500 | Citește parametrii de consens curenți, ajustați de PRISM |
Interfețe Solidity
IQorePQC.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
interface IQorePQC {
/// @notice Verify an ML-DSA-87 (Dilithium-5) signature
/// @param pubkey The 2592-byte ML-DSA-87 public key
/// @param signature The 4627-byte ML-DSA-87 signature
/// @param message The original message bytes
/// @return valid True if the signature is valid
function pqcVerify(
bytes calldata pubkey,
bytes calldata signature,
bytes calldata message
) external view returns (bool valid);
/// @notice Check if an account has a registered PQC public key
/// @param account The Ethereum-style address to check
/// @return registered True if a PQC key is registered
/// @return algorithmId The PQC algorithm identifier (1 = ML-DSA-87)
/// @return pubkey The registered public key bytes (empty if not registered)
/// @return possessionProven True only if the key was registered with a verified proof of possession
function pqcKeyStatus(address account)
external
view
returns (bool registered, uint8 algorithmId, bytes memory pubkey, bool possessionProven);
}
Începând cu v3.2.4 (mainnet din 23 octombrie 2026, testnet din 19 octombrie 2026), ieșirea lui pqcKeyStatus conține o a patra valoare, bool possessionProven, după pubkey: dacă cheia curentă a contului a fost dovedită printr-o dovadă de posesie verificată (vezi Semnarea post-cuantică). Este returnată oriunde precompilatul este activ: pe testnet este live (un apel pentru un cont fără cheie returnează false, 0, 0x, false), iar pe mainnet după ce un upgrade activează precompilatul. Interfața de mai sus listează toate cele patru ieșiri. Un contract care trebuie să aibă încredere în cheie trebuie să verifice și a patra valoare: dovada de posesie este opțională la înregistrare, deci registered singur nu este suficient.
IQoreAI.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
interface IQoreAI {
/// @notice Get the AI-generated risk score for transaction data
/// @param txData The transaction data to evaluate
/// @return score Risk score in basis points (0-10000)
/// @return level Risk level: 0=SAFE, 1=LOW, 2=MEDIUM, 3=HIGH, 4=CRITICAL
function aiRiskScore(bytes calldata txData)
external
view
returns (uint256 score, uint8 level);
/// @notice Check if a transfer is flagged as anomalous
/// @param sender The sender address
/// @param amount The transfer amount in wei
/// @return anomalyScore The anomaly score (higher = more anomalous)
/// @return flagged True if the transfer exceeds the anomaly threshold
function aiAnomalyCheck(address sender, uint256 amount)
external
view
returns (uint256 anomalyScore, bool flagged);
}
IQoreConsensus.sol
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
interface IQoreConsensus {
/// @notice Get current PRISM-tuned consensus parameters
/// @return blockTime Current target block time in milliseconds
/// @return baseGasPrice Current base gas price in wei
/// @return validatorSetSize Current active validator set size
/// @return epoch Current PRISM epoch number
function rlConsensusParams()
external
view
returns (
uint256 blockTime,
uint256 baseGasPrice,
uint256 validatorSetSize,
uint256 epoch
);
}
Exemple de utilizare
PQC Verify — Verificarea unei semnături post-cuantice
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;
import "./interfaces/IQorePQC.sol";
contract PQCVerifier {
IQorePQC constant PQC = IQorePQC(0x0000000000000000000000000000000000000a01);
/// @notice Verify a PQC signature and revert if invalid
function verifyOrRevert(
bytes calldata pubkey,
bytes calldata signature,
bytes calldata message
) external view {
bool valid = PQC.pqcVerify(pubkey, signature, message);
require(valid, "PQC signature verification failed");
}
}
Cost de gaz: 25.000 de bază + 8 gaz per octet de date de intrare. Intrarea este apelul codificat ABI (cheia publică de 2592 octeți, semnătura de 4627 octeți, mesajul, plus offset-urile și padding-ul ABI), deci o verificare tipică ML-DSA-87 costă aproximativ 85.000-90.000 gaz.
PQC Key Status — Verificarea înregistrării unui cont
contract PQCChecker {
IQorePQC constant PQC_STATUS = IQorePQC(0x0000000000000000000000000000000000000a02);
function requirePQCKey(address account) external view {
(bool registered, , , bool possessionProven) = PQC_STATUS.pqcKeyStatus(account);
require(registered, "Account must have a registered PQC key");
require(possessionProven, "The key was registered without a proof of possession");
}
}
Dovada de posesie este opțională la înregistrare, deci registered singur nu arată că contul controlează cheia. Un contract care se bazează pe o cheie post-cuantică înregistrată trebuie să ceară și ca possessionProven să fie adevărat.
Cost de gaz: 2.500, fix.
AI Risk Score — Evaluarea riscului unei tranzacții
import "./interfaces/IQoreAI.sol";
contract RiskGate {
IQoreAI constant AI = IQoreAI(0x0000000000000000000000000000000000000b01);
uint8 constant MAX_ALLOWED_RISK = 2; // Allow up to MEDIUM
function executeIfSafe(bytes calldata txData) external {
(uint256 score, uint8 level) = AI.aiRiskScore(txData);
require(level <= MAX_ALLOWED_RISK, "Risk level too high");
// Proceed with execution...
}
}
Niveluri de risc:
| Nivel | Valoare |
|---|---|
| SAFE | 0 |
| LOW | 1 |
| MEDIUM | 2 |
| HIGH | 3 |
| CRITICAL | 4 |
Nivelul provine din eticheta de severitate a motorului AI pentru tranzacție; scorul este returnat în puncte de bază (0 - 10000). Nu există o corespondență fixă între intervalele de scor și niveluri, așa că condiționează pe level, nu pe praguri de scor.
Cost de gaz: 50.000, fix.
AI Anomaly Check — Marcarea transferurilor suspecte
contract AnomalyGuard {
IQoreAI constant AI = IQoreAI(0x0000000000000000000000000000000000000b02);
function safeTransfer(address sender, uint256 amount) external view {
(uint256 anomalyScore, bool flagged) = AI.aiAnomalyCheck(sender, amount);
if (flagged) {
revert("Transfer flagged as anomalous");
}
}
}
Cost de gaz: 40.000, fix.
PRISM Consensus Params — Citirea stării consensului
contract ConsensusReader {
IQoreConsensus constant RL = IQoreConsensus(
0x0000000000000000000000000000000000000c01
);
function getBlockTime() external view returns (uint256) {
(uint256 blockTime, , , ) = RL.rlConsensusParams();
return blockTime;
}
function getCurrentEpoch() external view returns (uint256) {
(, , , uint256 epoch) = RL.rlConsensusParams();
return epoch;
}
}
Cost de gaz: 1.500, fix, plus citirile de stare pe care le execută apelul, la costul standard.
Începând cu v3.2.6 (ambele rețele o rulează sau rulează o versiune ulterioară; precompilatul în sine este activ doar pe testnet) rlConsensusParams returnează valorile deținute de modulul rlconsensus, în locul unor valori fixe de umplutură: ținta de timp de bloc aplicată, în milisecunde, pragul de preț al gazului aplicat, default_validator_set_size al modulului și epoca curentă a agentului. Pe testnet, la 27 octombrie 2026, a returnat 5000, 100, 100, 1 (aceleași valori aplicate ca GET /qorechain/rlconsensus/v1/applied_params, vezi Endpoint-uri REST / gRPC). Acestea sunt setările proprii ale modulului, nu timpul de bloc măsurat (aproximativ 3,1 s pe mainnet și aproximativ 1,3 s pe testnet), iar agentul rulează în mod shadow pe testnet, deci nu aplică nimic. Pe mainnet adresa nu se află în lista activă: un eth_call către ea a returnat date goale (0x) la 4 noiembrie 2026, deși codul v3.2.6 se află în binar (rl-params-precompile-live este activat). Pe un nod mai vechi decât v3.2.6, același apel returnează valori implicite fixe, de umplutură.
CrossVM Bridge — Apelarea QoreChain Native din EVM
Precompilatul CrossVM bridge nu este activ pe mainnet și este activ pe testnet (citit la 7 noiembrie 2026), unde un eth_call doar pentru citire a fost rulat prin el pe 7 noiembrie 2026, după upgrade-ul v3.2.7: o țintă din lista de permisiuni ajunge la contract, o țintă din afara ei este refuzată cu is not allowlisted (detalii în Interoperabilitate Cross-VM). Pe mainnet rămâne oprit, împreună cu apelurile cross-VM, chiar și după un upgrade la v3.2.7, până la o decizie separată de guvernanță. Binarul, începând cu v3.2.3, conține o versiune întărită a acestuia care: refuză un STATICCALL; rulează apelul imbricat pe un contor de gaz limitat de ceea ce îi mai rămâne frame-ului apelant și îl jurnalizează, astfel încât un revert în contractul apelant anulează și partea QoreChain Native; ajunge doar la ținte QoreChain Native din lista permisă (țintele EVM sunt refuzate); și respectă circuit breaker-ul cross-VM. Până când o propunere de guvernanță îl activează pe mainnet, nu există acolo o cale sincronă de la EVM la QoreChain Native; vezi Interoperabilitate Cross-VM pentru calea de mesaj MsgCrossVMCall, care este ea însăși oprită pe mainnet în prezent.
Nodul decodează calldata ca executeCrossVMCall(uint8 targetVM, string targetContract, bytes payload) (selector de 4 octeți, apoi argumentele codificate ABI). Singura utilizare acceptată este de la EVM la QoreChain Native (targetVM = 1); ABI-ul se mai poate schimba înainte de activare. Helper-ul @qorechain/rdk encodeCrossVmCalldata codifică acest layout începând cu 0.6.0 (versiunile anterioare codificau o altă funcție), iar isCrossVmPrecompileActive al său citește lista live active_static_precompiles; vezi Multi-VM.
Cost de gaz: 50.000 de bază + 4 gaz per octet de date de intrare, plus costul de execuție al contractului țintă. Vezi Interoperabilitate Cross-VM pentru detalii.
Locațiile fișierelor de interfață
Fișierele de interfață Solidity sunt disponibile în repository pentru import direct:
contracts/
interfaces/
IQorePQC.sol
IQoreAI.sol
IQoreConsensus.sol
Instalează-le în proiectul tău Hardhat sau Foundry:
# Copy interfaces to your project
cp -r contracts/interfaces/ my-project/contracts/interfaces/
Sau referențiază-le prin calea de import în fișierele tale Solidity:
import "./interfaces/IQorePQC.sol";
import "./interfaces/IQoreAI.sol";
import "./interfaces/IQoreConsensus.sol";
Pași următori
- Interoperabilitate Cross-VM — Documentația completă a mesageriei cross-VM
- Dezvoltare EVM — Implementarea contractelor Solidity
- Abstractizarea contului — Autentificatori pentru portofele conectate și reguli de cheltuire (activat pe testnet, dezactivat pe mainnet)