@qorechain/sdk 0.7.0 → 0.8.0

package/dist/index.d.ts

@@ -549,6 +549,31 @@ interface BroadcastResult {
     gasWanted?: bigint;
     /** Raw ABCI log, when present. */
     rawLog?: string;
+    /**
+     * The ABCI events emitted by the tx (only for `commit`).
+     *
+     * Helpers that read typed attributes out of a delivery — e.g. the cross-VM
+     * client's message-id extraction — read them from here.
+     */
+    events?: ReadonlyArray<{
+        type: string;
+        attributes: ReadonlyArray<{
+            key: string;
+            value: string;
+        }>;
+    }>;
+    /**
+     * The protobuf-encoded `Msg*Response` for each message in the tx, in order
+     * (only for `commit`).
+     *
+     * Each entry is the response's `typeUrl` plus its encoded bytes, so a caller
+     * can decode the typed response — e.g. `MsgCrossVMCallResponse` to read a
+     * cross-VM callee's return value — without a second round-trip.
+     */
+    msgResponses?: ReadonlyArray<{
+        typeUrl: string;
+        value: Uint8Array;
+    }>;
 }
 
 /**
@@ -1555,11 +1580,29 @@ declare function generatePqcKeypair(seed?: Uint8Array): PqcKeypair;
  * `(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.
+ *
+ * The secret key length is checked explicitly before the library is called (see
+ * {@link pqcVerify} for why the bindings validate sizes themselves).
+ *
+ * @throws if `secretKey` is not exactly {@link ML_DSA_87_SECRET_KEY_LENGTH} bytes.
  */
 declare function pqcSign(secretKey: Uint8Array, message: Uint8Array, opts?: {
     hedged?: boolean;
 }): Uint8Array;
-/** Verify an ML-DSA-87 (Dilithium-5) signature over a message. */
+/**
+ * Verify an ML-DSA-87 (Dilithium-5) signature over a message.
+ *
+ * STRICT SIZES. The public key and signature must be EXACTLY
+ * {@link ML_DSA_87_PUBLIC_KEY_LENGTH} and {@link ML_DSA_87_SIGNATURE_LENGTH}
+ * bytes; anything else returns `false` without reaching the library. This is
+ * enforced here, not left to the underlying implementation, because ML-DSA
+ * libraries disagree about trailing garbage: some accept a signature with extra
+ * bytes appended as valid while others reject it. A signature that one official
+ * binding accepts and another rejects is a consensus hazard, so every QoreChain
+ * binding applies the same exact-length rule before verifying.
+ *
+ * @returns `false` for a malformed input, exactly as for a bad signature.
+ */
 declare function pqcVerify(publicKey: Uint8Array, message: Uint8Array, signature: Uint8Array): boolean;
 /**
  * The on-chain `PQCHybridSignature` TX extension, as a plain object whose keys
@@ -1751,49 +1794,52 @@ declare function deriveUnifiedAccount(mnemonic: string, index?: number): Promise
  * Same address derivation as {@link deriveUnifiedAccount}; the PQC key is derived
  * from `shake256("qorechain:pqc:v1|" + cosmos + "|seed:" + hex(seed32), 32)` (note
  * the literal `"seed:"` prefix, so a seed-derived PQC key never collides with a
- * mnemonic-derived one). Use this for accounts anchored to a signature or an
- * externally supplied secret (see the Phantom P1a helper).
- *
- * @param seed32 - Exactly 32 bytes, used directly as the secp256k1 private key.
+ * mnemonic-derived one).
+ *
+ * SAFETY: `seed32` becomes the account's spend key, so it MUST be real secret
+ * entropy — a CSPRNG seed (`crypto.getRandomValues`) or a key derived from a
+ * BIP-39 mnemonic. NEVER derive it from a wallet signature, or from any other
+ * value a third party can ask the wallet (or the user) to produce: such a value
+ * is a bearer secret, and whoever obtains it controls the account. To let an
+ * external wallet key act for an account, use the authenticator lanes
+ * (`MsgRegisterAuthenticator` + `MsgExecuteCosmos` / `MsgExecuteEVM`) instead.
+ *
+ * @param seed32 - Exactly 32 bytes of secret entropy, used directly as the
+ *   secp256k1 private key.
  * @throws if `seed32` is not 32 bytes or is not a valid secp256k1 scalar.
  */
 declare function unifiedAccountFromSeed(seed32: Uint8Array): UnifiedAccount;
 
 /**
- * Phantom P1a — derive a unified QoreChain account from a Phantom signature.
+ * REMOVED in v0.8.0 — the Phantom signature-derived account API.
  *
- * A user can bootstrap ONE canonical QoreChain identity (native / EVM / SVM, one
- * balance) from their Phantom wallet WITHOUT exporting any key: they sign a fixed,
- * domain-separated message with Phantom's ed25519 key, and the 32-byte SHAKE-256
- * of that signature seeds a unified eth-native secp256k1 account
- * ({@link ../accounts/unified.unifiedAccountFromSeed}).
- *
- * This is NON-CUSTODIAL and produces a SEPARATE canonical key from the Phantom
- * ed25519 key — Phantom never sees the derived secp256k1/PQC secrets, and the
- * derived account is a distinct on-chain identity, not the Phantom address. As
- * long as the same Phantom key signs the same fixed message, the same QoreChain
- * account is reproduced deterministically.
+ * This module used to turn a wallet signature into a spend key. That is unsafe:
+ * a wallet signature is a bearer secret that any page can ask the wallet to
+ * produce, so it cannot stand in for secret entropy, and anyone who obtains it
+ * controls the resulting account. The exported functions remain so existing
+ * imports fail loudly with an explanation instead of silently changing meaning;
+ * both throw as soon as they are called. Link an external wallet key through the
+ * authenticator lanes instead — register it with `MsgRegisterAuthenticator` and
+ * spend via `MsgExecuteCosmos` / `MsgExecuteEVM`, which keeps the canonical
+ * account's own key the only thing that can move funds. See the Authenticators
+ * guide (`docs/docs/guides/authenticators.md`). Any account previously derived
+ * through this API must be treated as exposed — move its funds.
  */
 
 /**
- * The fixed domain-separation prefix signed by Phantom. The full signed message
- * is this line, a newline, and the signer's base58 public key — binding the
- * derivation to the specific Phantom key.
- */
-declare const PHANTOM_DERIVATION_DOMAIN = "QoreChain unified account derivation v1";
-/**
- * Derive a unified QoreChain account from a raw Phantom (ed25519) signature.
+ * REMOVED in v0.8.0. Always throws.
  *
- * The account seed is `shake256(signatureBytes, 32)`, used directly as the
- * eth-native secp256k1 private key. Deterministic: the same signature always
- * yields the same account.
+ * Use the authenticator lanes instead — see the module doc-comment and the
+ * Authenticators guide.
  *
- * @param signatureBytes - The raw ed25519 signature bytes returned by the wallet.
+ * @throws always.
  */
 declare function unifiedAccountFromPhantomSignature(signatureBytes: Uint8Array): UnifiedAccount;
 /**
- * The minimal shape of an injected Phantom-style provider used here: `connect`
- * to obtain the public key and `signMessage` to sign the derivation message.
+ * The minimal shape of an injected Phantom-style provider this module once used.
+ *
+ * Retained only so the removed {@link connectPhantomUnified} signature still
+ * type-checks for existing callers; nothing here is called any more.
  */
 interface PhantomProvider {
     connect(): Promise<{
@@ -1808,26 +1854,18 @@ interface PhantomProvider {
         signature: Uint8Array;
     } | Uint8Array>;
 }
-/** Options for {@link connectPhantomUnified}. */
+/** Options for the removed {@link connectPhantomUnified}. */
 interface ConnectPhantomUnifiedOptions {
-    /**
-     * The Phantom-style provider. Defaults to `window.solana` in a browser. Pass an
-     * explicit provider in tests or non-`window.solana` environments.
-     */
+    /** The Phantom-style provider. Unused: the function always throws. */
     provider?: PhantomProvider;
 }
 /**
- * Connect Phantom in the browser and derive the user's unified QoreChain account.
+ * REMOVED in v0.8.0. Always throws.
  *
- * Flow: `connect()` → sign the fixed domain-separated message
- * `"QoreChain unified account derivation v1\n<phantom-pubkey-base58>"` → derive the
- * unified account from the signature via
- * {@link unifiedAccountFromPhantomSignature}.
+ * Use the authenticator lanes instead — see the module doc-comment and the
+ * Authenticators guide.
  *
- * NON-CUSTODIAL: the returned account is a separate canonical key from the Phantom
- * ed25519 key; Phantom never handles the derived secp256k1/PQC secrets.
- *
- * @throws if no provider is available or the wallet returns no public key.
+ * @throws always.
  */
 declare function connectPhantomUnified(opts?: ConnectPhantomUnifiedOptions): Promise<UnifiedAccount>;
 
@@ -2493,6 +2531,161 @@ declare function encodeHybridExtension(ext: PQCHybridSignature$1): Any;
  */
 declare function attachHybridExtension(body: TxBody, ext: PQCHybridSignature$1, opts?: AttachHybridOptions): TxBody;
 
+/**
+ * Sign-bytes for the payloads a QoreChain key signs outside SIGN_MODE_DIRECT:
+ * the post-quantum half of a hybrid transaction, a PQC key migration, and a
+ * bridge attestation. Each exists in two forms, and a network verifies exactly
+ * ONE of them at any height — there is no overlap window.
+ *
+ * ──────────────────────────────────────────────────────────────────────────
+ *  Which form to sign
+ * ──────────────────────────────────────────────────────────────────────────
+ * Chain release v3.1.98 introduced the v2 forms, which bind a domain tag and
+ * the chain id. Networks that existed before it (`qorechain-vladi`,
+ * `qorechain-diana`) verify v1 until the `v3.1.98` upgrade plan is applied on
+ * that network, and v2 from then on. Any other chain verifies v2 from its first
+ * block. The testnet and mainnet switch at different heights, so a client must
+ * ask the target network rather than hardcode either form:
+ *
+ *     GET {rest}/cosmos/upgrade/v1beta1/applied_plan/v3.1.98 -> {"height":"<n>"}
+ *     v2 iff n > 0, or the chain is not one of the legacy networks.
+ *
+ * The height is an int64 and crosses the REST gateway as a STRING; a network
+ * that has not upgraded answers `{"height":"0"}` (or `{}` on older nodes), so
+ * the decision is numeric, never a presence check.
+ *
+ * {@link resolveSignBytesVersion} does this with a short cache;
+ * {@link signBytesVersionFor} is the pure rule for callers that already know
+ * the applied height.
+ */
+
+/** A concrete sign-bytes form. */
+type SignBytesVersion = "v1" | "v2";
+/** A form, or `"auto"` to ask the target network. */
+type SignBytesVersionOption = SignBytesVersion | "auto";
+/** The upgrade plan whose application switches a legacy network to v2. */
+declare const SIGN_BYTES_V2_UPGRADE = "v3.1.98";
+/** Networks that ran before v2 existed and switch only at {@link SIGN_BYTES_V2_UPGRADE}. */
+declare const LEGACY_SIGN_BYTES_CHAINS: readonly string[];
+/** Domain tag of the v2 hybrid PQC sign-bytes. */
+declare const HYBRID_SIGN_BYTES_V2_DOMAIN = "qorechain-pqc-hybrid-v2";
+/** Domain tag of the v2 PQC key-migration sign-bytes. */
+declare const MIGRATION_SIGN_BYTES_V2_DOMAIN = "qorechain-key-migration-v2";
+/** Domain tag of the v2 bridge attestation sign-bytes. */
+declare const BRIDGE_ATTESTATION_V2_DOMAIN = "qorechain-bridge-attestation-v2";
+/** v1 hybrid form: `BE32(len B0) ‖ B0 ‖ BE32(len A) ‖ A`. */
+declare function hybridSignBytesV1(b0: Uint8Array, authInfo: Uint8Array): Uint8Array;
+/**
+ * v2 hybrid form:
+ * `"qorechain-pqc-hybrid-v2" ‖ BE64(len chainId) ‖ chainId ‖ BE32(len B0) ‖ B0 ‖ BE32(len A) ‖ A`.
+ */
+declare function hybridSignBytesV2(chainId: string, b0: Uint8Array, authInfo: Uint8Array): Uint8Array;
+/**
+ * The message the ML-DSA key signs for a hybrid transaction, in the given form.
+ * `B0` is the `TxBody` WITHOUT the PQC extension; `authInfo` is the AuthInfo
+ * bytes verbatim.
+ */
+declare function hybridSignBytes(version: SignBytesVersion, chainId: string, b0: Uint8Array, authInfo: Uint8Array): Uint8Array;
+/** Inputs of the key-migration sign-bytes (both keys sign the same bytes). */
+interface MigrationSignBytesInput {
+    chainId: string;
+    /** The migrating account's `qor1…` address. */
+    account: string;
+    fromAlgorithmId: number;
+    toAlgorithmId: number;
+    /** The height the migration executes at. */
+    height: number | bigint;
+    /** The current public key (v2 only). */
+    oldPublicKey: Uint8Array;
+    /** The destination public key (v2 only). */
+    newPublicKey: Uint8Array;
+}
+/**
+ * v1 key-migration form (ASCII):
+ * `qorechain-key-migration:chain=<chainId>:from=<from>:to=<to>:account=<account>:height=<height>`.
+ */
+declare function migrationSignBytesV1(input: Omit<MigrationSignBytesInput, "oldPublicKey" | "newPublicKey">): Uint8Array;
+/**
+ * v2 key-migration form:
+ * `"qorechain-key-migration-v2" ‖ BE64(len chainId) ‖ chainId ‖ BE64(len account) ‖ account ‖
+ *  BE32(from) ‖ BE32(to) ‖ BE64(height) ‖ BE32(len oldPub) ‖ oldPub ‖ BE32(len newPub) ‖ newPub`.
+ */
+declare function migrationSignBytesV2(input: MigrationSignBytesInput): Uint8Array;
+/** The key-migration sign-bytes in the given form. */
+declare function migrationSignBytes(version: SignBytesVersion, input: MigrationSignBytesInput): Uint8Array;
+/** Inputs of a bridge attestation payload (validator signers only). */
+interface BridgeAttestationSignBytesInput {
+    chainId: string;
+    chain: string;
+    eventType: string;
+    operationId: string;
+    txHash: string;
+    /** The amount as the chain prints it (`math.Int.String()`). */
+    amount: string;
+    asset: string;
+}
+/** v1 attestation form (ASCII, no chain id): `chain|eventType|operationId|txHash|amount|asset`. */
+declare function bridgeAttestationSignBytesV1(input: Omit<BridgeAttestationSignBytesInput, "chainId">): Uint8Array;
+/**
+ * v2 attestation form: `"qorechain-bridge-attestation-v2"` then, for each of
+ * `[chainId, chain, eventType, operationId, txHash, amount, asset]`, `BE64(len f) ‖ f`.
+ */
+declare function bridgeAttestationSignBytesV2(input: BridgeAttestationSignBytesInput): Uint8Array;
+/** The bridge attestation sign-bytes in the given form. */
+declare function bridgeAttestationSignBytes(version: SignBytesVersion, input: BridgeAttestationSignBytesInput): Uint8Array;
+/** True when `chainId` is a network that verifies v1 until its v3.1.98 upgrade. */
+declare function isLegacySignBytesChain(chainId: string): boolean;
+/**
+ * The form a network verifies, given the height at which the v3.1.98 plan was
+ * applied on it (0 when it has not been). Client-side mirror of the chain's
+ * own switch.
+ */
+declare function signBytesVersionFor(chainId: string, v2AppliedHeight: number | bigint): SignBytesVersion;
+/**
+ * Ask a node at which height the v3.1.98 plan was applied (0 when not).
+ * @throws on a transport or parse failure — the caller must not guess.
+ */
+declare function fetchSignBytesV2AppliedHeight(rest: string, fetchImpl?: FetchLike): Promise<bigint>;
+/** Options for {@link resolveSignBytesVersion}. */
+interface ResolveSignBytesVersionOptions {
+    chainId: string;
+    /** The network's REST (LCD) base URL. Required for `"auto"` on a legacy network. */
+    rest?: string;
+    /** `"auto"` (default) asks the network; `"v1"`/`"v2"` are returned as-is. */
+    signBytesVersion?: SignBytesVersionOption;
+    /** Injectable `fetch`. Defaults to `globalThis.fetch`. */
+    fetch?: FetchLike;
+    /** How long an answer is reused, in ms. Defaults to 60000. */
+    ttlMs?: number;
+    /** Bypass the cache (e.g. after a `pqc` code 21 refusal). */
+    forceRefresh?: boolean;
+}
+/** Forget every cached answer. */
+declare function clearSignBytesCache(): void;
+/**
+ * The form to sign for a network right now.
+ *
+ * - `"v1"` / `"v2"`: returned unchanged, no network call.
+ * - `"auto"` on a chain that is not a legacy network: `"v2"`, no network call.
+ * - `"auto"` on `qorechain-vladi` / `qorechain-diana`: asks `rest` whether the
+ *   v3.1.98 plan is applied; the answer is cached per (rest, chainId) for
+ *   `ttlMs` because a network can upgrade while a wallet stays open.
+ *
+ * @throws when a legacy network has no `rest`, or the query fails. Pass an
+ * explicit `"v1"`/`"v2"` in that case — a wrong guess is refused on-chain.
+ */
+declare function resolveSignBytesVersion(opts: ResolveSignBytesVersionOptions): Promise<SignBytesVersion>;
+/** The chain's message for a hybrid signature that does not verify (`pqc` code 21). */
+declare const HYBRID_SIGN_BYTES_REJECTION_LOG = "hybrid PQC signature verification failed";
+/**
+ * True when a broadcast failure is the chain refusing the hybrid PQC signature
+ * (`pqc` code 21) — the symptom of signing the wrong sign-bytes form. Accepts a
+ * thrown cosmjs `BroadcastTxError` (`code`, `codespace`, `log`), a
+ * `DeliverTxResponse`-like result (`code`, `rawLog`), or a plain `Error`.
+ * Code 21 from any other codespace does NOT match.
+ */
+declare function isHybridSignBytesRejection(x: unknown): boolean;
+
 /**
  * End-to-end hybrid (classical + post-quantum) transaction signing for
  * QoreChain.
@@ -2513,8 +2706,14 @@ declare function attachHybridExtension(body: TxBody, ext: PQCHybridSignature$1,
  *    messages/memo/timeoutHeight but NOT the `PQCHybridSignature` extension.
  *  - `A`  = the tx `authInfoBytes`, verbatim — the same bytes that are
  *    broadcast.
- *  - PQC signed message = `BE32(len(B0)) || B0 || BE32(len(A)) || A`
- *    (4-byte big-endian length prefixes; NO hashing, NO domain prefix).
+ *  - PQC signed message = the hybrid sign-bytes in the form the TARGET network
+ *    verifies (see ./signbytes):
+ *      v1: `BE32(len(B0)) || B0 || BE32(len(A)) || A`
+ *      v2: `"qorechain-pqc-hybrid-v2" || BE64(len chainId) || chainId || v1-body`
+ *    A network verifies exactly one form at any height. `qorechain-vladi` and
+ *    `qorechain-diana` switch from v1 to v2 when their v3.1.98 upgrade is
+ *    applied (at different heights); other chains are v2 from genesis. The
+ *    default `signBytesVersion: "auto"` asks the network (needs `rest`).
  *  - PQC signature       = `ml_dsa87.sign(pqcSecretKey, message)` (pure
  *    ML-DSA-87, empty context) — 4627 bytes for Dilithium-5.
  *  - The `PQCHybridSignature` extension is then added to
@@ -2577,6 +2776,19 @@ interface BuildHybridTxOptions {
      * is expected to already be registered via `MsgRegisterPQCKey`).
      */
     includePqcPublicKey?: boolean;
+    /**
+     * Which hybrid sign-bytes form to sign. `"auto"` (default) asks the network
+     * via `rest` (see {@link resolveSignBytesVersion}); `"v1"` / `"v2"` force a
+     * form. On `qorechain-vladi` / `qorechain-diana`, `"auto"` without `rest`
+     * throws rather than guess.
+     */
+    signBytesVersion?: SignBytesVersionOption;
+    /** The network's REST (LCD) base URL, used by `signBytesVersion: "auto"`. */
+    rest?: string;
+    /** Injectable `fetch` for the `"auto"` lookup. Defaults to `globalThis.fetch`. */
+    fetch?: FetchLike;
+    /** Bypass the cached `"auto"` answer. */
+    forceRefreshSignBytesVersion?: boolean;
 }
 /** The fully assembled hybrid transaction and the intermediate artifacts. */
 interface BuiltHybridTx {
@@ -2590,6 +2802,8 @@ interface BuiltHybridTx {
     pqcSignedMessage: Uint8Array;
     /** The raw ML-DSA-87 signature (Dilithium-5: 4627 bytes). */
     pqcSignature: Uint8Array;
+    /** The sign-bytes form the PQC signature was computed over. */
+    signBytesVersion: SignBytesVersion;
 }
 /**
  * Build a fully signed hybrid transaction following the chain contract.
@@ -2666,8 +2880,8 @@ declare function signAndBroadcastHybrid(opts: SignAndBroadcastHybridOptions): Pr
  * only for the one-time, bootstrap-exempt `MsgRegisterPQCKeyV2`).
  *
  * The hybrid PQC framing/extension reuse the SDK's existing, live-testnet-verified
- * helpers ({@link ../tx/hybrid.encodeHybridExtension}, the `BE32(len)`-prefixed
- * frame, and {@link ../accounts/pqc.buildHybridSignatureExtension}); only the
+ * helpers ({@link ../tx/hybrid.encodeHybridExtension}, the per-network hybrid
+ * sign-bytes ({@link ./signbytes.hybridSignBytes}), and {@link ../accounts/pqc.buildHybridSignatureExtension}); only the
  * classical hash (keccak vs sha256) and the pubkey type URL change here.
  */
 
@@ -2710,6 +2924,13 @@ interface EthSignParams {
      * `value` is already a `Uint8Array`) are accepted.
      */
     encodeMessage?: (m: EncodeObject) => Any;
+    /**
+     * The hybrid sign-bytes form (hybrid signing only). Resolve it with
+     * {@link resolveSignBytesVersion} for the target network. When omitted, a
+     * chain born on v2 gets `"v2"`; on `qorechain-vladi` / `qorechain-diana`
+     * (which switch at their own upgrade heights) omitting it throws.
+     */
+    signBytesVersion?: SignBytesVersion;
 }
 /** The result of an eth-native sign: the broadcastable `TxRaw` and artifacts. */
 interface SignedEthTx {
@@ -2736,7 +2957,8 @@ declare function signClassicalEth(params: EthSignParams): SignedEthTx;
  * Sign a native tx with the eth_secp256k1 + ML-DSA-87 HYBRID scheme.
  *
  * The chain verifies the PQC signature over the tx body WITHOUT the PQC extension
- * (`B0`), framed with `authInfoBytes`: `BE32(len B0) || B0 || BE32(len A) || A`.
+ * (`B0`) and `authInfoBytes`, in the hybrid sign-bytes form the network verifies
+ * (`params.signBytesVersion`, see ./signbytes).
  * The classical signature then covers the FINAL body (with the extension) via
  * SIGN_MODE_DIRECT (keccak256 hash). This mirrors the SDK's existing hybrid path
  * ({@link ../tx/hybrid-tx.buildHybridTx}); only the classical hash and the pubkey
@@ -2795,6 +3017,15 @@ interface EthNativeSignerOptions {
      * `MsgRegisterPQCKeyV2`).
      */
     signMode?: "hybrid" | "classical";
+    /**
+     * Hybrid sign-bytes form. `"auto"` (default) asks the network via `rest` in
+     * {@link EthNativeSigner.signAndBroadcast}; `"v1"` / `"v2"` force a form.
+     */
+    signBytesVersion?: SignBytesVersionOption;
+    /** The network's REST (LCD) base URL, used by `signBytesVersion: "auto"`. */
+    rest?: string;
+    /** Injectable `fetch` for the `"auto"` lookup. */
+    fetch?: FetchLike;
 }
 /** Params for building/broadcasting a tx with {@link EthNativeSigner}. */
 interface EthTxParams extends AccountSequence {
@@ -2803,6 +3034,11 @@ interface EthTxParams extends AccountSequence {
     fee: StdFee;
     memo?: string;
     timeoutHeight?: bigint;
+    /**
+     * The resolved hybrid sign-bytes form for {@link EthNativeSigner.sign}.
+     * {@link EthNativeSigner.signAndBroadcast} resolves it when omitted.
+     */
+    signBytesVersion?: SignBytesVersion;
 }
 /**
  * Sign QoreChain native txs from a unified eth-native account.
@@ -2817,7 +3053,15 @@ declare class EthNativeSigner {
     private readonly key;
     private readonly registry;
     private readonly signMode;
+    private readonly signBytesVersion;
+    private readonly rest?;
+    private readonly fetchImpl?;
     constructor(account: UnifiedAccount, opts?: EthNativeSignerOptions);
+    /**
+     * The hybrid sign-bytes form for `chainId` under this signer's settings.
+     * Pass `forceRefresh` to bypass the cached answer.
+     */
+    resolveSignBytesVersion(chainId: string, forceRefresh?: boolean): Promise<SignBytesVersion>;
     /** Encode a message to `Any` via the bound registry. */
     private encode;
     /** Build and sign a `TxRaw` for the given messages. Does not broadcast. */
@@ -2930,6 +3174,41 @@ declare const MsgRegisterSVMPQCKey: MessageFns$p<MsgRegisterSVMPQCKey>;
 interface MsgRegisterSVMPQCKeyResponse {
 }
 declare const MsgRegisterSVMPQCKeyResponse: MessageFns$p<MsgRegisterSVMPQCKeyResponse>;
+/**
+ * SVMParams mirrors the module's runtime parameters so governance can replace
+ * them wholesale. The store keeps them as JSON, so the handler converts.
+ */
+interface SVMParams {
+    maxProgramSize: string;
+    maxAccountDataSize: string;
+    computeBudgetMax: string;
+    lamportsPerByte: string;
+    rentExemptionMulti: string;
+    enabled: boolean;
+    svmSlotOffset: string;
+    defaultSigScheme: number;
+    maxCpi: number;
+}
+declare const SVMParams: MessageFns$p<SVMParams>;
+/**
+ * MsgUpdateParams replaces the SVM runtime parameters wholesale.
+ *
+ * WHY THIS EXISTS. Until now x/svm had no governance message at all, so there was
+ * no transaction that could turn the lane off. When the August 2026 incident
+ * required closing it, the only available guarantee was a compile-time constant
+ * (SVMLaneHardDisabled), which means every later change of mind costs a binary
+ * release and a coordinated upgrade. With this message, disabling the lane is a
+ * governance proposal like any other.
+ */
+interface MsgUpdateParams {
+    /** authority must be the governance module account. */
+    authority: string;
+    params?: SVMParams | undefined;
+}
+declare const MsgUpdateParams: MessageFns$p<MsgUpdateParams>;
+interface MsgUpdateParamsResponse {
+}
+declare const MsgUpdateParamsResponse: MessageFns$p<MsgUpdateParamsResponse>;
 type MsgDefinition$a = typeof MsgDefinition$a;
 declare const MsgDefinition$a: {
     readonly name: "Msg";
@@ -2967,6 +3246,14 @@ declare const MsgDefinition$a: {
             readonly responseStream: false;
             readonly options: {};
         };
+        readonly updateParams: {
+            readonly name: "UpdateParams";
+            readonly requestType: typeof MsgUpdateParams;
+            readonly requestStream: false;
+            readonly responseType: typeof MsgUpdateParamsResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
     };
 };
 type Builtin$p = Date | Function | Uint8Array | string | number | boolean | undefined;
@@ -2990,10 +3277,13 @@ declare const tx$a_MsgExecuteProgram: typeof MsgExecuteProgram;
 declare const tx$a_MsgExecuteProgramResponse: typeof MsgExecuteProgramResponse;
 declare const tx$a_MsgRegisterSVMPQCKey: typeof MsgRegisterSVMPQCKey;
 declare const tx$a_MsgRegisterSVMPQCKeyResponse: typeof MsgRegisterSVMPQCKeyResponse;
+declare const tx$a_MsgUpdateParams: typeof MsgUpdateParams;
+declare const tx$a_MsgUpdateParamsResponse: typeof MsgUpdateParamsResponse;
 declare const tx$a_SVMAuth: typeof SVMAuth;
+declare const tx$a_SVMParams: typeof SVMParams;
 declare const tx$a_SvmAccountMeta: typeof SvmAccountMeta;
 declare namespace tx$a {
-  export { type DeepPartial$p as DeepPartial, type MessageFns$p as MessageFns, tx$a_MsgCreateAccount as MsgCreateAccount, tx$a_MsgCreateAccountResponse as MsgCreateAccountResponse, MsgDefinition$a as MsgDefinition, tx$a_MsgDeployProgram as MsgDeployProgram, tx$a_MsgDeployProgramResponse as MsgDeployProgramResponse, tx$a_MsgExecuteProgram as MsgExecuteProgram, tx$a_MsgExecuteProgramResponse as MsgExecuteProgramResponse, tx$a_MsgRegisterSVMPQCKey as MsgRegisterSVMPQCKey, tx$a_MsgRegisterSVMPQCKeyResponse as MsgRegisterSVMPQCKeyResponse, tx$a_SVMAuth as SVMAuth, tx$a_SvmAccountMeta as SvmAccountMeta, protobufPackage$o as protobufPackage };
+  export { type DeepPartial$p as DeepPartial, type MessageFns$p as MessageFns, tx$a_MsgCreateAccount as MsgCreateAccount, tx$a_MsgCreateAccountResponse as MsgCreateAccountResponse, MsgDefinition$a as MsgDefinition, tx$a_MsgDeployProgram as MsgDeployProgram, tx$a_MsgDeployProgramResponse as MsgDeployProgramResponse, tx$a_MsgExecuteProgram as MsgExecuteProgram, tx$a_MsgExecuteProgramResponse as MsgExecuteProgramResponse, tx$a_MsgRegisterSVMPQCKey as MsgRegisterSVMPQCKey, tx$a_MsgRegisterSVMPQCKeyResponse as MsgRegisterSVMPQCKeyResponse, tx$a_MsgUpdateParams as MsgUpdateParams, tx$a_MsgUpdateParamsResponse as MsgUpdateParamsResponse, tx$a_SVMAuth as SVMAuth, tx$a_SVMParams as SVMParams, tx$a_SvmAccountMeta as SvmAccountMeta, protobufPackage$o as protobufPackage };
 }
 
 declare const protobufPackage$n = "qorechain.bridge.v1";
@@ -4460,15 +4750,35 @@ declare namespace tx$2 {
 declare const protobufPackage$f = "qorechain.crossvm.v1";
 interface MsgCrossVMCall {
     sender: string;
+    /**
+     * source_vm is IGNORED on input. The chain derives the origin lane from the
+     * execution context, because a caller describing itself cannot be evidence of
+     * what it is. Retained so the field number stays taken and older clients that
+     * still set it are accepted rather than rejected.
+     */
     sourceVm: string;
     targetVm: string;
     targetContract: string;
     payload: Uint8Array;
     funds: Coin[];
+    /**
+     * async queues the call instead of executing it, to be dispatched later by
+     * ProcessQueue. The default is to execute now and return the answer, which is
+     * what a caller that needs the result requires.
+     */
+    async: boolean;
 }
 declare const MsgCrossVMCall: MessageFns$f<MsgCrossVMCall>;
 interface MsgCrossVMCallResponse {
     messageId: string;
+    /** executed is false for a queued call, whose result is not known yet. */
+    executed: boolean;
+    /**
+     * data is the callee's return value, carried back to the caller. A CosmWasm
+     * contract reads it from the submessage reply.
+     */
+    data: Uint8Array;
+    gasUsed: string;
 }
 declare const MsgCrossVMCallResponse: MessageFns$f<MsgCrossVMCallResponse>;
 interface MsgProcessQueue {
@@ -4484,7 +4794,11 @@ declare const MsgDefinition$1: {
     readonly name: "Msg";
     readonly fullName: "qorechain.crossvm.v1.Msg";
     readonly methods: {
-        /** CrossVMCall submits a cross-VM message to the queue. */
+        /**
+         * CrossVMCall invokes a contract on another VM. It executes within the
+         * transaction and returns the callee's answer, unless async is set, in which
+         * case it is queued for ProcessQueue to dispatch later.
+         */
         readonly crossVMCall: {
             readonly name: "CrossVMCall";
             readonly requestType: typeof MsgCrossVMCall;
@@ -4738,6 +5052,17 @@ declare const svm: {
     createAccount: (value: PartialMsg<MsgCreateAccount>) => EncodeObject;
     executeProgram: (value: PartialMsg<MsgExecuteProgram>) => EncodeObject;
     registerSvmPqcKey: (value: PartialMsg<MsgRegisterSVMPQCKey>) => EncodeObject;
+    /**
+     * Replace the x/svm runtime parameters wholesale (chain v3.1.97).
+     *
+     * GOVERNANCE ONLY: `authority` must be the governance module account, so this
+     * message is submitted inside a gov proposal, not signed by a user. It is what
+     * makes enabling/disabling the SVM lane a proposal rather than a binary
+     * release. `params` is replaced in full — send every field, not just the ones
+     * you mean to change. `rentExemptionMulti` is a `LegacyDec` string (e.g.
+     * `"2.000000000000000000"`).
+     */
+    updateParams: (value: PartialMsg<MsgUpdateParams>) => EncodeObject;
 };
 /** Light-node lifecycle message composers. */
 declare const lightnode: {
@@ -6920,6 +7245,10 @@ declare const msg: {
                 readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
             } | undefined;
         }) => _cosmjs_proto_signing.EncodeObject;
+        updateParams: (value: {
+            authority?: string | undefined;
+            params?: SVMParams | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
     };
     readonly lightnode: {
         registerLightNode: (value: {
@@ -7382,6 +7711,7 @@ declare const msg: {
                 denom?: string | undefined;
                 amount?: string | undefined;
             } | undefined)[] | undefined;
+            async?: boolean | undefined;
         }) => _cosmjs_proto_signing.EncodeObject;
         processQueue: (value: {
             authority?: string | undefined;
@@ -10162,6 +10492,12 @@ declare function createRollupClient(tx: TxClient, opts?: CreateRollupClientOptio
  * under a single signature — e.g. an EVM call, an SVM call, and a CosmWasm call
  * that all land together or not at all.
  *
+ * A call executes inside the transaction and returns the callee's answer: the
+ * result carries `executed`, `data` (the return value) and `gasUsed`, decoded
+ * from `MsgCrossVMCallResponse`. Pass `async: true` to queue the call for a
+ * later `ProcessQueue` dispatch instead, in which case nothing has run yet and
+ * only the message id is meaningful.
+ *
  * 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
@@ -10222,7 +10558,15 @@ interface CrossVMWriteOptions {
 }
 /** Common cross-VM call fields (without the payload or write options). */
 interface CrossVMCallBase {
-    /** The VM the call originates from. Defaults to `"evm"`. */
+    /**
+     * The VM the call claims to originate from.
+     *
+     * IGNORED BY THE CHAIN (v3.1.97). The chain derives the origin lane from the
+     * execution context rather than trusting the caller's self-description, so
+     * setting this changes nothing about how the call is handled. The field is
+     * retained — and still sent, defaulting to `"evm"` — purely for wire
+     * compatibility, so older nodes and clients keep accepting the message.
+     */
     sourceVm?: VMType;
     /** The VM the call targets. */
     targetVm: VMType;
@@ -10230,13 +10574,42 @@ interface CrossVMCallBase {
     targetContract: string;
     /** Optional funds (coins) to forward with the call. */
     funds?: Coin$1[];
+    /**
+     * Queue the call for a later `ProcessQueue` dispatch instead of executing it
+     * inside this transaction.
+     *
+     * Defaults to `false`, matching the chain's default: execute now and return
+     * the callee's answer (see {@link CrossVMCallResult.data}). With `async: true`
+     * the call is only enqueued, so the response carries `executed: false` and no
+     * `data` — use it when you do not need the result in this transaction.
+     */
+    async?: boolean;
 }
 /** 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;
+/**
+ * The decoded `MsgCrossVMCallResponse` fields for one cross-VM call.
+ *
+ * Populated from the tx's per-message responses when the node returns them
+ * (`commit` broadcasts). When they are absent — a `sync`/`async` broadcast, or
+ * an older node — `executed` is `false`, `data` is empty and `gasUsed` is `0n`;
+ * read the result with {@link CrossVMClient.getMessage} instead.
+ */
+interface CrossVMCallOutcome {
+    /**
+     * Whether the callee actually ran inside this transaction. `false` for a
+     * queued (`async: true`) call, whose result is not known yet.
+     */
+    executed: boolean;
+    /** The callee's return value. Empty when the call was queued. */
+    data: Uint8Array;
+    /** Gas consumed by the callee. `0n` when the call was queued. */
+    gasUsed: bigint;
+}
 /** Result of a single {@link CrossVMClient.call}. */
-interface CrossVMCallResult {
+interface CrossVMCallResult extends CrossVMCallOutcome {
     /** The cross-VM message id assigned by the chain (parsed from tx events). */
     messageId: string;
     /** The raw broadcast result. */
@@ -10246,6 +10619,13 @@ interface CrossVMCallResult {
 interface CrossVMAtomicResult {
     /** The cross-VM message ids assigned by the chain (best-effort, from events). */
     messageIds: string[];
+    /**
+     * The decoded per-call outcomes, in the order the calls were passed.
+     *
+     * Empty when the node returned no per-message responses (see
+     * {@link CrossVMCallOutcome}).
+     */
+    outcomes: CrossVMCallOutcome[];
     /** The raw broadcast result for the single packing transaction. */
     result: BroadcastResult;
 }
@@ -10289,7 +10669,9 @@ interface CreateCrossVMClientOptions {
  * 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"`.
+ * never repeats their address. `sourceVm` still defaults to `"evm"` on the wire
+ * but is ignored by the chain (see {@link CrossVMCallBase.sourceVm}); `async`
+ * defaults to `false`, i.e. execute now and return the callee's answer.
  *
  * @param tx - A connected signing client (from `client.connectTx(signer)`).
  * @param opts - Optional typed query client and/or `qor_` client for reads.
@@ -10514,6 +10896,6 @@ declare function migrateToHybrid(tx: TxClient, opts: MigrateToHybridOptions): Pr
  * callers who want to compose them directly. Internal helpers are not exported.
  */
 /** SDK version. */
-declare const VERSION = "0.7.0";
+declare const VERSION = "0.8.0";
 
-export { type AbstractAccountConfigView, type AbstractAccountQueryClient, type AbstractAccountView, type Account, type AccountSequence, AlgorithmDilithium5, type AlgorithmID, AlgorithmMLKEM1024, AlgorithmUnspecified, type AllBalancesResponse, type AmmQueryClient, type AnchorStateOptions, type AttachHybridOptions, type AuthenticatorWallet, type AutoFeeOptions, type BalanceResponse, type BankSendOptions, type Bech32Config, type Bech32Prefixes, type BridgeQueryClient, type BroadcastMode, type BroadcastResult, type BuildHybridTxOptions, type BuildMetaMaskExecuteCosmosOptions, type BuildMetaMaskExecuteEvmOptions, type BuildPhantomExecuteCosmosOptions, type BuildPhantomExecuteEvmOptions, type BuiltHybridTx, CANONICAL_DERIVATION, type CallOptions, type ChallengeBatchOptions, type ClientFees, type CoinInfo, type ConnectPhantomUnifiedOptions, type ConnectTxOptions, type ContractMsg, type CosmWasmPayload, type CosmWasmReadClient, type CosmWasmSigningClient, type CosmosAuthSignBytesInput, 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, ETHSECP256K1_PUBKEY_TYPE, type Ed25519Account, type Eip1193Provider, type EnsurePqcRegisteredOptions, type EnsurePqcRegisteredResult, type EstimateFeeOptions, type EthBroadcaster, EthNativeSigner, type EthNativeSignerOptions, type EthSignParams, type EthSigningKey, type EthTxParams, type EventFilters, type EventStream, type EvmAuthSignBytesInput, type EvmPayload, type ExecuteCosmosMsgInput, type ExecuteEvmMsgInput, 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, LEGACY_DERIVATION, type LicenseQueryClient, 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, PHANTOM_DERIVATION_DOMAIN, type PQCHybridSignature$1 as PQCHybridSignature, PQC_KEY_STATUS_PRECOMPILE_ADDRESS, type PageResponse, type PaginatedOptions, type Pagination, type ParsedAccountAuth, type PayloadInput, type PendingCrossVmMessagesResponse, type PermissionSchemaResponse, type PhantomProvider, 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 RegisterEthAuthenticatorMsgInput, type RegisterPaychainOptions, type RegisterSidechainOptions, type ReputationQueryClient, type RequestFaucetOptions, type ResolveChallengeOptions, RestClient, type RestClientOptions, type RetryOptions, type RevokeAuthenticatorMsgInput, type RlConsensusQueryClient, type RollupClient, type RollupLifecycleOptions, type RollupWriteOptions, type RotatePqcKeyMsgFromMnemonicOptions, type RotatePqcKeyMsgFromMnemonicResult, type RotatePqcKeyMsgInput, type RouteTransactionOptions, STATIC_FALLBACK, type SearchTxsOptions, type SearchTxsResponse, type Secp256k1Account, type SignAndBroadcastHybridOptions, type SignAndBroadcastOptions, type SignOutput, type SignatureMode, type SignedEthTx, 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 UnifiedAccount, type UnifiedAddresses, type Unsubscribe, VERSION, type VMType, VM_TYPES, type WaitForTxOptions, abstractaccount, accountAuthInfo, addressesFrom20, algorithmName, amm, attachHybridExtension, authz, bank, be64, bech32ToHex, bridge, broadcastAndWait, buildAminoTypes, buildEventsQuery, buildHybridSignatureExtension, buildHybridTx, buildMetaMaskExecuteCosmos, buildMetaMaskExecuteEvm, buildPhantomExecuteCosmos, buildPhantomExecuteEvm, buildRegisterPqcKeyMsg, buildTxQuery, buildUrl, bytesToBech32, calculateFee, clearAdmin, connectCosmWasmSigner, connectPhantomUnified, connectQueryClients, cosmosAuthSignBytes, createClient, createCosmWasmClient, createCrossVMClient, createMultilayerClient, createQueryClients, createRollupClient, createSubscriptionClient, crossvm, decodeTxError, deriveEvmAccount, deriveNativeAccount, derivePqcLegacy, deriveSvmAccount, deriveUnifiedAccount, directSignerFromPrivateKey, distribution, encodeHybridExtension, ensurePqcRegistered, estimateFee, evmAuthSignBytes, evmToQor, execute, executeCosmosMsg, executeEvmMsg, 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, lengthPrefixed, license, lightnode, listNetworks, migrate, migratePqcKey, migrateToHybrid, msg, multilayer, parseEthPubkeyAny, parseUnits, postJsonRpc, pqc as pqcMsg, pqcSign, pqcVerify, qorToEvm, qoreAddresses, qorechainRegistry, qorechainRegistryTypes, index as qorechainTypes, queryContractSmart, rdk, registerEthAuthenticatorMsg, requestFaucet, revokeAuthenticatorMsg, ripemd160, ripemd160Hex, rlconsensus, rotatePqcKeyMsg, rotatePqcKeyMsgFromMnemonic, rotationSignBytes, searchTxs, sha256, sha256Hex, signAndBroadcastHybrid, signClassicalEth, signHybridEth, staking, subscribeNewBlocks, subscribeTx, suggestChainInfo, svm, toBase, toChecksumAddress, toHex, txErrorFrom, unifiedAccountFromPhantomSignature, unifiedAccountFromSeed, updateAdmin, uploadCode, validateMnemonic, waitForTx, withRetry };
+export { type AbstractAccountConfigView, type AbstractAccountQueryClient, type AbstractAccountView, type Account, type AccountSequence, AlgorithmDilithium5, type AlgorithmID, AlgorithmMLKEM1024, AlgorithmUnspecified, type AllBalancesResponse, type AmmQueryClient, type AnchorStateOptions, type AttachHybridOptions, type AuthenticatorWallet, type AutoFeeOptions, BRIDGE_ATTESTATION_V2_DOMAIN, type BalanceResponse, type BankSendOptions, type Bech32Config, type Bech32Prefixes, type BridgeAttestationSignBytesInput, type BridgeQueryClient, type BroadcastMode, type BroadcastResult, type BuildHybridTxOptions, type BuildMetaMaskExecuteCosmosOptions, type BuildMetaMaskExecuteEvmOptions, type BuildPhantomExecuteCosmosOptions, type BuildPhantomExecuteEvmOptions, type BuiltHybridTx, CANONICAL_DERIVATION, type CallOptions, type ChallengeBatchOptions, type ClientFees, type CoinInfo, type ConnectPhantomUnifiedOptions, type ConnectTxOptions, type ContractMsg, type CosmWasmPayload, type CosmWasmReadClient, type CosmWasmSigningClient, type CosmosAuthSignBytesInput, 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, ETHSECP256K1_PUBKEY_TYPE, type Ed25519Account, type Eip1193Provider, type EnsurePqcRegisteredOptions, type EnsurePqcRegisteredResult, type EstimateFeeOptions, type EthBroadcaster, EthNativeSigner, type EthNativeSignerOptions, type EthSignParams, type EthSigningKey, type EthTxParams, type EventFilters, type EventStream, type EvmAuthSignBytesInput, type EvmPayload, type ExecuteCosmosMsgInput, type ExecuteEvmMsgInput, type ExecuteWithdrawalOptions, type ExplorerConfig, type FaucetConfig, type FeeInput, type FeeUrgency, type FetchLike, GasPrice, type GetBlockResponse, type GetCosmosWalletOptions, type GetJsonOptions, type GetTxFn, type GetTxResponse, HYBRID_SIGN_BYTES_REJECTION_LOG, HYBRID_SIGN_BYTES_V2_DOMAIN, 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, LEGACY_DERIVATION, LEGACY_SIGN_BYTES_CHAINS, type LicenseQueryClient, type LightNodeQueryClient, MIGRATION_SIGN_BYTES_V2_DOMAIN, 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 MigrationSignBytesInput, type MultilayerClient, type MultilayerQueryClient, type MultilayerWriteOptions, NETWORKS, type NetworkConfig, type NetworkEndpoints, type NetworkName, type NewBlockEventLike, type PQCHybridSignature$1 as PQCHybridSignature, PQC_KEY_STATUS_PRECOMPILE_ADDRESS, type PageResponse, type PaginatedOptions, type Pagination, type ParsedAccountAuth, type PayloadInput, type PendingCrossVmMessagesResponse, type PermissionSchemaResponse, type PhantomProvider, 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 RegisterEthAuthenticatorMsgInput, type RegisterPaychainOptions, type RegisterSidechainOptions, type ReputationQueryClient, type RequestFaucetOptions, type ResolveChallengeOptions, type ResolveSignBytesVersionOptions, RestClient, type RestClientOptions, type RetryOptions, type RevokeAuthenticatorMsgInput, type RlConsensusQueryClient, type RollupClient, type RollupLifecycleOptions, type RollupWriteOptions, type RotatePqcKeyMsgFromMnemonicOptions, type RotatePqcKeyMsgFromMnemonicResult, type RotatePqcKeyMsgInput, type RouteTransactionOptions, SIGN_BYTES_V2_UPGRADE, STATIC_FALLBACK, type SearchTxsOptions, type SearchTxsResponse, type Secp256k1Account, type SignAndBroadcastHybridOptions, type SignAndBroadcastOptions, type SignBytesVersion, type SignBytesVersionOption, type SignOutput, type SignatureMode, type SignedEthTx, 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 UnifiedAccount, type UnifiedAddresses, type Unsubscribe, VERSION, type VMType, VM_TYPES, type WaitForTxOptions, abstractaccount, accountAuthInfo, addressesFrom20, algorithmName, amm, attachHybridExtension, authz, bank, be64, bech32ToHex, bridge, bridgeAttestationSignBytes, bridgeAttestationSignBytesV1, bridgeAttestationSignBytesV2, broadcastAndWait, buildAminoTypes, buildEventsQuery, buildHybridSignatureExtension, buildHybridTx, buildMetaMaskExecuteCosmos, buildMetaMaskExecuteEvm, buildPhantomExecuteCosmos, buildPhantomExecuteEvm, buildRegisterPqcKeyMsg, buildTxQuery, buildUrl, bytesToBech32, calculateFee, clearAdmin, clearSignBytesCache, connectCosmWasmSigner, connectPhantomUnified, connectQueryClients, cosmosAuthSignBytes, createClient, createCosmWasmClient, createCrossVMClient, createMultilayerClient, createQueryClients, createRollupClient, createSubscriptionClient, crossvm, decodeTxError, deriveEvmAccount, deriveNativeAccount, derivePqcLegacy, deriveSvmAccount, deriveUnifiedAccount, directSignerFromPrivateKey, distribution, encodeHybridExtension, ensurePqcRegistered, estimateFee, evmAuthSignBytes, evmToQor, execute, executeCosmosMsg, executeEvmMsg, explorerAddressUrl, explorerBlockUrl, explorerTxUrl, feegrant, fetchSignBytesV2AppliedHeight, formatUnits, fromBase, generateMnemonic, generatePqcKeypair, getBlock, getCodeDetails, getCodes, getContractInfo, getContracts, getCosmosWallet, getCrossVmMessage, getCrossVmParams, getJson, getLatestBlock, getNetwork, getPendingCrossVmMessages, getPqcStatus, getTx, gov, hexToBech32, hybridSignBytes, hybridSignBytesV1, hybridSignBytesV2, ibc, instantiate, instantiate2, isChecksumAddress, isHybridSignBytesRejection, isLegacySignBytesChain, isPqcRegistered, isSignatureAlgorithm, isTxFailure, isValidBech32, isValidEvmAddress, isValidSvmAddress, joinUrl, keccak256, keccak256Hex, lengthPrefixed, license, lightnode, listNetworks, migrate, migratePqcKey, migrateToHybrid, migrationSignBytes, migrationSignBytesV1, migrationSignBytesV2, msg, multilayer, parseEthPubkeyAny, parseUnits, postJsonRpc, pqc as pqcMsg, pqcSign, pqcVerify, qorToEvm, qoreAddresses, qorechainRegistry, qorechainRegistryTypes, index as qorechainTypes, queryContractSmart, rdk, registerEthAuthenticatorMsg, requestFaucet, resolveSignBytesVersion, revokeAuthenticatorMsg, ripemd160, ripemd160Hex, rlconsensus, rotatePqcKeyMsg, rotatePqcKeyMsgFromMnemonic, rotationSignBytes, searchTxs, sha256, sha256Hex, signAndBroadcastHybrid, signBytesVersionFor, signClassicalEth, signHybridEth, staking, subscribeNewBlocks, subscribeTx, suggestChainInfo, svm, toBase, toChecksumAddress, toHex, txErrorFrom, unifiedAccountFromPhantomSignature, unifiedAccountFromSeed, updateAdmin, uploadCode, validateMnemonic, waitForTx, withRetry };