@qorechain/sdk 0.4.0 → 0.5.1

package/dist/index.d.cts

@@ -1,9 +1,11 @@
 import * as _cosmjs_proto_signing from '@cosmjs/proto-signing';
 import { EncodeObject, OfflineSigner, GeneratedType, Registry, OfflineDirectSigner } from '@cosmjs/proto-signing';
+export { EncodeObject } from '@cosmjs/proto-signing';
 import { Coin as Coin$1, StdFee } from '@cosmjs/amino';
 export { Coin, StdFee } from '@cosmjs/amino';
 import { DeliverTxResponse, AminoTypes, AminoConverters, SigningStargateClientOptions, QueryClient, ProtobufRpcClient } from '@cosmjs/stargate';
 import { CosmWasmClient, SigningCosmWasmClient } from '@cosmjs/cosmwasm-stargate';
+export { AI_ANOMALY_CHECK_ADDRESS, AI_RISK_SCORE_ADDRESS, AiAnomalyCheck, AiRiskScore, PreflightResult, PreflightTx, RISK_LEVEL_UNSAFE_THRESHOLD, ai, aiAnomalyCheck, aiRiskScore, simulateWithRiskScore } from '@qorechain/evm';
 import { Any } from 'cosmjs-types/google/protobuf/any';
 import { TxBody, TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
 import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
@@ -407,13 +409,13 @@ declare class QorClient extends JsonRpcClient {
 
 /**
  * Default static-fallback parameters, used when the AI fee oracle is
- * unavailable. The gas price (`uqor` per unit of gas) is intentionally
- * conservative and matches the relayer default in the core repo
- * (`gas_price = 0.025 uqor`).
+ * unavailable. The gas price (`uqor` per unit of gas) sits above the chain's
+ * genesis min-gas-price (BaseFee) of `0.1uqor` per unit of gas, which is
+ * enforced on both networks.
  */
 declare const STATIC_FALLBACK: {
     /** Fallback gas price, in base denom per unit of gas. */
-    readonly gasPrice: "0.025";
+    readonly gasPrice: "0.15";
     /** Base denomination fees are paid in. */
     readonly denom: "uqor";
     /** Default gas limit when the caller does not supply one. */
@@ -573,8 +575,13 @@ declare function calculateFee(gas: number | string, gasPrice: GasPrice | string)
 declare const MSG_SEND_TYPE_URL = "/cosmos.bank.v1beta1.MsgSend";
 /** Default gas-used safety multiplier applied to a simulation result. */
 declare const DEFAULT_GAS_MULTIPLIER = 1.4;
-/** Default gas price for the auto-fee path (conservative, matches `tx/fees`). */
-declare const DEFAULT_GAS_PRICE = "0.025uqor";
+/**
+ * Default gas price for the auto-fee path (matches `tx/fees`).
+ *
+ * The chain enforces a genesis min-gas-price (BaseFee) of `0.1uqor` per unit
+ * of gas on both networks; the default sits above the floor for headroom.
+ */
+declare const DEFAULT_GAS_PRICE = "0.15uqor";
 /**
  * A fee that is either an explicit {@link StdFee} or the literal `"auto"`, which
  * triggers simulation-based gas estimation and fee computation.
@@ -734,7 +741,7 @@ declare 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:
@@ -1437,18 +1444,24 @@ interface Signer {
  * assemble or broadcast transactions — the tx-builder attaches the extension
  * the {@link buildHybridSignatureExtension} result describes.
  *
- * Crypto is delegated entirely to the audited, pure-TS `@noble/post-quantum`
- * (`ml_dsa87`). No primitives are reimplemented here.
+ * Crypto is delegated entirely to `@qorechain/pqc` (`mldsa87`, wrapping the
+ * audited, pure-TS `@noble/post-quantum`). No primitives are reimplemented
+ * here.
+ *
+ * Signing is DETERMINISTIC (FIPS-204 §3.4, rnd = 32 zero bytes) by default:
+ * the chain's on-chain PQC verifier accepts ONLY deterministic ML-DSA-87
+ * signatures (hedged signatures are rejected with codespace `pqc`), so this
+ * default is consensus-critical. Pass `{ hedged: true }` to {@link pqcSign}
+ * only for off-chain uses that want side-channel hedging.
  */
 
 /**
  * ML-DSA-87 (Dilithium-5) byte lengths.
  *
  * These are fixed by NIST FIPS 204 and match the chain's `x/pqc` constants
- * exactly. The installed `@noble/post-quantum` `ml_dsa87` does not expose these
- * as runtime properties, so we encode the standard's values directly; the test
- * suite asserts that the library actually produces keys/signatures of these
- * lengths, guarding against any future library drift.
+ * exactly. We encode the standard's values directly; the test suite asserts
+ * that the library actually produces keys/signatures of these lengths,
+ * guarding against any future library drift.
  */
 /** ML-DSA-87 public-key length, in bytes (FIPS 204 / core: 2592). */
 declare const ML_DSA_87_PUBLIC_KEY_LENGTH = 2592;
@@ -1479,8 +1492,17 @@ interface PqcKeypair {
  *   Must be exactly {@link ML_DSA_87_SEED_LENGTH} bytes if provided.
  */
 declare function generatePqcKeypair(seed?: Uint8Array): PqcKeypair;
-/** Sign a message with an ML-DSA-87 (Dilithium-5) secret key. */
-declare function pqcSign(secretKey: Uint8Array, message: Uint8Array): Uint8Array;
+/**
+ * Sign a message with an ML-DSA-87 (Dilithium-5) secret key.
+ *
+ * DETERMINISTIC (FIPS-204 §3.4, rnd = 32 zero bytes) by default — the same
+ * `(secretKey, message)` always yields the same signature. The chain's PQC
+ * verifier accepts ONLY deterministic signatures, so do not pass
+ * `{ hedged: true }` for anything that goes on-chain.
+ */
+declare function pqcSign(secretKey: Uint8Array, message: Uint8Array, opts?: {
+    hedged?: boolean;
+}): Uint8Array;
 /** Verify an ML-DSA-87 (Dilithium-5) signature over a message. */
 declare function pqcVerify(publicKey: Uint8Array, message: Uint8Array, signature: Uint8Array): boolean;
 /**
@@ -7851,6 +7873,363 @@ interface CreateRollupClientOptions {
  */
 declare function createRollupClient(tx: TxClient, opts?: CreateRollupClientOptions): RollupClient;
 
+/**
+ * High-level Cross-VM client — unified calls across QoreChain's three VMs.
+ *
+ * QoreChain runs EVM, SVM, and CosmWasm side by side and lets a single native
+ * account invoke a contract on any of them through the `x/crossvm` module's
+ * {@link MsgCrossVMCall}. This helper wraps that message — and the cross-VM query
+ * client — so an app developer never hand-builds a `{ typeUrl, value }`, encodes a
+ * payload by hand, or remembers a service/method name.
+ *
+ * The headline capability is {@link CrossVMClient.callAtomic}: pack several
+ * `MsgCrossVMCall` messages into ONE transaction body so they execute atomically
+ * under a single signature — e.g. an EVM call, an SVM call, and a CosmWasm call
+ * that all land together or not at all.
+ *
+ * Per-VM payload encoding (pick exactly one shape per call):
+ *  - `{ payload }` — raw bytes / hex, passed through unchanged.
+ *  - `{ evm: { abi, functionName, args } }` — ABI-encoded with viem's
+ *    `encodeFunctionData` (selector + args). Requires the optional `viem` peer.
+ *  - `{ cosmwasm: object }` — `JSON.stringify` then UTF-8 bytes (the CosmWasm
+ *    execute-msg convention).
+ *  - `{ svm: { data } }` — raw bytes / hex (already an SVM instruction blob).
+ *
+ * Construct one with {@link createCrossVMClient}, passing a connected
+ * {@link TxClient} (for writes) and, optionally, a {@link CrossVmQueryClient}
+ * and/or a {@link QorClient} for the reads.
+ */
+
+/** The three execution environments a cross-VM call can target. */
+type VMType = "evm" | "cosmwasm" | "svm";
+/** The set of supported VM type strings. */
+declare const VM_TYPES: readonly ["evm", "cosmwasm", "svm"];
+/** A hex string (`0x`-prefixed) as accepted for raw payloads. */
+type Hex = `0x${string}`;
+/** Raw, pre-encoded payload — passed through to the chain unchanged. */
+interface RawPayload {
+    /** The opaque payload bytes (raw `Uint8Array` or `0x`-hex). */
+    payload: Uint8Array | Hex;
+}
+/** EVM payload built by ABI-encoding a function call with viem. */
+interface EvmPayload {
+    evm: {
+        /** The contract ABI (viem `Abi`-compatible array). */
+        abi: readonly unknown[];
+        /** The function to call. */
+        functionName: string;
+        /** The call arguments. */
+        args?: readonly unknown[];
+    };
+}
+/** CosmWasm payload: a JSON execute-message object (stringified to UTF-8). */
+interface CosmWasmPayload {
+    /** The CosmWasm execute message (e.g. `{ transfer: { ... } }`). */
+    cosmwasm: object;
+}
+/** SVM payload: a pre-built instruction blob (raw bytes / hex). */
+interface SvmPayload {
+    svm: {
+        /** The SVM instruction data (raw `Uint8Array` or `0x`-hex). */
+        data: Uint8Array | Hex;
+    };
+}
+/** Exactly one of the supported payload shapes. */
+type PayloadInput = RawPayload | EvmPayload | CosmWasmPayload | SvmPayload;
+/** Shared write-path options forwarded to {@link TxClient.signAndBroadcast}. */
+interface CrossVMWriteOptions {
+    /** Fee: an explicit `StdFee` or `"auto"` (simulate + price). Default `"auto"`. */
+    fee?: FeeInput$1;
+    /** Optional memo string. */
+    memo?: string;
+    /** Auto-fee tuning (gas multiplier / gas price) when `fee` is `"auto"`. */
+    autoFee?: AutoFeeOptions;
+}
+/** Common cross-VM call fields (without the payload or write options). */
+interface CrossVMCallBase {
+    /** The VM the call originates from. Defaults to `"evm"`. */
+    sourceVm?: VMType;
+    /** The VM the call targets. */
+    targetVm: VMType;
+    /** The target contract address/identifier on `targetVm`. */
+    targetContract: string;
+    /** Optional funds (coins) to forward with the call. */
+    funds?: Coin$1[];
+}
+/** Options for a single cross-VM call (base + payload). */
+type CrossVMCallOptions = CrossVMCallBase & PayloadInput;
+/** Options for {@link CrossVMClient.call} (adds write-path options). */
+type CallOptions = CrossVMCallOptions & CrossVMWriteOptions;
+/** Result of a single {@link CrossVMClient.call}. */
+interface CrossVMCallResult {
+    /** The cross-VM message id assigned by the chain (parsed from tx events). */
+    messageId: string;
+    /** The raw broadcast result. */
+    result: BroadcastResult;
+}
+/** Result of an atomic {@link CrossVMClient.callAtomic} batch. */
+interface CrossVMAtomicResult {
+    /** The cross-VM message ids assigned by the chain (best-effort, from events). */
+    messageIds: string[];
+    /** The raw broadcast result for the single packing transaction. */
+    result: BroadcastResult;
+}
+/**
+ * Ergonomic client for the `x/crossvm` module.
+ *
+ * Writes build + sign + broadcast a {@link MsgCrossVMCall}; {@link callAtomic}
+ * packs several into one body. {@link buildCall} is the offline build-only path.
+ * Reads return the typed query response (or the `qor_` JSON-RPC fallback).
+ */
+interface CrossVMClient {
+    /** Build, sign, and broadcast a single cross-VM call. */
+    call(opts: CallOptions): Promise<CrossVMCallResult>;
+    /** Build a single `MsgCrossVMCall` without broadcasting. */
+    buildCall(opts: CrossVMCallOptions): EncodeObject;
+    /**
+     * Pack multiple cross-VM calls into ONE transaction body so they execute
+     * atomically under a single signature (the triple-VM headline).
+     */
+    callAtomic(calls: CrossVMCallOptions[], opts?: CrossVMWriteOptions): Promise<CrossVMAtomicResult>;
+    /**
+     * Read a cross-VM message by id. Uses the typed query client when provided,
+     * otherwise falls back to the `qor_getCrossVMMessage` JSON-RPC method.
+     */
+    getMessage(id: string): Promise<QueryMessageResponse | Record<string, unknown>>;
+}
+/** Options for {@link createCrossVMClient}. */
+interface CreateCrossVMClientOptions {
+    /**
+     * Typed query client for {@link CrossVMClient.getMessage} (preferred). Obtain
+     * it via {@link connectQueryClients} / {@link createQueryClients}.
+     */
+    query?: CrossVmQueryClient;
+    /**
+     * `qor_` JSON-RPC client used as the {@link CrossVMClient.getMessage} fallback
+     * (via `qor_getCrossVMMessage`) when no typed query client is supplied.
+     */
+    qor?: QorClient;
+}
+/**
+ * Create a {@link CrossVMClient} bound to a connected {@link TxClient}.
+ *
+ * The `TxClient`'s sender address is used as the message `sender`, so the caller
+ * never repeats their address. `sourceVm` defaults to `"evm"`.
+ *
+ * @param tx - A connected signing client (from `client.connectTx(signer)`).
+ * @param opts - Optional typed query client and/or `qor_` client for reads.
+ */
+declare function createCrossVMClient(tx: TxClient, opts?: CreateCrossVMClientOptions): CrossVMClient;
+
+/**
+ * High-level quantum-safe developer-experience helpers.
+ *
+ * QoreChain treats post-quantum cryptography (PQC) as a first-class signature
+ * scheme: an account registers an ML-DSA-87 (Dilithium-5) key on-chain
+ * (`MsgRegisterPQCKeyV2`), after which its transactions can carry a hybrid
+ * (classical secp256k1 + ML-DSA-87) signature that the ante handler verifies in
+ * full. The low-level primitives already exist — {@link generatePqcKeypair},
+ * {@link buildHybridTx}, {@link signAndBroadcastHybrid}, the
+ * `msg.pqc.registerPqcKey` composer, and the `qor_getPQCKeyStatus` read. This
+ * module wraps them into a tiny, idempotent surface so a dApp becomes
+ * **quantum-safe by default**: one call to be PQC-protected.
+ *
+ * The headline calls:
+ *  - {@link isPqcRegistered} / {@link getPqcStatus} — read whether an address has
+ *    a registered PQC key (via `qor_getPQCKeyStatus`).
+ *  - {@link ensurePqcRegistered} — register the signer's Dilithium key if (and
+ *    only if) it is not already registered. Idempotent: safe to call on every
+ *    app start.
+ *  - {@link migrateToHybrid} — ensure registration, then hand back a hybrid send
+ *    path wired to {@link buildHybridTx} / {@link signAndBroadcastHybrid}.
+ *  - {@link migratePqcKey} — rotate an account's PQC key (`MsgMigratePQCKey`).
+ *
+ * Reads accept either a {@link QorClient} or anything exposing a `qor`
+ * sub-client (e.g. the composed `QoreChainClient` from `createClient`). Writes
+ * take a connected {@link TxClient}.
+ *
+ * Precompile alternative: the same status is readable on the EVM side via the
+ * `pqcKeyStatus(address) returns (bool registered, uint8 algorithmId, bytes
+ * pubkey)` precompile at `0x0000000000000000000000000000000000000A02` (exposed
+ * as `pqcKeyStatus` in `@qorechain/evm`). The helpers below prefer the
+ * `qor_getPQCKeyStatus` JSON-RPC method, which needs no viem peer; the
+ * precompile is the documented alternative for callers already on the EVM side.
+ */
+
+/** EVM precompile address for the `pqcKeyStatus` read (documented alternative). */
+declare const PQC_KEY_STATUS_PRECOMPILE_ADDRESS = "0x0000000000000000000000000000000000000A02";
+/**
+ * A source for PQC status reads: either a {@link QorClient} directly, or any
+ * object exposing one as `.qor` (e.g. the composed `QoreChainClient`).
+ */
+type PqcStatusSource = QorClient | {
+    qor: QorClient;
+};
+/** Normalized PQC registration status for an address. */
+interface PqcStatus {
+    /** Whether the address has a registered PQC key. */
+    registered: boolean;
+    /** The registered algorithm id, when known (Dilithium-5 = {@link AlgorithmDilithium5}). */
+    algorithmId?: number;
+    /** The registered PQC public key, when the chain returns it (hex or bytes). */
+    pubkey?: string | Uint8Array;
+}
+/**
+ * Read the PQC registration status of an address via `qor_getPQCKeyStatus`.
+ *
+ * The chain returns a rich JSON object; this helper normalizes the common
+ * fields (`registered`, `algorithmId`/`algorithm_id`, `pubkey`/`public_key`)
+ * into a {@link PqcStatus}. Unknown shapes degrade to `{ registered: false }`.
+ *
+ * Alternative: on the EVM side, call the `pqcKeyStatus(address)` precompile at
+ * {@link PQC_KEY_STATUS_PRECOMPILE_ADDRESS} (via `@qorechain/evm`).
+ */
+declare function getPqcStatus(source: PqcStatusSource, address: string): Promise<PqcStatus>;
+/**
+ * Whether `address` has a registered PQC key.
+ *
+ * Thin boolean wrapper over {@link getPqcStatus} using `qor_getPQCKeyStatus`
+ * (preferred). The EVM `pqcKeyStatus` precompile is the documented alternative.
+ */
+declare function isPqcRegistered(source: PqcStatusSource, address: string): Promise<boolean>;
+/** Options for {@link ensurePqcRegistered}. */
+interface EnsurePqcRegisteredOptions {
+    /**
+     * The signer's ML-DSA-87 (Dilithium-5) keypair. Its `publicKey` is registered
+     * on-chain as the account's Dilithium key.
+     */
+    pqcKeypair: PqcKeypair;
+    /**
+     * The account's classical ECDSA (secp256k1) public key, registered alongside
+     * the Dilithium key. When omitted, an empty key is sent — the chain binds the
+     * registration to the transaction signer, so this is optional for accounts
+     * whose classical key is already known on-chain.
+     */
+    ecdsaPubkey?: Uint8Array;
+    /** Key-type tag forwarded to `MsgRegisterPQCKeyV2` (default `"hybrid"`). */
+    keyType?: string;
+    /** Fee: explicit `StdFee` or `"auto"` (simulate + price). Default `"auto"`. */
+    fee?: FeeInput$1;
+    /** Optional memo string. */
+    memo?: string;
+    /** Auto-fee tuning when `fee` is `"auto"`. */
+    autoFee?: AutoFeeOptions;
+    /**
+     * A pre-read status to avoid a redundant `qor_getPQCKeyStatus` round-trip. When
+     * provided and `registered`, the registration is skipped.
+     */
+    status?: PqcStatus;
+    /**
+     * A status source for the pre-flight registration check. When omitted, the
+     * registration message is broadcast unconditionally (relying on the chain's
+     * own idempotency) — pass `{ qor }` to make the helper truly idempotent.
+     */
+    statusSource?: PqcStatusSource;
+}
+/** Result of {@link ensurePqcRegistered}. */
+interface EnsurePqcRegisteredResult {
+    /** `true` when the key was already registered (no transaction was sent). */
+    alreadyRegistered: boolean;
+    /** The registration transaction hash, when a registration was broadcast. */
+    txHash?: string;
+    /** The raw broadcast result, when a registration was broadcast. */
+    result?: BroadcastResult;
+}
+/**
+ * Build the `MsgRegisterPQCKeyV2` for a signer without broadcasting.
+ *
+ * Useful for packing registration into a larger transaction body, or for the
+ * offline build path. Uses `/qorechain.pqc.v1.MsgRegisterPQCKeyV2` — the
+ * chain's current (classical-exempt bootstrap) registration path — with an
+ * explicit `algorithmId` (ML-DSA-87 / Dilithium-5).
+ */
+declare function buildRegisterPqcKeyMsg(sender: string, opts: Pick<EnsurePqcRegisteredOptions, "pqcKeypair" | "ecdsaPubkey" | "keyType">): EncodeObject;
+/**
+ * Register the signer's PQC key if it is not already registered — idempotent.
+ *
+ * If a {@link EnsurePqcRegisteredOptions.statusSource} (or pre-read `status`) is
+ * supplied and the key is already registered, this returns
+ * `{ alreadyRegistered: true }` WITHOUT broadcasting. Otherwise it builds and
+ * broadcasts `MsgRegisterPQCKeyV2` with the signer's Dilithium public key (from
+ * `pqcKeypair`) plus the supplied ECDSA public key.
+ *
+ * This is the single call that makes a dApp quantum-safe: run it once at startup
+ * (or before the first hybrid tx) and the account is PQC-protected thereafter.
+ *
+ * @param tx - A connected signing client (the sender address is its identity).
+ * @param opts - The signer's PQC keypair, optional ECDSA pubkey, and write opts.
+ */
+declare function ensurePqcRegistered(tx: TxClient, opts: EnsurePqcRegisteredOptions): Promise<EnsurePqcRegisteredResult>;
+/** Options for {@link migratePqcKey} (PQC key rotation). */
+interface MigratePqcKeyOptions {
+    /** The current (old) PQC public key being rotated out. */
+    oldPublicKey: Uint8Array;
+    /** The new PQC public key to register. */
+    newPublicKey: Uint8Array;
+    /** The new key's algorithm id (default {@link AlgorithmDilithium5}). */
+    newAlgorithmId?: number;
+    /** Signature by the OLD key proving ownership of the rotation request. */
+    oldSignature: Uint8Array;
+    /** Signature by the NEW key proving ownership of the new key. */
+    newSignature: Uint8Array;
+    /** Fee: explicit `StdFee` or `"auto"`. Default `"auto"`. */
+    fee?: FeeInput$1;
+    /** Optional memo string. */
+    memo?: string;
+    /** Auto-fee tuning when `fee` is `"auto"`. */
+    autoFee?: AutoFeeOptions;
+}
+/**
+ * Rotate an account's PQC key via `MsgMigratePQCKey`.
+ *
+ * The chain proves ownership of BOTH the old and new keys (the caller supplies
+ * `oldSignature` / `newSignature` per the chain's migration contract), so key
+ * rotation never strands an account. Use this when upgrading algorithms or
+ * rolling a compromised key.
+ */
+declare function migratePqcKey(tx: TxClient, opts: MigratePqcKeyOptions): Promise<BroadcastResult>;
+/** Options for {@link migrateToHybrid}. */
+interface MigrateToHybridOptions extends EnsurePqcRegisteredOptions {
+    /**
+     * A status source used both for the registration pre-flight and (when omitted
+     * elsewhere) the idempotency check. Forwarded to {@link ensurePqcRegistered}.
+     */
+    statusSource?: PqcStatusSource;
+}
+/**
+ * A hybrid send path returned by {@link migrateToHybrid}: the PQC key is
+ * guaranteed registered, and these methods build / broadcast hybrid (classical +
+ * ML-DSA-87) transactions via {@link buildHybridTx} / {@link signAndBroadcastHybrid}.
+ *
+ * The `pqcKeypair` is bound, so callers pass everything else hybrid signing
+ * needs (registry, classical signer, chainId, account number, sequence, ...).
+ */
+interface HybridSendPath {
+    /** Whether the PQC key was already registered before this call. */
+    alreadyRegistered: boolean;
+    /** The registration tx hash, when a registration was broadcast. */
+    registrationTxHash?: string;
+    /** The bound ML-DSA-87 keypair used for the hybrid half. */
+    pqcKeypair: PqcKeypair;
+    /** Build a fully signed hybrid tx (PQC keypair pre-bound). */
+    buildHybridTx(opts: Omit<BuildHybridTxOptions, "pqcKeypair">): Promise<BuiltHybridTx>;
+    /** Build, sign, and broadcast a hybrid tx (PQC keypair pre-bound). */
+    signAndBroadcastHybrid(opts: Omit<SignAndBroadcastHybridOptions, "pqcKeypair">): Promise<BroadcastResult>;
+}
+/**
+ * Make an account quantum-safe and hand back a hybrid send path.
+ *
+ * Ensures the signer's PQC key is registered (idempotent — see
+ * {@link ensurePqcRegistered}), then returns a {@link HybridSendPath} with the
+ * keypair pre-bound to the existing {@link buildHybridTx} /
+ * {@link signAndBroadcastHybrid} builders. After this call, the dApp's
+ * transactions can carry a verified hybrid signature.
+ *
+ * @param tx - A connected signing client (used for the registration tx).
+ * @param opts - The PQC keypair and registration/idempotency options.
+ */
+declare function migrateToHybrid(tx: TxClient, opts: MigrateToHybridOptions): Promise<HybridSendPath>;
+
 /**
  * `@qorechain/sdk` public API.
  *
@@ -7860,6 +8239,6 @@ declare function createRollupClient(tx: TxClient, opts?: CreateRollupClientOptio
  * callers who want to compose them directly. Internal helpers are not exported.
  */
 /** SDK version. */
-declare const VERSION = "0.3.0";
+declare const VERSION = "0.5.0";
 
-export { type Account, AlgorithmDilithium5, type AlgorithmID, AlgorithmMLKEM1024, AlgorithmUnspecified, type AllBalancesResponse, type AnchorStateOptions, type AttachHybridOptions, type AutoFeeOptions, type BalanceResponse, type BankSendOptions, type Bech32Config, type Bech32Prefixes, type BridgeQueryClient, type BroadcastMode, type BroadcastResult, type BuildHybridTxOptions, type BuiltHybridTx, type ChallengeBatchOptions, type ClientFees, type CoinInfo, type ConnectTxOptions, type ContractMsg, type CosmWasmReadClient, type CosmWasmSigningClient, type CosmosWalletConnection, type CosmosWalletName, type CreateClientOptions, type CreateMultilayerClientOptions, type CreateRollupClientOptions, type CreateRollupOptions, type CrossVmMessage, type CrossVmMessageResponse, type CrossVmParamsResponse, type CrossVmQueryClient, DEFAULT_GAS_MULTIPLIER, DEFAULT_GAS_PRICE, type DecodedTxError, type DenomOptions, type DerivationOptions, type Ed25519Account, type EstimateFeeOptions, type EventFilters, type EventStream, type ExecuteWithdrawalOptions, type ExplorerConfig, type FaucetConfig, type FeeInput, type FeeUrgency, type FetchLike, GasPrice, type GetBlockResponse, type GetCosmosWalletOptions, type GetJsonOptions, type GetTxFn, type GetTxResponse, HYBRID_SIG_TYPE_URL, type Handler, type HashInput, type HttpOptions, type HybridBroadcaster, type HybridPlacement, HybridSigner, type IncludedTx, type InjectedCosmosWallet, type InstantiateOpts, JsonRpcClient, type JsonRpcClientOptions, JsonRpcError, type JsonRpcErrorObject, type JsonRpcResponse, type KeplrChainInfo, type KeplrCurrency, type KeplrFeeCurrency, type KeyType, type LightNodeQueryClient, ML_DSA_87_PUBLIC_KEY_LENGTH, ML_DSA_87_SECRET_KEY_LENGTH, ML_DSA_87_SEED_LENGTH, ML_DSA_87_SIGNATURE_LENGTH, MSG_SEND_TYPE_URL, type MultilayerClient, type MultilayerQueryClient, type MultilayerWriteOptions, NETWORKS, type NetworkConfig, type NetworkEndpoints, type NetworkName, type NewBlockEventLike, type PQCHybridSignature, type PageResponse, type PaginatedOptions, type Pagination, type PendingCrossVmMessagesResponse, type PqcKeypair, type PqcQueryClient, type PqcSignaturePart, PqcSigner, type QcaQueryClient, QorClient, type QoreChainClient, type QoreChainQueryClients, QoreHttpError, QoreTxError, type QueryValue, type RdkQueryClient, type RegisterPaychainOptions, type RegisterSidechainOptions, type ReputationQueryClient, type RequestFaucetOptions, type ResolveChallengeOptions, RestClient, type RestClientOptions, type RetryOptions, type RlConsensusQueryClient, type RollupClient, type RollupLifecycleOptions, type RollupWriteOptions, type RouteTransactionOptions, STATIC_FALLBACK, type SearchTxsOptions, type SearchTxsResponse, type Secp256k1Account, type SignAndBroadcastHybridOptions, type SignAndBroadcastOptions, type SignOutput, type SignatureMode, type Signer, type SigningClientLike, type SimulateOptions, type SubmitBatchOptions, type SubscriptionClient, type SvmQueryClient, type SyncBroadcaster, TxClient, type TxClientOptions, type TxConnectOptions, type TxErrorInput, type TxEventLike, type FeeInput$1 as TxFeeInput, type TxOrderBy, type TxQueryFilters, type TxResultLike, type Unsubscribe, VERSION, type WaitForTxOptions, abstractaccount, algorithmName, amm, attachHybridExtension, authz, bank, bech32ToHex, bridge, broadcastAndWait, buildAminoTypes, buildEventsQuery, buildHybridSignatureExtension, buildHybridTx, buildTxQuery, buildUrl, bytesToBech32, calculateFee, clearAdmin, connectCosmWasmSigner, connectQueryClients, createClient, createCosmWasmClient, createMultilayerClient, createQueryClients, createRollupClient, createSubscriptionClient, crossvm, decodeTxError, deriveEvmAccount, deriveNativeAccount, deriveSvmAccount, directSignerFromPrivateKey, distribution, encodeHybridExtension, estimateFee, evmToQor, execute, explorerAddressUrl, explorerBlockUrl, explorerTxUrl, feegrant, formatUnits, fromBase, generateMnemonic, generatePqcKeypair, getBlock, getCodeDetails, getCodes, getContractInfo, getContracts, getCosmosWallet, getCrossVmMessage, getCrossVmParams, getJson, getLatestBlock, getNetwork, getPendingCrossVmMessages, getTx, gov, hexToBech32, ibc, instantiate, instantiate2, isChecksumAddress, isSignatureAlgorithm, isTxFailure, isValidBech32, isValidEvmAddress, isValidSvmAddress, joinUrl, keccak256, keccak256Hex, license, lightnode, listNetworks, migrate, msg, multilayer, parseUnits, postJsonRpc, pqc as pqcMsg, pqcSign, pqcVerify, qorToEvm, qorechainRegistry, qorechainRegistryTypes, index as qorechainTypes, queryContractSmart, rdk, requestFaucet, ripemd160, ripemd160Hex, rlconsensus, searchTxs, sha256, sha256Hex, signAndBroadcastHybrid, staking, subscribeNewBlocks, subscribeTx, suggestChainInfo, svm, toBase, toChecksumAddress, toHex, txErrorFrom, updateAdmin, uploadCode, validateMnemonic, waitForTx, withRetry };
+export { type Account, AlgorithmDilithium5, type AlgorithmID, AlgorithmMLKEM1024, AlgorithmUnspecified, type AllBalancesResponse, type AnchorStateOptions, type AttachHybridOptions, type AutoFeeOptions, type BalanceResponse, type BankSendOptions, type Bech32Config, type Bech32Prefixes, type BridgeQueryClient, type BroadcastMode, type BroadcastResult, type BuildHybridTxOptions, type BuiltHybridTx, type CallOptions, type ChallengeBatchOptions, type ClientFees, type CoinInfo, type ConnectTxOptions, type ContractMsg, type CosmWasmPayload, type CosmWasmReadClient, type CosmWasmSigningClient, type CosmosWalletConnection, type CosmosWalletName, type CreateClientOptions, type CreateCrossVMClientOptions, type CreateMultilayerClientOptions, type CreateRollupClientOptions, type CreateRollupOptions, type CrossVMAtomicResult, type CrossVMCallBase, type CrossVMCallOptions, type CrossVMCallResult, type CrossVMClient, type CrossVMWriteOptions, type CrossVmMessage, type CrossVmMessageResponse, type CrossVmParamsResponse, type CrossVmQueryClient, DEFAULT_GAS_MULTIPLIER, DEFAULT_GAS_PRICE, type DecodedTxError, type DenomOptions, type DerivationOptions, type Ed25519Account, type EnsurePqcRegisteredOptions, type EnsurePqcRegisteredResult, type EstimateFeeOptions, type EventFilters, type EventStream, type EvmPayload, type ExecuteWithdrawalOptions, type ExplorerConfig, type FaucetConfig, type FeeInput, type FeeUrgency, type FetchLike, GasPrice, type GetBlockResponse, type GetCosmosWalletOptions, type GetJsonOptions, type GetTxFn, type GetTxResponse, HYBRID_SIG_TYPE_URL, type Handler, type HashInput, type HttpOptions, type HybridBroadcaster, type HybridPlacement, type HybridSendPath, HybridSigner, type IncludedTx, type InjectedCosmosWallet, type InstantiateOpts, JsonRpcClient, type JsonRpcClientOptions, JsonRpcError, type JsonRpcErrorObject, type JsonRpcResponse, type KeplrChainInfo, type KeplrCurrency, type KeplrFeeCurrency, type KeyType, type LightNodeQueryClient, ML_DSA_87_PUBLIC_KEY_LENGTH, ML_DSA_87_SECRET_KEY_LENGTH, ML_DSA_87_SEED_LENGTH, ML_DSA_87_SIGNATURE_LENGTH, MSG_SEND_TYPE_URL, type MigratePqcKeyOptions, type MigrateToHybridOptions, type MultilayerClient, type MultilayerQueryClient, type MultilayerWriteOptions, NETWORKS, type NetworkConfig, type NetworkEndpoints, type NetworkName, type NewBlockEventLike, type PQCHybridSignature, PQC_KEY_STATUS_PRECOMPILE_ADDRESS, type PageResponse, type PaginatedOptions, type Pagination, type PayloadInput, type PendingCrossVmMessagesResponse, type PqcKeypair, type PqcQueryClient, type PqcSignaturePart, PqcSigner, type PqcStatus, type PqcStatusSource, type QcaQueryClient, QorClient, type QoreChainClient, type QoreChainQueryClients, QoreHttpError, QoreTxError, type QueryValue, type RawPayload, type RdkQueryClient, type RegisterPaychainOptions, type RegisterSidechainOptions, type ReputationQueryClient, type RequestFaucetOptions, type ResolveChallengeOptions, RestClient, type RestClientOptions, type RetryOptions, type RlConsensusQueryClient, type RollupClient, type RollupLifecycleOptions, type RollupWriteOptions, type RouteTransactionOptions, STATIC_FALLBACK, type SearchTxsOptions, type SearchTxsResponse, type Secp256k1Account, type SignAndBroadcastHybridOptions, type SignAndBroadcastOptions, type SignOutput, type SignatureMode, type Signer, type SigningClientLike, type SimulateOptions, type SubmitBatchOptions, type SubscriptionClient, type SvmPayload, type SvmQueryClient, type SyncBroadcaster, TxClient, type TxClientOptions, type TxConnectOptions, type TxErrorInput, type TxEventLike, type FeeInput$1 as TxFeeInput, type TxOrderBy, type TxQueryFilters, type TxResultLike, type Unsubscribe, VERSION, type VMType, VM_TYPES, type WaitForTxOptions, abstractaccount, algorithmName, amm, attachHybridExtension, authz, bank, bech32ToHex, bridge, broadcastAndWait, buildAminoTypes, buildEventsQuery, buildHybridSignatureExtension, buildHybridTx, buildRegisterPqcKeyMsg, buildTxQuery, buildUrl, bytesToBech32, calculateFee, clearAdmin, connectCosmWasmSigner, connectQueryClients, createClient, createCosmWasmClient, createCrossVMClient, createMultilayerClient, createQueryClients, createRollupClient, createSubscriptionClient, crossvm, decodeTxError, deriveEvmAccount, deriveNativeAccount, deriveSvmAccount, directSignerFromPrivateKey, distribution, encodeHybridExtension, ensurePqcRegistered, estimateFee, evmToQor, execute, explorerAddressUrl, explorerBlockUrl, explorerTxUrl, feegrant, formatUnits, fromBase, generateMnemonic, generatePqcKeypair, getBlock, getCodeDetails, getCodes, getContractInfo, getContracts, getCosmosWallet, getCrossVmMessage, getCrossVmParams, getJson, getLatestBlock, getNetwork, getPendingCrossVmMessages, getPqcStatus, getTx, gov, hexToBech32, ibc, instantiate, instantiate2, isChecksumAddress, isPqcRegistered, isSignatureAlgorithm, isTxFailure, isValidBech32, isValidEvmAddress, isValidSvmAddress, joinUrl, keccak256, keccak256Hex, license, lightnode, listNetworks, migrate, migratePqcKey, migrateToHybrid, msg, multilayer, parseUnits, postJsonRpc, pqc as pqcMsg, pqcSign, pqcVerify, qorToEvm, qorechainRegistry, qorechainRegistryTypes, index as qorechainTypes, queryContractSmart, rdk, requestFaucet, ripemd160, ripemd160Hex, rlconsensus, searchTxs, sha256, sha256Hex, signAndBroadcastHybrid, staking, subscribeNewBlocks, subscribeTx, suggestChainInfo, svm, toBase, toChecksumAddress, toHex, txErrorFrom, updateAdmin, uploadCode, validateMnemonic, waitForTx, withRetry };