@qorechain/sdk 0.4.0 → 0.5.0

package/dist/index.d.ts

@@ -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';
@@ -7851,6 +7853,361 @@ 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
+ * (`MsgRegisterPQCKey`), 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 `MsgRegisterPQCKey` (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 `MsgRegisterPQCKey` for a signer without broadcasting.
+ *
+ * Useful for packing registration into a larger transaction body, or for the
+ * offline build path.
+ */
+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 `MsgRegisterPQCKey` 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 +8217,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 };

package/dist/index.js

@@ -16,6 +16,7 @@ import { HDKey } from 'micro-key-producer/slip10.js';
 import { secp256k1 } from '@noble/curves/secp256k1';
 import { ml_dsa87 } from '@noble/post-quantum/ml-dsa.js';
 import { randomBytes } from '@noble/hashes/utils';
+export { AI_ANOMALY_CHECK_ADDRESS, AI_RISK_SCORE_ADDRESS, RISK_LEVEL_UNSAFE_THRESHOLD, ai, aiAnomalyCheck, aiRiskScore, simulateWithRiskScore } from '@qorechain/evm';
 import { connectComet } from '@cosmjs/tendermint-rpc';
 import { Any } from 'cosmjs-types/google/protobuf/any';
 import { TxBody, SignDoc, TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
@@ -19597,9 +19598,224 @@ function createRollupClient(tx, opts = {}) {
   };
 }
 
+// src/helpers/crossvm.ts
+var VM_TYPES = ["evm", "cosmwasm", "svm"];
+var HEX_RE = /^0x[0-9a-fA-F]*$/;
+function rawToBytes(data) {
+  if (typeof data !== "string") return data;
+  if (!HEX_RE.test(data)) {
+    throw new Error(
+      `crossvm: invalid hex payload (expected 0x-prefixed hex, got "${data.slice(0, 12)}...")`
+    );
+  }
+  const hex = data.slice(2);
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function cosmwasmToBytes(msg2) {
+  return new TextEncoder().encode(JSON.stringify(msg2));
+}
+async function encodePayload(input) {
+  if ("payload" in input) {
+    return rawToBytes(input.payload);
+  }
+  if ("cosmwasm" in input) {
+    return cosmwasmToBytes(input.cosmwasm);
+  }
+  if ("svm" in input) {
+    return rawToBytes(input.svm.data);
+  }
+  const { encodeFunctionData } = await import('viem');
+  const data = encodeFunctionData({
+    // viem's Abi typing is structurally compatible; cast at the boundary.
+    abi: input.evm.abi,
+    functionName: input.evm.functionName,
+    args: input.evm.args ?? []
+  });
+  return rawToBytes(data);
+}
+function requireGetMessageSource(query, qor) {
+  if (!query && !qor) {
+    throw new Error(
+      "crossvm getMessage requires a query client or a qor client \u2014 pass { query } or { qor } to createCrossVMClient"
+    );
+  }
+}
+function extractMessageIds(result) {
+  const events = result.events;
+  const ids = [];
+  if (Array.isArray(events)) {
+    for (const ev of events) {
+      const attrs = ev.attributes;
+      if (!Array.isArray(attrs)) continue;
+      for (const a of attrs) {
+        const key = String(a.key ?? "");
+        if (key === "message_id" || key === "messageId") {
+          ids.push(String(a.value ?? ""));
+        }
+      }
+    }
+  }
+  return ids;
+}
+function createCrossVMClient(tx, opts = {}) {
+  const sender = tx.senderAddress;
+  const query = opts.query;
+  const qor = opts.qor;
+  const buildFrom = (o, payload) => crossvm.crossVmCall({
+    sender,
+    sourceVm: o.sourceVm ?? "evm",
+    targetVm: o.targetVm,
+    targetContract: o.targetContract,
+    payload,
+    funds: o.funds ?? []
+  });
+  const buildCallSync = (o, payload) => buildFrom(o, payload);
+  const buildCall = (o) => {
+    if ("evm" in o) {
+      throw new Error(
+        "crossvm buildCall: EVM payloads are ABI-encoded asynchronously (viem). Use `call`/`callAtomic`, or pre-encode and pass `{ payload }`."
+      );
+    }
+    let payload;
+    if ("payload" in o) payload = rawToBytes(o.payload);
+    else if ("cosmwasm" in o) payload = cosmwasmToBytes(o.cosmwasm);
+    else payload = rawToBytes(o.svm.data);
+    return buildCallSync(o, payload);
+  };
+  const call = async (o) => {
+    const payload = await encodePayload(o);
+    const message = buildFrom(o, payload);
+    const result = await tx.signAndBroadcast(
+      [message],
+      o.fee ?? "auto",
+      o.memo ?? "",
+      { autoFee: o.autoFee }
+    );
+    const [messageId = ""] = extractMessageIds(result);
+    return { messageId, result };
+  };
+  const callAtomic = async (calls, w = {}) => {
+    if (calls.length === 0) {
+      throw new Error("crossvm callAtomic: provide at least one call");
+    }
+    const messages = await Promise.all(
+      calls.map(async (o) => buildFrom(o, await encodePayload(o)))
+    );
+    const result = await tx.signAndBroadcast(
+      messages,
+      w.fee ?? "auto",
+      w.memo ?? "",
+      { autoFee: w.autoFee }
+    );
+    return { messageIds: extractMessageIds(result), result };
+  };
+  const getMessage = (id) => {
+    requireGetMessageSource(query, qor);
+    if (query) return query.message({ id });
+    return qor.getCrossVmMessage(id);
+  };
+  return { call, buildCall, callAtomic, getMessage };
+}
+
+// src/helpers/pqc.ts
+var PQC_KEY_STATUS_PRECOMPILE_ADDRESS = "0x0000000000000000000000000000000000000A02";
+function resolveQor(source) {
+  if ("qor" in source && source.qor) return source.qor;
+  return source;
+}
+function asBool(v) {
+  if (typeof v === "boolean") return v;
+  if (typeof v === "number") return v !== 0;
+  if (typeof v === "string") return v === "true" || v === "1";
+  return false;
+}
+function asNumber(v) {
+  if (typeof v === "number") return v;
+  if (typeof v === "string" && v.trim() !== "" && !Number.isNaN(Number(v))) {
+    return Number(v);
+  }
+  return void 0;
+}
+async function getPqcStatus(source, address) {
+  const qor = resolveQor(source);
+  const raw = await qor.getPqcKeyStatus(address);
+  if (raw == null || typeof raw !== "object") {
+    return { registered: false };
+  }
+  const registered = asBool(
+    raw.registered ?? raw.isRegistered ?? raw.is_registered
+  );
+  const algorithmId = asNumber(raw.algorithmId ?? raw.algorithm_id);
+  const pubkeyRaw = raw.pubkey ?? raw.publicKey ?? raw.public_key;
+  const pubkey = typeof pubkeyRaw === "string" || pubkeyRaw instanceof Uint8Array ? pubkeyRaw : void 0;
+  const status = { registered };
+  if (algorithmId !== void 0) status.algorithmId = algorithmId;
+  if (pubkey !== void 0) status.pubkey = pubkey;
+  return status;
+}
+async function isPqcRegistered(source, address) {
+  const status = await getPqcStatus(source, address);
+  return status.registered;
+}
+function buildRegisterPqcKeyMsg(sender, opts) {
+  return pqc.registerPqcKey({
+    sender,
+    dilithiumPubkey: opts.pqcKeypair.publicKey,
+    ecdsaPubkey: opts.ecdsaPubkey ?? new Uint8Array(0),
+    keyType: opts.keyType ?? "hybrid"
+  });
+}
+async function ensurePqcRegistered(tx, opts) {
+  const sender = tx.senderAddress;
+  const status = opts.status ?? (opts.statusSource ? await getPqcStatus(opts.statusSource, sender) : void 0);
+  if (status?.registered) {
+    return { alreadyRegistered: true };
+  }
+  const message = buildRegisterPqcKeyMsg(sender, opts);
+  const result = await tx.signAndBroadcast(
+    [message],
+    opts.fee ?? "auto",
+    opts.memo ?? "",
+    { autoFee: opts.autoFee }
+  );
+  return {
+    alreadyRegistered: false,
+    txHash: result.transactionHash,
+    result
+  };
+}
+async function migratePqcKey(tx, opts) {
+  const message = pqc.migratePqcKey({
+    sender: tx.senderAddress,
+    oldPublicKey: opts.oldPublicKey,
+    newPublicKey: opts.newPublicKey,
+    newAlgorithmId: opts.newAlgorithmId ?? AlgorithmDilithium5,
+    oldSignature: opts.oldSignature,
+    newSignature: opts.newSignature
+  });
+  return tx.signAndBroadcast([message], opts.fee ?? "auto", opts.memo ?? "", {
+    autoFee: opts.autoFee
+  });
+}
+async function migrateToHybrid(tx, opts) {
+  const ensured = await ensurePqcRegistered(tx, opts);
+  const pqcKeypair = opts.pqcKeypair;
+  return {
+    alreadyRegistered: ensured.alreadyRegistered,
+    registrationTxHash: ensured.txHash,
+    pqcKeypair,
+    buildHybridTx: (o) => buildHybridTx({ ...o, pqcKeypair }),
+    signAndBroadcastHybrid: (o) => signAndBroadcastHybrid({ ...o, pqcKeypair })
+  };
+}
+
 // src/index.ts
-var VERSION = "0.3.0";
+var VERSION = "0.5.0";
 
-export { AlgorithmDilithium5, AlgorithmMLKEM1024, AlgorithmUnspecified, DEFAULT_GAS_MULTIPLIER, DEFAULT_GAS_PRICE, GasPrice, HYBRID_SIG_TYPE_URL, HybridSigner, JsonRpcClient, JsonRpcError, 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, NETWORKS, PqcSigner, QorClient, QoreHttpError, QoreTxError, RestClient, STATIC_FALLBACK, TxClient, VERSION, 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, codegen_exports 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, withRetry2 as withRetry };
+export { AlgorithmDilithium5, AlgorithmMLKEM1024, AlgorithmUnspecified, DEFAULT_GAS_MULTIPLIER, DEFAULT_GAS_PRICE, GasPrice, HYBRID_SIG_TYPE_URL, HybridSigner, JsonRpcClient, JsonRpcError, 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, NETWORKS, PQC_KEY_STATUS_PRECOMPILE_ADDRESS, PqcSigner, QorClient, QoreHttpError, QoreTxError, RestClient, STATIC_FALLBACK, TxClient, VERSION, VM_TYPES, 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, codegen_exports 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, withRetry2 as withRetry };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map