@qorechain/sdk 0.5.0 → 0.5.2

package/README.md

@@ -17,7 +17,16 @@ network — a quantum-safe, triple-VM Layer 1 with native, EVM, and SVM accounts
 - **NFT helpers** — ERC-721 / ERC-1155 wrappers in `@qorechain/evm`.
 - **CosmWasm lifecycle** — query, upload, instantiate/instantiate2, execute,
   migrate, and admin management.
-- **PQC** — ML-DSA-87 (Dilithium-5) signing and hybrid-signature transactions.
+- **PQC** — ML-DSA-87 (Dilithium-5) signing and hybrid-signature transactions,
+  plus quantum-safe DX helpers (`ensurePqcRegistered` / `migrateToHybrid`).
+- **Sidechains, paychains & rollups** — high-level `createMultilayerClient` and
+  `createRollupClient` helpers (v0.4.0).
+- **Unified cross-VM calls** — `createCrossVMClient` with atomic triple-VM
+  transactions over `MsgCrossVMCall` (v0.5.0).
+- **AI pre-flight** — on-chain risk/anomaly scoring (`simulateWithRiskScore`)
+  over the EVM precompiles before you sign (v0.5.0).
+- **React kit** — hooks + connect kit in
+  [`@qorechain/react`](../react/README.md).
 
 ## Install
 
@@ -40,9 +49,9 @@ const client = createClient(); // testnet, localhost defaults
 
 const remote = createClient({
   endpoints: {
-    rest: "https://rest.testnet.example", // Cosmos REST (LCD)
-    rpc: "https://rpc.testnet.example",    // consensus RPC (for signing)
-    evmRpc: "https://evm.testnet.example", // EVM + qor_ JSON-RPC
+    rest: "https://api-testnet.qore.host", // Cosmos REST (LCD)
+    rpc: "https://rpc-testnet.qore.host",    // consensus RPC (for signing)
+    evmRpc: "https://evm-testnet.qore.host", // EVM + qor_ JSON-RPC
   },
 });
 ```
@@ -133,19 +142,180 @@ const info = await getContractInfo(cw, "qor1contract...");
 const state = await queryContractSmart(cw, "qor1contract...", { get_count: {} });
 
 // Writes
-const signing = await connectCosmWasmSigner("https://rpc.testnet.example", signer);
+const signing = await connectCosmWasmSigner("https://rpc-testnet.qore.host", signer);
 const inst = await instantiate(signing, sender, codeId, { count: 0 }, "my-contract", {
   fee: "auto",
 });
 await execute(signing, sender, inst.contractAddress, { increment: {} }, "auto");
 ```
 
-### Cross-VM messages
+### Sidechains, paychains & rollups (v0.4.0)
 
-QoreChain routes calls across its native, EVM, and CosmWasm execution
-environments. The EVM→native direction (e.g. an EVM contract triggering a native
-AMM swap) is performed on-chain through the cross-VM bridge precompile exposed in
-the `@qorechain/evm` package. From this SDK you can read message state:
+QoreChain's multilayer module lets a dApp register and operate its own
+sidechains/paychains, and the rollup development kit (`rdk`) provides an
+optimistic rollup lifecycle. Two high-level, strongly-typed helpers wrap the
+typed message composers and query clients so you never hand-build protobuf `Any`
+payloads. Both bind to a connected `TxClient`; pass a typed query client (from
+`connectQueryClients`) for the reads.
+
+```ts
+import {
+  createClient,
+  createMultilayerClient,
+  createRollupClient,
+  connectQueryClients,
+} from "@qorechain/sdk";
+
+const client = createClient({ endpoints });
+const tx = await client.connectTx(signer);
+const query = await connectQueryClients("https://grpc.example");
+
+// --- Multilayer: register → anchor → route ---
+const ml = createMultilayerClient(tx, { query });
+await ml.registerSidechain({ layerId: "game-l2", description: "game sidechain" });
+await ml.registerPaychain({ layerId: "pay-l2", description: "payments paychain" });
+await ml.anchorState({ layerId: "game-l2", layerHeight: 100n, stateRoot, validatorSetHash });
+await ml.routeTransaction({ transactionPayload, preferredLayer: "game-l2" });
+// Reads
+const layer = await ml.getLayer("game-l2");
+const layers = await ml.listLayers();
+const stats = await ml.getRoutingStats();
+
+// --- Rollups: create → submitBatch → executeWithdrawal ---
+const rollup = createRollupClient(tx, { query, qor: client.qor });
+await rollup.createRollup({ rollupId: "r1", profile: "default", vmType: "evm" });
+await rollup.submitBatch({ rollupId: "r1", batchIndex: 0n, stateRoot, txCount: 12n });
+await rollup.executeWithdrawal({ rollupId: "r1", batchIndex: 0n, withdrawalIndex: 0n, recipient, denom: "uqor", amount: 100n, proof });
+// Reads (typed gRPC + qor_ conveniences)
+const r = await rollup.getRollup("r1");
+const batch = await rollup.getLatestBatch("r1");
+const rollupStatus = await rollup.getRollupStatus("r1");
+```
+
+Every write also has a `*Msg(...)` variant (`registerSidechainMsg`,
+`submitBatchMsg`, …) that returns an `EncodeObject` for batching with other
+messages. The challenge game (`challengeBatch` / `resolveChallenge`) and lifecycle
+controls are exposed on the rollup client too.
+
+You can also reach the typed query clients directly — `connectQueryClients`
+returns `multilayer`, `rdk`, `bridge`, and `crossvm` clients (among others):
+
+```ts
+const layers = await query.multilayer.layers({});
+const rollups = await query.rdk.rollups({});
+const bridgeChains = await query.bridge.chainConfigs({});
+```
+
+See the [multilayer](../../docs/docs/guides/multilayer.md) and
+[rollups](../../docs/docs/guides/rollups.md) guides.
+
+### AI pre-flight risk scoring (v0.5.0)
+
+QoreChain exposes an on-chain AI risk/anomaly model to any dApp through plain
+`eth_call`s, so you can get an advisory verdict on a transaction **before** it is
+signed or broadcast. The helpers live in `@qorechain/evm` (which owns viem) and
+are re-exported from `@qorechain/sdk` for discovery — install `@qorechain/evm`
+and `viem` (an optional peer) to use them.
+
+`simulateWithRiskScore` bundles a gas estimate, a risk score from the
+`aiRiskScore` precompile (`0x…0B01`), and an anomaly check from the
+`aiAnomalyCheck` precompile (`0x…0B02`) into one `PreflightResult`:
+
+```ts
+import { simulateWithRiskScore, aiRiskScore, aiAnomalyCheck } from "@qorechain/sdk";
+import { createPublicClient, http } from "viem";
+
+const evm = createPublicClient({ transport: http("https://evm.example") });
+
+const verdict = await simulateWithRiskScore(evm, {
+  from: "0xSender",
+  to: "0xContract",
+  data: "0x…", // calldata
+  value: 0n,
+});
+if (!verdict.safe) throw new Error("AI pre-flight flagged this transaction");
+
+// Or call the precompiles individually:
+const risk = await aiRiskScore(evm, "0xCalldata");      // { score, level }
+const anomaly = await aiAnomalyCheck(evm, "0xSender", 1_000_000n); // { anomalyScore, flagged }
+```
+
+See the [AI pre-flight](../../docs/docs/guides/ai-preflight.md) guide.
+
+### Unified cross-VM calls (v0.5.0)
+
+QoreChain routes calls across its EVM, CosmWasm, and SVM execution environments
+over a single `MsgCrossVMCall`. `createCrossVMClient` builds, signs, and
+broadcasts these for you — including `callAtomic`, which packs several calls into
+**one** transaction so a triple-VM workflow settles atomically.
+
+This SDK encodes the payload per VM: an `{ evm: { abi, functionName, args } }`
+payload is ABI-encoded with viem's `encodeFunctionData`, a `{ cosmwasm: {...} }`
+payload is `JSON.stringify`'d to UTF-8, and a raw `{ payload }` is sent as-is.
+
+```ts
+import { createCrossVMClient, connectQueryClients } from "@qorechain/sdk";
+
+const query = await connectQueryClients("https://grpc.example");
+const xvm = createCrossVMClient(tx, { query });
+
+// Single call into a CosmWasm contract (payload JSON-encoded).
+const res = await xvm.call({
+  targetVm: "cosmwasm",
+  targetContract: "qor1contract…",
+  payload: { cosmwasm: { increment: {} } },
+});
+
+// Atomic triple-VM batch in ONE tx.
+const atomic = await xvm.callAtomic([
+  { targetVm: "evm", targetContract: "0xC…", payload: { evm: { abi, functionName: "swap", args: [a, b] } } },
+  { targetVm: "svm", targetContract: "Prog…", payload: { payload: rawBytes } },
+  { targetVm: "cosmwasm", targetContract: "qor1…", payload: { cosmwasm: { stake: {} } } },
+]);
+
+// build-only (returns an EncodeObject) and read message status:
+const msg = xvm.buildCall({ targetVm: "evm", targetContract: "0xC…", payload: { payload: rawBytes } });
+const status = await xvm.getMessage("42");
+```
+
+`targetVm` is one of `"evm" | "cosmwasm" | "svm"` (see `VM_TYPES`). See the
+[cross-VM](../../docs/docs/guides/cross-vm.md) guide.
+
+### Quantum-safe DX (v0.5.0)
+
+QoreChain enforces hybrid post-quantum signatures (ML-DSA-87 + secp256k1) by
+default. These helpers make a dApp PQC-protected in one idempotent call: check
+whether the signer's Dilithium key is registered, register it if not, and route
+subsequent transactions through the hybrid signing path.
+
+```ts
+import {
+  isPqcRegistered,
+  getPqcStatus,
+  ensurePqcRegistered,
+  migrateToHybrid,
+  migratePqcKey,
+} from "@qorechain/sdk";
+
+// Read-only status (over the qor_ namespace or the pqcKeyStatus precompile).
+const registered = await isPqcRegistered(client.qor, native.address);
+const status = await getPqcStatus(client.qor, native.address);
+
+// Idempotent: registers the signer's PQC key only if it isn't already.
+await ensurePqcRegistered({ tx, signer: pqcSigner /* … */ });
+
+// Migrate an existing classical account to hybrid signing, then sign hybrid.
+const path = await migrateToHybrid({ tx, signer: pqcSigner /* … */ });
+
+// Rotate an account's on-chain PQC key (MsgMigratePQCKey).
+await migratePqcKey({ tx, /* new key material … */ });
+```
+
+See the [quantum-safe](../../docs/docs/guides/quantum-safe.md) guide.
+
+### Cross-VM message reads
+
+You can also read cross-VM message state without the client above:
 
 ```ts
 const pending = await client.crossvm.pending();

package/dist/index.cjs

@@ -16,7 +16,7 @@ var english = require('@scure/bip39/wordlists/english');
 var bip32 = require('@scure/bip32');
 var slip10_js = require('micro-key-producer/slip10.js');
 var secp256k1 = require('@noble/curves/secp256k1');
-var mlDsa_js = require('@noble/post-quantum/ml-dsa.js');
+var pqc$1 = require('@qorechain/pqc');
 var utils = require('@noble/hashes/utils');
 var evm = require('@qorechain/evm');
 var tendermintRpc = require('@cosmjs/tendermint-rpc');
@@ -443,7 +443,7 @@ var QorClient = class extends JsonRpcClient {
 // src/tx/fees.ts
 var STATIC_FALLBACK = {
   /** Fallback gas price, in base denom per unit of gas. */
-  gasPrice: "0.025",
+  gasPrice: "0.15",
   /** Base denomination fees are paid in. */
   denom: "uqor",
   /** Default gas limit when the caller does not supply one. */
@@ -9716,7 +9716,7 @@ function calculateFee(gas, gasPrice) {
 // src/tx/builder.ts
 var MSG_SEND_TYPE_URL = "/cosmos.bank.v1beta1.MsgSend";
 var DEFAULT_GAS_MULTIPLIER = 1.4;
-var DEFAULT_GAS_PRICE = "0.025uqor";
+var DEFAULT_GAS_PRICE = "0.15uqor";
 function buildAminoTypes(extra) {
   return new stargate.AminoTypes({
     ...stargate.createDefaultAminoConverters(),
@@ -9795,7 +9795,7 @@ var TxClient = class _TxClient {
    *
    * `fee` may be an explicit {@link StdFee} or the literal `"auto"`, which
    * simulates the tx to estimate gas and computes the fee from a gas
-   * multiplier (default 1.4) and gas price (default `0.025uqor`); tune both via
+   * multiplier (default 1.4) and gas price (default `0.15uqor`); tune both via
    * `opts.autoFee`.
    *
    * Broadcast mode maps onto cosmjs transports:
@@ -10451,14 +10451,14 @@ function generatePqcKeypair(seed) {
     );
   }
   const xi = seed ?? utils.randomBytes(ML_DSA_87_SEED_LENGTH);
-  const kp = mlDsa_js.ml_dsa87.keygen(xi);
+  const kp = pqc$1.mldsa87.keygen(xi);
   return { publicKey: kp.publicKey, secretKey: kp.secretKey };
 }
-function pqcSign(secretKey, message) {
-  return mlDsa_js.ml_dsa87.sign(secretKey, message);
+function pqcSign(secretKey, message, opts) {
+  return pqc$1.mldsa87.sign(secretKey, message, opts);
 }
 function pqcVerify(publicKey, message, signature) {
-  return mlDsa_js.ml_dsa87.verify(publicKey, message, signature);
+  return pqc$1.mldsa87.verify(publicKey, message, signature);
 }
 function buildHybridSignatureExtension(args) {
   const { algorithmId, signature, publicKey } = args;
@@ -19156,7 +19156,7 @@ function suggestChainInfo(network) {
   };
   const feeCurrency = {
     ...currency,
-    gasPriceStep: { low: 0.01, average: 0.025, high: 0.04 }
+    gasPriceStep: { low: 0.1, average: 0.15, high: 0.25 }
   };
   return {
     chainId,
@@ -19764,9 +19764,10 @@ async function isPqcRegistered(source, address) {
   return status.registered;
 }
 function buildRegisterPqcKeyMsg(sender, opts) {
-  return pqc.registerPqcKey({
+  return pqc.registerPqcKeyV2({
     sender,
-    dilithiumPubkey: opts.pqcKeypair.publicKey,
+    publicKey: opts.pqcKeypair.publicKey,
+    algorithmId: AlgorithmDilithium5,
     ecdsaPubkey: opts.ecdsaPubkey ?? new Uint8Array(0),
     keyType: opts.keyType ?? "hybrid"
   });