Sari la conținutul principal

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.

notă

Precompilatele sunt disponibile atât pe rețeaua mainnet qorechain-vladi (ID chain EVM 9801, live din 7 iunie 2026 pe versiunea de chain v3.1.97), cât și pe rețeaua testnet qorechain-diana (ID chain EVM 9800). Toate exemplele folosesc endpoint-ul JSON-RPC pe portul 8545.

Harta adreselor precompilatelor​

PrecompilatAdresăGaz de bazăDescriere
CrossVM Bridge0x000000000000000000000000000000000000090150.000Apeluri sincrone cross-VM (de la EVM la CosmWasm)
PQC Verify0x0000000000000000000000000000000000000A0125.000 + 8/octetVerifică semnături post-cuantice ML-DSA-87
PQC Key Status0x0000000000000000000000000000000000000A022.500Verifică dacă un cont are o cheie PQC înregistrată
AI Risk Score0x0000000000000000000000000000000000000B0150.000Obține scorul de risc generat de AI pentru date de tranzacție
AI Anomaly Check0x0000000000000000000000000000000000000B0240.000Verifică dacă un transfer este marcat drept anomal
PRISM Consensus Params0x0000000000000000000000000000000000000C011.500Citeș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)
    function pqcKeyStatus(address account)
        external
        view
        returns (bool registered, uint8 algorithmId, bytes memory pubkey);
}

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. Pentru o verificare tipică ML-DSA-87 (2592 + 4627 + octeții mesajului), se estimează aproximativ 80.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, , ) = PQC_STATUS.pqcKeyStatus(account);
        require(registered, "Account must have a registered PQC key");
    }
}

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:

NivelValoareInterval scor (bps)
SAFE00 - 1000
LOW11001 - 3000
MEDIUM23001 - 6000
HIGH36001 - 8500
CRITICAL48501 - 10000

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.

CrossVM Bridge — Apelarea CosmWasm din EVM​

interface ICrossVM {
    function call(bytes calldata payload) external returns (bytes memory);
}

contract CrossVMExample {
    ICrossVM constant CROSSVM = ICrossVM(
        0x0000000000000000000000000000000000000901
    );

    function callCosmWasm(
        string memory contractAddr,
        string memory executeMsg
    ) external returns (bytes memory) {
        bytes memory payload = abi.encode(contractAddr, executeMsg, uint256(0));
        return CROSSVM.call(payload);
    }
}

Cost de gaz: 50.000 de bază + 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
    ICrossVM.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​