@qorechain/sdk 0.6.1 → 0.8.0

package/dist/index.d.cts

@@ -213,6 +213,39 @@ interface PaginatedOptions {
 type RestClientOptions = HttpOptions;
 /** Relative urgency of a fee estimate. */
 type FeeUrgency = "fast" | "normal" | "slow";
+/**
+ * REST shape of `GET /qorechain/abstractaccount/v1/permission_schema` — the
+ * canonical authenticator permission taxonomy (v3.1.85). `schema_version` bumps
+ * whenever the taxonomy or the mapping changes, so clients compare it to their
+ * embedded copy to detect drift.
+ */
+interface PermissionSchemaResponse {
+    /** Version tag that bumps on any taxonomy/mapping change. */
+    schema_version: string;
+    /** Every valid permission string (e.g. `send`, `evm`, `svm`, `all`). */
+    permissions: string[];
+    /** Maps a message typeURL to the permission it requires. */
+    msg_permissions: Record<string, string>;
+    /** TypeURLs that are NEVER delegable to a linked authenticator key. */
+    key_management_msgs: string[];
+}
+/** REST shape of an abstract-account view (subset of `AccountView`). */
+interface AbstractAccountView {
+    address: string;
+    contract_address?: string;
+    account_type?: string;
+    spending_rules_count?: number;
+    session_keys_count?: number;
+    created_at?: string;
+    owner?: string;
+}
+/** REST shape of the abstractaccount module config view. */
+interface AbstractAccountConfigView {
+    enabled: boolean;
+    max_session_keys?: number;
+    max_spending_rules?: number;
+    default_session_ttl?: string;
+}
 /** Native + QoreChain REST read client. */
 declare class RestClient {
     private readonly baseUrl;
@@ -252,6 +285,28 @@ declare class RestClient {
     getXqorePosition<T = Record<string, unknown>>(address: string): Promise<T>;
     /** Current inflation rate (`/qorechain/inflation/v1/rate`). */
     getInflationRate<T = Record<string, unknown>>(): Promise<T>;
+    /**
+     * The canonical authenticator permission taxonomy
+     * (`/qorechain/abstractaccount/v1/permission_schema`): the valid permission
+     * strings, the message-typeURL→permission mapping, the never-delegable
+     * key-management typeURLs, and a `schema_version` for drift detection.
+     */
+    getPermissionSchema(): Promise<PermissionSchemaResponse>;
+    /** Abstract-account module config (`/qorechain/abstractaccount/v1/config`). */
+    getAbstractAccountConfig<T = {
+        config: AbstractAccountConfigView;
+    }>(): Promise<T>;
+    /** All abstract accounts (`/qorechain/abstractaccount/v1/accounts`). */
+    getAbstractAccounts<T = {
+        accounts: AbstractAccountView[];
+    }>(): Promise<T>;
+    /**
+     * A single abstract account by address
+     * (`/qorechain/abstractaccount/v1/accounts/{address}`).
+     */
+    getAbstractAccount<T = {
+        account: AbstractAccountView;
+    }>(address: string): Promise<T>;
 }
 
 /**
@@ -494,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;
+    }>;
 }
 
 /**
@@ -1500,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
@@ -1696,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<{
@@ -1753,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>;
 
@@ -2254,6 +2347,117 @@ interface RetryOptions {
  */
 declare function withRetry<T>(fn: (attempt: number) => Promise<T>, opts?: RetryOptions): Promise<T>;
 
+/**
+ * Authenticator-lane sign-bytes (v3.1.85).
+ *
+ * QoreChain "authenticator lanes" let a linked external key (a Phantom ed25519
+ * key, or an EVM secp256k1 key) spend from the ONE canonical PQC-required
+ * account under least-privilege, spend-limited, revocable terms — WITHOUT the
+ * external key ever producing an ML-DSA co-signature. A relayer submits and
+ * pays fees (its own hybrid-PQC signature satisfies the ante on the envelope);
+ * the authenticator's signature over the domain-separated, replay-bound
+ * sign-bytes below IS the authorization.
+ *
+ * There are three lanes:
+ *   - EVM lane    — `MsgExecuteEVM`:    an EVM call/transfer from the account's
+ *                   0x address, authorized by {@link evmAuthSignBytes}.
+ *   - Native lane — `MsgExecuteCosmos`: a bank send from the account, authorized
+ *                   by {@link cosmosAuthSignBytes}.
+ *   - Key rotation — `MsgRotatePQCKey`: dual-signed over
+ *                    {@link rotationSignBytes}.
+ *
+ * The digests here are rebuilt BYTE-FOR-BYTE from what the chain re-derives
+ * (`x/abstractaccount/types/{evm,cosmos}_sign.go`, `x/pqc/types` rotation
+ * bytes). A mismatch is rejected on-chain (codespace `abstractaccount`, code 11
+ * replay / 10 permission / 5 spending-limit / 6 session-expired; codespace
+ * `pqc`, code 21 hybrid-verify-failed).
+ *
+ * These are pure byte-builders — no wallet, no network. See
+ * {@link ../wallet/authenticator} for the DX builders that sign them.
+ */
+/** 8-byte big-endian encoding of a non-negative integer (`binary.BigEndian`). */
+declare function be64(n: number | bigint): Uint8Array;
+/** Length-prefixed field: `BE64(len) ‖ bytes` (the chain's framing). */
+declare function lengthPrefixed(bytes: Uint8Array): Uint8Array;
+/** Input to {@link evmAuthSignBytes}. */
+interface EvmAuthSignBytesInput {
+    /** The chain id (e.g. `qorechain-diana`). */
+    chainId: string;
+    /** The bech32 canonical account the authenticator acts for. */
+    account: string;
+    /** The authenticator's raw public key (32 bytes for ed25519; the 20-byte eth address for secp256k1). */
+    pubkey: Uint8Array;
+    /** 0x-hex recipient/contract address; empty string for contract creation. */
+    to?: string;
+    /** Native QOR amount in wei (aqor) as a decimal string. */
+    value?: string;
+    /** EVM calldata. */
+    data?: Uint8Array;
+    /**
+     * The account's CURRENT EVM nonce. The relayer is a DIFFERENT account than the
+     * owner, so the relayer envelope does NOT bump the account's nonce — use the
+     * current value as-is (do NOT +1).
+     */
+    nonce: number | bigint;
+}
+/**
+ * Rebuild the 32-byte digest the chain re-derives for a `MsgExecuteEVM`:
+ *
+ * ```
+ * sha256( "qorechain-evm-auth-v1"
+ *         ‖ LP(chainId) ‖ LP(account) ‖ LP(pubkey)
+ *         ‖ LP(to) ‖ LP(value) ‖ LP(data) ‖ BE64(nonce) )
+ * ```
+ *
+ * where `LP(x) = BE64(len(x)) ‖ x`. Returns the raw 32 bytes the authenticator
+ * signs.
+ */
+declare function evmAuthSignBytes(input: EvmAuthSignBytesInput): Uint8Array;
+/** Input to {@link cosmosAuthSignBytes}. */
+interface CosmosAuthSignBytesInput {
+    /** The chain id (e.g. `qorechain-diana`). */
+    chainId: string;
+    /** The bech32 canonical account the authenticator acts for. */
+    account: string;
+    /** The authenticator's raw public key (32 bytes for ed25519; the 20-byte eth address for secp256k1). */
+    pubkey: Uint8Array;
+    /** The bech32 recipient address. */
+    to: string;
+    /** The CANONICAL single-coin amount string (e.g. `100uqor`). */
+    amount: string;
+    /**
+     * The per-authenticator sequence for `(account, pubkey)` — a store counter
+     * distinct from the account's own sequence, incremented on each successful
+     * Native-lane spend.
+     */
+    nonce: number | bigint;
+}
+/**
+ * Rebuild the 32-byte digest the chain re-derives for a `MsgExecuteCosmos`:
+ *
+ * ```
+ * sha256( "qorechain-cosmos-auth-v1"
+ *         ‖ LP(chainId) ‖ LP(account) ‖ LP(pubkey)
+ *         ‖ LP(to) ‖ LP(amount) ‖ BE64(nonce) )
+ * ```
+ *
+ * `amount` is the canonical single-coin string (e.g. `100uqor`). Returns the
+ * raw 32 bytes the authenticator signs.
+ */
+declare function cosmosAuthSignBytes(input: CosmosAuthSignBytesInput): Uint8Array;
+/**
+ * The domain-separated STRING both the old and the new key sign for a
+ * `MsgRotatePQCKey`:
+ *
+ * ```
+ * "qorechain-pqc-rotate-v1|<chainId>|<algorithmId>|<account>|<oldHex>|<newHex>"
+ * ```
+ *
+ * `oldHex`/`newHex` are lowercase hex of the public keys. Sign `utf8(result)`
+ * with BOTH the old and the new key.
+ */
+declare function rotationSignBytes(chainId: string, algorithmId: number, account: string, oldPub: Uint8Array, newPub: Uint8Array): string;
+
 /**
  * Encoding and attachment of the QoreChain PQC hybrid-signature extension to a
  * native tx.
@@ -2327,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.
@@ -2347,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
@@ -2411,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 {
@@ -2424,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.
@@ -2500,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.
  */
 
@@ -2544,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 {
@@ -2570,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
@@ -2629,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 {
@@ -2637,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.
@@ -2651,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. */
@@ -2729,7 +3139,7 @@ declare const SvmAccountMeta: MessageFns$p<SvmAccountMeta>;
 /**
  * SVMAuth carries a foreign-scheme (e.g. Phantom ed25519) authorization for an
  * SVM action. When present on MsgExecuteProgram, the EFFECTIVE SVM signer is the
- * canonical account this key authenticates (verified on-chain), NOT the Native
+ * canonical account this key authenticates (verified on-chain), NOT the Cosmos
  * `sender` — so any funded account may relay a Phantom-authorized action through
  * consensus while the foreign key remains the authority.
  */
@@ -2764,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";
@@ -2801,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;
@@ -2824,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";
@@ -3732,6 +4188,24 @@ declare const MsgMigratePQCKey: MessageFns$j<MsgMigratePQCKey>;
 interface MsgMigratePQCKeyResponse {
 }
 declare const MsgMigratePQCKeyResponse: MessageFns$j<MsgMigratePQCKeyResponse>;
+/**
+ * MsgRotatePQCKey replaces an account's PQC key with a new key of the SAME
+ * algorithm. Both signatures are over the domain-separated bytes
+ * "qorechain-pqc-rotate-v1|chainid|algo|account|oldkey|newkey" (no block height —
+ * the signer cannot predict it; replay is prevented because after the rotation
+ * the old key no longer matches the registered key).
+ */
+interface MsgRotatePQCKey {
+    sender: string;
+    oldPublicKey: Uint8Array;
+    newPublicKey: Uint8Array;
+    oldSignature: Uint8Array;
+    newSignature: Uint8Array;
+}
+declare const MsgRotatePQCKey: MessageFns$j<MsgRotatePQCKey>;
+interface MsgRotatePQCKeyResponse {
+}
+declare const MsgRotatePQCKeyResponse: MessageFns$j<MsgRotatePQCKeyResponse>;
 /** MsgDeprecateAlgorithm proposes deprecating an algorithm (starts migration period). */
 interface MsgDeprecateAlgorithm {
     authority: string;
@@ -3786,6 +4260,20 @@ declare const MsgDefinition$5: {
             readonly responseStream: false;
             readonly options: {};
         };
+        /**
+         * RotatePQCKey replaces an account's PQC key with a NEW key of the SAME
+         * algorithm — for rotating a compromised key or moving a legacy-derived key to
+         * the canonical derivation. Dual-signed (old proves ownership, new proves
+         * control); needs no active algorithm migration.
+         */
+        readonly rotatePQCKey: {
+            readonly name: "RotatePQCKey";
+            readonly requestType: typeof MsgRotatePQCKey;
+            readonly requestStream: false;
+            readonly responseType: typeof MsgRotatePQCKeyResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
         /** DeprecateAlgorithm starts the migration period for an algorithm (governance). */
         readonly deprecateAlgorithm: {
             readonly name: "DeprecateAlgorithm";
@@ -3829,8 +4317,10 @@ declare const tx$5_MsgRegisterPQCKey: typeof MsgRegisterPQCKey;
 declare const tx$5_MsgRegisterPQCKeyResponse: typeof MsgRegisterPQCKeyResponse;
 declare const tx$5_MsgRegisterPQCKeyV2: typeof MsgRegisterPQCKeyV2;
 declare const tx$5_MsgRegisterPQCKeyV2Response: typeof MsgRegisterPQCKeyV2Response;
+declare const tx$5_MsgRotatePQCKey: typeof MsgRotatePQCKey;
+declare const tx$5_MsgRotatePQCKeyResponse: typeof MsgRotatePQCKeyResponse;
 declare namespace tx$5 {
-  export { type DeepPartial$j as DeepPartial, type MessageFns$j as MessageFns, MsgDefinition$5 as MsgDefinition, tx$5_MsgDeprecateAlgorithm as MsgDeprecateAlgorithm, tx$5_MsgDeprecateAlgorithmResponse as MsgDeprecateAlgorithmResponse, tx$5_MsgDisableAlgorithm as MsgDisableAlgorithm, tx$5_MsgDisableAlgorithmResponse as MsgDisableAlgorithmResponse, tx$5_MsgMigratePQCKey as MsgMigratePQCKey, tx$5_MsgMigratePQCKeyResponse as MsgMigratePQCKeyResponse, tx$5_MsgRegisterPQCKey as MsgRegisterPQCKey, tx$5_MsgRegisterPQCKeyResponse as MsgRegisterPQCKeyResponse, tx$5_MsgRegisterPQCKeyV2 as MsgRegisterPQCKeyV2, tx$5_MsgRegisterPQCKeyV2Response as MsgRegisterPQCKeyV2Response, protobufPackage$j as protobufPackage };
+  export { type DeepPartial$j as DeepPartial, type MessageFns$j as MessageFns, MsgDefinition$5 as MsgDefinition, tx$5_MsgDeprecateAlgorithm as MsgDeprecateAlgorithm, tx$5_MsgDeprecateAlgorithmResponse as MsgDeprecateAlgorithmResponse, tx$5_MsgDisableAlgorithm as MsgDisableAlgorithm, tx$5_MsgDisableAlgorithmResponse as MsgDisableAlgorithmResponse, tx$5_MsgMigratePQCKey as MsgMigratePQCKey, tx$5_MsgMigratePQCKeyResponse as MsgMigratePQCKeyResponse, tx$5_MsgRegisterPQCKey as MsgRegisterPQCKey, tx$5_MsgRegisterPQCKeyResponse as MsgRegisterPQCKeyResponse, tx$5_MsgRegisterPQCKeyV2 as MsgRegisterPQCKeyV2, tx$5_MsgRegisterPQCKeyV2Response as MsgRegisterPQCKeyV2Response, tx$5_MsgRotatePQCKey as MsgRotatePQCKey, tx$5_MsgRotatePQCKeyResponse as MsgRotatePQCKeyResponse, protobufPackage$j as protobufPackage };
 }
 
 declare const protobufPackage$i = "qorechain.lightnode.v1";
@@ -4098,6 +4588,79 @@ declare const MsgRevokeAuthenticator: MessageFns$g<MsgRevokeAuthenticator>;
 interface MsgRevokeAuthenticatorResponse {
 }
 declare const MsgRevokeAuthenticatorResponse: MessageFns$g<MsgRevokeAuthenticatorResponse>;
+/**
+ * MsgExecuteEVM executes an EVM call/transfer authorized by a linked
+ * authenticator (v3.1.85). The relayer submits + pays fees; the authenticator
+ * (scheme,pubkey) signs the domain-separated sign-bytes binding chain-id, the
+ * canonical account, the pubkey, to/value/data and the account's expected EVM
+ * nonce (replay protection — the nonce must equal the account's current EVM
+ * nonce, and executing the call increments it, so a signature cannot be replayed).
+ * The chain resolves the authenticator, checks the "evm" permission + SpendingRule
+ * against `value`, then executes the call FROM the canonical account's EVM address.
+ */
+interface MsgExecuteEVM {
+    relayer: string;
+    /** bech32 canonical account (the authenticator's owner) */
+    account: string;
+    /** "ed25519" | "secp256k1" */
+    scheme: string;
+    /** authenticator public key */
+    pubkey: Uint8Array;
+    /** authenticator signature over the EVM auth sign-bytes */
+    signature: Uint8Array;
+    /** 0x-hex recipient/contract; empty = contract create */
+    to: string;
+    /** native QOR amount in wei (aqor), decimal string */
+    value: string;
+    /** EVM calldata */
+    data: Uint8Array;
+    gasLimit: string;
+    /** MUST equal the account's current EVM nonce */
+    nonce: string;
+}
+declare const MsgExecuteEVM: MessageFns$g<MsgExecuteEVM>;
+interface MsgExecuteEVMResponse {
+    success: boolean;
+    ret: Uint8Array;
+    gasUsed: string;
+    vmError: string;
+}
+declare const MsgExecuteEVMResponse: MessageFns$g<MsgExecuteEVMResponse>;
+/**
+ * MsgExecuteCosmos executes a Native-lane (Cosmos) bank transfer authorized by a
+ * linked authenticator (v3.1.85). It is the Native counterpart of MsgExecuteEVM:
+ * the relayer submits + pays fees and signs the outer tx (so the account's own
+ * PQC-required signature is not needed — the relayer's hybrid-PQC signature
+ * satisfies the ante on the envelope), while the authenticator (scheme,pubkey)
+ * signs the domain-separated sign-bytes binding chain-id, the canonical account,
+ * the pubkey, the recipient, the amount and a per-authenticator sequence (replay:
+ * nonce must equal the account+key's current sequence, incremented on success).
+ * The chain resolves the authenticator, checks the "send" permission + SpendingRule
+ * against `amount`, then moves the coins FROM the canonical account via x/bank.
+ * This lets an external key (Phantom ed25519 / EVM secp256k1) spend native QOR from
+ * a PQC-required account under least-privilege, spend-limited, revocable terms.
+ */
+interface MsgExecuteCosmos {
+    relayer: string;
+    /** bech32 canonical account (the authenticator's owner) */
+    account: string;
+    /** "ed25519" | "secp256k1" */
+    scheme: string;
+    /** authenticator public key */
+    pubkey: Uint8Array;
+    /** authenticator signature over the Cosmos auth sign-bytes */
+    signature: Uint8Array;
+    /** bech32 recipient */
+    to: string;
+    amount: Coin[];
+    /** MUST equal the account+key's current authenticator sequence */
+    nonce: string;
+}
+declare const MsgExecuteCosmos: MessageFns$g<MsgExecuteCosmos>;
+interface MsgExecuteCosmosResponse {
+    success: boolean;
+}
+declare const MsgExecuteCosmosResponse: MessageFns$g<MsgExecuteCosmosResponse>;
 /** Msg defines the abstractaccount module's transaction service. */
 type MsgDefinition$2 = typeof MsgDefinition$2;
 declare const MsgDefinition$2: {
@@ -4136,6 +4699,22 @@ declare const MsgDefinition$2: {
             readonly responseStream: false;
             readonly options: {};
         };
+        readonly executeEVM: {
+            readonly name: "ExecuteEVM";
+            readonly requestType: typeof MsgExecuteEVM;
+            readonly requestStream: false;
+            readonly responseType: typeof MsgExecuteEVMResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly executeCosmos: {
+            readonly name: "ExecuteCosmos";
+            readonly requestType: typeof MsgExecuteCosmos;
+            readonly requestStream: false;
+            readonly responseType: typeof MsgExecuteCosmosResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
     };
 };
 type Builtin$g = Date | Function | Uint8Array | string | number | boolean | undefined;
@@ -4153,6 +4732,10 @@ interface MessageFns$g<T> {
 
 declare const tx$2_MsgCreateAbstractAccount: typeof MsgCreateAbstractAccount;
 declare const tx$2_MsgCreateAbstractAccountResponse: typeof MsgCreateAbstractAccountResponse;
+declare const tx$2_MsgExecuteCosmos: typeof MsgExecuteCosmos;
+declare const tx$2_MsgExecuteCosmosResponse: typeof MsgExecuteCosmosResponse;
+declare const tx$2_MsgExecuteEVM: typeof MsgExecuteEVM;
+declare const tx$2_MsgExecuteEVMResponse: typeof MsgExecuteEVMResponse;
 declare const tx$2_MsgRegisterAuthenticator: typeof MsgRegisterAuthenticator;
 declare const tx$2_MsgRegisterAuthenticatorResponse: typeof MsgRegisterAuthenticatorResponse;
 declare const tx$2_MsgRevokeAuthenticator: typeof MsgRevokeAuthenticator;
@@ -4161,21 +4744,41 @@ declare const tx$2_MsgUpdateSpendingRules: typeof MsgUpdateSpendingRules;
 declare const tx$2_MsgUpdateSpendingRulesResponse: typeof MsgUpdateSpendingRulesResponse;
 declare const tx$2_SpendingRule: typeof SpendingRule;
 declare namespace tx$2 {
-  export { type DeepPartial$g as DeepPartial, type MessageFns$g as MessageFns, tx$2_MsgCreateAbstractAccount as MsgCreateAbstractAccount, tx$2_MsgCreateAbstractAccountResponse as MsgCreateAbstractAccountResponse, MsgDefinition$2 as MsgDefinition, tx$2_MsgRegisterAuthenticator as MsgRegisterAuthenticator, tx$2_MsgRegisterAuthenticatorResponse as MsgRegisterAuthenticatorResponse, tx$2_MsgRevokeAuthenticator as MsgRevokeAuthenticator, tx$2_MsgRevokeAuthenticatorResponse as MsgRevokeAuthenticatorResponse, tx$2_MsgUpdateSpendingRules as MsgUpdateSpendingRules, tx$2_MsgUpdateSpendingRulesResponse as MsgUpdateSpendingRulesResponse, tx$2_SpendingRule as SpendingRule, protobufPackage$g as protobufPackage };
+  export { type DeepPartial$g as DeepPartial, type MessageFns$g as MessageFns, tx$2_MsgCreateAbstractAccount as MsgCreateAbstractAccount, tx$2_MsgCreateAbstractAccountResponse as MsgCreateAbstractAccountResponse, MsgDefinition$2 as MsgDefinition, tx$2_MsgExecuteCosmos as MsgExecuteCosmos, tx$2_MsgExecuteCosmosResponse as MsgExecuteCosmosResponse, tx$2_MsgExecuteEVM as MsgExecuteEVM, tx$2_MsgExecuteEVMResponse as MsgExecuteEVMResponse, tx$2_MsgRegisterAuthenticator as MsgRegisterAuthenticator, tx$2_MsgRegisterAuthenticatorResponse as MsgRegisterAuthenticatorResponse, tx$2_MsgRevokeAuthenticator as MsgRevokeAuthenticator, tx$2_MsgRevokeAuthenticatorResponse as MsgRevokeAuthenticatorResponse, tx$2_MsgUpdateSpendingRules as MsgUpdateSpendingRules, tx$2_MsgUpdateSpendingRulesResponse as MsgUpdateSpendingRulesResponse, tx$2_SpendingRule as SpendingRule, protobufPackage$g as protobufPackage };
 }
 
 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 {
@@ -4191,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;
@@ -4430,6 +5037,14 @@ declare const pqc: {
     migratePqcKey: (value: PartialMsg<MsgMigratePQCKey>) => EncodeObject;
     deprecateAlgorithm: (value: PartialMsg<MsgDeprecateAlgorithm>) => EncodeObject;
     disableAlgorithm: (value: PartialMsg<MsgDisableAlgorithm>) => EncodeObject;
+    /**
+     * Replace an account's PQC key with a NEW key of the SAME algorithm (rotate a
+     * compromised key, or migrate a legacy-derived key to the canonical
+     * derivation). Dual-signed over the domain-separated rotation bytes (the old
+     * key proves ownership, the new key proves control). Sender-signed; broadcast
+     * BY the account, cosigned (hybrid) with the OLD key.
+     */
+    rotatePqcKey: (value: PartialMsg<MsgRotatePQCKey>) => EncodeObject;
 };
 /** SVM (virtual machine programs/accounts) message composers. */
 declare const svm: {
@@ -4437,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: {
@@ -4464,6 +5090,20 @@ declare const abstractaccount: {
     registerAuthenticator: (value: PartialMsg<MsgRegisterAuthenticator>) => EncodeObject;
     /** Instantly disable a previously linked wallet key. Owner-signed. */
     revokeAuthenticator: (value: PartialMsg<MsgRevokeAuthenticator>) => EncodeObject;
+    /**
+     * EVM-lane spend: execute an EVM call/transfer FROM the canonical account's
+     * 0x address, authorized by a linked authenticator's signature over the EVM
+     * auth sign-bytes. Relayer-signed (it submits + pays fees). See
+     * {@link ../tx/authenticator.evmAuthSignBytes}.
+     */
+    executeEvm: (value: PartialMsg<MsgExecuteEVM>) => EncodeObject;
+    /**
+     * Native-lane spend: move native QOR FROM the canonical account via x/bank,
+     * authorized by a linked authenticator's signature over the Cosmos auth
+     * sign-bytes. Relayer-signed (it submits + pays fees). See
+     * {@link ../tx/authenticator.cosmosAuthSignBytes}.
+     */
+    executeCosmos: (value: PartialMsg<MsgExecuteCosmos>) => EncodeObject;
 };
 /** Cross-VM message composers. */
 declare const crossvm: {
@@ -6041,11 +6681,9 @@ declare const msg: {
             algorithmId?: number | undefined;
             reason?: string | undefined;
         }) => _cosmjs_proto_signing.EncodeObject;
-    };
-    readonly svm: {
-        deployProgram: (value: {
+        rotatePqcKey: (value: {
             sender?: string | undefined;
-            bytecode?: {
+            oldPublicKey?: {
                 [x: number]: number | undefined;
                 readonly BYTES_PER_ELEMENT?: number | undefined;
                 readonly buffer?: ({
@@ -6090,10 +6728,7 @@ declare const msg: {
                 [Symbol.iterator]?: {} | undefined;
                 readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
             } | undefined;
-        }) => _cosmjs_proto_signing.EncodeObject;
-        createAccount: (value: {
-            sender?: string | undefined;
-            owner?: {
+            newPublicKey?: {
                 [x: number]: number | undefined;
                 readonly BYTES_PER_ELEMENT?: number | undefined;
                 readonly buffer?: ({
@@ -6138,9 +6773,7 @@ declare const msg: {
                 [Symbol.iterator]?: {} | undefined;
                 readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
             } | undefined;
-            space?: string | undefined;
-            lamports?: string | undefined;
-            salt?: {
+            oldSignature?: {
                 [x: number]: number | undefined;
                 readonly BYTES_PER_ELEMENT?: number | undefined;
                 readonly buffer?: ({
@@ -6185,10 +6818,7 @@ declare const msg: {
                 [Symbol.iterator]?: {} | undefined;
                 readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
             } | undefined;
-        }) => _cosmjs_proto_signing.EncodeObject;
-        executeProgram: (value: {
-            sender?: string | undefined;
-            programId?: {
+            newSignature?: {
                 [x: number]: number | undefined;
                 readonly BYTES_PER_ELEMENT?: number | undefined;
                 readonly buffer?: ({
@@ -6233,48 +6863,241 @@ declare const msg: {
                 [Symbol.iterator]?: {} | undefined;
                 readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
             } | undefined;
-            accounts?: ({
-                address?: {
-                    [x: number]: number | undefined;
-                    readonly BYTES_PER_ELEMENT?: number | undefined;
-                    readonly buffer?: ({
-                        readonly byteLength?: number | undefined;
-                        slice?: {} | undefined;
-                        readonly [Symbol.toStringTag]?: "ArrayBuffer" | undefined;
-                    } | {
-                        readonly byteLength?: number | undefined;
-                        slice?: {} | undefined;
-                        readonly [Symbol.toStringTag]?: "SharedArrayBuffer" | undefined;
-                    }) | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+    };
+    readonly svm: {
+        deployProgram: (value: {
+            sender?: string | undefined;
+            bytecode?: {
+                [x: number]: number | undefined;
+                readonly BYTES_PER_ELEMENT?: number | undefined;
+                readonly buffer?: ({
                     readonly byteLength?: number | undefined;
-                    readonly byteOffset?: number | undefined;
-                    copyWithin?: {} | undefined;
-                    every?: {} | undefined;
-                    fill?: {} | undefined;
-                    filter?: {} | undefined;
-                    find?: {} | undefined;
-                    findIndex?: {} | undefined;
-                    forEach?: {} | undefined;
-                    indexOf?: {} | undefined;
-                    join?: {} | undefined;
-                    lastIndexOf?: {} | undefined;
-                    readonly length?: number | undefined;
-                    map?: {} | undefined;
-                    reduce?: {} | undefined;
-                    reduceRight?: {} | undefined;
-                    reverse?: {} | undefined;
-                    set?: {} | undefined;
                     slice?: {} | undefined;
-                    some?: {} | undefined;
-                    sort?: {} | undefined;
-                    subarray?: {} | undefined;
-                    toLocaleString?: {} | undefined;
-                    toString?: {} | undefined;
-                    valueOf?: {} | undefined;
-                    entries?: {} | undefined;
-                    keys?: {} | undefined;
-                    values?: {} | undefined;
-                    includes?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "ArrayBuffer" | undefined;
+                } | {
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "SharedArrayBuffer" | undefined;
+                }) | undefined;
+                readonly byteLength?: number | undefined;
+                readonly byteOffset?: number | undefined;
+                copyWithin?: {} | undefined;
+                every?: {} | undefined;
+                fill?: {} | undefined;
+                filter?: {} | undefined;
+                find?: {} | undefined;
+                findIndex?: {} | undefined;
+                forEach?: {} | undefined;
+                indexOf?: {} | undefined;
+                join?: {} | undefined;
+                lastIndexOf?: {} | undefined;
+                readonly length?: number | undefined;
+                map?: {} | undefined;
+                reduce?: {} | undefined;
+                reduceRight?: {} | undefined;
+                reverse?: {} | undefined;
+                set?: {} | undefined;
+                slice?: {} | undefined;
+                some?: {} | undefined;
+                sort?: {} | undefined;
+                subarray?: {} | undefined;
+                toLocaleString?: {} | undefined;
+                toString?: {} | undefined;
+                valueOf?: {} | undefined;
+                entries?: {} | undefined;
+                keys?: {} | undefined;
+                values?: {} | undefined;
+                includes?: {} | undefined;
+                at?: {} | undefined;
+                [Symbol.iterator]?: {} | undefined;
+                readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
+            } | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+        createAccount: (value: {
+            sender?: string | undefined;
+            owner?: {
+                [x: number]: number | undefined;
+                readonly BYTES_PER_ELEMENT?: number | undefined;
+                readonly buffer?: ({
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "ArrayBuffer" | undefined;
+                } | {
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "SharedArrayBuffer" | undefined;
+                }) | undefined;
+                readonly byteLength?: number | undefined;
+                readonly byteOffset?: number | undefined;
+                copyWithin?: {} | undefined;
+                every?: {} | undefined;
+                fill?: {} | undefined;
+                filter?: {} | undefined;
+                find?: {} | undefined;
+                findIndex?: {} | undefined;
+                forEach?: {} | undefined;
+                indexOf?: {} | undefined;
+                join?: {} | undefined;
+                lastIndexOf?: {} | undefined;
+                readonly length?: number | undefined;
+                map?: {} | undefined;
+                reduce?: {} | undefined;
+                reduceRight?: {} | undefined;
+                reverse?: {} | undefined;
+                set?: {} | undefined;
+                slice?: {} | undefined;
+                some?: {} | undefined;
+                sort?: {} | undefined;
+                subarray?: {} | undefined;
+                toLocaleString?: {} | undefined;
+                toString?: {} | undefined;
+                valueOf?: {} | undefined;
+                entries?: {} | undefined;
+                keys?: {} | undefined;
+                values?: {} | undefined;
+                includes?: {} | undefined;
+                at?: {} | undefined;
+                [Symbol.iterator]?: {} | undefined;
+                readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
+            } | undefined;
+            space?: string | undefined;
+            lamports?: string | undefined;
+            salt?: {
+                [x: number]: number | undefined;
+                readonly BYTES_PER_ELEMENT?: number | undefined;
+                readonly buffer?: ({
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "ArrayBuffer" | undefined;
+                } | {
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "SharedArrayBuffer" | undefined;
+                }) | undefined;
+                readonly byteLength?: number | undefined;
+                readonly byteOffset?: number | undefined;
+                copyWithin?: {} | undefined;
+                every?: {} | undefined;
+                fill?: {} | undefined;
+                filter?: {} | undefined;
+                find?: {} | undefined;
+                findIndex?: {} | undefined;
+                forEach?: {} | undefined;
+                indexOf?: {} | undefined;
+                join?: {} | undefined;
+                lastIndexOf?: {} | undefined;
+                readonly length?: number | undefined;
+                map?: {} | undefined;
+                reduce?: {} | undefined;
+                reduceRight?: {} | undefined;
+                reverse?: {} | undefined;
+                set?: {} | undefined;
+                slice?: {} | undefined;
+                some?: {} | undefined;
+                sort?: {} | undefined;
+                subarray?: {} | undefined;
+                toLocaleString?: {} | undefined;
+                toString?: {} | undefined;
+                valueOf?: {} | undefined;
+                entries?: {} | undefined;
+                keys?: {} | undefined;
+                values?: {} | undefined;
+                includes?: {} | undefined;
+                at?: {} | undefined;
+                [Symbol.iterator]?: {} | undefined;
+                readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
+            } | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+        executeProgram: (value: {
+            sender?: string | undefined;
+            programId?: {
+                [x: number]: number | undefined;
+                readonly BYTES_PER_ELEMENT?: number | undefined;
+                readonly buffer?: ({
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "ArrayBuffer" | undefined;
+                } | {
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "SharedArrayBuffer" | undefined;
+                }) | undefined;
+                readonly byteLength?: number | undefined;
+                readonly byteOffset?: number | undefined;
+                copyWithin?: {} | undefined;
+                every?: {} | undefined;
+                fill?: {} | undefined;
+                filter?: {} | undefined;
+                find?: {} | undefined;
+                findIndex?: {} | undefined;
+                forEach?: {} | undefined;
+                indexOf?: {} | undefined;
+                join?: {} | undefined;
+                lastIndexOf?: {} | undefined;
+                readonly length?: number | undefined;
+                map?: {} | undefined;
+                reduce?: {} | undefined;
+                reduceRight?: {} | undefined;
+                reverse?: {} | undefined;
+                set?: {} | undefined;
+                slice?: {} | undefined;
+                some?: {} | undefined;
+                sort?: {} | undefined;
+                subarray?: {} | undefined;
+                toLocaleString?: {} | undefined;
+                toString?: {} | undefined;
+                valueOf?: {} | undefined;
+                entries?: {} | undefined;
+                keys?: {} | undefined;
+                values?: {} | undefined;
+                includes?: {} | undefined;
+                at?: {} | undefined;
+                [Symbol.iterator]?: {} | undefined;
+                readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
+            } | undefined;
+            accounts?: ({
+                address?: {
+                    [x: number]: number | undefined;
+                    readonly BYTES_PER_ELEMENT?: number | undefined;
+                    readonly buffer?: ({
+                        readonly byteLength?: number | undefined;
+                        slice?: {} | undefined;
+                        readonly [Symbol.toStringTag]?: "ArrayBuffer" | undefined;
+                    } | {
+                        readonly byteLength?: number | undefined;
+                        slice?: {} | undefined;
+                        readonly [Symbol.toStringTag]?: "SharedArrayBuffer" | undefined;
+                    }) | undefined;
+                    readonly byteLength?: number | undefined;
+                    readonly byteOffset?: number | undefined;
+                    copyWithin?: {} | undefined;
+                    every?: {} | undefined;
+                    fill?: {} | undefined;
+                    filter?: {} | undefined;
+                    find?: {} | undefined;
+                    findIndex?: {} | undefined;
+                    forEach?: {} | undefined;
+                    indexOf?: {} | undefined;
+                    join?: {} | undefined;
+                    lastIndexOf?: {} | undefined;
+                    readonly length?: number | undefined;
+                    map?: {} | undefined;
+                    reduce?: {} | undefined;
+                    reduceRight?: {} | undefined;
+                    reverse?: {} | undefined;
+                    set?: {} | undefined;
+                    slice?: {} | undefined;
+                    some?: {} | undefined;
+                    sort?: {} | undefined;
+                    subarray?: {} | undefined;
+                    toLocaleString?: {} | undefined;
+                    toString?: {} | undefined;
+                    valueOf?: {} | undefined;
+                    entries?: {} | undefined;
+                    keys?: {} | undefined;
+                    values?: {} | undefined;
+                    includes?: {} | undefined;
                     at?: {} | undefined;
                     [Symbol.iterator]?: {} | undefined;
                     readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
@@ -6327,11 +7150,316 @@ declare const msg: {
                 [Symbol.iterator]?: {} | undefined;
                 readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
             } | undefined;
-            auth?: SVMAuth | undefined;
-        }) => _cosmjs_proto_signing.EncodeObject;
-        registerSvmPqcKey: (value: {
-            sender?: string | undefined;
-            svmAddr?: {
+            auth?: SVMAuth | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+        registerSvmPqcKey: (value: {
+            sender?: string | undefined;
+            svmAddr?: {
+                [x: number]: number | undefined;
+                readonly BYTES_PER_ELEMENT?: number | undefined;
+                readonly buffer?: ({
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "ArrayBuffer" | undefined;
+                } | {
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "SharedArrayBuffer" | undefined;
+                }) | undefined;
+                readonly byteLength?: number | undefined;
+                readonly byteOffset?: number | undefined;
+                copyWithin?: {} | undefined;
+                every?: {} | undefined;
+                fill?: {} | undefined;
+                filter?: {} | undefined;
+                find?: {} | undefined;
+                findIndex?: {} | undefined;
+                forEach?: {} | undefined;
+                indexOf?: {} | undefined;
+                join?: {} | undefined;
+                lastIndexOf?: {} | undefined;
+                readonly length?: number | undefined;
+                map?: {} | undefined;
+                reduce?: {} | undefined;
+                reduceRight?: {} | undefined;
+                reverse?: {} | undefined;
+                set?: {} | undefined;
+                slice?: {} | undefined;
+                some?: {} | undefined;
+                sort?: {} | undefined;
+                subarray?: {} | undefined;
+                toLocaleString?: {} | undefined;
+                toString?: {} | undefined;
+                valueOf?: {} | undefined;
+                entries?: {} | undefined;
+                keys?: {} | undefined;
+                values?: {} | undefined;
+                includes?: {} | undefined;
+                at?: {} | undefined;
+                [Symbol.iterator]?: {} | undefined;
+                readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
+            } | undefined;
+            pqcPubKey?: {
+                [x: number]: number | undefined;
+                readonly BYTES_PER_ELEMENT?: number | undefined;
+                readonly buffer?: ({
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "ArrayBuffer" | undefined;
+                } | {
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "SharedArrayBuffer" | undefined;
+                }) | undefined;
+                readonly byteLength?: number | undefined;
+                readonly byteOffset?: number | undefined;
+                copyWithin?: {} | undefined;
+                every?: {} | undefined;
+                fill?: {} | undefined;
+                filter?: {} | undefined;
+                find?: {} | undefined;
+                findIndex?: {} | undefined;
+                forEach?: {} | undefined;
+                indexOf?: {} | undefined;
+                join?: {} | undefined;
+                lastIndexOf?: {} | undefined;
+                readonly length?: number | undefined;
+                map?: {} | undefined;
+                reduce?: {} | undefined;
+                reduceRight?: {} | undefined;
+                reverse?: {} | undefined;
+                set?: {} | undefined;
+                slice?: {} | undefined;
+                some?: {} | undefined;
+                sort?: {} | undefined;
+                subarray?: {} | undefined;
+                toLocaleString?: {} | undefined;
+                toString?: {} | undefined;
+                valueOf?: {} | undefined;
+                entries?: {} | undefined;
+                keys?: {} | undefined;
+                values?: {} | undefined;
+                includes?: {} | undefined;
+                at?: {} | undefined;
+                [Symbol.iterator]?: {} | undefined;
+                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: {
+            operator?: string | undefined;
+            nodeType?: string | undefined;
+            version?: string | undefined;
+            capabilities?: (string | undefined)[] | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+        heartbeat: (value: {
+            operator?: string | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+        deregisterLightNode: (value: {
+            operator?: string | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+        claimLightNodeRewards: (value: {
+            operator?: string | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+    };
+    readonly license: {
+        grantLicense: (value: {
+            authority?: string | undefined;
+            grantee?: string | undefined;
+            featureId?: string | undefined;
+            expiresAt?: string | undefined;
+            metadata?: string | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+        revokeLicense: (value: {
+            authority?: string | undefined;
+            grantee?: string | undefined;
+            featureId?: string | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+        suspendLicense: (value: {
+            authority?: string | undefined;
+            grantee?: string | undefined;
+            featureId?: string | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+        resumeLicense: (value: {
+            authority?: string | undefined;
+            grantee?: string | undefined;
+            featureId?: string | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+    };
+    readonly abstractaccount: {
+        createAbstractAccount: (value: {
+            owner?: string | undefined;
+            accountType?: string | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+        updateSpendingRules: (value: {
+            owner?: string | undefined;
+            accountAddress?: string | undefined;
+            rules?: ({
+                id?: string | undefined;
+                dailyLimit?: string | undefined;
+                perTxLimit?: string | undefined;
+                allowedDenoms?: (string | undefined)[] | undefined;
+                enabled?: boolean | undefined;
+            } | undefined)[] | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+        registerAuthenticator: (value: {
+            owner?: string | undefined;
+            accountAddress?: string | undefined;
+            scheme?: string | undefined;
+            pubkey?: {
+                [x: number]: number | undefined;
+                readonly BYTES_PER_ELEMENT?: number | undefined;
+                readonly buffer?: ({
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "ArrayBuffer" | undefined;
+                } | {
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "SharedArrayBuffer" | undefined;
+                }) | undefined;
+                readonly byteLength?: number | undefined;
+                readonly byteOffset?: number | undefined;
+                copyWithin?: {} | undefined;
+                every?: {} | undefined;
+                fill?: {} | undefined;
+                filter?: {} | undefined;
+                find?: {} | undefined;
+                findIndex?: {} | undefined;
+                forEach?: {} | undefined;
+                indexOf?: {} | undefined;
+                join?: {} | undefined;
+                lastIndexOf?: {} | undefined;
+                readonly length?: number | undefined;
+                map?: {} | undefined;
+                reduce?: {} | undefined;
+                reduceRight?: {} | undefined;
+                reverse?: {} | undefined;
+                set?: {} | undefined;
+                slice?: {} | undefined;
+                some?: {} | undefined;
+                sort?: {} | undefined;
+                subarray?: {} | undefined;
+                toLocaleString?: {} | undefined;
+                toString?: {} | undefined;
+                valueOf?: {} | undefined;
+                entries?: {} | undefined;
+                keys?: {} | undefined;
+                values?: {} | undefined;
+                includes?: {} | undefined;
+                at?: {} | undefined;
+                [Symbol.iterator]?: {} | undefined;
+                readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
+            } | undefined;
+            permissions?: (string | undefined)[] | undefined;
+            expiryUnix?: string | undefined;
+            label?: string | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+        revokeAuthenticator: (value: {
+            owner?: string | undefined;
+            accountAddress?: string | undefined;
+            scheme?: string | undefined;
+            pubkey?: {
+                [x: number]: number | undefined;
+                readonly BYTES_PER_ELEMENT?: number | undefined;
+                readonly buffer?: ({
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "ArrayBuffer" | undefined;
+                } | {
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "SharedArrayBuffer" | undefined;
+                }) | undefined;
+                readonly byteLength?: number | undefined;
+                readonly byteOffset?: number | undefined;
+                copyWithin?: {} | undefined;
+                every?: {} | undefined;
+                fill?: {} | undefined;
+                filter?: {} | undefined;
+                find?: {} | undefined;
+                findIndex?: {} | undefined;
+                forEach?: {} | undefined;
+                indexOf?: {} | undefined;
+                join?: {} | undefined;
+                lastIndexOf?: {} | undefined;
+                readonly length?: number | undefined;
+                map?: {} | undefined;
+                reduce?: {} | undefined;
+                reduceRight?: {} | undefined;
+                reverse?: {} | undefined;
+                set?: {} | undefined;
+                slice?: {} | undefined;
+                some?: {} | undefined;
+                sort?: {} | undefined;
+                subarray?: {} | undefined;
+                toLocaleString?: {} | undefined;
+                toString?: {} | undefined;
+                valueOf?: {} | undefined;
+                entries?: {} | undefined;
+                keys?: {} | undefined;
+                values?: {} | undefined;
+                includes?: {} | undefined;
+                at?: {} | undefined;
+                [Symbol.iterator]?: {} | undefined;
+                readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
+            } | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+        executeEvm: (value: {
+            relayer?: string | undefined;
+            account?: string | undefined;
+            scheme?: string | undefined;
+            pubkey?: {
+                [x: number]: number | undefined;
+                readonly BYTES_PER_ELEMENT?: number | undefined;
+                readonly buffer?: ({
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "ArrayBuffer" | undefined;
+                } | {
+                    readonly byteLength?: number | undefined;
+                    slice?: {} | undefined;
+                    readonly [Symbol.toStringTag]?: "SharedArrayBuffer" | undefined;
+                }) | undefined;
+                readonly byteLength?: number | undefined;
+                readonly byteOffset?: number | undefined;
+                copyWithin?: {} | undefined;
+                every?: {} | undefined;
+                fill?: {} | undefined;
+                filter?: {} | undefined;
+                find?: {} | undefined;
+                findIndex?: {} | undefined;
+                forEach?: {} | undefined;
+                indexOf?: {} | undefined;
+                join?: {} | undefined;
+                lastIndexOf?: {} | undefined;
+                readonly length?: number | undefined;
+                map?: {} | undefined;
+                reduce?: {} | undefined;
+                reduceRight?: {} | undefined;
+                reverse?: {} | undefined;
+                set?: {} | undefined;
+                slice?: {} | undefined;
+                some?: {} | undefined;
+                sort?: {} | undefined;
+                subarray?: {} | undefined;
+                toLocaleString?: {} | undefined;
+                toString?: {} | undefined;
+                valueOf?: {} | undefined;
+                entries?: {} | undefined;
+                keys?: {} | undefined;
+                values?: {} | undefined;
+                includes?: {} | undefined;
+                at?: {} | undefined;
+                [Symbol.iterator]?: {} | undefined;
+                readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
+            } | undefined;
+            signature?: {
                 [x: number]: number | undefined;
                 readonly BYTES_PER_ELEMENT?: number | undefined;
                 readonly buffer?: ({
@@ -6376,7 +7504,9 @@ declare const msg: {
                 [Symbol.iterator]?: {} | undefined;
                 readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
             } | undefined;
-            pqcPubKey?: {
+            to?: string | undefined;
+            value?: string | undefined;
+            data?: {
                 [x: number]: number | undefined;
                 readonly BYTES_PER_ELEMENT?: number | undefined;
                 readonly buffer?: ({
@@ -6421,68 +7551,12 @@ declare const msg: {
                 [Symbol.iterator]?: {} | undefined;
                 readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
             } | undefined;
+            gasLimit?: string | undefined;
+            nonce?: string | undefined;
         }) => _cosmjs_proto_signing.EncodeObject;
-    };
-    readonly lightnode: {
-        registerLightNode: (value: {
-            operator?: string | undefined;
-            nodeType?: string | undefined;
-            version?: string | undefined;
-            capabilities?: (string | undefined)[] | undefined;
-        }) => _cosmjs_proto_signing.EncodeObject;
-        heartbeat: (value: {
-            operator?: string | undefined;
-        }) => _cosmjs_proto_signing.EncodeObject;
-        deregisterLightNode: (value: {
-            operator?: string | undefined;
-        }) => _cosmjs_proto_signing.EncodeObject;
-        claimLightNodeRewards: (value: {
-            operator?: string | undefined;
-        }) => _cosmjs_proto_signing.EncodeObject;
-    };
-    readonly license: {
-        grantLicense: (value: {
-            authority?: string | undefined;
-            grantee?: string | undefined;
-            featureId?: string | undefined;
-            expiresAt?: string | undefined;
-            metadata?: string | undefined;
-        }) => _cosmjs_proto_signing.EncodeObject;
-        revokeLicense: (value: {
-            authority?: string | undefined;
-            grantee?: string | undefined;
-            featureId?: string | undefined;
-        }) => _cosmjs_proto_signing.EncodeObject;
-        suspendLicense: (value: {
-            authority?: string | undefined;
-            grantee?: string | undefined;
-            featureId?: string | undefined;
-        }) => _cosmjs_proto_signing.EncodeObject;
-        resumeLicense: (value: {
-            authority?: string | undefined;
-            grantee?: string | undefined;
-            featureId?: string | undefined;
-        }) => _cosmjs_proto_signing.EncodeObject;
-    };
-    readonly abstractaccount: {
-        createAbstractAccount: (value: {
-            owner?: string | undefined;
-            accountType?: string | undefined;
-        }) => _cosmjs_proto_signing.EncodeObject;
-        updateSpendingRules: (value: {
-            owner?: string | undefined;
-            accountAddress?: string | undefined;
-            rules?: ({
-                id?: string | undefined;
-                dailyLimit?: string | undefined;
-                perTxLimit?: string | undefined;
-                allowedDenoms?: (string | undefined)[] | undefined;
-                enabled?: boolean | undefined;
-            } | undefined)[] | undefined;
-        }) => _cosmjs_proto_signing.EncodeObject;
-        registerAuthenticator: (value: {
-            owner?: string | undefined;
-            accountAddress?: string | undefined;
+        executeCosmos: (value: {
+            relayer?: string | undefined;
+            account?: string | undefined;
             scheme?: string | undefined;
             pubkey?: {
                 [x: number]: number | undefined;
@@ -6529,15 +7603,7 @@ declare const msg: {
                 [Symbol.iterator]?: {} | undefined;
                 readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
             } | undefined;
-            permissions?: (string | undefined)[] | undefined;
-            expiryUnix?: string | undefined;
-            label?: string | undefined;
-        }) => _cosmjs_proto_signing.EncodeObject;
-        revokeAuthenticator: (value: {
-            owner?: string | undefined;
-            accountAddress?: string | undefined;
-            scheme?: string | undefined;
-            pubkey?: {
+            signature?: {
                 [x: number]: number | undefined;
                 readonly BYTES_PER_ELEMENT?: number | undefined;
                 readonly buffer?: ({
@@ -6582,6 +7648,12 @@ declare const msg: {
                 [Symbol.iterator]?: {} | undefined;
                 readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
             } | undefined;
+            to?: string | undefined;
+            amount?: ({
+                denom?: string | undefined;
+                amount?: string | undefined;
+            } | undefined)[] | undefined;
+            nonce?: string | undefined;
         }) => _cosmjs_proto_signing.EncodeObject;
     };
     readonly crossvm: {
@@ -6639,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;
@@ -6672,7 +7745,7 @@ declare const protobufPackage$d = "qorechain.pqc.v1";
  * PQCHybridSignature is a transaction extension option carried in
  * TxBody.extension_options. It pairs a post-quantum (Dilithium-5) signature with
  * the account's classical secp256k1 signature so every transaction can be
- * quantum-safe while remaining compatible with the standard Native auth
+ * quantum-safe while remaining compatible with the standard Cosmos SDK auth
  * path. It is registered as a cosmos.tx.v1beta1.TxExtensionOptionI.
  */
 interface PQCHybridSignature {
@@ -6745,6 +7818,30 @@ interface QueryAccountsResponse {
     accounts: AccountView[];
 }
 declare const QueryAccountsResponse: MessageFns$c<QueryAccountsResponse>;
+interface QueryPermissionSchemaRequest {
+}
+declare const QueryPermissionSchemaRequest: MessageFns$c<QueryPermissionSchemaRequest>;
+interface QueryPermissionSchemaResponse {
+    /**
+     * schema_version bumps whenever the taxonomy or the mapping changes; clients
+     * compare it to their embedded copy to detect drift.
+     */
+    schemaVersion: string;
+    /** permissions is every valid permission string (e.g. send, evm, svm, all). */
+    permissions: string[];
+    /** msg_permissions maps a message typeURL to the permission it requires. */
+    msgPermissions: {
+        [key: string]: string;
+    };
+    /** key_management_msgs are typeURLs that are NEVER delegable to a linked key. */
+    keyManagementMsgs: string[];
+}
+declare const QueryPermissionSchemaResponse: MessageFns$c<QueryPermissionSchemaResponse>;
+interface QueryPermissionSchemaResponse_MsgPermissionsEntry {
+    key: string;
+    value: string;
+}
+declare const QueryPermissionSchemaResponse_MsgPermissionsEntry: MessageFns$c<QueryPermissionSchemaResponse_MsgPermissionsEntry>;
 /** Query defines the gRPC query service for the abstractaccount module. */
 type QueryDefinition$c = typeof QueryDefinition$c;
 declare const QueryDefinition$c: {
@@ -6758,7 +7855,11 @@ declare const QueryDefinition$c: {
             readonly requestStream: false;
             readonly responseType: typeof QueryConfigResponse$2;
             readonly responseStream: false;
-            readonly options: {};
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
         };
         /** Account returns a single abstract account by address. */
         readonly account: {
@@ -6767,7 +7868,11 @@ declare const QueryDefinition$c: {
             readonly requestStream: false;
             readonly responseType: typeof QueryAccountResponse$2;
             readonly responseStream: false;
-            readonly options: {};
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
         };
         /** Accounts lists all abstract accounts. */
         readonly accounts: {
@@ -6776,7 +7881,28 @@ declare const QueryDefinition$c: {
             readonly requestStream: false;
             readonly responseType: typeof QueryAccountsResponse;
             readonly responseStream: false;
-            readonly options: {};
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
+        };
+        /**
+         * PermissionSchema returns the canonical authenticator permission taxonomy so
+         * clients (QoreX/dashboard/relayer) validate scopes without hardcoding strings
+         * and detect drift via schema_version (v3.1.85).
+         */
+        readonly permissionSchema: {
+            readonly name: "PermissionSchema";
+            readonly requestType: typeof QueryPermissionSchemaRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryPermissionSchemaResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
         };
     };
 };
@@ -6797,8 +7923,11 @@ declare const query$c_AccountView: typeof AccountView;
 declare const query$c_ConfigView: typeof ConfigView;
 declare const query$c_QueryAccountsRequest: typeof QueryAccountsRequest;
 declare const query$c_QueryAccountsResponse: typeof QueryAccountsResponse;
+declare const query$c_QueryPermissionSchemaRequest: typeof QueryPermissionSchemaRequest;
+declare const query$c_QueryPermissionSchemaResponse: typeof QueryPermissionSchemaResponse;
+declare const query$c_QueryPermissionSchemaResponse_MsgPermissionsEntry: typeof QueryPermissionSchemaResponse_MsgPermissionsEntry;
 declare namespace query$c {
-  export { query$c_AccountView as AccountView, query$c_ConfigView as ConfigView, type DeepPartial$c as DeepPartial, type MessageFns$c as MessageFns, QueryAccountRequest$2 as QueryAccountRequest, QueryAccountResponse$2 as QueryAccountResponse, query$c_QueryAccountsRequest as QueryAccountsRequest, query$c_QueryAccountsResponse as QueryAccountsResponse, QueryConfigRequest$2 as QueryConfigRequest, QueryConfigResponse$2 as QueryConfigResponse, QueryDefinition$c as QueryDefinition, protobufPackage$c as protobufPackage };
+  export { query$c_AccountView as AccountView, query$c_ConfigView as ConfigView, type DeepPartial$c as DeepPartial, type MessageFns$c as MessageFns, QueryAccountRequest$2 as QueryAccountRequest, QueryAccountResponse$2 as QueryAccountResponse, query$c_QueryAccountsRequest as QueryAccountsRequest, query$c_QueryAccountsResponse as QueryAccountsResponse, QueryConfigRequest$2 as QueryConfigRequest, QueryConfigResponse$2 as QueryConfigResponse, QueryDefinition$c as QueryDefinition, query$c_QueryPermissionSchemaRequest as QueryPermissionSchemaRequest, query$c_QueryPermissionSchemaResponse as QueryPermissionSchemaResponse, query$c_QueryPermissionSchemaResponse_MsgPermissionsEntry as QueryPermissionSchemaResponse_MsgPermissionsEntry, protobufPackage$c as protobufPackage };
 }
 
 declare const protobufPackage$b = "qorechain.amm.v1";
@@ -8457,6 +9586,246 @@ declare namespace index {
   export { tx$2 as abstractaccount, query$c as abstractaccountQuery, tx$8 as amm, query$b as ammQuery, tx$9 as bridge, query$a as bridgeQuery, tx$1 as crossvm, query$9 as crossvmQuery, tx$3 as license, query$8 as licenseQuery, tx$4 as lightnode, query$7 as lightnodeQuery, tx$6 as multilayer, query$6 as multilayerQuery, tx$5 as pqc, hybrid as pqcHybrid, query$5 as pqcQuery, query$4 as qcaQuery, tx$7 as rdk, query$3 as rdkQuery, query$2 as reputationQuery, tx as rlconsensus, query$1 as rlconsensusQuery, tx$a as svm, query as svmQuery };
 }
 
+/**
+ * Wallet DX for the v3.1.85 authenticator lanes.
+ *
+ * These builders mirror the reference wallet-adapter: they take a linked
+ * external wallet (a Phantom ed25519 key, or a MetaMask / EIP-1193 secp256k1
+ * key), rebuild the domain-separated authenticator sign-bytes (see
+ * {@link ../tx/authenticator}), have the wallet sign the 32-byte digest, and
+ * return a relayer-ready `{ typeUrl, value }` message for the EVM or Native
+ * lane. A relayer then submits and pays fees; the authenticator's signature IS
+ * the authorization — the external key never produces an ML-DSA co-signature.
+ *
+ * Signature schemes:
+ *   - `ed25519` (Phantom): the chain verifies `ed25519.Verify(pubkey, digest,
+ *     sig)`, so a Phantom `signMessage(digest)` matches directly.
+ *   - `secp256k1` (MetaMask): the key is linked by its 20-byte ETH ADDRESS; the
+ *     wallet produces a 65-byte `personal_sign` (EIP-191) signature over the
+ *     same digest.
+ *
+ * Also included: the low-level message composers, and mnemonic-based PQC key
+ * rotation (legacy→canonical migration) with both keys dual-signing the
+ * rotation bytes.
+ */
+
+/** Fields for {@link executeEvmMsg}. */
+interface ExecuteEvmMsgInput {
+    relayer: string;
+    account: string;
+    scheme: "ed25519" | "secp256k1";
+    pubkey: Uint8Array;
+    signature: Uint8Array;
+    to?: string;
+    value?: string;
+    data?: Uint8Array;
+    gasLimit: number | bigint;
+    nonce: number | bigint;
+}
+/**
+ * Build a `MsgExecuteEVM` (`{ typeUrl, value }`) — the relayer broadcasts this
+ * and is the fee payer. `to` is a 0x-hex address, `value` a decimal wei string.
+ */
+declare function executeEvmMsg(input: ExecuteEvmMsgInput): EncodeObject;
+/** Fields for {@link executeCosmosMsg}. */
+interface ExecuteCosmosMsgInput {
+    relayer: string;
+    account: string;
+    scheme: "ed25519" | "secp256k1";
+    pubkey: Uint8Array;
+    signature: Uint8Array;
+    to: string;
+    /** Single-coin amount string, e.g. `100uqor`. */
+    amount: string;
+    nonce: number | bigint;
+}
+/**
+ * Build a `MsgExecuteCosmos` (`{ typeUrl, value }`) — the relayer broadcasts
+ * this. `amount` is a single-coin string like `100uqor`.
+ */
+declare function executeCosmosMsg(input: ExecuteCosmosMsgInput): EncodeObject;
+/** Fields for {@link revokeAuthenticatorMsg}. */
+interface RevokeAuthenticatorMsgInput {
+    owner: string;
+    account?: string;
+    scheme: "ed25519" | "secp256k1";
+    pubkey: Uint8Array;
+}
+/**
+ * Build a `MsgRevokeAuthenticator` (`{ typeUrl, value }`) — owner-signed;
+ * instantly disables a linked key. `account` defaults to `owner`.
+ */
+declare function revokeAuthenticatorMsg(input: RevokeAuthenticatorMsgInput): EncodeObject;
+/** Fields for {@link registerEthAuthenticatorMsg}. */
+interface RegisterEthAuthenticatorMsgInput {
+    owner: string;
+    account?: string;
+    /** 0x-hex 20-byte ETH address that becomes the authenticator pubkey. */
+    ethAddress: string;
+    permissions?: string[];
+    expiryUnix: number | bigint;
+    label?: string;
+}
+/**
+ * Build a `MsgRegisterAuthenticator` (`{ typeUrl, value }`) that links a
+ * MetaMask / EVM key (by its 0x address, scheme `secp256k1`) to the owner's
+ * account. Owner-signed. `account` defaults to `owner`.
+ */
+declare function registerEthAuthenticatorMsg(input: RegisterEthAuthenticatorMsgInput): EncodeObject;
+/** Fields for {@link rotatePqcKeyMsg}. */
+interface RotatePqcKeyMsgInput {
+    sender: string;
+    oldPublicKey: Uint8Array;
+    newPublicKey: Uint8Array;
+    oldSignature: Uint8Array;
+    newSignature: Uint8Array;
+}
+/**
+ * Build a `MsgRotatePQCKey` (`{ typeUrl, value }`) — sender-signed (hybrid, with
+ * the OLD key); dual-signed payload.
+ */
+declare function rotatePqcKeyMsg(input: RotatePqcKeyMsgInput): EncodeObject;
+/**
+ * The minimal Phantom-style ed25519 wallet shape the builders need: a public
+ * key (as `.toBytes()` or raw bytes) and `signMessage` returning `{ signature }`
+ * or raw bytes.
+ */
+interface AuthenticatorWallet {
+    publicKey: {
+        toBytes(): Uint8Array;
+    } | Uint8Array;
+    signMessage(message: Uint8Array): Promise<{
+        signature: Uint8Array;
+    } | Uint8Array>;
+}
+/** Fields for {@link buildPhantomExecuteEvm}. */
+interface BuildPhantomExecuteEvmOptions {
+    wallet: AuthenticatorWallet;
+    relayer: string;
+    chainId: string;
+    account: string;
+    to?: string;
+    value?: string;
+    data?: Uint8Array;
+    gasLimit?: number | bigint;
+    /** The account's CURRENT EVM nonce (relayer ≠ owner → do NOT +1). */
+    nonce: number | bigint;
+}
+/**
+ * Sign the EVM auth digest with a Phantom-style ed25519 wallet and return a
+ * `MsgExecuteEVM` ready for the relayer to broadcast.
+ */
+declare function buildPhantomExecuteEvm(opts: BuildPhantomExecuteEvmOptions): Promise<EncodeObject>;
+/** Fields for {@link buildPhantomExecuteCosmos}. */
+interface BuildPhantomExecuteCosmosOptions {
+    wallet: AuthenticatorWallet;
+    relayer: string;
+    chainId: string;
+    account: string;
+    to: string;
+    /** Single-coin amount string, e.g. `100uqor`. */
+    amount: string;
+    /** The per-authenticator sequence for `(account, pubkey)`. */
+    nonce: number | bigint;
+}
+/**
+ * Sign the Native (Cosmos) auth digest with a Phantom-style ed25519 wallet and
+ * return a `MsgExecuteCosmos` ready for the relayer to broadcast.
+ */
+declare function buildPhantomExecuteCosmos(opts: BuildPhantomExecuteCosmosOptions): Promise<EncodeObject>;
+/** The minimal EIP-1193 provider shape the MetaMask builders need. */
+interface Eip1193Provider {
+    request(args: {
+        method: string;
+        params: unknown[];
+    }): Promise<string>;
+}
+/** Fields for {@link buildMetaMaskExecuteEvm}. */
+interface BuildMetaMaskExecuteEvmOptions {
+    provider: Eip1193Provider;
+    /** 0x-hex 20-byte ETH address (the authenticator pubkey). */
+    address: string;
+    relayer: string;
+    chainId: string;
+    account: string;
+    to?: string;
+    value?: string;
+    data?: Uint8Array;
+    gasLimit?: number | bigint;
+    /** The account's CURRENT EVM nonce (relayer ≠ owner → do NOT +1). */
+    nonce: number | bigint;
+}
+/**
+ * Sign the EVM auth digest via MetaMask (EIP-191 `personal_sign`) and return a
+ * `MsgExecuteEVM` ready for the relayer. The key is linked by its 20-byte ETH
+ * address (scheme `secp256k1`).
+ */
+declare function buildMetaMaskExecuteEvm(opts: BuildMetaMaskExecuteEvmOptions): Promise<EncodeObject>;
+/** Fields for {@link buildMetaMaskExecuteCosmos}. */
+interface BuildMetaMaskExecuteCosmosOptions {
+    provider: Eip1193Provider;
+    /** 0x-hex 20-byte ETH address (the authenticator pubkey). */
+    address: string;
+    relayer: string;
+    chainId: string;
+    account: string;
+    to: string;
+    /** Single-coin amount string, e.g. `100uqor`. */
+    amount: string;
+    /** The per-authenticator sequence for `(account, address)`. */
+    nonce: number | bigint;
+}
+/**
+ * Sign the Native (Cosmos) auth digest via MetaMask (EIP-191 `personal_sign`)
+ * and return a `MsgExecuteCosmos` ready for the relayer.
+ */
+declare function buildMetaMaskExecuteCosmos(opts: BuildMetaMaskExecuteCosmosOptions): Promise<EncodeObject>;
+/**
+ * The CANONICAL address-bound PQC derivation (SDK / wallet-adapter):
+ * `shake256("qorechain:pqc:v1|" + account + "|" + mnemonic, 32)` → ML-DSA-87
+ * keygen. This matches {@link ../accounts/unified.deriveUnifiedAccount}.
+ */
+declare const CANONICAL_DERIVATION = "adapter";
+/**
+ * The LEGACY chain-bridge / faucet-api PQC derivation:
+ * `shake256(utf8(mnemonic), 32)` → ML-DSA-87 keygen. Not address-bound.
+ */
+declare const LEGACY_DERIVATION = "bridge";
+/** Derive the LEGACY (chain-bridge) ML-DSA-87 keypair for a mnemonic. */
+declare function derivePqcLegacy(mnemonic: string): PqcKeypair;
+/** Options for {@link rotatePqcKeyMsgFromMnemonic}. */
+interface RotatePqcKeyMsgFromMnemonicOptions {
+    account: string;
+    mnemonic: string;
+    chainId: string;
+    /** PQC algorithm id (ML-DSA-87 = 1). */
+    algorithmId?: number;
+    /** Source derivation (defaults to the legacy chain-bridge derivation). */
+    oldDerivation?: string;
+    /** Target derivation (defaults to the canonical address-bound derivation). */
+    newDerivation?: string;
+}
+/** Result of {@link rotatePqcKeyMsgFromMnemonic}. */
+interface RotatePqcKeyMsgFromMnemonicResult {
+    /** The `{ typeUrl, value }` `MsgRotatePQCKey` to broadcast. */
+    msg: EncodeObject;
+    /** The OLD keypair (still the registered key until the rotation lands). */
+    oldKeypair: PqcKeypair;
+    /** The NEW keypair (becomes the registered key after rotation). */
+    newKeypair: PqcKeypair;
+}
+/**
+ * Build a `MsgRotatePQCKey` that rotates an account's ML-DSA-87 key (SAME
+ * algorithm) from one derivation to another — canonically migrating a LEGACY
+ * chain-bridge key (`shake256(mnemonic)`) to the canonical address-bound key
+ * (`shake256("qorechain:pqc:v1|addr|mnemonic")`). Both keys dual-sign the
+ * domain-separated rotation bytes.
+ *
+ * The returned message must be broadcast BY the account, cosigned (hybrid) with
+ * the OLD key (it is still the registered key until the rotation lands).
+ */
+declare function rotatePqcKeyMsgFromMnemonic(opts: RotatePqcKeyMsgFromMnemonicOptions): RotatePqcKeyMsgFromMnemonicResult;
+
 /**
  * Native browser-wallet integration for QoreChain (Keplr and Leap).
  *
@@ -8660,6 +10029,13 @@ interface AbstractAccountQueryClient {
     account(req: QueryAccountRequest$2): Promise<QueryAccountResponse$2>;
     /** All abstract accounts. */
     accounts(req?: QueryAccountsRequest): Promise<QueryAccountsResponse>;
+    /**
+     * The canonical authenticator permission taxonomy (v3.1.85): the valid
+     * permission strings, the message-typeURL→permission mapping, the
+     * never-delegable key-management typeURLs, and a `schema_version` clients
+     * compare against their embedded copy to detect drift.
+     */
+    permissionSchema(req?: QueryPermissionSchemaRequest): Promise<QueryPermissionSchemaResponse>;
 }
 /** Multilayer (sidechain / paychain) module query client. */
 interface MultilayerQueryClient {
@@ -9116,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
@@ -9176,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;
@@ -9184,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. */
@@ -9200,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;
 }
@@ -9243,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.
@@ -9468,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.6.1";
+declare const VERSION = "0.8.0";
 
-export { type AbstractAccountQueryClient, type Account, type AccountSequence, AlgorithmDilithium5, type AlgorithmID, AlgorithmMLKEM1024, AlgorithmUnspecified, type AllBalancesResponse, type AmmQueryClient, 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 ConnectPhantomUnifiedOptions, 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, ETHSECP256K1_PUBKEY_TYPE, type Ed25519Account, type EnsurePqcRegisteredOptions, type EnsurePqcRegisteredResult, type EstimateFeeOptions, type EthBroadcaster, EthNativeSigner, type EthNativeSignerOptions, type EthSignParams, type EthSigningKey, type EthTxParams, 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 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 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 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 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, bech32ToHex, bridge, broadcastAndWait, buildAminoTypes, buildEventsQuery, buildHybridSignatureExtension, buildHybridTx, buildRegisterPqcKeyMsg, buildTxQuery, buildUrl, bytesToBech32, calculateFee, clearAdmin, connectCosmWasmSigner, connectPhantomUnified, connectQueryClients, createClient, createCosmWasmClient, createCrossVMClient, createMultilayerClient, createQueryClients, createRollupClient, createSubscriptionClient, crossvm, decodeTxError, deriveEvmAccount, deriveNativeAccount, deriveSvmAccount, deriveUnifiedAccount, 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, parseEthPubkeyAny, parseUnits, postJsonRpc, pqc as pqcMsg, pqcSign, pqcVerify, qorToEvm, qoreAddresses, qorechainRegistry, qorechainRegistryTypes, index as qorechainTypes, queryContractSmart, rdk, requestFaucet, ripemd160, ripemd160Hex, rlconsensus, 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 };