Aller au contenu principal

Multi-VM (appels inter-VM)

Le RDK inclut des assistants TypeScript qui encodent un appel d'un contrat EVM vers le précompilé inter-VM à l'adresse 0x0000000000000000000000000000000000000901, conçu pour l'acheminer vers un contrat QoreChain Native sur le runtime QoreChain Native (Wasm), ainsi qu'un modèle de structure (scaffold) multivm-rollup qui les câble. L'outillage couvre uniquement EVM → QoreChain Native ; la SVM est un environnement d'exécution distinct et ne fait pas partie du précompilé.

Pas encore utilisable sur les réseaux en service

Le précompilé inter-VM n'est pas activé sur le mainnet : la liste des précompilés statiques actifs du module EVM y est vide (vérifié le 4 novembre 2026). Sur le testnet, la liste ne contenait que 0x…0A01, 0x…0A02 et 0x…0C01 lors de la vérification du 27 octobre 2026, et aussi 0x…0901 à partir du 4 novembre ; elle a été relue le 7 novembre 2026 et liste toujours les quatre (voir la note sous Chaîne v3.2.5). Le 7 novembre 2026, après l'application de la chaîne v3.2.7 sur le testnet, un eth_call en lecture seule vers 0x…0901 a été testé sur le testnet : une cible de la liste d'autorisation a atteint son contrat, et une cible hors de la liste a été refusée (voir Testé sur le testnet). Sur le mainnet, eth_getCode pour 0x…0901 renvoie 0x, et un appel vers cette adresse réussit avec des données vides et n'exécute rien (un eth_call vers cette adresse a renvoyé des données vides le 4 novembre 2026). Le téléversement de contrats QoreChain Native est également fermé sur les deux réseaux, et la voie de transaction SVM est désactivée sur l'ensemble du réseau. Sur le mainnet, tant que le précompilé n'est pas activé et que les téléversements QoreChain Native ne sont pas rouverts, il n'y a rien à appeler ; sur le testnet, le précompilé est actif avec une liste d'autorisation et a été testé avec eth_call. Cette page documente l'outillage pour que vous puissiez vous préparer ; ne construisez pas de flux de production dessus. Voir Précompilés EVM : statut du réseau.

L'encodeur correspond à la disposition de la chaîne depuis la 0.6.0

encodeCrossVmCalldata dans @qorechain/rdk 0.5.0 et antérieures (ainsi que le point de départ CrossVmCaller.sol du modèle multivm-rollup de ces versions) utilisait executeCrossVMCall(string,bytes), un sélecteur de fonction différent de celui que décode le nœud ; aucun appel qu'elles encodaient n'aurait donc pu atteindre le précompilé, même sur un réseau qui l'aurait activé. La 0.6.0 encode executeCrossVMCall(uint8 targetVM, string targetContract, bytes payload) (sélecteur 0x3c11078c), ce que décode le nœud (sélecteur de 4 octets, puis les arguments encodés en ABI ; targetVM 1 correspond à QoreChain Native, la seule cible prise en charge), et les calldata de l'assistant font l'aller-retour dans le décodeur propre à la chaîne, selon les notes de version. L'ABI peut encore changer avant l'activation.

remarque

Depuis la version v0.4.2 du RDK, l'identifiant de l'option VM du runtime Wasm est native (QoreChain Native) ; cosmwasm reste un alias hérité accepté, et les deux correspondent à cosmwasm sur le réseau.

L'adresse du précompilé​

import { CROSS_VM_PRECOMPILE } from "@qorechain/rdk";

console.log(CROSS_VM_PRECOMPILE); // 0x0000000000000000000000000000000000000901

Encoder un appel inter-VM​

Encodez directement la disposition du nœud. payload est le message d'exécution du contrat, sous forme d'octets JSON UTF-8 (exemple avec viem) :

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, // QoreChain Native
"qor1cosmwasmcontractaddress...",
toHex(new TextEncoder().encode(JSON.stringify({ transfer: { recipient: "qor1...", amount: "100" } }))),
],
});

encodeCrossVmCalldata de @qorechain/rdk 0.6.0 et ultérieures (la 0.8.0 est la version actuelle) construit pour vous les mêmes calldata :

import {
CROSS_VM_PRECOMPILE,
CROSS_VM_TARGET,
encodeCrossVmCalldata,
isCrossVmPrecompileActive,
} from "@qorechain/rdk";

// Ask the node first: today this answers `active: false` on both networks.
const status = await isCrossVmPrecompileActive("https://api.qore.host");
console.log(status.active, status.reason);

const calldata = encodeCrossVmCalldata({
contract: "qor1cosmwasmcontractaddress...",
msg: JSON.stringify({ increment: {} }),
targetVm: CROSS_VM_TARGET.NATIVE, // 1 = QoreChain Native (CosmWasm); the default
});
// An EVM transaction to CROSS_VM_PRECOMPILE with `data: calldata`.

isCrossVmPrecompileActive(restBase) lit le paramètre EVM active_static_precompiles via REST et répond active: true uniquement lorsque l'adresse du précompilé figure dans la liste. C'est la seule vérification fiable, et elle doit se faire hors chaîne : le précompilé renvoie la réponse brute de la cible, de sorte qu'une réponse vide ne permet pas de distinguer un précompilé inactif d'un véritable appel à un contrat qui ne renvoie rien, et un précompilé n'a pas de bytecode, qu'il soit actif ou non. Même lorsqu'il indique active: true, le paquet documente qu'à partir de la chaîne v3.2.3 un appel n'atteint que les cibles que la gouvernance a placées sur la liste d'autorisation (le paramètre inter-VM bridge_allowed_targets, chaque entrée étant de la forme <vm>:<contract>), et que l'EVM vers l'EVM est refusé.

Testnet modifié après le 30 octobre 2026

Le 4 novembre 2026, la liste des précompilés actifs du testnet (active_static_precompiles dans les paramètres EVM) contenait aussi 0x…0901, et GET /qorechain/crossvm/v1/params sur le testnet listait trois cibles CosmWasm dans bridge_allowed_targets. Le mainnet était inchangé ce jour-là : liste active vide, liste d'autorisation vide, et un appel vers 0x…0901 par eth_call a renvoyé des données vides. La liste du testnet a été relue le 7 novembre 2026 et contient toujours 0x…0901. Les affirmations ci-dessous qui disent que le précompilé ou la liste d'autorisation est inactif ou vide sur le testnet décrivent la période du 27 au 30 octobre 2026 ; le comportement actuel du testnet est décrit dans Testé sur le testnet.

Chaîne v3.2.5 : liste d'autorisation, format de réponse et refus (les deux réseaux)​

La chaîne v3.2.5 change le comportement du pont. Le mainnet l'exécute depuis le 29 octobre 2026 (proposition de gouvernance 14, hauteur 3 906 833) et le testnet depuis le 26 octobre ; le mainnet exécute désormais la v3.2.7 et le testnet la v3.2.8. Comme le précompilé n'est pas actif sur le mainnet, le format de réponse ci-dessous est le comportement de la version et n'y a pas été exercé ; le format de refus a été observé sur le testnet le 7 novembre 2026 (voir Testé sur le testnet). Partout où cette page dit que le précompilé renvoie la réponse brute de la cible, cela décrit les versions antérieures à la v3.2.5.

  • Une route de liste d'autorisation. GET /qorechain/crossvm/v1/params sert les paramètres du pont, y compris la liste d'autorisation des cibles. Sur le mainnet, la liste d'autorisation est vide (vérifié le 4 novembre 2026) : aucune cible n'est donc encore autorisée ; sur le testnet, elle était vide le 30 octobre (voir la note ci-dessus).
  • Un format de réponse fixe. Le précompilé renvoie abi.encode(bytes), de sorte qu'une réponse fait toujours au moins 64 octets et qu'une réponse vide se distingue d'une réponse absente ; décodez-la avec abi.decode(ret, (bytes)).
  • Les refus portent un motif. Lorsque le pont refuse un appel, il annule avec Error(string), qu'un contrat peut lire et transmettre.
  • Actif sur le testnet, pas sur le mainnet. 0x...0901 ne figure pas dans la liste des précompilés actifs du mainnet ; la liste du testnet le contient (lu le 7 novembre 2026), et le refus ainsi que le comportement de la liste d'autorisation y ont été testés ce jour-là. Le mainnet garde les appels inter-VM désactivés jusqu'à une décision de gouvernance distincte, y compris après la mise à niveau v3.2.7 (appliquée sur le mainnet le 12 novembre 2026 ; le message d'appel cross-VM reste suspendu par le disjoncteur).

Testé sur le testnet​

Le testnet exécute la chaîne v3.2.8 depuis le 12 novembre 2026 (hauteur 9,929,500). Le 7 novembre 2026, deux requêtes eth_call en lecture seule ont été envoyées à 0x…0901 avec les calldata de executeCrossVMCall(uint8,string,bytes) (VM cible 1, charge utile {}) :

CibleRésultat
Une adresse CosmWasm qui ne figure pas dans bridge_allowed_targetsAnnulé avec cross-VM bridge call refused: target cosmwasm:<address> is not allowlisted
Un contrat CosmWasm issu de bridge_allowed_targetsL'appel a atteint le contrat, qui a rejeté la charge utile vide (Error parsing into type cw20::msg::Cw20ExecuteMsg) ; le pont l'a donc bien transmise, et aucun message que le contrat accepte n'a été envoyé

Cela montre la liste d'autorisation et le motif d'annulation. Cela ne montre pas un appel réussi qui modifie l'état, car eth_call ne change rien et la charge utile n'était volontairement pas un message valide. Le précompilé prend trois arguments ; la forme à deux arguments de la 0.5.0 et antérieures ne l'atteint pas. Le mainnet n'a pas ce comportement : le précompilé y est désactivé.

@qorechain/rdk 0.7.0 et ultérieures fournissent des assistants pour cela (vérifiés par rapport à des encodages produits par Solidity) : getCrossVmParams (la liste d'autorisation), crossVmTargetReady (précompilé actif, pont activé et cible sur la liste d'autorisation, avec le motif bloquant dans le cas contraire), decodeCrossVmResult (abi.decode(ret, (bytes))) et decodeRevertReason (Error(string)).

Le côté Solidity​

Depuis un contrat EVM, vous appelez l'adresse du précompilé avec l'appel encodé :

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

Comme le précompilé est inactif sur le mainnet, un simple .call vers celui-ci y renvoie un succès avec des données vides et ne fait rien ; l'indicateur ok ne vous dit pas que l'appel a pris effet. La protection fiable côté contrat est une cible qui renvoie toujours un accusé de réception non vide, avec un require(ret.length > 0) après l'appel, de sorte qu'une réponse vide soit traitée comme un échec ; le modèle multivm-rollup fait cela (0.6.0 et ultérieures).

Générer un rollup multi-VM​

npm create qorechain-rollup my-app -- --template multivm-rollup

Le modèle multivm-rollup inclut src/crossvm-call.ts (il vérifie si le précompilé est actif, puis affiche les calldata) et un contracts/CrossVmCaller.sol qui appelle executeCrossVMCall(uint8,string,bytes) et exige une réponse non vide de la cible. À partir de la 0.7.0, le contrat décode le résultat abi.encode(bytes), exige le minimum de 64 octets que renvoie un précompilé actif et transmet le motif de refus de la chaîne. Il ne fait pas fonctionner un appel tant que le précompilé est inactif. Consultez Déployer un Rollup pour tous les modèles du générateur de structure.