Saltar al contenido principal

Precompilados de EVM

QoreChain extiende el QoreChain EVM Engine con seis contratos precompilados personalizados que exponen funciones a nivel de protocolo directamente a Solidity. Estos precompilados brindan acceso on-chain a criptografía post-cuántica, puntuación de riesgo por IA, mensajería cross-VM y parámetros de consenso PRISM.

No activos en la mainnet; cuatro activos en la testnet

Los seis precompilados de QoreChain que se describen a continuación están compilados en el nodo, pero la EVM solo despacha las direcciones listadas en el parámetro active_static_precompiles. En la mainnet qorechain-vladi (ID de cadena EVM 9801) esa lista está vacía en el momento de escribir esto, así que ninguno está activo allí. En la testnet qorechain-diana (ID de cadena EVM 9800) están activos PQC Verify, PQC Key Status y PRISM Consensus Params, activados por la propuesta de gobernanza 21 de la testnet (aprobada el 27 de octubre de 2026), y el CrossVM Bridge (0x…0901) también está en la lista (leído el 7 de noviembre de 2026; funciona con una lista de permitidos de contratos revisados, véase Estado de la red). Los dos precompilados de IA no están activos en ninguna de las dos redes. Una llamada a una dirección que no figura en la lista tiene éxito y devuelve datos vacíos (0x); no revierte ni devuelve un error. Consulte Estado de la red antes de depender de cualquiera de ellos.

Estado de la red​

PrecompiladoDirecciónqorechain-vladi (mainnet)qorechain-diana (testnet)
CrossVM Bridge0x…0901No activoActivo con una lista de permitidos (lista leída el 7 de noviembre de 2026; un eth_call tras la actualización v3.2.7 alcanzó un contrato de la lista de permitidos y se rechazó para uno fuera de la lista; véase Multi-VM)
PQC Verify0x…0A01No activoActivo (desde el 27 de octubre de 2026)
PQC Key Status0x…0A02No activoActivo (desde el 27 de octubre de 2026)
AI Risk Score0x…0B01No activoNo activo
AI Anomaly Check0x…0B02No activoNo activo
PRISM Consensus Params0x…0C01No activoActivo (desde el 27 de octubre de 2026)

Estado leído del parámetro active_static_precompiles en vivo el 27 de octubre de 2026 (mainnet releído el 4 de noviembre de 2026, tras la v3.2.6: sigue vacío; ambas redes releídas el 7 de noviembre de 2026: mainnet vacía, testnet con 0x…0901, 0x…0A01, 0x…0A02 y 0x…0C01). Es un parámetro de la cadena que cambia la gobernanza, así que la lista de cada red solo cambia cuando se aprueba una propuesta de gobernanza; la lista de la testnet la fijó la propuesta 21, y ninguna propuesta de la mainnet la cambia en el momento de escribir esto. La versión v3.2.3 (mainnet, 20 de octubre de 2026) incluyó en el binario las versiones reforzadas del CrossVM Bridge y del precompilado AI Anomaly Check, detrás de una función de protocolo, pero no activó ningún precompilado, y tampoco lo cambian la v3.2.4 (en la mainnet desde el 23 de octubre de 2026, en la testnet desde el 19 de octubre de 2026) ni la v3.2.6 (en la mainnet desde el 4 de noviembre de 2026) ni la v3.2.7 (en la testnet desde el 6 de noviembre de 2026, en la mainnet desde el 12 de noviembre de 2026) lo cambia: la lista de la mainnet se leyó de nuevo el 12 de noviembre de 2026 y sigue vacía. Primero van los precompilados de PQC y de consenso de solo lectura, el par de IA una vez que esté lista su ruta de solo lectura en punto fijo, y el CrossVM Bridge en último lugar. Esta tabla enumera solo lo que está aplicado: una propuesta que sigue en su periodo de votación no es un estado.

Compruebe usted mismo la lista actual (una lista vacía significa que ninguno está activo):

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

Protéjase frente a datos de retorno vacíos​

Como una dirección inactiva (o que no es de QoreChain) devuelve éxito sin datos, nunca lea los bytes de retorno sin procesar de una llamada de bajo nivel sin comprobar su longitud. abi.decode y las llamadas a interfaces tipadas revierten con datos vacíos, que es el resultado seguro; una llamada de bajo nivel escrita a mano debe comprobarlo explícitamente:

(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));

No envíe valor a estas direcciones. No son payable, y el valor enviado a una dirección de precompilado inactiva se queda allí sin forma de recuperarlo.

En la testnet, una comprobación rápida de que los tres precompilados activos responden (con cast de Foundry; en la mainnet estas direcciones devuelven datos vacíos):

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

Precompilados estándar​

Además de los seis precompilados de QoreChain, el nodo incluye los precompilados estándar de cosmos/evm. Siguen la misma regla: solo se ejecutan donde la gobernanza ha listado su dirección en active_static_precompiles, y la compilación comunitaria del nodo no los incluye.

DirecciónPrecompilado
0x…0100P-256 (sin estado)
0x…0400Bech32 (sin estado)
0x…0800Staking
0x…0801Distribution
0x…0802Transferencia IBC (ICS-20)
0x…0804Bank (solo lectura)
0x…0805Governance
0x…0806Slashing

0x…0803 (vesting) está reservada en upstream y no está implementada: no hay nada en esa dirección. El staking, la delegación y las operaciones de validador en QoreChain son solo del carril nativo (véase Staking y validadores), así que no construyas flujos de staking sobre el precompilado de staking. Fuente: docs/EVM_PRECOMPILES.md en el repositorio público del core, en la etiqueta v3.2.6.


Mapa de direcciones de precompilados​

Las cifras de gas son lo que el nodo cobra una vez que un precompilado está activo (por byte significa por byte de la entrada de la llamada).

PrecompiladoDirecciónGas baseDescripción
CrossVM Bridge0x000000000000000000000000000000000000090150,000 + 4/byteLlamadas cross-VM síncronas (EVM a QoreChain Native)
PQC Verify0x0000000000000000000000000000000000000a0125,000 + 8/byteVerifica firmas post-cuánticas ML-DSA-87
PQC Key Status0x0000000000000000000000000000000000000a022,500Verifica si una cuenta tiene una clave PQC registrada
AI Risk Score0x0000000000000000000000000000000000000b0150,000Obtiene la puntuación de riesgo generada por IA para datos de transacción
AI Anomaly Check0x0000000000000000000000000000000000000b0240,000Verifica si una transferencia está marcada como anómala
PRISM Consensus Params0x0000000000000000000000000000000000000c011,500Lee los parámetros de consenso actuales ajustados por PRISM

Interfaces de 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);
}

Desde v3.2.4 (mainnet desde el 23 de octubre de 2026, testnet desde el 19 de octubre de 2026), la salida de pqcKeyStatus incluye un cuarto valor, bool possessionProven, después de pubkey: si la clave actual de la cuenta fue demostrada mediante una prueba de posesión verificada (consulte Firma post-cuántica). Se devuelve allí donde el precompilado esté activo: en la testnet ya está en vivo (una llamada para una cuenta sin clave devuelve false, 0, 0x, false), y en la mainnet lo estará cuando una actualización active el precompilado. La interfaz anterior enumera las cuatro salidas. Un contrato que deba confiar en la clave tiene que comprobar la cuarta: la prueba de posesión es opcional en el registro, así que registered por sí solo no basta.

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
);
}

Ejemplos de uso​

PQC Verify — Verificar una firma post-cuántica​

// 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");
}
}

Costo de gas: 25,000 base + 8 gas por byte de datos de entrada. La entrada es la llamada codificada en ABI (clave pública de 2592 bytes, firma de 4627 bytes, el mensaje, más los desplazamientos y el relleno de ABI), por lo que una verificación típica de ML-DSA-87 cuesta aproximadamente 85,000-90,000 de gas.

PQC Key Status — Verificar el registro de una cuenta​

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");
}
}
Comprueba possessionProven

La prueba de posesión es opcional en el registro, así que registered por sí solo no demuestra que la cuenta controle la clave. Un contrato que se apoye en una clave poscuántica registrada debe exigir además que possessionProven sea true.

Costo de gas: 2,500 fijo.

AI Risk Score — Evaluar el riesgo de una transacción​

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...
}
}

Niveles de riesgo:

NivelValor
SAFE0
LOW1
MEDIUM2
HIGH3
CRITICAL4

El nivel proviene de la etiqueta de gravedad que el motor de IA asigna a la transacción; la puntuación se devuelve en puntos básicos (0 - 10000). No hay una correspondencia fija entre rangos de puntuación y niveles, así que condicione la decisión a level en lugar de a umbrales de puntuación.

Costo de gas: 50,000 fijo.

AI Anomaly Check — Marcar transferencias sospechosas​

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");
}
}
}

Costo de gas: 40,000 fijo.

PRISM Consensus Params — Leer el estado del consenso​

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;
}
}

Costo de gas: 1,500 fijo, más las lecturas de estado que realiza la llamada al costo estándar.

Qué son los cuatro valores

Desde la v3.2.6 (ambas redes la ejecutan o una versión posterior; el precompilado en sí está activo solo en la testnet) rlConsensusParams devuelve los valores que mantiene el módulo rlconsensus en lugar de marcadores de posición fijos: el objetivo de tiempo de bloque aplicado en milisegundos, el piso de precio del gas aplicado, el default_validator_set_size del módulo y la época actual del agente. En la testnet, el 27 de octubre de 2026, devolvió 5000, 100, 100, 1 (los mismos valores aplicados que GET /qorechain/rlconsensus/v1/applied_params, consulte Endpoints REST / gRPC). Son los ajustes propios del módulo, no el tiempo de bloque medido (aproximadamente 3,1 s en la mainnet y aproximadamente 1,3 s en la testnet), y el agente funciona en modo sombra en la testnet, por lo que no aplica nada. En la mainnet la dirección no está en la lista de activos: un eth_call a ella devolvió datos vacíos (0x) el 4 de noviembre de 2026, aunque el código de v3.2.6 está en el binario (rl-params-precompile-live está activado). En un nodo anterior a la v3.2.6, la misma llamada devuelve valores predeterminados fijos de marcador de posición.

CrossVM Bridge — Llamar a QoreChain Native desde EVM​

aviso

El precompilado CrossVM Bridge no está activo en la mainnet y está activo en la testnet (leído el 7 de noviembre de 2026), donde el 7 de noviembre de 2026 se ejecutó un eth_call de solo lectura a través de él tras la actualización v3.2.7: un destino de la lista de permitidos alcanza el contrato, un destino fuera de ella se rechaza con is not allowlisted (detalles en Interoperabilidad Cross-VM). En la mainnet sigue desactivado, junto con las llamadas cross-VM, incluso después de una actualización a v3.2.7, hasta una decisión de gobernanza independiente. El binario desde v3.2.3 incluye una versión reforzada que: rechaza un STATICCALL; ejecuta la llamada anidada con un medidor de gas limitado por lo que le queda al marco que llama y la registra en el diario, de modo que una reversión en el contrato que llama también deshace el lado de QoreChain Native; solo alcanza destinos QoreChain Native de la lista de permitidos (los destinos EVM se rechazan); y respeta el circuit breaker cross-VM. Hasta que una propuesta de gobernanza lo active en la mainnet no existe allí una ruta síncrona de EVM a QoreChain Native; consulte Interoperabilidad Cross-VM para la ruta de mensajes MsgCrossVMCall, que a su vez está desactivada hoy en mainnet.

El nodo decodifica el calldata como executeCrossVMCall(uint8 targetVM, string targetContract, bytes payload) (selector de 4 bytes y, a continuación, los argumentos codificados en ABI). El único uso admitido es de EVM a QoreChain Native (targetVM = 1); el ABI aún puede cambiar antes de la activación. El helper encodeCrossVmCalldata de @qorechain/rdk codifica este formato desde la 0.6.0 (las versiones anteriores codificaban otra función), y su isCrossVmPrecompileActive lee la lista en vivo active_static_precompiles; consulte Multi-VM.

Costo de gas: 50,000 base + 4 gas por byte de entrada, más el costo de ejecución del contrato de destino. Consulte Interoperabilidad Cross-VM para más detalles.


Ubicaciones de los archivos de interfaz​

Los archivos de interfaz de Solidity están disponibles en el repositorio para importación directa:

contracts/
interfaces/
IQorePQC.sol
IQoreAI.sol
IQoreConsensus.sol

Instálelos en su proyecto de Hardhat o Foundry:

# Copy interfaces to your project
cp -r contracts/interfaces/ my-project/contracts/interfaces/

O referéncielos mediante la ruta de importación en sus archivos Solidity:

import "./interfaces/IQorePQC.sol";
import "./interfaces/IQoreAI.sol";
import "./interfaces/IQoreConsensus.sol";

Próximos pasos​