Skip to main content

Why QoreChain SDK

The QoreChain SDK gives you everything a modern multi-chain SDK does — typed messages for every module, typed queries, accounts for three VMs from one mnemonic, auto-gas, error decoding, subscriptions, wallets, and a React kit.

But five capabilities are only possible on QoreChain, because they are built on protocol features no other Layer 1 has: on-chain AI, three co-resident VMs with a native bridge, mandatory post-quantum cryptography, one 20-byte identity across all three VM lanes, and PQC-safe delegated spending for external wallet keys. These are the reasons to build here.


1. AI pre-flight risk scoring​

Scan a transaction with on-chain AI before you broadcast it (requires the AI precompiles to be active on the target network, which they are not on the public networks yet).

QoreChain builds AI risk analysis into EVM precompiles. The SDK calls them for you and returns gas plus a risk/anomaly verdict in a single call, so a wallet or dApp can warn (or block) before signing. The AI precompiles are not active yet on mainnet or testnet (see EVM Precompiles: Network status).

import { createEvmClient, simulateWithRiskScore } from "@qorechain/evm";

const { publicClient } = await createEvmClient({ endpoints: { evmRpc } });

const preflight = await simulateWithRiskScore(publicClient, {
from: account.address,
to: contractAddress,
data: calldata,
value: 0n,
});

console.log(preflight.gas); // estimated gas
console.log(preflight.risk.level); // on-chain risk level
console.log(preflight.anomaly.flagged);// anomalous pattern?
if (!preflight.safe) {
// advisory verdict — set your own policy
console.warn("Transaction flagged by on-chain AI risk scoring");
}

Why it's different: the scoring is designed to run inside the chain as a deterministic precompile (aiRiskScore at 0x…0B01, aiAnomalyCheck at 0x…0B02), not as an off-chain service. Until those precompiles are activated, the helpers above throw on the public networks (returned no data ("0x"); the testnet's three active precompiles are the PQC and consensus ones, not these). See AI pre-flight.


2. Unified cross-VM calls — one account, three VMs, one transaction​

Call a contract on any VM, and batch calls across all three atomically.

QoreChain runs QoreChain Native, EVM, and SVM contracts on the same chain with a native cross-VM bridge. The SDK exposes one interface to call any of them — and to pack several cross-VM calls into a single, atomic transaction signed once.

import { connectQueryClients, createCrossVMClient } from "@qorechain/sdk";

// rpcClient: a connected consensus-RPC client (the CosmJS RPC client type).
const crossVM = createCrossVMClient(tx, { query: connectQueryClients(rpcClient).crossvm });

// Call an EVM contract from a native account (payload ABI-encoded for you).
await crossVM.call({
targetVm: "evm",
targetContract: "0xToken…",
evm: { abi, functionName: "transfer", args: [recipient, amount] },
});

// One signature, three VMs, atomic: EVM → SVM → QoreChain Native.
await crossVM.callAtomic([
{ targetVm: "evm", targetContract: "0x…", evm: { abi, functionName: "approve", args } },
{ targetVm: "svm", targetContract: "Prog…", svm: { data } },
{ targetVm: "cosmwasm", targetContract: "qor1…", cosmwasm: { swap: {} } },
]);

Why it's different: QoreChain runs three co-resident VMs with a native bridge module (crossvm, plus the CrossVMBridge precompile once it is active; it is not active on mainnet; the testnet has it active with an allowlist, tested with eth_call on 7 November 2026), so one SDK interface can address all three. Single-VM chains have nothing equivalent to wrap. Today the reach of a call is limited by the lane it targets: MsgCrossVMCall is switched off on mainnet, SVM transactions are disabled, and QoreChain Native upload and instantiate are permissioned (instantiate is open on the testnet). See Cross-VM calls.


3. Hybrid signing by default​

Register a signer's ML-DSA-87 key in one call.

QoreChain enforces hybrid post-quantum signatures (ML-DSA-87 + classical) at the protocol level. The SDK makes adopting them a one-liner: check, register, and migrate to hybrid signing — with a React badge that shows whether an address has a registered key.

import { ensurePqcRegistered, migrateToHybrid } from "@qorechain/sdk";

// Registers the signer's ML-DSA-87 key on-chain unless the chain already has it:
// it reads the status over REST first and never registers blind.
const rest = "https://api.qore.host";
const { alreadyRegistered, txHash } = await ensurePqcRegistered(tx, { pqcKeypair, rest });

// Switch the signing path to hybrid (classical + post-quantum).
const hybrid = await migrateToHybrid(tx, { pqcKeypair, rest });
await hybrid.signAndBroadcastHybrid({
registry, signer, messages, fee, chainId, accountNumber, sequence,
rest: "https://api.qore.host", // resolves the v1/v2 PQC sign-bytes form
transport,
});
import { PqcStatusBadge } from "@qorechain/react";

// Shows a status badge when the address has a registered PQC key
// (read over REST, so it works on the public endpoints from `@qorechain/react` 0.9.0 and later).
<PqcStatusBadge address={account.address} />

Why it matters: post-quantum cryptography is native and mandatory on QoreChain's Native path, not an experiment, and the SDK reduces adopting it to a register call plus a hybrid send path. Registration is explicit: there is no auto-registration on the first transaction. See Hybrid signing.


4. Unified eth-native accounts — one key, three addresses, one balance​

One eth_secp256k1 key is one 20-byte identity on all three lanes. (SDK 0.6.0, chain v3.1.83.) The SVM transaction lane is disabled network-wide today, and the EVM lane needs an authorization window; the shared balance and address mapping hold regardless.

import { deriveUnifiedAccount } from "@qorechain/sdk";

const account = await deriveUnifiedAccount(mnemonic);
account.cosmos; // "qor1…" bech32 — Native lane
account.evm; // "0x…" EIP-55 — EVM lane
account.svm; // base58 — SVM lane (same 20 bytes + 12 zero bytes)
// A deposit to ANY of the three lands in ONE balance,
// and the same key signs on every enabled lane (signHybridEth on the Native path).

Why it's unique: on multi-VM setups elsewhere, each runtime has its own account space and funds get stranded per-lane. QoreChain renders one 20-byte identity three ways with one shared balance — a wallet never "has funds on one lane but not another". An external wallet such as Phantom can be linked to that identity as a limited authenticator (Authenticators). See Unified accounts.


5. Authenticator lanes — delegated spending without giving up PQC​

A linked Phantom or MetaMask key spends from the canonical PQC-required account, under limits, via a relayer. (SDK 0.7.0, chain v3.1.85.)

Not available on mainnet yet

The abstractaccount module is switched off on qorechain-vladi (GET /qorechain/abstractaccount/v1/config returns "enabled": false), and from chain v3.2.0 that flag is enforced on every path, so on mainnet a key cannot be linked and the lanes below cannot be used. The module is enabled on the qorechain-diana testnet (checked 27 October 2026). See the Authenticators guide.

import { buildPhantomExecuteCosmos } from "@qorechain/sdk";

// The Phantom key signs a domain-separated digest; a relayer pays fees and
// broadcasts. The external key NEVER produces an ML-DSA co-signature.
const msg = await buildPhantomExecuteCosmos({
wallet: window.solana,
relayer: relayerAddress,
chainId: "qorechain-vladi",
account: canonicalAccount, // the PQC-required owner
to: recipient,
amount: "100uqor",
nonce, // per-authenticator sequence
});

Why it matters: once the module is enabled, every spend by a linked key is bounded by an on-chain permission taxonomy, SpendingRule limits, and an expiry — least-privilege and revocable — while the account itself stays post-quantum protected. See Authenticators & delegated spending.


Everything else, too​

Beyond the five differentiators, the SDK covers the full chain surface across TypeScript, Python, Go, Rust, and Java: typed composers for every module (including sidechains/paychains via multilayer and rollups via rdk), typed queries, the tx lifecycle, subscriptions, browser wallets, and the @qorechain/react hooks kit.

Ready to build? Start with the Quickstart.