Aller au contenu principal

Kit React (@qorechain/react)

@qorechain/react est la couche React officielle au-dessus de @qorechain/sdk : un provider, une poignée de hooks, et deux composants prêts à l'emploi — y compris un badge d'état PQC en une ligne. Il fait de la construction d'une dApp à signature hybride ML-DSA-87 le chemin par défaut.

npm i @qorechain/react @qorechain/sdk react react-dom

react (>=18) est une dépendance pair ; @qorechain/sdk est une dépendance directe (^0.14.0 depuis le kit 0.14.0 ; sur une version 0.x, le caret reste dans la 0.14, de sorte qu'un correctif du SDK n'installe pas une seconde copie). Utilisez @qorechain/react 0.14.0 (la 0.9.0 et les suivantes fonctionnent de la même façon) : la 0.8.0 épingle le SDK 0.8.0, qui signe la mauvaise forme hybride sur le mainnet, et les versions 0.8.x antérieures peuvent afficher un solde ou un statut obsolète après un changement d'adresse.

Limites du kit React sur les réseaux en direct (0.9.0 à 0.14.0)

useTx se connecte avec le signataire du wallet et sans paire de clés post-quantique ; il envoie donc uniquement avec la signature classique, que les réseaux en direct rejettent (le chemin Native exige l'extension hybride ML-DSA-87) : send / sendTokens ne peuvent pas faire aboutir une transaction sur le mainnet ni sur le testnet. Pour les envois, utilisez le TxClient hybride du SDK (client.connectTx(signer, { pqcKeypair }), voir Signature hybride). usePqcStatus et <PqcStatusBadge/> lisent le statut via getPqcStatus avec le client composé du provider, qui depuis le SDK 0.9.0 lit via REST (/qorechain/pqc/v1/account/{address}) ; ils fonctionnent donc contre *.qore.host (le kit 0.8.x lisait qor_getPQCKeyStatus, que les endpoints publics ne servent pas, et ne pouvait pas y confirmer une clé). Les lectures de solde (useBalance) et la connexion du wallet fonctionnent.

Provider​

Enveloppez votre application une fois dans QoreChainProvider. Il détient une seule instance createClient() ainsi que l'état de connexion du wallet en direct dont chaque hook se sert.

import { QoreChainProvider } from "@qorechain/react";

function Root() {
return (
<QoreChainProvider
config={{
network: "testnet",
endpoints: {
rpc: "https://rpc-testnet.qore.host",
rest: "https://api-testnet.qore.host",
evmRpc: "https://evm-testnet.qore.host",
},
}}
>
<App />
</QoreChainProvider>
);
}

Pour changer de réseau à l'exécution, remontez le provider avec une key React différente. Pour les tests, passez une prop client pré-construite (ou simulée) au lieu de config.

Hooks​

HookRenvoie
useQoreClient()Le QoreChainClient composé pour des lectures ponctuelles.
useAccount(){ addresses, address, isConnected, status, wallet } — adresses native / EVM / SVM.
useBalance(address?, options?){ data, isLoading, error, refetch } ; rafraîchissement automatique via refreshInterval.
useConnect() / useWallet(){ connect, disconnect, status, isConnecting, error }.
useTx(){ send, sendTokens, status, data, error, isPending, reset }.
usePqcStatus(address?, options?){ data, isRegistered, isLoading, error, refetch }.

Connecter des wallets​

useConnect encapsule les adaptateurs existants du SDK :

const { connect } = useConnect();
await connect({ kind: "keplr" }); // or "leap" | "evm" | "svm"
  • keplr / leap — wallets Cosmos via getCosmosWallet. Suggère et active la chaîne, renvoie un signataire câblé dans un TxClient, de sorte que useTx peut signer immédiatement. Définit addresses.native.
  • evm — tout provider EIP-1193 injecté (window.ethereum, p. ex. MetaMask) via eth_requestAccounts. Définit addresses.evm.
  • svm — tout provider Wallet-Standard injecté (window.solana, p. ex. Phantom) via connect(). Définit addresses.svm.

Les chemins EVM et SVM utilisent directement l'API de requête standard du provider injecté, de sorte que ni viem ni un SDK Solana ne sont importés. Passez provider dans les options de connexion pour injecter un wallet pour les tests. Associez à @qorechain/evm / @qorechain/svm pour un outillage complet par VM.

Envoyer des transactions​

import { msg } from "@qorechain/sdk";
import { useTx } from "@qorechain/react";

function Send() {
const { sendTokens, isPending } = useTx();
return (
<button
disabled={isPending}
onClick={() =>
sendTokens("qor1recipient…", [{ denom: "uqor", amount: "1000000" }])
}
>
Send 1 QOR
</button>
);
}

send([{ typeUrl, value }], opts) prend des messages bruts issus des composeurs msg.* pour tout ce qui va au-delà d'un transfert bancaire.

Composants​

<ConnectButton/>​

Un contrôle de connexion / déconnexion minimal et quasi headless. Passez wallets pour proposer un sélecteur, className / style pour le styliser, ou une render-prop children pour un contrôle total :

<ConnectButton wallets={["keplr", "leap", "evm"]} />

<PqcStatusBadge/>​

Affiche un indicateur d'état lorsque l'adresse possède une clé post-quantique enregistrée (via usePqcStatus), sinon un état atténué « non enregistrée ». Par défaut, il s'applique au compte connecté. Les libellés par défaut sont « PQC key registered » et « No PQC key » (remplacez-les avec safeLabel / unsafeLabel) ; l'élément racine porte data-pqc-status et data-quantum-safe, avec les mêmes valeurs.

<PqcStatusBadge />
<PqcStatusBadge address="qor1…" hideWhenUnsafe />

PqcStatusBadge est arrivé avec le kit 0.11.0. QuantumSafeBadge (avec QuantumSafeBadgeProps et QuantumSafeRenderState) reste exporté comme alias obsolète du même composant, de sorte que le code existant continue de fonctionner.

Tout assembler​

import {
ConnectButton,
PqcStatusBadge,
useAccount,
useBalance,
} from "@qorechain/react";

function Dashboard() {
const { address, isConnected } = useAccount();
const { data: balance } = useBalance(undefined, { refreshInterval: 10_000 });
return (
<>
<ConnectButton wallets={["keplr", "leap", "evm"]} />
{isConnected && (
<p>
{balance?.amount ?? "…"} {balance?.denom} <PqcStatusBadge />
</p>
)}
</>
);
}

Voir l'exemple react-dapp exécutable et le guide de la signature hybride pour les appels SDK sous-jacents.