@qorechain/sdk 0.5.2 → 0.6.1

package/dist/index.d.cts

@@ -8,6 +8,7 @@ import { CosmWasmClient, SigningCosmWasmClient } from '@cosmjs/cosmwasm-stargate
 export { AI_ANOMALY_CHECK_ADDRESS, AI_RISK_SCORE_ADDRESS, AiAnomalyCheck, AiRiskScore, PreflightResult, PreflightTx, RISK_LEVEL_UNSAFE_THRESHOLD, ai, aiAnomalyCheck, aiRiskScore, simulateWithRiskScore } from '@qorechain/evm';
 import { Any } from 'cosmjs-types/google/protobuf/any';
 import { TxBody, TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+import { BaseAccount } from 'cosmjs-types/cosmos/auth/v1beta1/auth';
 import { BinaryWriter, BinaryReader } from '@bufbuild/protobuf/wire';
 import * as cosmjs_types_ibc_applications_transfer_v1_tx from 'cosmjs-types/ibc/applications/transfer/v1/tx';
 import { MsgTransfer } from 'cosmjs-types/ibc/applications/transfer/v1/tx';
@@ -52,9 +53,9 @@ interface CoinInfo {
 }
 /** Service endpoints for talking to a network across its supported VMs. */
 interface NetworkEndpoints {
-    /** Cosmos SDK REST (LCD) endpoint. */
+    /** Native REST (LCD) endpoint. */
     rest: string;
-    /** Cosmos SDK gRPC endpoint. */
+    /** Native gRPC endpoint. */
     grpc: string;
     /** Consensus RPC endpoint. */
     rpc: string;
@@ -175,7 +176,7 @@ declare function postJsonRpc<T>(url: string, body: unknown, opts?: HttpOptions):
 /**
  * REST (LCD) read client for QoreChain.
  *
- * Wraps the standard Cosmos SDK bank endpoints plus QoreChain's custom module
+ * Wraps the standard Native bank endpoints plus QoreChain's custom module
  * read routes under `/qorechain/<module>/v1/...`. All requests go through the
  * shared {@link getJson} helper, so `fetch` is injectable and failures surface
  * as {@link QoreHttpError}.
@@ -185,7 +186,7 @@ declare function postJsonRpc<T>(url: string, body: unknown, opts?: HttpOptions):
  * defaulting to {@link Record}<string, unknown> rather than over-modeled here.
  */
 
-/** Cosmos pagination response metadata. */
+/** Native pagination response metadata. */
 interface PageResponse {
     next_key: string | null;
     total?: string;
@@ -199,7 +200,7 @@ interface AllBalancesResponse {
 interface BalanceResponse {
     balance: Coin$1;
 }
-/** Cosmos-style key/limit pagination input. */
+/** Native key/limit pagination input. */
 interface Pagination {
     key?: string;
     limit?: number;
@@ -212,7 +213,7 @@ interface PaginatedOptions {
 type RestClientOptions = HttpOptions;
 /** Relative urgency of a fee estimate. */
 type FeeUrgency = "fast" | "normal" | "slow";
-/** Cosmos + QoreChain REST read client. */
+/** Native + QoreChain REST read client. */
 declare class RestClient {
     private readonly baseUrl;
     private readonly opts;
@@ -396,7 +397,7 @@ declare class QorClient extends JsonRpcClient {
  * QoreChain exposes an AI-assisted fee oracle at the REST route
  * `/qorechain/ai/v1/fee-estimate?urgency=fast|normal|slow` (see the core
  * `AI_ENGINE.md` / `API_REFERENCE.md`). {@link estimateFee} queries it via the
- * shared {@link RestClient} and shapes the answer as a Cosmos `StdFee`
+ * shared {@link RestClient} and shapes the answer as a Native `StdFee`
  * (`{ amount: Coin[]; gas: string }`).
  *
  * The oracle can be unavailable (node still syncing, sidecar down, custom RPC
@@ -442,7 +443,7 @@ interface EstimateFeeOptions {
 /**
  * Estimate a transaction fee for the given urgency.
  *
- * Queries the QoreChain AI fee oracle and returns a Cosmos `StdFee`. If the
+ * Queries the QoreChain AI fee oracle and returns a Native `StdFee`. If the
  * oracle is unavailable or returns no usable fee, falls back to a deterministic
  * static fee computed from {@link EstimateFeeOptions.fallbackGasPrice}.
  *
@@ -454,7 +455,7 @@ declare function estimateFee(rest: RestClient, opts?: EstimateFeeOptions): Promi
 /**
  * Broadcast-mode definitions and the broadcast result shape for native txs.
  *
- * Cosmos nodes accept transactions in three modes:
+ * QoreChain Native nodes accept transactions in three modes:
  * - `sync`  — return after `CheckTx` (mempool admission); you get a tx hash but
  *   not an on-chain result.
  * - `async` — return immediately after submission, without waiting for
@@ -502,7 +503,7 @@ interface BroadcastResult {
  * single token like `"0.025uqor"`. {@link GasPrice.fromString} parses that into
  * an exact fraction (numerator / denominator) so fee math stays integer-exact
  * with no floating-point drift, and {@link calculateFee} turns a gas limit plus
- * a gas price into a Cosmos {@link StdFee}.
+ * a gas price into a Native {@link StdFee}.
  *
  * This mirrors the cosmjs `GasPrice`/`calculateFee` concept but is reimplemented
  * here so the SDK does not depend on cosmjs's internal fee module and so the
@@ -553,7 +554,7 @@ declare function calculateFee(gas: number | string, gasPrice: GasPrice | string)
  * Native transaction builder and broadcaster for QoreChain.
  *
  * {@link TxClient} wraps cosmjs's `SigningStargateClient` to simulate, sign, and
- * broadcast native (Cosmos SDK) transactions, with a `bankSend` convenience for
+ * broadcast native (QoreChain Native) transactions, with a `bankSend` convenience for
  * the common transfer case. It is constructed in two ways:
  *
  *  - {@link TxClient.connect} — the production path: connect to the network's
@@ -600,7 +601,7 @@ interface AutoFeeOptions {
 /**
  * Build the {@link AminoTypes} used for Amino-mode signing.
  *
- * Seeds cosmjs's `createDefaultAminoConverters()` (standard Cosmos modules:
+ * Seeds cosmjs's `createDefaultAminoConverters()` (standard Native modules:
  * bank, staking, gov, distribution, IBC, etc.) and merges any `extra`
  * converters on top — e.g. for QoreChain custom modules to support Ledger.
  *
@@ -635,14 +636,14 @@ interface TxConnectOptions {
      * {@link directSignerFromPrivateKey}) or an Amino signer — including the
      * `OfflineSigner` returned by a browser wallet's `getOfflineSignerAuto`
      * (Keplr/Leap), which picks DIRECT or Amino automatically. Custom QoreChain
-     * messages sign via DIRECT mode; Amino mode covers standard Cosmos messages
+     * messages sign via DIRECT mode; Amino mode covers standard Native messages
      * (see `aminoTypes`).
      */
     signer: OfflineSigner;
     /**
      * Extra protobuf message types to register, as `[typeUrl, GeneratedType]`
      * pairs. Added on top of the default {@link qorechainRegistry} (standard
-     * Cosmos types + all QoreChain custom-module messages). Use this for messages
+     * Native types + all QoreChain custom-module messages). Use this for messages
      * the SDK does not ship, e.g. from a private module. Ignored if `registry`
      * is supplied.
      */
@@ -655,7 +656,7 @@ interface TxConnectOptions {
     /**
      * Amino converters for Amino-mode signing (Ledger and some hardware/mobile
      * wallets sign Amino). Defaults to cosmjs's `createDefaultAminoConverters()`,
-     * which covers the standard Cosmos modules (bank, staking, gov, distribution,
+     * which covers the standard Native modules (bank, staking, gov, distribution,
      * etc.). When set, this replaces the defaults entirely — to add converters on
      * top of the defaults use {@link extraAminoConverters} instead.
      *
@@ -666,7 +667,7 @@ interface TxConnectOptions {
     /**
      * Extra Amino converters merged on top of the default converters. Use this to
      * register converters for custom modules (e.g. for Ledger support) without
-     * losing the standard Cosmos converters. Ignored if `aminoTypes` is supplied.
+     * losing the standard Native converters. Ignored if `aminoTypes` is supplied.
      */
     extraAminoConverters?: AminoConverters;
     /** Additional cosmjs `SigningStargateClientOptions` (gas price, etc.). */
@@ -893,7 +894,7 @@ interface ClientCrossVm {
 interface QoreChainClient {
     /** The resolved network config (with any endpoint/chain-id overrides applied). */
     readonly network: NetworkConfig;
-    /** Cosmos + QoreChain REST read client (uses `endpoints.rest`). */
+    /** Native + QoreChain REST read client (uses `endpoints.rest`). */
     readonly rest: RestClient;
     /** EVM JSON-RPC client (uses `endpoints.evmRpc`). */
     readonly evm: JsonRpcClient;
@@ -1262,7 +1263,7 @@ interface Ed25519Account extends Account {
  * Mnemonic generation/validation and hierarchical-deterministic (HD) derivation
  * of QoreChain accounts in all three supported schemes:
  *
- * 1. native — Cosmos-style secp256k1, BIP-44 path `m/44'/118'/0'/0/{index}`,
+ * 1. native — Native secp256k1, BIP-44 path `m/44'/118'/0'/0/{index}`,
  *    address = bech32(`qor`, ripemd160(sha256(compressedPubkey))).
  * 2. evm    — secp256k1, BIP-44 path `m/44'/60'/0'/0/{index}`,
  *    address = `0x` + last 20 bytes of keccak256(uncompressedPubkey[1:]),
@@ -1301,7 +1302,7 @@ declare function generateMnemonic(strength?: 128 | 256): string;
  */
 declare function validateMnemonic(mnemonic: string): boolean;
 /**
- * Derive a native QoreChain account (Cosmos-style secp256k1) from a mnemonic.
+ * Derive a native QoreChain account (Native secp256k1) from a mnemonic.
  *
  * Path: `m/44'/118'/0'/0/{accountIndex}`. The address is the bech32 (`qor`)
  * encoding of `ripemd160(sha256(compressedPublicKey))`.
@@ -1521,7 +1522,7 @@ declare function pqcVerify(publicKey: Uint8Array, message: Uint8Array, signature
  * The tx-builder is responsible for encoding this and attaching it under
  * {@link HYBRID_SIG_TYPE_URL}.
  */
-interface PQCHybridSignature {
+interface PQCHybridSignature$1 {
     /** PQC algorithm ID (core `AlgorithmID`). */
     algorithm_id: AlgorithmID;
     /** Raw PQC signature bytes. */
@@ -1543,7 +1544,7 @@ declare function buildHybridSignatureExtension(args: {
     algorithmId: AlgorithmID;
     signature: Uint8Array;
     publicKey?: Uint8Array;
-}): PQCHybridSignature;
+}): PQCHybridSignature$1;
 /**
  * A pqc-only {@link Signer}: produces an ML-DSA-87 (Dilithium-5) signature and
  * no classical signature. Corresponds to the chain's `pqc_only` key type.
@@ -1583,6 +1584,198 @@ declare class HybridSigner implements Signer {
     sign(message: Uint8Array): Promise<SignOutput>;
 }
 
+/**
+ * Unified eth-native QoreChain accounts.
+ *
+ * ONE `eth_secp256k1` key = ONE 20-byte identity, rendered THREE ways so a wallet
+ * never "has funds on one lane but not another". The 20 bytes are the Ethereum
+ * derivation `keccak256(uncompressedPubkey[1:])[12:]`, so the key is natively
+ * spendable on the EVM lane; the native (`qor1…`) and SVM (base58) forms are just
+ * other encodings of the SAME 20 bytes — the chain reads one x/bank balance for
+ * the account, visible under all three encodings.
+ *
+ * This is ADDITIVE. The legacy coin-118 native derivation
+ * ({@link ../accounts/wallet.deriveNativeAccount}) is unchanged and still
+ * supported; unified accounts are a distinct, opt-in identity model built on the
+ * eth-native (coin-60) key.
+ *
+ * ```
+ *   {
+ *     mnemonic, privateKey (0x hex, 32B),
+ *     publicKey (33B compressed, 0x hex),
+ *     addressBytes (20B),
+ *     cosmos: "qor1…",              // bech32
+ *     evm:    "0x…" (EIP-55),       // hex
+ *     svm:    "<base58>",           // base58(20B ‖ 12 zero bytes) = 32-byte addr
+ *     pqc:    { publicKey, secretKey }  // ML-DSA-87 (Dilithium-5), for the hybrid ante
+ *   }
+ * ```
+ *
+ * Derivation uses audited primitives: @scure/bip39 (mnemonic + seed), @scure/bip32
+ * (secp256k1 HD), @noble/curves (secp256k1), @noble/hashes (keccak256), @scure/base
+ * (base58), and `@qorechain/pqc` (ML-DSA-87 + SHAKE-256). Secret material is
+ * returned explicitly and never logged.
+ */
+
+/**
+ * The three address encodings of a single 20-byte QoreChain account, plus the
+ * raw address bytes.
+ */
+interface UnifiedAddresses {
+    /** The raw 20-byte account address. */
+    addressBytes: Uint8Array;
+    /** Bech32 (`qor1…`) native encoding. */
+    cosmos: string;
+    /** `0x`-prefixed, EIP-55 mixed-case checksummed hex encoding. */
+    evm: string;
+    /** base58 of the 32-byte SVM address (`addr20 ‖ 12 zero bytes`). */
+    svm: string;
+}
+/**
+ * A fully derived unified eth-native account: one secp256k1 key rendered as all
+ * three QoreChain address encodings, plus its deterministic ML-DSA-87 PQC keypair
+ * for the hybrid ante.
+ *
+ * Secret fields (`mnemonic`, `privateKey`, `pqc.secretKey`) are returned so the
+ * caller can sign; they are never logged by the SDK.
+ */
+interface UnifiedAccount extends UnifiedAddresses {
+    /**
+     * The BIP-39 mnemonic this account was derived from, when derived from a
+     * mnemonic. `undefined` for seed-derived accounts
+     * ({@link unifiedAccountFromSeed}).
+     */
+    mnemonic?: string;
+    /** `0x`-prefixed 32-byte secp256k1 private key. Handle as a secret. */
+    privateKey: string;
+    /** `0x`-prefixed 33-byte compressed secp256k1 public key. */
+    publicKey: string;
+    /** The ML-DSA-87 (Dilithium-5) keypair for the hybrid signature extension. */
+    pqc: PqcKeypair;
+}
+/**
+ * Derive the three address encodings from a 20-byte account address.
+ *
+ * The SVM form is the base58 of the 32-byte address `addr20 ‖ 12 zero bytes`
+ * (right-padded), matching the chain's unified 32-byte SVM address layout.
+ *
+ * @throws if `addr20` is not exactly 20 bytes.
+ */
+declare function addressesFrom20(addr20: Uint8Array): UnifiedAddresses;
+/**
+ * Decode any ONE of the three encodings of a unified account into all three.
+ *
+ * Provide exactly one of `cosmos` (`qor1…`), `evm` (`0x…`), or `hex` (20-byte
+ * hex, with or without `0x`). The SVM base58 form is not accepted as input here
+ * (it right-pads to 32 bytes; decode SVM externally to its 20-byte prefix if
+ * needed).
+ *
+ * @throws if none of the inputs is provided, or the decoded payload is not 20 bytes.
+ */
+declare function qoreAddresses(input: {
+    cosmos?: string;
+    evm?: string;
+    hex?: string;
+}): UnifiedAddresses;
+/**
+ * Derive a unified eth-native QoreChain account from a BIP-39 mnemonic.
+ *
+ * HD path: `m/44'/60'/0'/0/{index}` (SLIP-10 secp256k1). The 20-byte address is
+ * `keccak256(uncompressedPubkey[1:])[12:]`; the PQC key is deterministically
+ * derived from `shake256("qorechain:pqc:v1|" + cosmos + "|" + mnemonic, 32)`.
+ *
+ * @param mnemonic - A valid BIP-39 English mnemonic. Validated (checksum too).
+ * @param index - Zero-based address index (last path segment). Defaults to `0`.
+ * @throws if the mnemonic is invalid or `index` is not a non-negative integer.
+ */
+declare function deriveUnifiedAccount(mnemonic: string, index?: number): Promise<UnifiedAccount>;
+/**
+ * Build a unified eth-native account directly from a 32-byte seed used AS the
+ * secp256k1 private key (no HD derivation).
+ *
+ * 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.
+ * @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.
+ *
+ * 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.
+ */
+
+/**
+ * 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.
+ *
+ * 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.
+ *
+ * @param signatureBytes - The raw ed25519 signature bytes returned by the wallet.
+ */
+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.
+ */
+interface PhantomProvider {
+    connect(): Promise<{
+        publicKey: {
+            toBytes(): Uint8Array;
+        } | Uint8Array;
+    }>;
+    publicKey?: {
+        toBytes(): Uint8Array;
+    } | Uint8Array | null;
+    signMessage(message: Uint8Array, encoding?: string): Promise<{
+        signature: Uint8Array;
+    } | Uint8Array>;
+}
+/** Options for {@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.
+     */
+    provider?: PhantomProvider;
+}
+/**
+ * Connect Phantom in the browser and derive the user's unified QoreChain account.
+ *
+ * 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}.
+ *
+ * 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.
+ */
+declare function connectPhantomUnified(opts?: ConnectPhantomUnifiedOptions): Promise<UnifiedAccount>;
+
 /**
  * CosmWasm contract interaction for QoreChain.
  *
@@ -1711,7 +1904,7 @@ declare function getCodeDetails<T = unknown>(client: CosmWasmReadClient, codeId:
 declare function directSignerFromPrivateKey(privateKey: Uint8Array, prefix: string): Promise<OfflineDirectSigner>;
 
 /**
- * Structured decoding of failed Cosmos SDK transaction results.
+ * Structured decoding of failed QoreChain Native transaction results.
  *
  * When a transaction fails, the node returns an ABCI result with a non-zero
  * `code`, a `codespace` naming the module that rejected it, and a `rawLog`
@@ -1887,7 +2080,7 @@ declare function buildTxQuery(filters?: TxQueryFilters): string;
 declare function subscribeTx(client: SubscriptionClient, query: string | TxQueryFilters, handler: Handler<TxEventLike>, onError?: Handler<unknown>): Unsubscribe;
 
 /**
- * Block and transaction lookup/search over the Cosmos REST (LCD) endpoints.
+ * Block and transaction lookup/search over the Native REST (LCD) endpoints.
  *
  * Wraps the standard `/cosmos/tx/v1beta1` and `/cosmos/base/tendermint/v1beta1`
  * routes: fetch a single transaction by hash, fetch a block by height (or the
@@ -2073,13 +2266,15 @@ declare function withRetry<T>(fn: (attempt: number) => Promise<T>, opts?: RetryO
  * / {@link signAndBroadcastHybrid}) — prefer those for end-to-end signing. This
  * module documents the on-wire encoding the chain reads:
  *
- *  - `PQCHybridSignature` struct, JSON field tags (`algorithm_id`,
- *    `pqc_signature`, `pqc_public_key,omitempty`), and type URL
+ *  - `PQCHybridSignature` protobuf message (fields `algorithm_id` = 1,
+ *    `pqc_signature` = 2, `pqc_public_key` = 3) and type URL
  *    `/qorechain.pqc.v1.PQCHybridSignature`.
- *  - The ante handler extracts the extension by type URL and JSON-decodes it, so
- *    the `Any.value` carries the struct's Go-JSON encoding (Go marshals
- *    `[]byte` as standard padded base64 strings), NOT a protobuf message. This
- *    module encodes accordingly (see {@link toGoJson}).
+ *  - The ante handler extracts the extension by type URL and PROTOBUF-decodes it,
+ *    so the `Any.value` carries the message's protobuf encoding (via the
+ *    generated `PQCHybridSignature` codec), NOT JSON. Its first byte is `0x08`
+ *    (field-1 varint tag). A prior release JSON-encoded this value; the chain's
+ *    tx decoder rejected every such tx at CheckTx (the leading `0x7b` = `{` was
+ *    misread as field 15 `start_group`). Verified live on testnet 2026-07-05.
  *  - PLACEMENT: the extension is a CRITICAL extension option — it goes in
  *    `TxBody.extension_options`. {@link buildHybridTx} always uses this slot.
  *    This module additionally exposes `non_critical_extension_options` via
@@ -2113,11 +2308,13 @@ interface AttachHybridOptions {
  * `TxBody` extension option.
  *
  * The `Any.typeUrl` is the core {@link HYBRID_SIG_TYPE_URL}; the `Any.value` is
- * the UTF-8 bytes of the struct's Go-JSON encoding (see {@link toGoJson} and the
- * module header — the chain reads this extension by type URL + JSON decoding,
- * not protobuf).
+ * the PROTOBUF encoding of the `PQCHybridSignature` message (via the generated
+ * codec — fields `algorithmId` = 1, `pqcSignature` = 2, `pqcPublicKey` = 3), so
+ * the encoded value always begins with `0x08` (field-1 varint tag). The chain's
+ * ante handler protobuf-decodes this extension; a JSON-encoded value is rejected
+ * by the tx decoder at CheckTx.
  */
-declare function encodeHybridExtension(ext: PQCHybridSignature): Any;
+declare function encodeHybridExtension(ext: PQCHybridSignature$1): Any;
 /**
  * Return a copy of `body` with the encoded hybrid-signature extension attached.
  *
@@ -2128,7 +2325,7 @@ declare function encodeHybridExtension(ext: PQCHybridSignature): Any;
  * @see The module header — both the placement and the bytes the PQC signature
  *   must cover require live-testnet verification against the `full` build.
  */
-declare function attachHybridExtension(body: TxBody, ext: PQCHybridSignature, opts?: AttachHybridOptions): TxBody;
+declare function attachHybridExtension(body: TxBody, ext: PQCHybridSignature$1, opts?: AttachHybridOptions): TxBody;
 
 /**
  * End-to-end hybrid (classical + post-quantum) transaction signing for
@@ -2156,9 +2353,11 @@ declare function attachHybridExtension(body: TxBody, ext: PQCHybridSignature, op
  *    ML-DSA-87, empty context) — 4627 bytes for Dilithium-5.
  *  - The `PQCHybridSignature` extension is then added to
  *    `TxBody.extension_options` (CRITICAL extension options) as an `Any` with
- *    `type_url = "/qorechain.pqc.v1.PQCHybridSignature"` and `value` = UTF-8
- *    bytes of the Go-JSON `{ "algorithm_id", "pqc_signature", "pqc_public_key"? }`
- *    (standard padded base64; `pqc_public_key` omitted when not provided).
+ *    `type_url = "/qorechain.pqc.v1.PQCHybridSignature"` and `value` = the
+ *    PROTOBUF encoding of the `PQCHybridSignature` message (fields
+ *    `algorithm_id` = 1, `pqc_signature` = 2, `pqc_public_key` = 3; the encoded
+ *    value begins with `0x08`). The chain protobuf-decodes it — a JSON value is
+ *    rejected by the tx decoder.
  *  - The CLASSICAL signature is computed normally (SIGN_MODE_DIRECT) over the
  *    FINAL body (the one WITH the PQC extension) + authInfo + chainId +
  *    accountNumber, and goes in `TxRaw.signatures` (outside the body). There is
@@ -2280,7 +2479,358 @@ interface SignAndBroadcastHybridOptions extends BuildHybridTxOptions {
  */
 declare function signAndBroadcastHybrid(opts: SignAndBroadcastHybridOptions): Promise<BroadcastResult>;
 
-declare const protobufPackage$k = "qorechain.bridge.v1";
+/**
+ * eth_secp256k1 native-lane (QoreChain Native) transaction signing for QoreChain.
+ *
+ * A unified eth-native account (address = `keccak256(pubkey)[12:]`, see
+ * {@link ../accounts/unified.deriveUnifiedAccount}) signs native transactions with
+ * the `eth_secp256k1` scheme instead of the classic Native secp256k1 scheme. Two
+ * things differ from the standard path:
+ *
+ *  1. The classical signature is secp256k1 over the **keccak256** of the SignDoc
+ *     bytes (NOT sha256), serialized as the 64-byte `r ‖ s` (low-s normalized).
+ *  2. The `SignerInfo` public key `Any` uses the type URL
+ *     {@link ETHSECP256K1_PUBKEY_TYPE}; its `value` is the SAME wire shape as the
+ *     standard Native secp256k1 `PubKey` (`{ key: compressedPubkey }`), only the
+ *     type URL differs.
+ *
+ * This is the same account that spends on the EVM lane, so its `qor1…` / `0x…` /
+ * base58 forms are one identity. Mainnet enforces the ML-DSA-87 hybrid extension;
+ * {@link signHybridEth} attaches it, while {@link signClassicalEth} omits it (used
+ * 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
+ * classical hash (keccak vs sha256) and the pubkey type URL change here.
+ */
+
+/**
+ * The cosmos/evm `eth_secp256k1` public-key type URL. Its wire shape is identical
+ * to the Native secp256k1 `PubKey` (`{ key: bytes }`); only the type URL differs.
+ */
+declare const ETHSECP256K1_PUBKEY_TYPE = "/cosmos.evm.crypto.v1.ethsecp256k1.PubKey";
+/** The minimal account key material the eth signers need. */
+interface EthSigningKey {
+    /** `0x`-prefixed 32-byte secp256k1 private key. */
+    privateKey: string;
+    /** `0x`-prefixed 33-byte compressed secp256k1 public key. */
+    publicKey: string;
+    /** The ML-DSA-87 keypair (required for {@link signHybridEth}). */
+    pqc?: PqcKeypair;
+}
+/** Shared per-tx signing parameters. */
+interface EthSignParams {
+    /** The signing account (`privateKey`, `publicKey`, and `pqc` for hybrid). */
+    account: EthSigningKey;
+    /** The chain id (e.g. `"qorechain-vladi"`). */
+    chainId: string;
+    /** The on-chain account number of the signer. */
+    accountNumber: number | bigint;
+    /** The transaction messages as `{ typeUrl, value }` encode objects. */
+    messages: readonly EncodeObject[];
+    /** The fee to pay. */
+    fee: StdFee;
+    /** The signer's current account sequence (nonce). */
+    sequence: number | bigint;
+    /** Optional memo. Defaults to `""`. */
+    memo?: string;
+    /** Optional `timeoutHeight` for the tx body. Defaults to `0n`. */
+    timeoutHeight?: bigint;
+    /**
+     * A protobuf {@link EncodeObject}-to-`Any` encoder. Callers should pass a
+     * registry-bound encoder (e.g. `(m) => registry.encodeAsAny(m)`) so custom
+     * message types resolve. When omitted, only pre-encoded `Any` messages (whose
+     * `value` is already a `Uint8Array`) are accepted.
+     */
+    encodeMessage?: (m: EncodeObject) => Any;
+}
+/** The result of an eth-native sign: the broadcastable `TxRaw` and artifacts. */
+interface SignedEthTx {
+    /** Encoded `TxRaw` bytes, ready to broadcast. */
+    txRawBytes: Uint8Array;
+    /** The assembled `TxRaw`. */
+    txRaw: TxRaw;
+    /** The final `bodyBytes` (with the PQC extension for hybrid; B0 for classical). */
+    bodyBytes: Uint8Array;
+    /** The `authInfoBytes`. */
+    authInfoBytes: Uint8Array;
+    /** The 64-byte classical `r ‖ s` signature over `keccak256(signDoc)`. */
+    classicalSignature: Uint8Array;
+}
+/**
+ * Sign a native tx with the eth_secp256k1 CLASSICAL scheme only (no PQC extension).
+ *
+ * Use for the one-time `MsgRegisterPQCKeyV2`, which is bootstrap-exempt from the
+ * hybrid requirement. All other txs from a unified account should use
+ * {@link signHybridEth}.
+ */
+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`.
+ * 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
+ * type URL are eth-native here.
+ *
+ * @throws if `account.pqc` is not provided.
+ */
+declare function signHybridEth(params: EthSignParams): SignedEthTx;
+
+/**
+ * The eth-native tx lane: a signer that drives a unified eth-native account
+ * through the QoreChain Native tx path (`bankSend` / generic sends), plus the account
+ * parser the read side needs to accept an `eth_secp256k1` on-chain pubkey.
+ *
+ * A unified account ({@link ../accounts/unified.deriveUnifiedAccount}) signs with
+ * the eth_secp256k1 scheme (keccak256 hash + {@link ETHSECP256K1_PUBKEY_TYPE}
+ * pubkey), which cosmjs's standard `OfflineDirectSigner` does not produce. Rather
+ * than force it into cosmjs, {@link EthNativeSigner} builds the `TxRaw` natively
+ * via {@link signHybridEth} / {@link signClassicalEth} and hands the bytes to a
+ * minimal broadcast transport (which a connected cosmjs `StargateClient`
+ * satisfies).
+ *
+ * On the read side, an account whose `pub_key` is an `eth_secp256k1` `Any` must
+ * still be decoded for its `account_number` / `sequence`; {@link parseEthPubkeyAny}
+ * and {@link accountAuthInfo} handle that (the pubkey value is wire-identical to
+ * the Native secp256k1 `PubKey`, only the type URL differs).
+ */
+
+/** A minimal transport for broadcasting raw tx bytes. A cosmjs `StargateClient`
+ * (or `SigningStargateClient`) satisfies this via `broadcastTx`. */
+interface EthBroadcaster {
+    broadcastTx(tx: Uint8Array, timeoutMs?: number, pollIntervalMs?: number): Promise<{
+        code: number;
+        transactionHash: string;
+        height?: number;
+        gasUsed?: bigint;
+        gasWanted?: bigint;
+        rawLog?: string;
+    }>;
+}
+/** The `{ accountNumber, sequence }` pair a signer needs for a SignDoc. */
+interface AccountSequence {
+    accountNumber: number | bigint;
+    sequence: number | bigint;
+}
+/** Options for {@link EthNativeSigner}. */
+interface EthNativeSignerOptions {
+    /**
+     * The message registry used to encode messages into the tx body. Defaults to
+     * {@link qorechainRegistry} (standard Native + all QoreChain custom messages).
+     */
+    registry?: Registry;
+    /**
+     * The signing posture: `"hybrid"` (default) attaches the ML-DSA-87 extension
+     * required by mainnet; `"classical"` omits it (only for the bootstrap
+     * `MsgRegisterPQCKeyV2`).
+     */
+    signMode?: "hybrid" | "classical";
+}
+/** Params for building/broadcasting a tx with {@link EthNativeSigner}. */
+interface EthTxParams extends AccountSequence {
+    chainId: string;
+    messages: readonly EncodeObject[];
+    fee: StdFee;
+    memo?: string;
+    timeoutHeight?: bigint;
+}
+/**
+ * Sign QoreChain native txs from a unified eth-native account.
+ *
+ * The account's `eth_secp256k1` key signs via keccak256 + the ethsecp256k1 pubkey
+ * type URL. Use {@link sign} to produce a broadcastable `TxRaw`, or
+ * {@link bankSend} / {@link signAndBroadcast} with a transport to submit it.
+ */
+declare class EthNativeSigner {
+    /** The signing account's `qor1…` (native) address. */
+    readonly address: string;
+    private readonly key;
+    private readonly registry;
+    private readonly signMode;
+    constructor(account: UnifiedAccount, opts?: EthNativeSignerOptions);
+    /** Encode a message to `Any` via the bound registry. */
+    private encode;
+    /** Build and sign a `TxRaw` for the given messages. Does not broadcast. */
+    sign(params: EthTxParams): SignedEthTx;
+    /** Sign and broadcast the given messages via `transport`. */
+    signAndBroadcast(transport: EthBroadcaster, params: EthTxParams): Promise<{
+        transactionHash: string;
+        code: number;
+        height?: number;
+        gasUsed?: bigint;
+        gasWanted?: bigint;
+        rawLog?: string;
+    }>;
+    /** Send `amount` to `toAddress` via a bank `MsgSend`, signed eth-native. */
+    bankSend(transport: EthBroadcaster, toAddress: string, amount: Coin$1[], params: Omit<EthTxParams, "messages">): Promise<{
+        transactionHash: string;
+        code: number;
+    }>;
+}
+/**
+ * Decode a signer's public key `Any`, accepting BOTH the Native secp256k1 pubkey
+ * type and the `eth_secp256k1` type ({@link ETHSECP256K1_PUBKEY_TYPE}). The two
+ * carry the same wire shape (`{ key: compressedPubkey }`); only the type URL
+ * differs. Returns the 33-byte compressed public key.
+ *
+ * @throws if the `Any` is not one of the accepted secp256k1 pubkey types.
+ */
+declare function parseEthPubkeyAny(pubkey: Any): Uint8Array;
+/** The auth info read off a `BaseAccount`, with the account's pubkey (if set). */
+interface ParsedAccountAuth {
+    accountNumber: bigint;
+    sequence: bigint;
+    /** The 33-byte compressed pubkey, when the account has one on chain. */
+    publicKey?: Uint8Array;
+    /** The pubkey type URL as stored on chain, when present. */
+    pubkeyType?: string;
+}
+/**
+ * Parse a protobuf `BaseAccount`'s `account_number` / `sequence` (and pubkey when
+ * present), accepting an `eth_secp256k1` pubkey `Any`.
+ *
+ * Use this to read the sequence for building a SignDoc when an account was
+ * created eth-native (its on-chain pubkey uses {@link ETHSECP256K1_PUBKEY_TYPE},
+ * which cosmjs's default account parser rejects).
+ */
+declare function accountAuthInfo(account: BaseAccount): ParsedAccountAuth;
+
+declare const protobufPackage$o = "qorechain.svm.v1";
+interface MsgDeployProgram {
+    sender: string;
+    bytecode: Uint8Array;
+}
+declare const MsgDeployProgram: MessageFns$p<MsgDeployProgram>;
+interface MsgDeployProgramResponse {
+    programId: Uint8Array;
+}
+declare const MsgDeployProgramResponse: MessageFns$p<MsgDeployProgramResponse>;
+interface MsgCreateAccount {
+    sender: string;
+    owner: Uint8Array;
+    space: string;
+    lamports: string;
+    salt: Uint8Array;
+}
+declare const MsgCreateAccount: MessageFns$p<MsgCreateAccount>;
+interface MsgCreateAccountResponse {
+}
+declare const MsgCreateAccountResponse: MessageFns$p<MsgCreateAccountResponse>;
+interface SvmAccountMeta {
+    address: Uint8Array;
+    isSigner: boolean;
+    isWritable: boolean;
+}
+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
+ * `sender` — so any funded account may relay a Phantom-authorized action through
+ * consensus while the foreign key remains the authority.
+ */
+interface SVMAuth {
+    /** "ed25519" | "secp256k1" */
+    scheme: string;
+    pubkey: Uint8Array;
+    signature: Uint8Array;
+    /** raw 32-byte recent blockhash */
+    recentBlockhash: Uint8Array;
+}
+declare const SVMAuth: MessageFns$p<SVMAuth>;
+interface MsgExecuteProgram {
+    sender: string;
+    programId: Uint8Array;
+    accounts: SvmAccountMeta[];
+    data: Uint8Array;
+    /** optional foreign-scheme authorization (relayed) */
+    auth?: SVMAuth | undefined;
+}
+declare const MsgExecuteProgram: MessageFns$p<MsgExecuteProgram>;
+interface MsgExecuteProgramResponse {
+    result: Uint8Array;
+}
+declare const MsgExecuteProgramResponse: MessageFns$p<MsgExecuteProgramResponse>;
+interface MsgRegisterSVMPQCKey {
+    sender: string;
+    svmAddr: Uint8Array;
+    pqcPubKey: Uint8Array;
+}
+declare const MsgRegisterSVMPQCKey: MessageFns$p<MsgRegisterSVMPQCKey>;
+interface MsgRegisterSVMPQCKeyResponse {
+}
+declare const MsgRegisterSVMPQCKeyResponse: MessageFns$p<MsgRegisterSVMPQCKeyResponse>;
+type MsgDefinition$a = typeof MsgDefinition$a;
+declare const MsgDefinition$a: {
+    readonly name: "Msg";
+    readonly fullName: "qorechain.svm.v1.Msg";
+    readonly methods: {
+        readonly deployProgram: {
+            readonly name: "DeployProgram";
+            readonly requestType: typeof MsgDeployProgram;
+            readonly requestStream: false;
+            readonly responseType: typeof MsgDeployProgramResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly createAccount: {
+            readonly name: "CreateAccount";
+            readonly requestType: typeof MsgCreateAccount;
+            readonly requestStream: false;
+            readonly responseType: typeof MsgCreateAccountResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly executeProgram: {
+            readonly name: "ExecuteProgram";
+            readonly requestType: typeof MsgExecuteProgram;
+            readonly requestStream: false;
+            readonly responseType: typeof MsgExecuteProgramResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly registerSVMPQCKey: {
+            readonly name: "RegisterSVMPQCKey";
+            readonly requestType: typeof MsgRegisterSVMPQCKey;
+            readonly requestStream: false;
+            readonly responseType: typeof MsgRegisterSVMPQCKeyResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+type Builtin$p = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$p<T> = T extends Builtin$p ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$p<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$p<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$p<T[K]>;
+} : Partial<T>;
+interface MessageFns$p<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial$p<T>): T;
+    fromPartial(object: DeepPartial$p<T>): T;
+}
+
+declare const tx$a_MsgCreateAccount: typeof MsgCreateAccount;
+declare const tx$a_MsgCreateAccountResponse: typeof MsgCreateAccountResponse;
+declare const tx$a_MsgDeployProgram: typeof MsgDeployProgram;
+declare const tx$a_MsgDeployProgramResponse: typeof MsgDeployProgramResponse;
+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_SVMAuth: typeof SVMAuth;
+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 };
+}
+
+declare const protobufPackage$n = "qorechain.bridge.v1";
 /**
  * MsgUpdateChainConfig sets/replaces a chain's bridge configuration. Empty
  * string / zero fields fall back to the existing config (merge semantics in the
@@ -2301,10 +2851,10 @@ interface MsgUpdateChainConfig {
     /** hex topic0 of the lock event (EVM/light-client chains) */
     lockEventSig: string;
 }
-declare const MsgUpdateChainConfig: MessageFns$l<MsgUpdateChainConfig>;
+declare const MsgUpdateChainConfig: MessageFns$o<MsgUpdateChainConfig>;
 interface MsgUpdateChainConfigResponse {
 }
-declare const MsgUpdateChainConfigResponse: MessageFns$l<MsgUpdateChainConfigResponse>;
+declare const MsgUpdateChainConfigResponse: MessageFns$o<MsgUpdateChainConfigResponse>;
 /**
  * MsgSetVerifierBootstrap installs a verifier trust root. Exactly one of the
  * sub-messages must be populated; the handler routes by which is non-nil.
@@ -2318,27 +2868,27 @@ interface MsgSetVerifierBootstrap {
     bitcoin?: BitcoinCheckpoint | undefined;
     starknetStateRoot: Uint8Array;
 }
-declare const MsgSetVerifierBootstrap: MessageFns$l<MsgSetVerifierBootstrap>;
+declare const MsgSetVerifierBootstrap: MessageFns$o<MsgSetVerifierBootstrap>;
 interface MsgSetVerifierBootstrapResponse {
 }
-declare const MsgSetVerifierBootstrapResponse: MessageFns$l<MsgSetVerifierBootstrapResponse>;
+declare const MsgSetVerifierBootstrapResponse: MessageFns$o<MsgSetVerifierBootstrapResponse>;
 interface WormholeGuardianSet {
     /** 20-byte guardian eth addresses */
     addresses: Uint8Array[];
     quorum: number;
 }
-declare const WormholeGuardianSet: MessageFns$l<WormholeGuardianSet>;
+declare const WormholeGuardianSet: MessageFns$o<WormholeGuardianSet>;
 interface ValidatorQuorum {
     /** ed25519 (32B) or BLS (48B) pubkeys */
     pubkeys: Uint8Array[];
     threshold: number;
 }
-declare const ValidatorQuorum: MessageFns$l<ValidatorQuorum>;
+declare const ValidatorQuorum: MessageFns$o<ValidatorQuorum>;
 interface BitcoinCheckpoint {
     blockHash: Uint8Array;
     minConfs: number;
 }
-declare const BitcoinCheckpoint: MessageFns$l<BitcoinCheckpoint>;
+declare const BitcoinCheckpoint: MessageFns$o<BitcoinCheckpoint>;
 interface MsgBridgeDeposit {
     sender: string;
     sourceChain: string;
@@ -2348,10 +2898,10 @@ interface MsgBridgeDeposit {
     bridgeValidatorSigs: Uint8Array;
     pqcCommitment: Uint8Array;
 }
-declare const MsgBridgeDeposit: MessageFns$l<MsgBridgeDeposit>;
+declare const MsgBridgeDeposit: MessageFns$o<MsgBridgeDeposit>;
 interface MsgBridgeDepositResponse {
 }
-declare const MsgBridgeDepositResponse: MessageFns$l<MsgBridgeDepositResponse>;
+declare const MsgBridgeDepositResponse: MessageFns$o<MsgBridgeDepositResponse>;
 interface MsgBridgeWithdraw {
     sender: string;
     destinationChain: string;
@@ -2359,19 +2909,19 @@ interface MsgBridgeWithdraw {
     asset: string;
     amount: string;
 }
-declare const MsgBridgeWithdraw: MessageFns$l<MsgBridgeWithdraw>;
+declare const MsgBridgeWithdraw: MessageFns$o<MsgBridgeWithdraw>;
 interface MsgBridgeWithdrawResponse {
 }
-declare const MsgBridgeWithdrawResponse: MessageFns$l<MsgBridgeWithdrawResponse>;
+declare const MsgBridgeWithdrawResponse: MessageFns$o<MsgBridgeWithdrawResponse>;
 interface MsgRegisterBridgeValidator {
     validatorAddress: string;
     pqcPubkey: Uint8Array;
     supportedChains: string[];
 }
-declare const MsgRegisterBridgeValidator: MessageFns$l<MsgRegisterBridgeValidator>;
+declare const MsgRegisterBridgeValidator: MessageFns$o<MsgRegisterBridgeValidator>;
 interface MsgRegisterBridgeValidatorResponse {
 }
-declare const MsgRegisterBridgeValidatorResponse: MessageFns$l<MsgRegisterBridgeValidatorResponse>;
+declare const MsgRegisterBridgeValidatorResponse: MessageFns$o<MsgRegisterBridgeValidatorResponse>;
 interface MsgBridgeAttestation {
     validator: string;
     chain: string;
@@ -2383,10 +2933,10 @@ interface MsgBridgeAttestation {
     proof: Uint8Array;
     pqcSignature: Uint8Array;
 }
-declare const MsgBridgeAttestation: MessageFns$l<MsgBridgeAttestation>;
+declare const MsgBridgeAttestation: MessageFns$o<MsgBridgeAttestation>;
 interface MsgBridgeAttestationResponse {
 }
-declare const MsgBridgeAttestationResponse: MessageFns$l<MsgBridgeAttestationResponse>;
+declare const MsgBridgeAttestationResponse: MessageFns$o<MsgBridgeAttestationResponse>;
 interface MsgUpdateEthLightClient {
     relayer: string;
     /**
@@ -2395,13 +2945,13 @@ interface MsgUpdateEthLightClient {
      */
     update: Uint8Array;
 }
-declare const MsgUpdateEthLightClient: MessageFns$l<MsgUpdateEthLightClient>;
+declare const MsgUpdateEthLightClient: MessageFns$o<MsgUpdateEthLightClient>;
 interface MsgUpdateEthLightClientResponse {
 }
-declare const MsgUpdateEthLightClientResponse: MessageFns$l<MsgUpdateEthLightClientResponse>;
+declare const MsgUpdateEthLightClientResponse: MessageFns$o<MsgUpdateEthLightClientResponse>;
 /** Msg defines the bridge module's transaction service. */
-type MsgDefinition$a = typeof MsgDefinition$a;
-declare const MsgDefinition$a: {
+type MsgDefinition$9 = typeof MsgDefinition$9;
+declare const MsgDefinition$9: {
     readonly name: "Msg";
     readonly fullName: "qorechain.bridge.v1.Msg";
     readonly methods: {
@@ -2484,38 +3034,38 @@ declare const MsgDefinition$a: {
         };
     };
 };
-type Builtin$l = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$l<T> = T extends Builtin$l ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$l<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$l<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$l<T[K]>;
+type Builtin$o = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$o<T> = T extends Builtin$o ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$o<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$o<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$o<T[K]>;
 } : Partial<T>;
-interface MessageFns$l<T> {
+interface MessageFns$o<T> {
     encode(message: T, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): T;
     fromJSON(object: any): T;
     toJSON(message: T): unknown;
-    create(base?: DeepPartial$l<T>): T;
-    fromPartial(object: DeepPartial$l<T>): T;
+    create(base?: DeepPartial$o<T>): T;
+    fromPartial(object: DeepPartial$o<T>): T;
 }
 
-declare const tx$a_BitcoinCheckpoint: typeof BitcoinCheckpoint;
-declare const tx$a_MsgBridgeAttestation: typeof MsgBridgeAttestation;
-declare const tx$a_MsgBridgeAttestationResponse: typeof MsgBridgeAttestationResponse;
-declare const tx$a_MsgBridgeDeposit: typeof MsgBridgeDeposit;
-declare const tx$a_MsgBridgeDepositResponse: typeof MsgBridgeDepositResponse;
-declare const tx$a_MsgBridgeWithdraw: typeof MsgBridgeWithdraw;
-declare const tx$a_MsgBridgeWithdrawResponse: typeof MsgBridgeWithdrawResponse;
-declare const tx$a_MsgRegisterBridgeValidator: typeof MsgRegisterBridgeValidator;
-declare const tx$a_MsgRegisterBridgeValidatorResponse: typeof MsgRegisterBridgeValidatorResponse;
-declare const tx$a_MsgSetVerifierBootstrap: typeof MsgSetVerifierBootstrap;
-declare const tx$a_MsgSetVerifierBootstrapResponse: typeof MsgSetVerifierBootstrapResponse;
-declare const tx$a_MsgUpdateChainConfig: typeof MsgUpdateChainConfig;
-declare const tx$a_MsgUpdateChainConfigResponse: typeof MsgUpdateChainConfigResponse;
-declare const tx$a_MsgUpdateEthLightClient: typeof MsgUpdateEthLightClient;
-declare const tx$a_MsgUpdateEthLightClientResponse: typeof MsgUpdateEthLightClientResponse;
-declare const tx$a_ValidatorQuorum: typeof ValidatorQuorum;
-declare const tx$a_WormholeGuardianSet: typeof WormholeGuardianSet;
-declare namespace tx$a {
-  export { tx$a_BitcoinCheckpoint as BitcoinCheckpoint, type DeepPartial$l as DeepPartial, type MessageFns$l as MessageFns, tx$a_MsgBridgeAttestation as MsgBridgeAttestation, tx$a_MsgBridgeAttestationResponse as MsgBridgeAttestationResponse, tx$a_MsgBridgeDeposit as MsgBridgeDeposit, tx$a_MsgBridgeDepositResponse as MsgBridgeDepositResponse, tx$a_MsgBridgeWithdraw as MsgBridgeWithdraw, tx$a_MsgBridgeWithdrawResponse as MsgBridgeWithdrawResponse, MsgDefinition$a as MsgDefinition, tx$a_MsgRegisterBridgeValidator as MsgRegisterBridgeValidator, tx$a_MsgRegisterBridgeValidatorResponse as MsgRegisterBridgeValidatorResponse, tx$a_MsgSetVerifierBootstrap as MsgSetVerifierBootstrap, tx$a_MsgSetVerifierBootstrapResponse as MsgSetVerifierBootstrapResponse, tx$a_MsgUpdateChainConfig as MsgUpdateChainConfig, tx$a_MsgUpdateChainConfigResponse as MsgUpdateChainConfigResponse, tx$a_MsgUpdateEthLightClient as MsgUpdateEthLightClient, tx$a_MsgUpdateEthLightClientResponse as MsgUpdateEthLightClientResponse, tx$a_ValidatorQuorum as ValidatorQuorum, tx$a_WormholeGuardianSet as WormholeGuardianSet, protobufPackage$k as protobufPackage };
+declare const tx$9_BitcoinCheckpoint: typeof BitcoinCheckpoint;
+declare const tx$9_MsgBridgeAttestation: typeof MsgBridgeAttestation;
+declare const tx$9_MsgBridgeAttestationResponse: typeof MsgBridgeAttestationResponse;
+declare const tx$9_MsgBridgeDeposit: typeof MsgBridgeDeposit;
+declare const tx$9_MsgBridgeDepositResponse: typeof MsgBridgeDepositResponse;
+declare const tx$9_MsgBridgeWithdraw: typeof MsgBridgeWithdraw;
+declare const tx$9_MsgBridgeWithdrawResponse: typeof MsgBridgeWithdrawResponse;
+declare const tx$9_MsgRegisterBridgeValidator: typeof MsgRegisterBridgeValidator;
+declare const tx$9_MsgRegisterBridgeValidatorResponse: typeof MsgRegisterBridgeValidatorResponse;
+declare const tx$9_MsgSetVerifierBootstrap: typeof MsgSetVerifierBootstrap;
+declare const tx$9_MsgSetVerifierBootstrapResponse: typeof MsgSetVerifierBootstrapResponse;
+declare const tx$9_MsgUpdateChainConfig: typeof MsgUpdateChainConfig;
+declare const tx$9_MsgUpdateChainConfigResponse: typeof MsgUpdateChainConfigResponse;
+declare const tx$9_MsgUpdateEthLightClient: typeof MsgUpdateEthLightClient;
+declare const tx$9_MsgUpdateEthLightClientResponse: typeof MsgUpdateEthLightClientResponse;
+declare const tx$9_ValidatorQuorum: typeof ValidatorQuorum;
+declare const tx$9_WormholeGuardianSet: typeof WormholeGuardianSet;
+declare namespace tx$9 {
+  export { tx$9_BitcoinCheckpoint as BitcoinCheckpoint, type DeepPartial$o as DeepPartial, type MessageFns$o as MessageFns, tx$9_MsgBridgeAttestation as MsgBridgeAttestation, tx$9_MsgBridgeAttestationResponse as MsgBridgeAttestationResponse, tx$9_MsgBridgeDeposit as MsgBridgeDeposit, tx$9_MsgBridgeDepositResponse as MsgBridgeDepositResponse, tx$9_MsgBridgeWithdraw as MsgBridgeWithdraw, tx$9_MsgBridgeWithdrawResponse as MsgBridgeWithdrawResponse, MsgDefinition$9 as MsgDefinition, tx$9_MsgRegisterBridgeValidator as MsgRegisterBridgeValidator, tx$9_MsgRegisterBridgeValidatorResponse as MsgRegisterBridgeValidatorResponse, tx$9_MsgSetVerifierBootstrap as MsgSetVerifierBootstrap, tx$9_MsgSetVerifierBootstrapResponse as MsgSetVerifierBootstrapResponse, tx$9_MsgUpdateChainConfig as MsgUpdateChainConfig, tx$9_MsgUpdateChainConfigResponse as MsgUpdateChainConfigResponse, tx$9_MsgUpdateEthLightClient as MsgUpdateEthLightClient, tx$9_MsgUpdateEthLightClientResponse as MsgUpdateEthLightClientResponse, tx$9_ValidatorQuorum as ValidatorQuorum, tx$9_WormholeGuardianSet as WormholeGuardianSet, protobufPackage$n as protobufPackage };
 }
 
 /**
@@ -2528,22 +3078,22 @@ interface Coin {
     denom: string;
     amount: string;
 }
-declare const Coin: MessageFns$k<Coin>;
-type Builtin$k = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$k<T> = T extends Builtin$k ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$k<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$k<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$k<T[K]>;
+declare const Coin: MessageFns$n<Coin>;
+type Builtin$n = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$n<T> = T extends Builtin$n ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$n<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$n<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$n<T[K]>;
 } : Partial<T>;
-interface MessageFns$k<T> {
+interface MessageFns$n<T> {
     encode(message: T, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): T;
     fromJSON(object: any): T;
     toJSON(message: T): unknown;
-    create(base?: DeepPartial$k<T>): T;
-    fromPartial(object: DeepPartial$k<T>): T;
+    create(base?: DeepPartial$n<T>): T;
+    fromPartial(object: DeepPartial$n<T>): T;
 }
 
 /**
- * Convenience message builders for the standard Cosmos SDK modules.
+ * Convenience message builders for the standard Native modules.
  *
  * These wrap `cosmjs-types` message types and return cosmjs
  * {@link EncodeObject}s with the correct on-chain `typeUrl`. The matching types
@@ -2595,7 +3145,7 @@ declare const ibc: {
     transfer: (value: Partial<MsgTransfer>) => EncodeObject;
 };
 
-declare const protobufPackage$j = "qorechain.amm.v1";
+declare const protobufPackage$m = "qorechain.amm.v1";
 interface MsgCreatePool {
     creator: string;
     poolType: string;
@@ -2603,11 +3153,11 @@ interface MsgCreatePool {
     initialDepositB?: Coin | undefined;
     amplificationCoefficient: number;
 }
-declare const MsgCreatePool: MessageFns$j<MsgCreatePool>;
+declare const MsgCreatePool: MessageFns$m<MsgCreatePool>;
 interface MsgCreatePoolResponse {
     poolId: string;
 }
-declare const MsgCreatePoolResponse: MessageFns$j<MsgCreatePoolResponse>;
+declare const MsgCreatePoolResponse: MessageFns$m<MsgCreatePoolResponse>;
 interface MsgAddLiquidity {
     sender: string;
     poolId: string;
@@ -2615,10 +3165,10 @@ interface MsgAddLiquidity {
     amountB?: Coin | undefined;
     minLpOut: string;
 }
-declare const MsgAddLiquidity: MessageFns$j<MsgAddLiquidity>;
+declare const MsgAddLiquidity: MessageFns$m<MsgAddLiquidity>;
 interface MsgAddLiquidityResponse {
 }
-declare const MsgAddLiquidityResponse: MessageFns$j<MsgAddLiquidityResponse>;
+declare const MsgAddLiquidityResponse: MessageFns$m<MsgAddLiquidityResponse>;
 interface MsgRemoveLiquidity {
     sender: string;
     poolId: string;
@@ -2626,10 +3176,10 @@ interface MsgRemoveLiquidity {
     minAmountA: string;
     minAmountB: string;
 }
-declare const MsgRemoveLiquidity: MessageFns$j<MsgRemoveLiquidity>;
+declare const MsgRemoveLiquidity: MessageFns$m<MsgRemoveLiquidity>;
 interface MsgRemoveLiquidityResponse {
 }
-declare const MsgRemoveLiquidityResponse: MessageFns$j<MsgRemoveLiquidityResponse>;
+declare const MsgRemoveLiquidityResponse: MessageFns$m<MsgRemoveLiquidityResponse>;
 interface MsgSwapExactIn {
     sender: string;
     poolId: string;
@@ -2637,10 +3187,10 @@ interface MsgSwapExactIn {
     denomOut: string;
     minOut: string;
 }
-declare const MsgSwapExactIn: MessageFns$j<MsgSwapExactIn>;
+declare const MsgSwapExactIn: MessageFns$m<MsgSwapExactIn>;
 interface MsgSwapExactInResponse {
 }
-declare const MsgSwapExactInResponse: MessageFns$j<MsgSwapExactInResponse>;
+declare const MsgSwapExactInResponse: MessageFns$m<MsgSwapExactInResponse>;
 interface MsgSwapExactOut {
     sender: string;
     poolId: string;
@@ -2648,30 +3198,30 @@ interface MsgSwapExactOut {
     tokenOut?: Coin | undefined;
     maxIn: string;
 }
-declare const MsgSwapExactOut: MessageFns$j<MsgSwapExactOut>;
+declare const MsgSwapExactOut: MessageFns$m<MsgSwapExactOut>;
 interface MsgSwapExactOutResponse {
 }
-declare const MsgSwapExactOutResponse: MessageFns$j<MsgSwapExactOutResponse>;
+declare const MsgSwapExactOutResponse: MessageFns$m<MsgSwapExactOutResponse>;
 interface MsgPausePool {
     authority: string;
     poolId: string;
     reason: string;
 }
-declare const MsgPausePool: MessageFns$j<MsgPausePool>;
+declare const MsgPausePool: MessageFns$m<MsgPausePool>;
 interface MsgPausePoolResponse {
 }
-declare const MsgPausePoolResponse: MessageFns$j<MsgPausePoolResponse>;
+declare const MsgPausePoolResponse: MessageFns$m<MsgPausePoolResponse>;
 interface MsgResumePool {
     authority: string;
     poolId: string;
 }
-declare const MsgResumePool: MessageFns$j<MsgResumePool>;
+declare const MsgResumePool: MessageFns$m<MsgResumePool>;
 interface MsgResumePoolResponse {
 }
-declare const MsgResumePoolResponse: MessageFns$j<MsgResumePoolResponse>;
-type MsgDefinition$9 = typeof MsgDefinition$9;
-declare const MsgDefinition$9: {
-    readonly name: "Msg";
+declare const MsgResumePoolResponse: MessageFns$m<MsgResumePoolResponse>;
+type MsgDefinition$8 = typeof MsgDefinition$8;
+declare const MsgDefinition$8: {
+    readonly name: "Msg";
     readonly fullName: "qorechain.amm.v1.Msg";
     readonly methods: {
         readonly createPool: {
@@ -2732,38 +3282,38 @@ declare const MsgDefinition$9: {
         };
     };
 };
-type Builtin$j = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$j<T> = T extends Builtin$j ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$j<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$j<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$j<T[K]>;
+type Builtin$m = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$m<T> = T extends Builtin$m ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$m<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$m<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$m<T[K]>;
 } : Partial<T>;
-interface MessageFns$j<T> {
+interface MessageFns$m<T> {
     encode(message: T, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): T;
     fromJSON(object: any): T;
     toJSON(message: T): unknown;
-    create(base?: DeepPartial$j<T>): T;
-    fromPartial(object: DeepPartial$j<T>): T;
+    create(base?: DeepPartial$m<T>): T;
+    fromPartial(object: DeepPartial$m<T>): T;
 }
 
-declare const tx$9_MsgAddLiquidity: typeof MsgAddLiquidity;
-declare const tx$9_MsgAddLiquidityResponse: typeof MsgAddLiquidityResponse;
-declare const tx$9_MsgCreatePool: typeof MsgCreatePool;
-declare const tx$9_MsgCreatePoolResponse: typeof MsgCreatePoolResponse;
-declare const tx$9_MsgPausePool: typeof MsgPausePool;
-declare const tx$9_MsgPausePoolResponse: typeof MsgPausePoolResponse;
-declare const tx$9_MsgRemoveLiquidity: typeof MsgRemoveLiquidity;
-declare const tx$9_MsgRemoveLiquidityResponse: typeof MsgRemoveLiquidityResponse;
-declare const tx$9_MsgResumePool: typeof MsgResumePool;
-declare const tx$9_MsgResumePoolResponse: typeof MsgResumePoolResponse;
-declare const tx$9_MsgSwapExactIn: typeof MsgSwapExactIn;
-declare const tx$9_MsgSwapExactInResponse: typeof MsgSwapExactInResponse;
-declare const tx$9_MsgSwapExactOut: typeof MsgSwapExactOut;
-declare const tx$9_MsgSwapExactOutResponse: typeof MsgSwapExactOutResponse;
-declare namespace tx$9 {
-  export { type DeepPartial$j as DeepPartial, type MessageFns$j as MessageFns, tx$9_MsgAddLiquidity as MsgAddLiquidity, tx$9_MsgAddLiquidityResponse as MsgAddLiquidityResponse, tx$9_MsgCreatePool as MsgCreatePool, tx$9_MsgCreatePoolResponse as MsgCreatePoolResponse, MsgDefinition$9 as MsgDefinition, tx$9_MsgPausePool as MsgPausePool, tx$9_MsgPausePoolResponse as MsgPausePoolResponse, tx$9_MsgRemoveLiquidity as MsgRemoveLiquidity, tx$9_MsgRemoveLiquidityResponse as MsgRemoveLiquidityResponse, tx$9_MsgResumePool as MsgResumePool, tx$9_MsgResumePoolResponse as MsgResumePoolResponse, tx$9_MsgSwapExactIn as MsgSwapExactIn, tx$9_MsgSwapExactInResponse as MsgSwapExactInResponse, tx$9_MsgSwapExactOut as MsgSwapExactOut, tx$9_MsgSwapExactOutResponse as MsgSwapExactOutResponse, protobufPackage$j as protobufPackage };
+declare const tx$8_MsgAddLiquidity: typeof MsgAddLiquidity;
+declare const tx$8_MsgAddLiquidityResponse: typeof MsgAddLiquidityResponse;
+declare const tx$8_MsgCreatePool: typeof MsgCreatePool;
+declare const tx$8_MsgCreatePoolResponse: typeof MsgCreatePoolResponse;
+declare const tx$8_MsgPausePool: typeof MsgPausePool;
+declare const tx$8_MsgPausePoolResponse: typeof MsgPausePoolResponse;
+declare const tx$8_MsgRemoveLiquidity: typeof MsgRemoveLiquidity;
+declare const tx$8_MsgRemoveLiquidityResponse: typeof MsgRemoveLiquidityResponse;
+declare const tx$8_MsgResumePool: typeof MsgResumePool;
+declare const tx$8_MsgResumePoolResponse: typeof MsgResumePoolResponse;
+declare const tx$8_MsgSwapExactIn: typeof MsgSwapExactIn;
+declare const tx$8_MsgSwapExactInResponse: typeof MsgSwapExactInResponse;
+declare const tx$8_MsgSwapExactOut: typeof MsgSwapExactOut;
+declare const tx$8_MsgSwapExactOutResponse: typeof MsgSwapExactOutResponse;
+declare namespace tx$8 {
+  export { type DeepPartial$m as DeepPartial, type MessageFns$m as MessageFns, tx$8_MsgAddLiquidity as MsgAddLiquidity, tx$8_MsgAddLiquidityResponse as MsgAddLiquidityResponse, tx$8_MsgCreatePool as MsgCreatePool, tx$8_MsgCreatePoolResponse as MsgCreatePoolResponse, MsgDefinition$8 as MsgDefinition, tx$8_MsgPausePool as MsgPausePool, tx$8_MsgPausePoolResponse as MsgPausePoolResponse, tx$8_MsgRemoveLiquidity as MsgRemoveLiquidity, tx$8_MsgRemoveLiquidityResponse as MsgRemoveLiquidityResponse, tx$8_MsgResumePool as MsgResumePool, tx$8_MsgResumePoolResponse as MsgResumePoolResponse, tx$8_MsgSwapExactIn as MsgSwapExactIn, tx$8_MsgSwapExactInResponse as MsgSwapExactInResponse, tx$8_MsgSwapExactOut as MsgSwapExactOut, tx$8_MsgSwapExactOutResponse as MsgSwapExactOutResponse, protobufPackage$m as protobufPackage };
 }
 
-declare const protobufPackage$i = "qorechain.rdk.v1";
+declare const protobufPackage$l = "qorechain.rdk.v1";
 interface MsgCreateRollup {
     creator: string;
     rollupId: string;
@@ -2771,11 +3321,11 @@ interface MsgCreateRollup {
     vmType: string;
     stakeAmount: string;
 }
-declare const MsgCreateRollup: MessageFns$i<MsgCreateRollup>;
+declare const MsgCreateRollup: MessageFns$l<MsgCreateRollup>;
 interface MsgCreateRollupResponse {
     rollupId: string;
 }
-declare const MsgCreateRollupResponse: MessageFns$i<MsgCreateRollupResponse>;
+declare const MsgCreateRollupResponse: MessageFns$l<MsgCreateRollupResponse>;
 interface MsgSubmitBatch {
     sequencer: string;
     rollupId: string;
@@ -2791,20 +3341,20 @@ interface MsgSubmitBatch {
      */
     withdrawalsRoot: Uint8Array;
 }
-declare const MsgSubmitBatch: MessageFns$i<MsgSubmitBatch>;
+declare const MsgSubmitBatch: MessageFns$l<MsgSubmitBatch>;
 interface MsgSubmitBatchResponse {
 }
-declare const MsgSubmitBatchResponse: MessageFns$i<MsgSubmitBatchResponse>;
+declare const MsgSubmitBatchResponse: MessageFns$l<MsgSubmitBatchResponse>;
 interface MsgChallengeBatch {
     challenger: string;
     rollupId: string;
     batchIndex: string;
     proof: Uint8Array;
 }
-declare const MsgChallengeBatch: MessageFns$i<MsgChallengeBatch>;
+declare const MsgChallengeBatch: MessageFns$l<MsgChallengeBatch>;
 interface MsgChallengeBatchResponse {
 }
-declare const MsgChallengeBatchResponse: MessageFns$i<MsgChallengeBatchResponse>;
+declare const MsgChallengeBatchResponse: MessageFns$l<MsgChallengeBatchResponse>;
 interface MsgResolveChallenge {
     resolver: string;
     rollupId: string;
@@ -2816,35 +3366,35 @@ interface MsgResolveChallenge {
      */
     fraudUpheld: boolean;
 }
-declare const MsgResolveChallenge: MessageFns$i<MsgResolveChallenge>;
+declare const MsgResolveChallenge: MessageFns$l<MsgResolveChallenge>;
 interface MsgResolveChallengeResponse {
 }
-declare const MsgResolveChallengeResponse: MessageFns$i<MsgResolveChallengeResponse>;
+declare const MsgResolveChallengeResponse: MessageFns$l<MsgResolveChallengeResponse>;
 interface MsgPauseRollup {
     creator: string;
     rollupId: string;
     reason: string;
 }
-declare const MsgPauseRollup: MessageFns$i<MsgPauseRollup>;
+declare const MsgPauseRollup: MessageFns$l<MsgPauseRollup>;
 interface MsgPauseRollupResponse {
 }
-declare const MsgPauseRollupResponse: MessageFns$i<MsgPauseRollupResponse>;
+declare const MsgPauseRollupResponse: MessageFns$l<MsgPauseRollupResponse>;
 interface MsgResumeRollup {
     creator: string;
     rollupId: string;
 }
-declare const MsgResumeRollup: MessageFns$i<MsgResumeRollup>;
+declare const MsgResumeRollup: MessageFns$l<MsgResumeRollup>;
 interface MsgResumeRollupResponse {
 }
-declare const MsgResumeRollupResponse: MessageFns$i<MsgResumeRollupResponse>;
+declare const MsgResumeRollupResponse: MessageFns$l<MsgResumeRollupResponse>;
 interface MsgStopRollup {
     creator: string;
     rollupId: string;
 }
-declare const MsgStopRollup: MessageFns$i<MsgStopRollup>;
+declare const MsgStopRollup: MessageFns$l<MsgStopRollup>;
 interface MsgStopRollupResponse {
 }
-declare const MsgStopRollupResponse: MessageFns$i<MsgStopRollupResponse>;
+declare const MsgStopRollupResponse: MessageFns$l<MsgStopRollupResponse>;
 /**
  * MsgExecuteWithdrawal finalizes an L2->L1 cross-layer message: it proves a
  * withdrawal leaf is committed in a finalized batch's withdrawals_root and pays
@@ -2863,13 +3413,13 @@ interface MsgExecuteWithdrawal {
     /** proof are the binary-Merkle sibling hashes from the leaf to withdrawals_root. */
     proof: Uint8Array[];
 }
-declare const MsgExecuteWithdrawal: MessageFns$i<MsgExecuteWithdrawal>;
+declare const MsgExecuteWithdrawal: MessageFns$l<MsgExecuteWithdrawal>;
 interface MsgExecuteWithdrawalResponse {
 }
-declare const MsgExecuteWithdrawalResponse: MessageFns$i<MsgExecuteWithdrawalResponse>;
+declare const MsgExecuteWithdrawalResponse: MessageFns$l<MsgExecuteWithdrawalResponse>;
 /** Msg defines the rdk module's transaction service. */
-type MsgDefinition$8 = typeof MsgDefinition$8;
-declare const MsgDefinition$8: {
+type MsgDefinition$7 = typeof MsgDefinition$7;
+declare const MsgDefinition$7: {
     readonly name: "Msg";
     readonly fullName: "qorechain.rdk.v1.Msg";
     readonly methods: {
@@ -2939,40 +3489,40 @@ declare const MsgDefinition$8: {
         };
     };
 };
-type Builtin$i = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$i<T> = T extends Builtin$i ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$i<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$i<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$i<T[K]>;
+type Builtin$l = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$l<T> = T extends Builtin$l ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$l<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$l<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$l<T[K]>;
 } : Partial<T>;
-interface MessageFns$i<T> {
+interface MessageFns$l<T> {
     encode(message: T, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): T;
     fromJSON(object: any): T;
     toJSON(message: T): unknown;
-    create(base?: DeepPartial$i<T>): T;
-    fromPartial(object: DeepPartial$i<T>): T;
+    create(base?: DeepPartial$l<T>): T;
+    fromPartial(object: DeepPartial$l<T>): T;
 }
 
-declare const tx$8_MsgChallengeBatch: typeof MsgChallengeBatch;
-declare const tx$8_MsgChallengeBatchResponse: typeof MsgChallengeBatchResponse;
-declare const tx$8_MsgCreateRollup: typeof MsgCreateRollup;
-declare const tx$8_MsgCreateRollupResponse: typeof MsgCreateRollupResponse;
-declare const tx$8_MsgExecuteWithdrawal: typeof MsgExecuteWithdrawal;
-declare const tx$8_MsgExecuteWithdrawalResponse: typeof MsgExecuteWithdrawalResponse;
-declare const tx$8_MsgPauseRollup: typeof MsgPauseRollup;
-declare const tx$8_MsgPauseRollupResponse: typeof MsgPauseRollupResponse;
-declare const tx$8_MsgResolveChallenge: typeof MsgResolveChallenge;
-declare const tx$8_MsgResolveChallengeResponse: typeof MsgResolveChallengeResponse;
-declare const tx$8_MsgResumeRollup: typeof MsgResumeRollup;
-declare const tx$8_MsgResumeRollupResponse: typeof MsgResumeRollupResponse;
-declare const tx$8_MsgStopRollup: typeof MsgStopRollup;
-declare const tx$8_MsgStopRollupResponse: typeof MsgStopRollupResponse;
-declare const tx$8_MsgSubmitBatch: typeof MsgSubmitBatch;
-declare const tx$8_MsgSubmitBatchResponse: typeof MsgSubmitBatchResponse;
-declare namespace tx$8 {
-  export { type DeepPartial$i as DeepPartial, type MessageFns$i as MessageFns, tx$8_MsgChallengeBatch as MsgChallengeBatch, tx$8_MsgChallengeBatchResponse as MsgChallengeBatchResponse, tx$8_MsgCreateRollup as MsgCreateRollup, tx$8_MsgCreateRollupResponse as MsgCreateRollupResponse, MsgDefinition$8 as MsgDefinition, tx$8_MsgExecuteWithdrawal as MsgExecuteWithdrawal, tx$8_MsgExecuteWithdrawalResponse as MsgExecuteWithdrawalResponse, tx$8_MsgPauseRollup as MsgPauseRollup, tx$8_MsgPauseRollupResponse as MsgPauseRollupResponse, tx$8_MsgResolveChallenge as MsgResolveChallenge, tx$8_MsgResolveChallengeResponse as MsgResolveChallengeResponse, tx$8_MsgResumeRollup as MsgResumeRollup, tx$8_MsgResumeRollupResponse as MsgResumeRollupResponse, tx$8_MsgStopRollup as MsgStopRollup, tx$8_MsgStopRollupResponse as MsgStopRollupResponse, tx$8_MsgSubmitBatch as MsgSubmitBatch, tx$8_MsgSubmitBatchResponse as MsgSubmitBatchResponse, protobufPackage$i as protobufPackage };
+declare const tx$7_MsgChallengeBatch: typeof MsgChallengeBatch;
+declare const tx$7_MsgChallengeBatchResponse: typeof MsgChallengeBatchResponse;
+declare const tx$7_MsgCreateRollup: typeof MsgCreateRollup;
+declare const tx$7_MsgCreateRollupResponse: typeof MsgCreateRollupResponse;
+declare const tx$7_MsgExecuteWithdrawal: typeof MsgExecuteWithdrawal;
+declare const tx$7_MsgExecuteWithdrawalResponse: typeof MsgExecuteWithdrawalResponse;
+declare const tx$7_MsgPauseRollup: typeof MsgPauseRollup;
+declare const tx$7_MsgPauseRollupResponse: typeof MsgPauseRollupResponse;
+declare const tx$7_MsgResolveChallenge: typeof MsgResolveChallenge;
+declare const tx$7_MsgResolveChallengeResponse: typeof MsgResolveChallengeResponse;
+declare const tx$7_MsgResumeRollup: typeof MsgResumeRollup;
+declare const tx$7_MsgResumeRollupResponse: typeof MsgResumeRollupResponse;
+declare const tx$7_MsgStopRollup: typeof MsgStopRollup;
+declare const tx$7_MsgStopRollupResponse: typeof MsgStopRollupResponse;
+declare const tx$7_MsgSubmitBatch: typeof MsgSubmitBatch;
+declare const tx$7_MsgSubmitBatchResponse: typeof MsgSubmitBatchResponse;
+declare namespace tx$7 {
+  export { type DeepPartial$l as DeepPartial, type MessageFns$l as MessageFns, tx$7_MsgChallengeBatch as MsgChallengeBatch, tx$7_MsgChallengeBatchResponse as MsgChallengeBatchResponse, tx$7_MsgCreateRollup as MsgCreateRollup, tx$7_MsgCreateRollupResponse as MsgCreateRollupResponse, MsgDefinition$7 as MsgDefinition, tx$7_MsgExecuteWithdrawal as MsgExecuteWithdrawal, tx$7_MsgExecuteWithdrawalResponse as MsgExecuteWithdrawalResponse, tx$7_MsgPauseRollup as MsgPauseRollup, tx$7_MsgPauseRollupResponse as MsgPauseRollupResponse, tx$7_MsgResolveChallenge as MsgResolveChallenge, tx$7_MsgResolveChallengeResponse as MsgResolveChallengeResponse, tx$7_MsgResumeRollup as MsgResumeRollup, tx$7_MsgResumeRollupResponse as MsgResumeRollupResponse, tx$7_MsgStopRollup as MsgStopRollup, tx$7_MsgStopRollupResponse as MsgStopRollupResponse, tx$7_MsgSubmitBatch as MsgSubmitBatch, tx$7_MsgSubmitBatchResponse as MsgSubmitBatchResponse, protobufPackage$l as protobufPackage };
 }
 
-declare const protobufPackage$h = "qorechain.multilayer.v1";
+declare const protobufPackage$k = "qorechain.multilayer.v1";
 interface MsgRegisterSidechain {
     creator: string;
     layerId: string;
@@ -2984,13 +3534,13 @@ interface MsgRegisterSidechain {
     supportedVmTypes: string[];
     supportedDomains: string[];
 }
-declare const MsgRegisterSidechain: MessageFns$h<MsgRegisterSidechain>;
+declare const MsgRegisterSidechain: MessageFns$k<MsgRegisterSidechain>;
 interface MsgRegisterSidechainResponse {
     layerId: string;
     chainId: string;
     status: string;
 }
-declare const MsgRegisterSidechainResponse: MessageFns$h<MsgRegisterSidechainResponse>;
+declare const MsgRegisterSidechainResponse: MessageFns$k<MsgRegisterSidechainResponse>;
 interface MsgRegisterPaychain {
     creator: string;
     layerId: string;
@@ -2999,12 +3549,12 @@ interface MsgRegisterPaychain {
     settlementIntervalBlocks: string;
     baseFeeMultiplier: string;
 }
-declare const MsgRegisterPaychain: MessageFns$h<MsgRegisterPaychain>;
+declare const MsgRegisterPaychain: MessageFns$k<MsgRegisterPaychain>;
 interface MsgRegisterPaychainResponse {
     layerId: string;
     status: string;
 }
-declare const MsgRegisterPaychainResponse: MessageFns$h<MsgRegisterPaychainResponse>;
+declare const MsgRegisterPaychainResponse: MessageFns$k<MsgRegisterPaychainResponse>;
 interface MsgAnchorState {
     relayer: string;
     layerId: string;
@@ -3015,12 +3565,12 @@ interface MsgAnchorState {
     transactionCount: string;
     compressedStateProof: Uint8Array;
 }
-declare const MsgAnchorState: MessageFns$h<MsgAnchorState>;
+declare const MsgAnchorState: MessageFns$k<MsgAnchorState>;
 interface MsgAnchorStateResponse {
     mainChainHeight: string;
     accepted: boolean;
 }
-declare const MsgAnchorStateResponse: MessageFns$h<MsgAnchorStateResponse>;
+declare const MsgAnchorStateResponse: MessageFns$k<MsgAnchorStateResponse>;
 interface MsgRouteTransaction {
     sender: string;
     transactionPayload: Uint8Array;
@@ -3028,23 +3578,23 @@ interface MsgRouteTransaction {
     maxLatencyMs: string;
     maxFee: string;
 }
-declare const MsgRouteTransaction: MessageFns$h<MsgRouteTransaction>;
+declare const MsgRouteTransaction: MessageFns$k<MsgRouteTransaction>;
 interface MsgRouteTransactionResponse {
     selectedLayer: string;
     reason: string;
     crossLayerMessageId: string;
 }
-declare const MsgRouteTransactionResponse: MessageFns$h<MsgRouteTransactionResponse>;
+declare const MsgRouteTransactionResponse: MessageFns$k<MsgRouteTransactionResponse>;
 interface MsgUpdateLayerStatus {
     authority: string;
     layerId: string;
     newStatus: string;
     reason: string;
 }
-declare const MsgUpdateLayerStatus: MessageFns$h<MsgUpdateLayerStatus>;
+declare const MsgUpdateLayerStatus: MessageFns$k<MsgUpdateLayerStatus>;
 interface MsgUpdateLayerStatusResponse {
 }
-declare const MsgUpdateLayerStatusResponse: MessageFns$h<MsgUpdateLayerStatusResponse>;
+declare const MsgUpdateLayerStatusResponse: MessageFns$k<MsgUpdateLayerStatusResponse>;
 interface MsgChallengeAnchor {
     challenger: string;
     layerId: string;
@@ -3052,14 +3602,14 @@ interface MsgChallengeAnchor {
     fraudProof: Uint8Array;
     challengeReason: string;
 }
-declare const MsgChallengeAnchor: MessageFns$h<MsgChallengeAnchor>;
+declare const MsgChallengeAnchor: MessageFns$k<MsgChallengeAnchor>;
 interface MsgChallengeAnchorResponse {
     challengeAccepted: boolean;
     resolution: string;
 }
-declare const MsgChallengeAnchorResponse: MessageFns$h<MsgChallengeAnchorResponse>;
-type MsgDefinition$7 = typeof MsgDefinition$7;
-declare const MsgDefinition$7: {
+declare const MsgChallengeAnchorResponse: MessageFns$k<MsgChallengeAnchorResponse>;
+type MsgDefinition$6 = typeof MsgDefinition$6;
+declare const MsgDefinition$6: {
     readonly name: "Msg";
     readonly fullName: "qorechain.multilayer.v1.Msg";
     readonly methods: {
@@ -3113,36 +3663,36 @@ declare const MsgDefinition$7: {
         };
     };
 };
-type Builtin$h = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$h<T> = T extends Builtin$h ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$h<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$h<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$h<T[K]>;
+type Builtin$k = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$k<T> = T extends Builtin$k ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$k<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$k<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$k<T[K]>;
 } : Partial<T>;
-interface MessageFns$h<T> {
+interface MessageFns$k<T> {
     encode(message: T, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): T;
     fromJSON(object: any): T;
     toJSON(message: T): unknown;
-    create(base?: DeepPartial$h<T>): T;
-    fromPartial(object: DeepPartial$h<T>): T;
+    create(base?: DeepPartial$k<T>): T;
+    fromPartial(object: DeepPartial$k<T>): T;
 }
 
-declare const tx$7_MsgAnchorState: typeof MsgAnchorState;
-declare const tx$7_MsgAnchorStateResponse: typeof MsgAnchorStateResponse;
-declare const tx$7_MsgChallengeAnchor: typeof MsgChallengeAnchor;
-declare const tx$7_MsgChallengeAnchorResponse: typeof MsgChallengeAnchorResponse;
-declare const tx$7_MsgRegisterPaychain: typeof MsgRegisterPaychain;
-declare const tx$7_MsgRegisterPaychainResponse: typeof MsgRegisterPaychainResponse;
-declare const tx$7_MsgRegisterSidechain: typeof MsgRegisterSidechain;
-declare const tx$7_MsgRegisterSidechainResponse: typeof MsgRegisterSidechainResponse;
-declare const tx$7_MsgRouteTransaction: typeof MsgRouteTransaction;
-declare const tx$7_MsgRouteTransactionResponse: typeof MsgRouteTransactionResponse;
-declare const tx$7_MsgUpdateLayerStatus: typeof MsgUpdateLayerStatus;
-declare const tx$7_MsgUpdateLayerStatusResponse: typeof MsgUpdateLayerStatusResponse;
-declare namespace tx$7 {
-  export { type DeepPartial$h as DeepPartial, type MessageFns$h as MessageFns, tx$7_MsgAnchorState as MsgAnchorState, tx$7_MsgAnchorStateResponse as MsgAnchorStateResponse, tx$7_MsgChallengeAnchor as MsgChallengeAnchor, tx$7_MsgChallengeAnchorResponse as MsgChallengeAnchorResponse, MsgDefinition$7 as MsgDefinition, tx$7_MsgRegisterPaychain as MsgRegisterPaychain, tx$7_MsgRegisterPaychainResponse as MsgRegisterPaychainResponse, tx$7_MsgRegisterSidechain as MsgRegisterSidechain, tx$7_MsgRegisterSidechainResponse as MsgRegisterSidechainResponse, tx$7_MsgRouteTransaction as MsgRouteTransaction, tx$7_MsgRouteTransactionResponse as MsgRouteTransactionResponse, tx$7_MsgUpdateLayerStatus as MsgUpdateLayerStatus, tx$7_MsgUpdateLayerStatusResponse as MsgUpdateLayerStatusResponse, protobufPackage$h as protobufPackage };
+declare const tx$6_MsgAnchorState: typeof MsgAnchorState;
+declare const tx$6_MsgAnchorStateResponse: typeof MsgAnchorStateResponse;
+declare const tx$6_MsgChallengeAnchor: typeof MsgChallengeAnchor;
+declare const tx$6_MsgChallengeAnchorResponse: typeof MsgChallengeAnchorResponse;
+declare const tx$6_MsgRegisterPaychain: typeof MsgRegisterPaychain;
+declare const tx$6_MsgRegisterPaychainResponse: typeof MsgRegisterPaychainResponse;
+declare const tx$6_MsgRegisterSidechain: typeof MsgRegisterSidechain;
+declare const tx$6_MsgRegisterSidechainResponse: typeof MsgRegisterSidechainResponse;
+declare const tx$6_MsgRouteTransaction: typeof MsgRouteTransaction;
+declare const tx$6_MsgRouteTransactionResponse: typeof MsgRouteTransactionResponse;
+declare const tx$6_MsgUpdateLayerStatus: typeof MsgUpdateLayerStatus;
+declare const tx$6_MsgUpdateLayerStatusResponse: typeof MsgUpdateLayerStatusResponse;
+declare namespace tx$6 {
+  export { type DeepPartial$k as DeepPartial, type MessageFns$k as MessageFns, tx$6_MsgAnchorState as MsgAnchorState, tx$6_MsgAnchorStateResponse as MsgAnchorStateResponse, tx$6_MsgChallengeAnchor as MsgChallengeAnchor, tx$6_MsgChallengeAnchorResponse as MsgChallengeAnchorResponse, MsgDefinition$6 as MsgDefinition, tx$6_MsgRegisterPaychain as MsgRegisterPaychain, tx$6_MsgRegisterPaychainResponse as MsgRegisterPaychainResponse, tx$6_MsgRegisterSidechain as MsgRegisterSidechain, tx$6_MsgRegisterSidechainResponse as MsgRegisterSidechainResponse, tx$6_MsgRouteTransaction as MsgRouteTransaction, tx$6_MsgRouteTransactionResponse as MsgRouteTransactionResponse, tx$6_MsgUpdateLayerStatus as MsgUpdateLayerStatus, tx$6_MsgUpdateLayerStatusResponse as MsgUpdateLayerStatusResponse, protobufPackage$k as protobufPackage };
 }
 
-declare const protobufPackage$g = "qorechain.pqc.v1";
+declare const protobufPackage$j = "qorechain.pqc.v1";
 /**
  * MsgRegisterPQCKey registers a PQC keypair for an account.
  * Deprecated: use MsgRegisterPQCKeyV2 which includes algorithm_id.
@@ -3153,10 +3703,10 @@ interface MsgRegisterPQCKey {
     ecdsaPubkey: Uint8Array;
     keyType: string;
 }
-declare const MsgRegisterPQCKey: MessageFns$g<MsgRegisterPQCKey>;
+declare const MsgRegisterPQCKey: MessageFns$j<MsgRegisterPQCKey>;
 interface MsgRegisterPQCKeyResponse {
 }
-declare const MsgRegisterPQCKeyResponse: MessageFns$g<MsgRegisterPQCKeyResponse>;
+declare const MsgRegisterPQCKeyResponse: MessageFns$j<MsgRegisterPQCKeyResponse>;
 /** MsgRegisterPQCKeyV2 registers a PQC key with explicit algorithm selection. */
 interface MsgRegisterPQCKeyV2 {
     sender: string;
@@ -3165,10 +3715,10 @@ interface MsgRegisterPQCKeyV2 {
     ecdsaPubkey: Uint8Array;
     keyType: string;
 }
-declare const MsgRegisterPQCKeyV2: MessageFns$g<MsgRegisterPQCKeyV2>;
+declare const MsgRegisterPQCKeyV2: MessageFns$j<MsgRegisterPQCKeyV2>;
 interface MsgRegisterPQCKeyV2Response {
 }
-declare const MsgRegisterPQCKeyV2Response: MessageFns$g<MsgRegisterPQCKeyV2Response>;
+declare const MsgRegisterPQCKeyV2Response: MessageFns$j<MsgRegisterPQCKeyV2Response>;
 /** MsgMigratePQCKey migrates an account's PQC key, proving ownership of both keys. */
 interface MsgMigratePQCKey {
     sender: string;
@@ -3178,10 +3728,10 @@ interface MsgMigratePQCKey {
     oldSignature: Uint8Array;
     newSignature: Uint8Array;
 }
-declare const MsgMigratePQCKey: MessageFns$g<MsgMigratePQCKey>;
+declare const MsgMigratePQCKey: MessageFns$j<MsgMigratePQCKey>;
 interface MsgMigratePQCKeyResponse {
 }
-declare const MsgMigratePQCKeyResponse: MessageFns$g<MsgMigratePQCKeyResponse>;
+declare const MsgMigratePQCKeyResponse: MessageFns$j<MsgMigratePQCKeyResponse>;
 /** MsgDeprecateAlgorithm proposes deprecating an algorithm (starts migration period). */
 interface MsgDeprecateAlgorithm {
     authority: string;
@@ -3189,23 +3739,23 @@ interface MsgDeprecateAlgorithm {
     migrationBlocks: string;
     replacementAlgorithmId: number;
 }
-declare const MsgDeprecateAlgorithm: MessageFns$g<MsgDeprecateAlgorithm>;
+declare const MsgDeprecateAlgorithm: MessageFns$j<MsgDeprecateAlgorithm>;
 interface MsgDeprecateAlgorithmResponse {
 }
-declare const MsgDeprecateAlgorithmResponse: MessageFns$g<MsgDeprecateAlgorithmResponse>;
+declare const MsgDeprecateAlgorithmResponse: MessageFns$j<MsgDeprecateAlgorithmResponse>;
 /** MsgDisableAlgorithm emergency-disables an algorithm (e.g., vulnerability discovered). */
 interface MsgDisableAlgorithm {
     authority: string;
     algorithmId: number;
     reason: string;
 }
-declare const MsgDisableAlgorithm: MessageFns$g<MsgDisableAlgorithm>;
+declare const MsgDisableAlgorithm: MessageFns$j<MsgDisableAlgorithm>;
 interface MsgDisableAlgorithmResponse {
 }
-declare const MsgDisableAlgorithmResponse: MessageFns$g<MsgDisableAlgorithmResponse>;
+declare const MsgDisableAlgorithmResponse: MessageFns$j<MsgDisableAlgorithmResponse>;
 /** Msg defines the PQC module's transaction service. */
-type MsgDefinition$6 = typeof MsgDefinition$6;
-declare const MsgDefinition$6: {
+type MsgDefinition$5 = typeof MsgDefinition$5;
+declare const MsgDefinition$5: {
     readonly name: "Msg";
     readonly fullName: "qorechain.pqc.v1.Msg";
     readonly methods: {
@@ -3256,177 +3806,65 @@ declare const MsgDefinition$6: {
         };
     };
 };
-type Builtin$g = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$g<T> = T extends Builtin$g ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$g<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$g<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$g<T[K]>;
-} : Partial<T>;
-interface MessageFns$g<T> {
-    encode(message: T, writer?: BinaryWriter): BinaryWriter;
-    decode(input: BinaryReader | Uint8Array, length?: number): T;
-    fromJSON(object: any): T;
-    toJSON(message: T): unknown;
-    create(base?: DeepPartial$g<T>): T;
-    fromPartial(object: DeepPartial$g<T>): T;
-}
-
-declare const tx$6_MsgDeprecateAlgorithm: typeof MsgDeprecateAlgorithm;
-declare const tx$6_MsgDeprecateAlgorithmResponse: typeof MsgDeprecateAlgorithmResponse;
-declare const tx$6_MsgDisableAlgorithm: typeof MsgDisableAlgorithm;
-declare const tx$6_MsgDisableAlgorithmResponse: typeof MsgDisableAlgorithmResponse;
-declare const tx$6_MsgMigratePQCKey: typeof MsgMigratePQCKey;
-declare const tx$6_MsgMigratePQCKeyResponse: typeof MsgMigratePQCKeyResponse;
-declare const tx$6_MsgRegisterPQCKey: typeof MsgRegisterPQCKey;
-declare const tx$6_MsgRegisterPQCKeyResponse: typeof MsgRegisterPQCKeyResponse;
-declare const tx$6_MsgRegisterPQCKeyV2: typeof MsgRegisterPQCKeyV2;
-declare const tx$6_MsgRegisterPQCKeyV2Response: typeof MsgRegisterPQCKeyV2Response;
-declare namespace tx$6 {
-  export { type DeepPartial$g as DeepPartial, type MessageFns$g as MessageFns, MsgDefinition$6 as MsgDefinition, tx$6_MsgDeprecateAlgorithm as MsgDeprecateAlgorithm, tx$6_MsgDeprecateAlgorithmResponse as MsgDeprecateAlgorithmResponse, tx$6_MsgDisableAlgorithm as MsgDisableAlgorithm, tx$6_MsgDisableAlgorithmResponse as MsgDisableAlgorithmResponse, tx$6_MsgMigratePQCKey as MsgMigratePQCKey, tx$6_MsgMigratePQCKeyResponse as MsgMigratePQCKeyResponse, tx$6_MsgRegisterPQCKey as MsgRegisterPQCKey, tx$6_MsgRegisterPQCKeyResponse as MsgRegisterPQCKeyResponse, tx$6_MsgRegisterPQCKeyV2 as MsgRegisterPQCKeyV2, tx$6_MsgRegisterPQCKeyV2Response as MsgRegisterPQCKeyV2Response, protobufPackage$g as protobufPackage };
-}
-
-declare const protobufPackage$f = "qorechain.svm.v1";
-interface MsgDeployProgram {
-    sender: string;
-    bytecode: Uint8Array;
-}
-declare const MsgDeployProgram: MessageFns$f<MsgDeployProgram>;
-interface MsgDeployProgramResponse {
-    programId: Uint8Array;
-}
-declare const MsgDeployProgramResponse: MessageFns$f<MsgDeployProgramResponse>;
-interface MsgCreateAccount {
-    sender: string;
-    owner: Uint8Array;
-    space: string;
-    lamports: string;
-    salt: Uint8Array;
-}
-declare const MsgCreateAccount: MessageFns$f<MsgCreateAccount>;
-interface MsgCreateAccountResponse {
-}
-declare const MsgCreateAccountResponse: MessageFns$f<MsgCreateAccountResponse>;
-interface SvmAccountMeta {
-    address: Uint8Array;
-    isSigner: boolean;
-    isWritable: boolean;
-}
-declare const SvmAccountMeta: MessageFns$f<SvmAccountMeta>;
-interface MsgExecuteProgram {
-    sender: string;
-    programId: Uint8Array;
-    accounts: SvmAccountMeta[];
-    data: Uint8Array;
-}
-declare const MsgExecuteProgram: MessageFns$f<MsgExecuteProgram>;
-interface MsgExecuteProgramResponse {
-    result: Uint8Array;
-}
-declare const MsgExecuteProgramResponse: MessageFns$f<MsgExecuteProgramResponse>;
-interface MsgRegisterSVMPQCKey {
-    sender: string;
-    svmAddr: Uint8Array;
-    pqcPubKey: Uint8Array;
-}
-declare const MsgRegisterSVMPQCKey: MessageFns$f<MsgRegisterSVMPQCKey>;
-interface MsgRegisterSVMPQCKeyResponse {
-}
-declare const MsgRegisterSVMPQCKeyResponse: MessageFns$f<MsgRegisterSVMPQCKeyResponse>;
-type MsgDefinition$5 = typeof MsgDefinition$5;
-declare const MsgDefinition$5: {
-    readonly name: "Msg";
-    readonly fullName: "qorechain.svm.v1.Msg";
-    readonly methods: {
-        readonly deployProgram: {
-            readonly name: "DeployProgram";
-            readonly requestType: typeof MsgDeployProgram;
-            readonly requestStream: false;
-            readonly responseType: typeof MsgDeployProgramResponse;
-            readonly responseStream: false;
-            readonly options: {};
-        };
-        readonly createAccount: {
-            readonly name: "CreateAccount";
-            readonly requestType: typeof MsgCreateAccount;
-            readonly requestStream: false;
-            readonly responseType: typeof MsgCreateAccountResponse;
-            readonly responseStream: false;
-            readonly options: {};
-        };
-        readonly executeProgram: {
-            readonly name: "ExecuteProgram";
-            readonly requestType: typeof MsgExecuteProgram;
-            readonly requestStream: false;
-            readonly responseType: typeof MsgExecuteProgramResponse;
-            readonly responseStream: false;
-            readonly options: {};
-        };
-        readonly registerSVMPQCKey: {
-            readonly name: "RegisterSVMPQCKey";
-            readonly requestType: typeof MsgRegisterSVMPQCKey;
-            readonly requestStream: false;
-            readonly responseType: typeof MsgRegisterSVMPQCKeyResponse;
-            readonly responseStream: false;
-            readonly options: {};
-        };
-    };
-};
-type Builtin$f = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$f<T> = T extends Builtin$f ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$f<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$f<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$f<T[K]>;
+type Builtin$j = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$j<T> = T extends Builtin$j ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$j<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$j<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$j<T[K]>;
 } : Partial<T>;
-interface MessageFns$f<T> {
+interface MessageFns$j<T> {
     encode(message: T, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): T;
     fromJSON(object: any): T;
     toJSON(message: T): unknown;
-    create(base?: DeepPartial$f<T>): T;
-    fromPartial(object: DeepPartial$f<T>): T;
+    create(base?: DeepPartial$j<T>): T;
+    fromPartial(object: DeepPartial$j<T>): T;
 }
 
-declare const tx$5_MsgCreateAccount: typeof MsgCreateAccount;
-declare const tx$5_MsgCreateAccountResponse: typeof MsgCreateAccountResponse;
-declare const tx$5_MsgDeployProgram: typeof MsgDeployProgram;
-declare const tx$5_MsgDeployProgramResponse: typeof MsgDeployProgramResponse;
-declare const tx$5_MsgExecuteProgram: typeof MsgExecuteProgram;
-declare const tx$5_MsgExecuteProgramResponse: typeof MsgExecuteProgramResponse;
-declare const tx$5_MsgRegisterSVMPQCKey: typeof MsgRegisterSVMPQCKey;
-declare const tx$5_MsgRegisterSVMPQCKeyResponse: typeof MsgRegisterSVMPQCKeyResponse;
-declare const tx$5_SvmAccountMeta: typeof SvmAccountMeta;
+declare const tx$5_MsgDeprecateAlgorithm: typeof MsgDeprecateAlgorithm;
+declare const tx$5_MsgDeprecateAlgorithmResponse: typeof MsgDeprecateAlgorithmResponse;
+declare const tx$5_MsgDisableAlgorithm: typeof MsgDisableAlgorithm;
+declare const tx$5_MsgDisableAlgorithmResponse: typeof MsgDisableAlgorithmResponse;
+declare const tx$5_MsgMigratePQCKey: typeof MsgMigratePQCKey;
+declare const tx$5_MsgMigratePQCKeyResponse: typeof MsgMigratePQCKeyResponse;
+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 namespace tx$5 {
-  export { type DeepPartial$f as DeepPartial, type MessageFns$f as MessageFns, tx$5_MsgCreateAccount as MsgCreateAccount, tx$5_MsgCreateAccountResponse as MsgCreateAccountResponse, MsgDefinition$5 as MsgDefinition, tx$5_MsgDeployProgram as MsgDeployProgram, tx$5_MsgDeployProgramResponse as MsgDeployProgramResponse, tx$5_MsgExecuteProgram as MsgExecuteProgram, tx$5_MsgExecuteProgramResponse as MsgExecuteProgramResponse, tx$5_MsgRegisterSVMPQCKey as MsgRegisterSVMPQCKey, tx$5_MsgRegisterSVMPQCKeyResponse as MsgRegisterSVMPQCKeyResponse, tx$5_SvmAccountMeta as SvmAccountMeta, protobufPackage$f 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, protobufPackage$j as protobufPackage };
 }
 
-declare const protobufPackage$e = "qorechain.lightnode.v1";
+declare const protobufPackage$i = "qorechain.lightnode.v1";
 interface MsgRegisterLightNode {
     operator: string;
     nodeType: string;
     version: string;
     capabilities: string[];
 }
-declare const MsgRegisterLightNode: MessageFns$e<MsgRegisterLightNode>;
+declare const MsgRegisterLightNode: MessageFns$i<MsgRegisterLightNode>;
 interface MsgRegisterLightNodeResponse {
 }
-declare const MsgRegisterLightNodeResponse: MessageFns$e<MsgRegisterLightNodeResponse>;
+declare const MsgRegisterLightNodeResponse: MessageFns$i<MsgRegisterLightNodeResponse>;
 interface MsgHeartbeat {
     operator: string;
 }
-declare const MsgHeartbeat: MessageFns$e<MsgHeartbeat>;
+declare const MsgHeartbeat: MessageFns$i<MsgHeartbeat>;
 interface MsgHeartbeatResponse {
 }
-declare const MsgHeartbeatResponse: MessageFns$e<MsgHeartbeatResponse>;
+declare const MsgHeartbeatResponse: MessageFns$i<MsgHeartbeatResponse>;
 interface MsgDeregisterLightNode {
     operator: string;
 }
-declare const MsgDeregisterLightNode: MessageFns$e<MsgDeregisterLightNode>;
+declare const MsgDeregisterLightNode: MessageFns$i<MsgDeregisterLightNode>;
 interface MsgDeregisterLightNodeResponse {
 }
-declare const MsgDeregisterLightNodeResponse: MessageFns$e<MsgDeregisterLightNodeResponse>;
+declare const MsgDeregisterLightNodeResponse: MessageFns$i<MsgDeregisterLightNodeResponse>;
 interface MsgClaimLightNodeRewards {
     operator: string;
 }
-declare const MsgClaimLightNodeRewards: MessageFns$e<MsgClaimLightNodeRewards>;
+declare const MsgClaimLightNodeRewards: MessageFns$i<MsgClaimLightNodeRewards>;
 interface MsgClaimLightNodeRewardsResponse {
 }
-declare const MsgClaimLightNodeRewardsResponse: MessageFns$e<MsgClaimLightNodeRewardsResponse>;
+declare const MsgClaimLightNodeRewardsResponse: MessageFns$i<MsgClaimLightNodeRewardsResponse>;
 /** Msg defines the lightnode module's transaction service. */
 type MsgDefinition$4 = typeof MsgDefinition$4;
 declare const MsgDefinition$4: {
@@ -3467,17 +3905,17 @@ declare const MsgDefinition$4: {
         };
     };
 };
-type Builtin$e = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$e<T> = T extends Builtin$e ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$e<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$e<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$e<T[K]>;
+type Builtin$i = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$i<T> = T extends Builtin$i ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$i<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$i<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$i<T[K]>;
 } : Partial<T>;
-interface MessageFns$e<T> {
+interface MessageFns$i<T> {
     encode(message: T, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): T;
     fromJSON(object: any): T;
     toJSON(message: T): unknown;
-    create(base?: DeepPartial$e<T>): T;
-    fromPartial(object: DeepPartial$e<T>): T;
+    create(base?: DeepPartial$i<T>): T;
+    fromPartial(object: DeepPartial$i<T>): T;
 }
 
 declare const tx$4_MsgClaimLightNodeRewards: typeof MsgClaimLightNodeRewards;
@@ -3489,10 +3927,10 @@ declare const tx$4_MsgHeartbeatResponse: typeof MsgHeartbeatResponse;
 declare const tx$4_MsgRegisterLightNode: typeof MsgRegisterLightNode;
 declare const tx$4_MsgRegisterLightNodeResponse: typeof MsgRegisterLightNodeResponse;
 declare namespace tx$4 {
-  export { type DeepPartial$e as DeepPartial, type MessageFns$e as MessageFns, tx$4_MsgClaimLightNodeRewards as MsgClaimLightNodeRewards, tx$4_MsgClaimLightNodeRewardsResponse as MsgClaimLightNodeRewardsResponse, MsgDefinition$4 as MsgDefinition, tx$4_MsgDeregisterLightNode as MsgDeregisterLightNode, tx$4_MsgDeregisterLightNodeResponse as MsgDeregisterLightNodeResponse, tx$4_MsgHeartbeat as MsgHeartbeat, tx$4_MsgHeartbeatResponse as MsgHeartbeatResponse, tx$4_MsgRegisterLightNode as MsgRegisterLightNode, tx$4_MsgRegisterLightNodeResponse as MsgRegisterLightNodeResponse, protobufPackage$e as protobufPackage };
+  export { type DeepPartial$i as DeepPartial, type MessageFns$i as MessageFns, tx$4_MsgClaimLightNodeRewards as MsgClaimLightNodeRewards, tx$4_MsgClaimLightNodeRewardsResponse as MsgClaimLightNodeRewardsResponse, MsgDefinition$4 as MsgDefinition, tx$4_MsgDeregisterLightNode as MsgDeregisterLightNode, tx$4_MsgDeregisterLightNodeResponse as MsgDeregisterLightNodeResponse, tx$4_MsgHeartbeat as MsgHeartbeat, tx$4_MsgHeartbeatResponse as MsgHeartbeatResponse, tx$4_MsgRegisterLightNode as MsgRegisterLightNode, tx$4_MsgRegisterLightNodeResponse as MsgRegisterLightNodeResponse, protobufPackage$i as protobufPackage };
 }
 
-declare const protobufPackage$d = "qorechain.license.v1";
+declare const protobufPackage$h = "qorechain.license.v1";
 interface MsgGrantLicense {
     authority: string;
     grantee: string;
@@ -3500,37 +3938,37 @@ interface MsgGrantLicense {
     expiresAt: string;
     metadata: string;
 }
-declare const MsgGrantLicense: MessageFns$d<MsgGrantLicense>;
+declare const MsgGrantLicense: MessageFns$h<MsgGrantLicense>;
 interface MsgGrantLicenseResponse {
 }
-declare const MsgGrantLicenseResponse: MessageFns$d<MsgGrantLicenseResponse>;
+declare const MsgGrantLicenseResponse: MessageFns$h<MsgGrantLicenseResponse>;
 interface MsgRevokeLicense {
     authority: string;
     grantee: string;
     featureId: string;
 }
-declare const MsgRevokeLicense: MessageFns$d<MsgRevokeLicense>;
+declare const MsgRevokeLicense: MessageFns$h<MsgRevokeLicense>;
 interface MsgRevokeLicenseResponse {
 }
-declare const MsgRevokeLicenseResponse: MessageFns$d<MsgRevokeLicenseResponse>;
+declare const MsgRevokeLicenseResponse: MessageFns$h<MsgRevokeLicenseResponse>;
 interface MsgSuspendLicense {
     authority: string;
     grantee: string;
     featureId: string;
 }
-declare const MsgSuspendLicense: MessageFns$d<MsgSuspendLicense>;
+declare const MsgSuspendLicense: MessageFns$h<MsgSuspendLicense>;
 interface MsgSuspendLicenseResponse {
 }
-declare const MsgSuspendLicenseResponse: MessageFns$d<MsgSuspendLicenseResponse>;
+declare const MsgSuspendLicenseResponse: MessageFns$h<MsgSuspendLicenseResponse>;
 interface MsgResumeLicense {
     authority: string;
     grantee: string;
     featureId: string;
 }
-declare const MsgResumeLicense: MessageFns$d<MsgResumeLicense>;
+declare const MsgResumeLicense: MessageFns$h<MsgResumeLicense>;
 interface MsgResumeLicenseResponse {
 }
-declare const MsgResumeLicenseResponse: MessageFns$d<MsgResumeLicenseResponse>;
+declare const MsgResumeLicenseResponse: MessageFns$h<MsgResumeLicenseResponse>;
 /** Msg defines the license module's transaction service. */
 type MsgDefinition$3 = typeof MsgDefinition$3;
 declare const MsgDefinition$3: {
@@ -3571,17 +4009,17 @@ declare const MsgDefinition$3: {
         };
     };
 };
-type Builtin$d = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$d<T> = T extends Builtin$d ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$d<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$d<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$d<T[K]>;
+type Builtin$h = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$h<T> = T extends Builtin$h ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$h<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$h<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$h<T[K]>;
 } : Partial<T>;
-interface MessageFns$d<T> {
+interface MessageFns$h<T> {
     encode(message: T, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): T;
     fromJSON(object: any): T;
     toJSON(message: T): unknown;
-    create(base?: DeepPartial$d<T>): T;
-    fromPartial(object: DeepPartial$d<T>): T;
+    create(base?: DeepPartial$h<T>): T;
+    fromPartial(object: DeepPartial$h<T>): T;
 }
 
 declare const tx$3_MsgGrantLicense: typeof MsgGrantLicense;
@@ -3593,10 +4031,10 @@ declare const tx$3_MsgRevokeLicenseResponse: typeof MsgRevokeLicenseResponse;
 declare const tx$3_MsgSuspendLicense: typeof MsgSuspendLicense;
 declare const tx$3_MsgSuspendLicenseResponse: typeof MsgSuspendLicenseResponse;
 declare namespace tx$3 {
-  export { type DeepPartial$d as DeepPartial, type MessageFns$d as MessageFns, MsgDefinition$3 as MsgDefinition, tx$3_MsgGrantLicense as MsgGrantLicense, tx$3_MsgGrantLicenseResponse as MsgGrantLicenseResponse, tx$3_MsgResumeLicense as MsgResumeLicense, tx$3_MsgResumeLicenseResponse as MsgResumeLicenseResponse, tx$3_MsgRevokeLicense as MsgRevokeLicense, tx$3_MsgRevokeLicenseResponse as MsgRevokeLicenseResponse, tx$3_MsgSuspendLicense as MsgSuspendLicense, tx$3_MsgSuspendLicenseResponse as MsgSuspendLicenseResponse, protobufPackage$d as protobufPackage };
+  export { type DeepPartial$h as DeepPartial, type MessageFns$h as MessageFns, MsgDefinition$3 as MsgDefinition, tx$3_MsgGrantLicense as MsgGrantLicense, tx$3_MsgGrantLicenseResponse as MsgGrantLicenseResponse, tx$3_MsgResumeLicense as MsgResumeLicense, tx$3_MsgResumeLicenseResponse as MsgResumeLicenseResponse, tx$3_MsgRevokeLicense as MsgRevokeLicense, tx$3_MsgRevokeLicenseResponse as MsgRevokeLicenseResponse, tx$3_MsgSuspendLicense as MsgSuspendLicense, tx$3_MsgSuspendLicenseResponse as MsgSuspendLicenseResponse, protobufPackage$h as protobufPackage };
 }
 
-declare const protobufPackage$c = "qorechain.abstractaccount.v1";
+declare const protobufPackage$g = "qorechain.abstractaccount.v1";
 /** SpendingRule defines spending limits for an abstract account. */
 interface SpendingRule {
     id: string;
@@ -3605,25 +4043,61 @@ interface SpendingRule {
     allowedDenoms: string[];
     enabled: boolean;
 }
-declare const SpendingRule: MessageFns$c<SpendingRule>;
+declare const SpendingRule: MessageFns$g<SpendingRule>;
 interface MsgCreateAbstractAccount {
     owner: string;
     accountType: string;
 }
-declare const MsgCreateAbstractAccount: MessageFns$c<MsgCreateAbstractAccount>;
+declare const MsgCreateAbstractAccount: MessageFns$g<MsgCreateAbstractAccount>;
 interface MsgCreateAbstractAccountResponse {
     address: string;
 }
-declare const MsgCreateAbstractAccountResponse: MessageFns$c<MsgCreateAbstractAccountResponse>;
+declare const MsgCreateAbstractAccountResponse: MessageFns$g<MsgCreateAbstractAccountResponse>;
 interface MsgUpdateSpendingRules {
     owner: string;
     accountAddress: string;
     rules: SpendingRule[];
 }
-declare const MsgUpdateSpendingRules: MessageFns$c<MsgUpdateSpendingRules>;
+declare const MsgUpdateSpendingRules: MessageFns$g<MsgUpdateSpendingRules>;
 interface MsgUpdateSpendingRulesResponse {
 }
-declare const MsgUpdateSpendingRulesResponse: MessageFns$c<MsgUpdateSpendingRulesResponse>;
+declare const MsgUpdateSpendingRulesResponse: MessageFns$g<MsgUpdateSpendingRulesResponse>;
+/**
+ * MsgRegisterAuthenticator links a foreign-scheme wallet key (e.g. a Phantom
+ * ed25519 key) to an account so it may act for that account under least-privilege,
+ * time-bounded, revocable terms. Only the account owner (root key) may call it.
+ */
+interface MsgRegisterAuthenticator {
+    owner: string;
+    accountAddress: string;
+    /** "ed25519" | "secp256k1" */
+    scheme: string;
+    /** raw public key bytes */
+    pubkey: Uint8Array;
+    /** e.g. "svm", "send" */
+    permissions: string[];
+    /** unix seconds; must be within MaxSessionTTL */
+    expiryUnix: string;
+    label: string;
+}
+declare const MsgRegisterAuthenticator: MessageFns$g<MsgRegisterAuthenticator>;
+interface MsgRegisterAuthenticatorResponse {
+}
+declare const MsgRegisterAuthenticatorResponse: MessageFns$g<MsgRegisterAuthenticatorResponse>;
+/**
+ * MsgRevokeAuthenticator instantly disables a previously linked wallet key.
+ * Only the account owner (root key) may call it.
+ */
+interface MsgRevokeAuthenticator {
+    owner: string;
+    accountAddress: string;
+    scheme: string;
+    pubkey: Uint8Array;
+}
+declare const MsgRevokeAuthenticator: MessageFns$g<MsgRevokeAuthenticator>;
+interface MsgRevokeAuthenticatorResponse {
+}
+declare const MsgRevokeAuthenticatorResponse: MessageFns$g<MsgRevokeAuthenticatorResponse>;
 /** Msg defines the abstractaccount module's transaction service. */
 type MsgDefinition$2 = typeof MsgDefinition$2;
 declare const MsgDefinition$2: {
@@ -3646,31 +4120,51 @@ declare const MsgDefinition$2: {
             readonly responseStream: false;
             readonly options: {};
         };
+        readonly registerAuthenticator: {
+            readonly name: "RegisterAuthenticator";
+            readonly requestType: typeof MsgRegisterAuthenticator;
+            readonly requestStream: false;
+            readonly responseType: typeof MsgRegisterAuthenticatorResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        readonly revokeAuthenticator: {
+            readonly name: "RevokeAuthenticator";
+            readonly requestType: typeof MsgRevokeAuthenticator;
+            readonly requestStream: false;
+            readonly responseType: typeof MsgRevokeAuthenticatorResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
     };
 };
-type Builtin$c = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$c<T> = T extends Builtin$c ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$c<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$c<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$c<T[K]>;
+type Builtin$g = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$g<T> = T extends Builtin$g ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$g<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$g<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$g<T[K]>;
 } : Partial<T>;
-interface MessageFns$c<T> {
+interface MessageFns$g<T> {
     encode(message: T, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): T;
     fromJSON(object: any): T;
     toJSON(message: T): unknown;
-    create(base?: DeepPartial$c<T>): T;
-    fromPartial(object: DeepPartial$c<T>): T;
+    create(base?: DeepPartial$g<T>): T;
+    fromPartial(object: DeepPartial$g<T>): T;
 }
 
 declare const tx$2_MsgCreateAbstractAccount: typeof MsgCreateAbstractAccount;
 declare const tx$2_MsgCreateAbstractAccountResponse: typeof MsgCreateAbstractAccountResponse;
+declare const tx$2_MsgRegisterAuthenticator: typeof MsgRegisterAuthenticator;
+declare const tx$2_MsgRegisterAuthenticatorResponse: typeof MsgRegisterAuthenticatorResponse;
+declare const tx$2_MsgRevokeAuthenticator: typeof MsgRevokeAuthenticator;
+declare const tx$2_MsgRevokeAuthenticatorResponse: typeof MsgRevokeAuthenticatorResponse;
 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$c as DeepPartial, type MessageFns$c as MessageFns, tx$2_MsgCreateAbstractAccount as MsgCreateAbstractAccount, tx$2_MsgCreateAbstractAccountResponse as MsgCreateAbstractAccountResponse, MsgDefinition$2 as MsgDefinition, tx$2_MsgUpdateSpendingRules as MsgUpdateSpendingRules, tx$2_MsgUpdateSpendingRulesResponse as MsgUpdateSpendingRulesResponse, tx$2_SpendingRule as SpendingRule, protobufPackage$c 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_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$b = "qorechain.crossvm.v1";
+declare const protobufPackage$f = "qorechain.crossvm.v1";
 interface MsgCrossVMCall {
     sender: string;
     sourceVm: string;
@@ -3679,18 +4173,18 @@ interface MsgCrossVMCall {
     payload: Uint8Array;
     funds: Coin[];
 }
-declare const MsgCrossVMCall: MessageFns$b<MsgCrossVMCall>;
+declare const MsgCrossVMCall: MessageFns$f<MsgCrossVMCall>;
 interface MsgCrossVMCallResponse {
     messageId: string;
 }
-declare const MsgCrossVMCallResponse: MessageFns$b<MsgCrossVMCallResponse>;
+declare const MsgCrossVMCallResponse: MessageFns$f<MsgCrossVMCallResponse>;
 interface MsgProcessQueue {
     authority: string;
 }
-declare const MsgProcessQueue: MessageFns$b<MsgProcessQueue>;
+declare const MsgProcessQueue: MessageFns$f<MsgProcessQueue>;
 interface MsgProcessQueueResponse {
 }
-declare const MsgProcessQueueResponse: MessageFns$b<MsgProcessQueueResponse>;
+declare const MsgProcessQueueResponse: MessageFns$f<MsgProcessQueueResponse>;
 /** Msg defines the crossvm module's transaction service. */
 type MsgDefinition$1 = typeof MsgDefinition$1;
 declare const MsgDefinition$1: {
@@ -3717,17 +4211,17 @@ declare const MsgDefinition$1: {
         };
     };
 };
-type Builtin$b = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$b<T> = T extends Builtin$b ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$b<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$b<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$b<T[K]>;
+type Builtin$f = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$f<T> = T extends Builtin$f ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$f<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$f<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$f<T[K]>;
 } : Partial<T>;
-interface MessageFns$b<T> {
+interface MessageFns$f<T> {
     encode(message: T, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): T;
     fromJSON(object: any): T;
     toJSON(message: T): unknown;
-    create(base?: DeepPartial$b<T>): T;
-    fromPartial(object: DeepPartial$b<T>): T;
+    create(base?: DeepPartial$f<T>): T;
+    fromPartial(object: DeepPartial$f<T>): T;
 }
 
 declare const tx$1_MsgCrossVMCall: typeof MsgCrossVMCall;
@@ -3735,35 +4229,35 @@ declare const tx$1_MsgCrossVMCallResponse: typeof MsgCrossVMCallResponse;
 declare const tx$1_MsgProcessQueue: typeof MsgProcessQueue;
 declare const tx$1_MsgProcessQueueResponse: typeof MsgProcessQueueResponse;
 declare namespace tx$1 {
-  export { type DeepPartial$b as DeepPartial, type MessageFns$b as MessageFns, tx$1_MsgCrossVMCall as MsgCrossVMCall, tx$1_MsgCrossVMCallResponse as MsgCrossVMCallResponse, MsgDefinition$1 as MsgDefinition, tx$1_MsgProcessQueue as MsgProcessQueue, tx$1_MsgProcessQueueResponse as MsgProcessQueueResponse, protobufPackage$b as protobufPackage };
+  export { type DeepPartial$f as DeepPartial, type MessageFns$f as MessageFns, tx$1_MsgCrossVMCall as MsgCrossVMCall, tx$1_MsgCrossVMCallResponse as MsgCrossVMCallResponse, MsgDefinition$1 as MsgDefinition, tx$1_MsgProcessQueue as MsgProcessQueue, tx$1_MsgProcessQueueResponse as MsgProcessQueueResponse, protobufPackage$f as protobufPackage };
 }
 
-declare const protobufPackage$a = "qorechain.rlconsensus.v1";
+declare const protobufPackage$e = "qorechain.rlconsensus.v1";
 interface MsgSetAgentMode {
     authority: string;
     /** mode cast to the named AgentMode (uint8) Go type. */
     mode: number;
 }
-declare const MsgSetAgentMode: MessageFns$a<MsgSetAgentMode>;
+declare const MsgSetAgentMode: MessageFns$e<MsgSetAgentMode>;
 interface MsgSetAgentModeResponse {
 }
-declare const MsgSetAgentModeResponse: MessageFns$a<MsgSetAgentModeResponse>;
+declare const MsgSetAgentModeResponse: MessageFns$e<MsgSetAgentModeResponse>;
 interface MsgResumeAgent {
     authority: string;
 }
-declare const MsgResumeAgent: MessageFns$a<MsgResumeAgent>;
+declare const MsgResumeAgent: MessageFns$e<MsgResumeAgent>;
 interface MsgResumeAgentResponse {
 }
-declare const MsgResumeAgentResponse: MessageFns$a<MsgResumeAgentResponse>;
+declare const MsgResumeAgentResponse: MessageFns$e<MsgResumeAgentResponse>;
 interface MsgUpdatePolicy {
     authority: string;
     /** JSON-encoded types.PolicyWeights (epoch + MLP config + weight vector). */
     weightsJson: string;
 }
-declare const MsgUpdatePolicy: MessageFns$a<MsgUpdatePolicy>;
+declare const MsgUpdatePolicy: MessageFns$e<MsgUpdatePolicy>;
 interface MsgUpdatePolicyResponse {
 }
-declare const MsgUpdatePolicyResponse: MessageFns$a<MsgUpdatePolicyResponse>;
+declare const MsgUpdatePolicyResponse: MessageFns$e<MsgUpdatePolicyResponse>;
 interface MsgUpdateRewardWeights {
     authority: string;
     throughput: string;
@@ -3772,10 +4266,10 @@ interface MsgUpdateRewardWeights {
     mev: string;
     failedTxs: string;
 }
-declare const MsgUpdateRewardWeights: MessageFns$a<MsgUpdateRewardWeights>;
+declare const MsgUpdateRewardWeights: MessageFns$e<MsgUpdateRewardWeights>;
 interface MsgUpdateRewardWeightsResponse {
 }
-declare const MsgUpdateRewardWeightsResponse: MessageFns$a<MsgUpdateRewardWeightsResponse>;
+declare const MsgUpdateRewardWeightsResponse: MessageFns$e<MsgUpdateRewardWeightsResponse>;
 /** Msg defines the rlconsensus module's governance-authority transactions. */
 type MsgDefinition = typeof MsgDefinition;
 declare const MsgDefinition: {
@@ -3820,17 +4314,17 @@ declare const MsgDefinition: {
         };
     };
 };
-type Builtin$a = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$a<T> = T extends Builtin$a ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$a<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$a<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$a<T[K]>;
+type Builtin$e = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$e<T> = T extends Builtin$e ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$e<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$e<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$e<T[K]>;
 } : Partial<T>;
-interface MessageFns$a<T> {
+interface MessageFns$e<T> {
     encode(message: T, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): T;
     fromJSON(object: any): T;
     toJSON(message: T): unknown;
-    create(base?: DeepPartial$a<T>): T;
-    fromPartial(object: DeepPartial$a<T>): T;
+    create(base?: DeepPartial$e<T>): T;
+    fromPartial(object: DeepPartial$e<T>): T;
 }
 
 declare const tx_MsgDefinition: typeof MsgDefinition;
@@ -3843,7 +4337,7 @@ declare const tx_MsgUpdatePolicyResponse: typeof MsgUpdatePolicyResponse;
 declare const tx_MsgUpdateRewardWeights: typeof MsgUpdateRewardWeights;
 declare const tx_MsgUpdateRewardWeightsResponse: typeof MsgUpdateRewardWeightsResponse;
 declare namespace tx {
-  export { type DeepPartial$a as DeepPartial, type MessageFns$a as MessageFns, tx_MsgDefinition as MsgDefinition, tx_MsgResumeAgent as MsgResumeAgent, tx_MsgResumeAgentResponse as MsgResumeAgentResponse, tx_MsgSetAgentMode as MsgSetAgentMode, tx_MsgSetAgentModeResponse as MsgSetAgentModeResponse, tx_MsgUpdatePolicy as MsgUpdatePolicy, tx_MsgUpdatePolicyResponse as MsgUpdatePolicyResponse, tx_MsgUpdateRewardWeights as MsgUpdateRewardWeights, tx_MsgUpdateRewardWeightsResponse as MsgUpdateRewardWeightsResponse, protobufPackage$a as protobufPackage };
+  export { type DeepPartial$e as DeepPartial, type MessageFns$e as MessageFns, tx_MsgDefinition as MsgDefinition, tx_MsgResumeAgent as MsgResumeAgent, tx_MsgResumeAgentResponse as MsgResumeAgentResponse, tx_MsgSetAgentMode as MsgSetAgentMode, tx_MsgSetAgentModeResponse as MsgSetAgentModeResponse, tx_MsgUpdatePolicy as MsgUpdatePolicy, tx_MsgUpdatePolicyResponse as MsgUpdatePolicyResponse, tx_MsgUpdateRewardWeights as MsgUpdateRewardWeights, tx_MsgUpdateRewardWeightsResponse as MsgUpdateRewardWeightsResponse, protobufPackage$e as protobufPackage };
 }
 
 /**
@@ -3962,6 +4456,14 @@ declare const license: {
 declare const abstractaccount: {
     createAbstractAccount: (value: PartialMsg<MsgCreateAbstractAccount>) => EncodeObject;
     updateSpendingRules: (value: PartialMsg<MsgUpdateSpendingRules>) => EncodeObject;
+    /**
+     * Link a foreign-scheme wallet key (e.g. a Phantom ed25519 key) to an account
+     * so it may act for that account under least-privilege, time-bounded, revocable
+     * terms. Owner-signed.
+     */
+    registerAuthenticator: (value: PartialMsg<MsgRegisterAuthenticator>) => EncodeObject;
+    /** Instantly disable a previously linked wallet key. Owner-signed. */
+    revokeAuthenticator: (value: PartialMsg<MsgRevokeAuthenticator>) => EncodeObject;
 };
 /** Cross-VM message composers. */
 declare const crossvm: {
@@ -3980,7 +4482,7 @@ declare const rlconsensus: {
  * Message registry for QoreChain transactions.
  *
  * {@link qorechainRegistry} returns a cosmjs {@link Registry} seeded with the
- * standard Cosmos SDK message types ({@link defaultRegistryTypes}: bank,
+ * standard Native message types ({@link defaultRegistryTypes}: bank,
  * staking, distribution, gov, authz, feegrant, IBC transfer, …) plus every
  * QoreChain custom module message, keyed by its on-chain `typeUrl`. This is the
  * registry {@link TxClient} uses by default, so `signAndBroadcast` — and the
@@ -4001,7 +4503,7 @@ declare const rlconsensus: {
  */
 declare const qorechainRegistryTypes: ReadonlyArray<[string, GeneratedType]>;
 /**
- * Build a cosmjs {@link Registry} covering the standard Cosmos SDK messages plus
+ * Build a cosmjs {@link Registry} covering the standard Native messages plus
  * every QoreChain custom-module message.
  *
  * @param extraTypes - Optional additional `[typeUrl, GeneratedType]` pairs to
@@ -4015,7 +4517,7 @@ declare function qorechainRegistry(extraTypes?: ReadonlyArray<[string, Generated
  *
  * The default export shape is a single grouped object so callers can write
  * `msg.amm.swapExactIn({ ... })`, `msg.staking.delegate({ ... })`,
- * `msg.pqc.registerPqcKey({ ... })`, etc. Standard Cosmos SDK modules
+ * `msg.pqc.registerPqcKey({ ... })`, etc. Standard Native modules
  * (bank/staking/distribution/gov/authz/feegrant/ibc) sit alongside the
  * QoreChain custom modules (amm/bridge/rdk/multilayer/pqc/svm/lightnode/
  * license/abstractaccount/crossvm/rlconsensus).
@@ -5825,6 +6327,7 @@ declare const msg: {
                 [Symbol.iterator]?: {} | undefined;
                 readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
             } | undefined;
+            auth?: SVMAuth | undefined;
         }) => _cosmjs_proto_signing.EncodeObject;
         registerSvmPqcKey: (value: {
             sender?: string | undefined;
@@ -5977,14 +6480,11 @@ declare const msg: {
                 enabled?: boolean | undefined;
             } | undefined)[] | undefined;
         }) => _cosmjs_proto_signing.EncodeObject;
-    };
-    readonly crossvm: {
-        crossVmCall: (value: {
-            sender?: string | undefined;
-            sourceVm?: string | undefined;
-            targetVm?: string | undefined;
-            targetContract?: string | undefined;
-            payload?: {
+        registerAuthenticator: (value: {
+            owner?: string | undefined;
+            accountAddress?: string | undefined;
+            scheme?: string | undefined;
+            pubkey?: {
                 [x: number]: number | undefined;
                 readonly BYTES_PER_ELEMENT?: number | undefined;
                 readonly buffer?: ({
@@ -6029,15 +6529,121 @@ declare const msg: {
                 [Symbol.iterator]?: {} | undefined;
                 readonly [Symbol.toStringTag]?: "Uint8Array" | undefined;
             } | undefined;
-            funds?: ({
-                denom?: string | undefined;
-                amount?: string | undefined;
-            } | undefined)[] | undefined;
+            permissions?: (string | undefined)[] | undefined;
+            expiryUnix?: string | undefined;
+            label?: string | undefined;
         }) => _cosmjs_proto_signing.EncodeObject;
-        processQueue: (value: {
-            authority?: 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;
+    };
+    readonly crossvm: {
+        crossVmCall: (value: {
+            sender?: string | undefined;
+            sourceVm?: string | undefined;
+            targetVm?: string | undefined;
+            targetContract?: string | undefined;
+            payload?: {
+                [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;
+            funds?: ({
+                denom?: string | undefined;
+                amount?: string | undefined;
+            } | undefined)[] | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+        processQueue: (value: {
+            authority?: string | undefined;
+        }) => _cosmjs_proto_signing.EncodeObject;
+    };
     readonly rlconsensus: {
         setAgentMode: (value: {
             authority?: string | undefined;
@@ -6061,7 +6667,365 @@ declare const msg: {
     };
 };
 
-declare const protobufPackage$9 = "qorechain.bridge.v1";
+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
+ * path. It is registered as a cosmos.tx.v1beta1.TxExtensionOptionI.
+ */
+interface PQCHybridSignature {
+    /** algorithm_id identifies the PQC signature algorithm (e.g. Dilithium-5 = 1). */
+    algorithmId: number;
+    /** pqc_signature is the raw PQC signature (Dilithium-5: 4627 bytes). */
+    pqcSignature: Uint8Array;
+    /**
+     * pqc_public_key optionally carries the signer's PQC public key
+     * (Dilithium-5: 2592 bytes).
+     */
+    pqcPublicKey: Uint8Array;
+}
+declare const PQCHybridSignature: MessageFns$d<PQCHybridSignature>;
+type Builtin$d = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$d<T> = T extends Builtin$d ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$d<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$d<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$d<T[K]>;
+} : Partial<T>;
+interface MessageFns$d<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial$d<T>): T;
+    fromPartial(object: DeepPartial$d<T>): T;
+}
+
+declare const hybrid_PQCHybridSignature: typeof PQCHybridSignature;
+declare namespace hybrid {
+  export { type DeepPartial$d as DeepPartial, type MessageFns$d as MessageFns, hybrid_PQCHybridSignature as PQCHybridSignature, protobufPackage$d as protobufPackage };
+}
+
+declare const protobufPackage$c = "qorechain.abstractaccount.v1";
+interface ConfigView {
+    enabled: boolean;
+    maxSessionKeys: number;
+    maxSpendingRules: number;
+    defaultSessionTtl: string;
+}
+declare const ConfigView: MessageFns$c<ConfigView>;
+interface AccountView {
+    address: string;
+    contractAddress: string;
+    accountType: string;
+    spendingRulesCount: number;
+    sessionKeysCount: number;
+    createdAt: string;
+    owner: string;
+}
+declare const AccountView: MessageFns$c<AccountView>;
+interface QueryConfigRequest$2 {
+}
+declare const QueryConfigRequest$2: MessageFns$c<QueryConfigRequest$2>;
+interface QueryConfigResponse$2 {
+    config?: ConfigView | undefined;
+}
+declare const QueryConfigResponse$2: MessageFns$c<QueryConfigResponse$2>;
+interface QueryAccountRequest$2 {
+    address: string;
+}
+declare const QueryAccountRequest$2: MessageFns$c<QueryAccountRequest$2>;
+interface QueryAccountResponse$2 {
+    account?: AccountView | undefined;
+}
+declare const QueryAccountResponse$2: MessageFns$c<QueryAccountResponse$2>;
+interface QueryAccountsRequest {
+}
+declare const QueryAccountsRequest: MessageFns$c<QueryAccountsRequest>;
+interface QueryAccountsResponse {
+    accounts: AccountView[];
+}
+declare const QueryAccountsResponse: MessageFns$c<QueryAccountsResponse>;
+/** Query defines the gRPC query service for the abstractaccount module. */
+type QueryDefinition$c = typeof QueryDefinition$c;
+declare const QueryDefinition$c: {
+    readonly name: "Query";
+    readonly fullName: "qorechain.abstractaccount.v1.Query";
+    readonly methods: {
+        /** Config returns the module config. */
+        readonly config: {
+            readonly name: "Config";
+            readonly requestType: typeof QueryConfigRequest$2;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryConfigResponse$2;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Account returns a single abstract account by address. */
+        readonly account: {
+            readonly name: "Account";
+            readonly requestType: typeof QueryAccountRequest$2;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryAccountResponse$2;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+        /** Accounts lists all abstract accounts. */
+        readonly accounts: {
+            readonly name: "Accounts";
+            readonly requestType: typeof QueryAccountsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryAccountsResponse;
+            readonly responseStream: false;
+            readonly options: {};
+        };
+    };
+};
+type Builtin$c = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$c<T> = T extends Builtin$c ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$c<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$c<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$c<T[K]>;
+} : Partial<T>;
+interface MessageFns$c<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial$c<T>): T;
+    fromPartial(object: DeepPartial$c<T>): T;
+}
+
+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 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 };
+}
+
+declare const protobufPackage$b = "qorechain.amm.v1";
+/**
+ * ParamsView is the query-facing view of the module parameters. Integer amounts
+ * are rendered as decimal strings.
+ */
+interface ParamsView$2 {
+    swapFeeBps: number;
+    protocolFeeBps: number;
+    minLiquidity: string;
+    maxPoolsPerCreator: number;
+    lpTokenDecimals: number;
+    poolCreationFee: string;
+    maxSwapImpactBps: number;
+    enabled: boolean;
+}
+declare const ParamsView$2: MessageFns$b<ParamsView$2>;
+/** PoolView is the query-facing view of a pool. */
+interface PoolView {
+    id: string;
+    poolType: string;
+    creator: string;
+    tokenA: string;
+    tokenB: string;
+    reserveA: string;
+    reserveB: string;
+    lpSupply: string;
+    lpDenom: string;
+    createdAt: string;
+    status: string;
+    weightedAvgPrice: string;
+    amplificationCoefficient: number;
+}
+declare const PoolView: MessageFns$b<PoolView>;
+interface QueryParamsRequest$6 {
+}
+declare const QueryParamsRequest$6: MessageFns$b<QueryParamsRequest$6>;
+interface QueryParamsResponse$6 {
+    params?: ParamsView$2 | undefined;
+}
+declare const QueryParamsResponse$6: MessageFns$b<QueryParamsResponse$6>;
+interface QueryPoolRequest {
+    poolId: string;
+}
+declare const QueryPoolRequest: MessageFns$b<QueryPoolRequest>;
+interface QueryPoolResponse {
+    pool?: PoolView | undefined;
+}
+declare const QueryPoolResponse: MessageFns$b<QueryPoolResponse>;
+interface QueryPoolsRequest {
+}
+declare const QueryPoolsRequest: MessageFns$b<QueryPoolsRequest>;
+interface QueryPoolsResponse {
+    pools: PoolView[];
+}
+declare const QueryPoolsResponse: MessageFns$b<QueryPoolsResponse>;
+interface QueryPoolByDenomsRequest {
+    denomA: string;
+    denomB: string;
+}
+declare const QueryPoolByDenomsRequest: MessageFns$b<QueryPoolByDenomsRequest>;
+interface QueryPoolByDenomsResponse {
+    pool?: PoolView | undefined;
+}
+declare const QueryPoolByDenomsResponse: MessageFns$b<QueryPoolByDenomsResponse>;
+interface QueryLPBalanceRequest {
+    poolId: string;
+    address: string;
+}
+declare const QueryLPBalanceRequest: MessageFns$b<QueryLPBalanceRequest>;
+interface QueryLPBalanceResponse {
+    balance: string;
+}
+declare const QueryLPBalanceResponse: MessageFns$b<QueryLPBalanceResponse>;
+interface QueryQuoteExactInRequest {
+    poolId: string;
+    denomIn: string;
+    amountIn: string;
+}
+declare const QueryQuoteExactInRequest: MessageFns$b<QueryQuoteExactInRequest>;
+interface QueryQuoteExactInResponse {
+    amountOut: string;
+    fee: string;
+}
+declare const QueryQuoteExactInResponse: MessageFns$b<QueryQuoteExactInResponse>;
+interface QueryQuoteExactOutRequest {
+    poolId: string;
+    denomOut: string;
+    amountOut: string;
+}
+declare const QueryQuoteExactOutRequest: MessageFns$b<QueryQuoteExactOutRequest>;
+interface QueryQuoteExactOutResponse {
+    amountIn: string;
+    fee: string;
+}
+declare const QueryQuoteExactOutResponse: MessageFns$b<QueryQuoteExactOutResponse>;
+/** Query defines the gRPC query service for the AMM module. */
+type QueryDefinition$b = typeof QueryDefinition$b;
+declare const QueryDefinition$b: {
+    readonly name: "Query";
+    readonly fullName: "qorechain.amm.v1.Query";
+    readonly methods: {
+        /** Params returns the module parameters. */
+        readonly params: {
+            readonly name: "Params";
+            readonly requestType: typeof QueryParamsRequest$6;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryParamsResponse$6;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
+        };
+        /** Pool returns a single pool by ID. */
+        readonly pool: {
+            readonly name: "Pool";
+            readonly requestType: typeof QueryPoolRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryPoolResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
+        };
+        /** Pools lists all pools. */
+        readonly pools: {
+            readonly name: "Pools";
+            readonly requestType: typeof QueryPoolsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryPoolsResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
+        };
+        /** PoolByDenoms finds a pool by its (denom_a, denom_b) tuple. */
+        readonly poolByDenoms: {
+            readonly name: "PoolByDenoms";
+            readonly requestType: typeof QueryPoolByDenomsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryPoolByDenomsResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
+        };
+        /** LPBalance returns an account's LP balance for a pool. */
+        readonly lPBalance: {
+            readonly name: "LPBalance";
+            readonly requestType: typeof QueryLPBalanceRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryLPBalanceResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
+        };
+        /** QuoteExactIn quotes the output for a fixed-input swap. */
+        readonly quoteExactIn: {
+            readonly name: "QuoteExactIn";
+            readonly requestType: typeof QueryQuoteExactInRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryQuoteExactInResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
+        };
+        /** QuoteExactOut quotes the input required for a fixed-output swap. */
+        readonly quoteExactOut: {
+            readonly name: "QuoteExactOut";
+            readonly requestType: typeof QueryQuoteExactOutRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryQuoteExactOutResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
+        };
+    };
+};
+type Builtin$b = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$b<T> = T extends Builtin$b ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$b<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$b<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$b<T[K]>;
+} : Partial<T>;
+interface MessageFns$b<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial$b<T>): T;
+    fromPartial(object: DeepPartial$b<T>): T;
+}
+
+declare const query$b_PoolView: typeof PoolView;
+declare const query$b_QueryLPBalanceRequest: typeof QueryLPBalanceRequest;
+declare const query$b_QueryLPBalanceResponse: typeof QueryLPBalanceResponse;
+declare const query$b_QueryPoolByDenomsRequest: typeof QueryPoolByDenomsRequest;
+declare const query$b_QueryPoolByDenomsResponse: typeof QueryPoolByDenomsResponse;
+declare const query$b_QueryPoolRequest: typeof QueryPoolRequest;
+declare const query$b_QueryPoolResponse: typeof QueryPoolResponse;
+declare const query$b_QueryPoolsRequest: typeof QueryPoolsRequest;
+declare const query$b_QueryPoolsResponse: typeof QueryPoolsResponse;
+declare const query$b_QueryQuoteExactInRequest: typeof QueryQuoteExactInRequest;
+declare const query$b_QueryQuoteExactInResponse: typeof QueryQuoteExactInResponse;
+declare const query$b_QueryQuoteExactOutRequest: typeof QueryQuoteExactOutRequest;
+declare const query$b_QueryQuoteExactOutResponse: typeof QueryQuoteExactOutResponse;
+declare namespace query$b {
+  export { type DeepPartial$b as DeepPartial, type MessageFns$b as MessageFns, ParamsView$2 as ParamsView, query$b_PoolView as PoolView, QueryDefinition$b as QueryDefinition, query$b_QueryLPBalanceRequest as QueryLPBalanceRequest, query$b_QueryLPBalanceResponse as QueryLPBalanceResponse, QueryParamsRequest$6 as QueryParamsRequest, QueryParamsResponse$6 as QueryParamsResponse, query$b_QueryPoolByDenomsRequest as QueryPoolByDenomsRequest, query$b_QueryPoolByDenomsResponse as QueryPoolByDenomsResponse, query$b_QueryPoolRequest as QueryPoolRequest, query$b_QueryPoolResponse as QueryPoolResponse, query$b_QueryPoolsRequest as QueryPoolsRequest, query$b_QueryPoolsResponse as QueryPoolsResponse, query$b_QueryQuoteExactInRequest as QueryQuoteExactInRequest, query$b_QueryQuoteExactInResponse as QueryQuoteExactInResponse, query$b_QueryQuoteExactOutRequest as QueryQuoteExactOutRequest, query$b_QueryQuoteExactOutResponse as QueryQuoteExactOutResponse, protobufPackage$b as protobufPackage };
+}
+
+declare const protobufPackage$a = "qorechain.bridge.v1";
 interface BridgeConfigView {
     minValidators: number;
     attestationThreshold: number;
@@ -6069,7 +7033,7 @@ interface BridgeConfigView {
     largeTransferThreshold: string;
     enabled: boolean;
 }
-declare const BridgeConfigView: MessageFns$9<BridgeConfigView>;
+declare const BridgeConfigView: MessageFns$a<BridgeConfigView>;
 interface ChainConfigView {
     chainId: string;
     name: string;
@@ -6081,7 +7045,7 @@ interface ChainConfigView {
     ibcChannelId: string;
     ibcPortId: string;
 }
-declare const ChainConfigView: MessageFns$9<ChainConfigView>;
+declare const ChainConfigView: MessageFns$a<ChainConfigView>;
 interface BridgeValidatorView {
     address: string;
     supportedChains: string[];
@@ -6089,7 +7053,7 @@ interface BridgeValidatorView {
     active: boolean;
     registeredAt: string;
 }
-declare const BridgeValidatorView: MessageFns$9<BridgeValidatorView>;
+declare const BridgeValidatorView: MessageFns$a<BridgeValidatorView>;
 interface BridgeOperationView {
     id: string;
     type: string;
@@ -6102,62 +7066,62 @@ interface BridgeOperationView {
     sourceTxHash: string;
     status: string;
 }
-declare const BridgeOperationView: MessageFns$9<BridgeOperationView>;
+declare const BridgeOperationView: MessageFns$a<BridgeOperationView>;
 interface QueryConfigRequest$1 {
 }
-declare const QueryConfigRequest$1: MessageFns$9<QueryConfigRequest$1>;
+declare const QueryConfigRequest$1: MessageFns$a<QueryConfigRequest$1>;
 interface QueryConfigResponse$1 {
     config?: BridgeConfigView | undefined;
 }
-declare const QueryConfigResponse$1: MessageFns$9<QueryConfigResponse$1>;
+declare const QueryConfigResponse$1: MessageFns$a<QueryConfigResponse$1>;
 interface QueryChainConfigRequest {
     chainId: string;
 }
-declare const QueryChainConfigRequest: MessageFns$9<QueryChainConfigRequest>;
+declare const QueryChainConfigRequest: MessageFns$a<QueryChainConfigRequest>;
 interface QueryChainConfigResponse {
     chain?: ChainConfigView | undefined;
 }
-declare const QueryChainConfigResponse: MessageFns$9<QueryChainConfigResponse>;
+declare const QueryChainConfigResponse: MessageFns$a<QueryChainConfigResponse>;
 interface QueryChainConfigsRequest {
 }
-declare const QueryChainConfigsRequest: MessageFns$9<QueryChainConfigsRequest>;
+declare const QueryChainConfigsRequest: MessageFns$a<QueryChainConfigsRequest>;
 interface QueryChainConfigsResponse {
     chains: ChainConfigView[];
 }
-declare const QueryChainConfigsResponse: MessageFns$9<QueryChainConfigsResponse>;
+declare const QueryChainConfigsResponse: MessageFns$a<QueryChainConfigsResponse>;
 interface QueryValidatorRequest {
     address: string;
 }
-declare const QueryValidatorRequest: MessageFns$9<QueryValidatorRequest>;
+declare const QueryValidatorRequest: MessageFns$a<QueryValidatorRequest>;
 interface QueryValidatorResponse {
     validator?: BridgeValidatorView | undefined;
 }
-declare const QueryValidatorResponse: MessageFns$9<QueryValidatorResponse>;
+declare const QueryValidatorResponse: MessageFns$a<QueryValidatorResponse>;
 interface QueryValidatorsRequest {
 }
-declare const QueryValidatorsRequest: MessageFns$9<QueryValidatorsRequest>;
+declare const QueryValidatorsRequest: MessageFns$a<QueryValidatorsRequest>;
 interface QueryValidatorsResponse {
     validators: BridgeValidatorView[];
 }
-declare const QueryValidatorsResponse: MessageFns$9<QueryValidatorsResponse>;
+declare const QueryValidatorsResponse: MessageFns$a<QueryValidatorsResponse>;
 interface QueryOperationRequest {
     id: string;
 }
-declare const QueryOperationRequest: MessageFns$9<QueryOperationRequest>;
+declare const QueryOperationRequest: MessageFns$a<QueryOperationRequest>;
 interface QueryOperationResponse {
     operation?: BridgeOperationView | undefined;
 }
-declare const QueryOperationResponse: MessageFns$9<QueryOperationResponse>;
+declare const QueryOperationResponse: MessageFns$a<QueryOperationResponse>;
 interface QueryOperationsRequest {
 }
-declare const QueryOperationsRequest: MessageFns$9<QueryOperationsRequest>;
+declare const QueryOperationsRequest: MessageFns$a<QueryOperationsRequest>;
 interface QueryOperationsResponse {
     operations: BridgeOperationView[];
 }
-declare const QueryOperationsResponse: MessageFns$9<QueryOperationsResponse>;
+declare const QueryOperationsResponse: MessageFns$a<QueryOperationsResponse>;
 /** Query defines the gRPC query service for the bridge module. */
-type QueryDefinition$9 = typeof QueryDefinition$9;
-declare const QueryDefinition$9: {
+type QueryDefinition$a = typeof QueryDefinition$a;
+declare const QueryDefinition$a: {
     readonly name: "Query";
     readonly fullName: "qorechain.bridge.v1.Query";
     readonly methods: {
@@ -6254,40 +7218,40 @@ declare const QueryDefinition$9: {
         };
     };
 };
-type Builtin$9 = Date | Function | Uint8Array | string | number | boolean | undefined;
-type DeepPartial$9<T> = T extends Builtin$9 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$9<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$9<U>> : T extends {} ? {
-    [K in keyof T]?: DeepPartial$9<T[K]>;
+type Builtin$a = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$a<T> = T extends Builtin$a ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$a<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$a<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$a<T[K]>;
 } : Partial<T>;
-interface MessageFns$9<T> {
+interface MessageFns$a<T> {
     encode(message: T, writer?: BinaryWriter): BinaryWriter;
     decode(input: BinaryReader | Uint8Array, length?: number): T;
     fromJSON(object: any): T;
     toJSON(message: T): unknown;
-    create(base?: DeepPartial$9<T>): T;
-    fromPartial(object: DeepPartial$9<T>): T;
+    create(base?: DeepPartial$a<T>): T;
+    fromPartial(object: DeepPartial$a<T>): T;
 }
 
-declare const query$9_BridgeConfigView: typeof BridgeConfigView;
-declare const query$9_BridgeOperationView: typeof BridgeOperationView;
-declare const query$9_BridgeValidatorView: typeof BridgeValidatorView;
-declare const query$9_ChainConfigView: typeof ChainConfigView;
-declare const query$9_QueryChainConfigRequest: typeof QueryChainConfigRequest;
-declare const query$9_QueryChainConfigResponse: typeof QueryChainConfigResponse;
-declare const query$9_QueryChainConfigsRequest: typeof QueryChainConfigsRequest;
-declare const query$9_QueryChainConfigsResponse: typeof QueryChainConfigsResponse;
-declare const query$9_QueryOperationRequest: typeof QueryOperationRequest;
-declare const query$9_QueryOperationResponse: typeof QueryOperationResponse;
-declare const query$9_QueryOperationsRequest: typeof QueryOperationsRequest;
-declare const query$9_QueryOperationsResponse: typeof QueryOperationsResponse;
-declare const query$9_QueryValidatorRequest: typeof QueryValidatorRequest;
-declare const query$9_QueryValidatorResponse: typeof QueryValidatorResponse;
-declare const query$9_QueryValidatorsRequest: typeof QueryValidatorsRequest;
-declare const query$9_QueryValidatorsResponse: typeof QueryValidatorsResponse;
-declare namespace query$9 {
-  export { query$9_BridgeConfigView as BridgeConfigView, query$9_BridgeOperationView as BridgeOperationView, query$9_BridgeValidatorView as BridgeValidatorView, query$9_ChainConfigView as ChainConfigView, type DeepPartial$9 as DeepPartial, type MessageFns$9 as MessageFns, query$9_QueryChainConfigRequest as QueryChainConfigRequest, query$9_QueryChainConfigResponse as QueryChainConfigResponse, query$9_QueryChainConfigsRequest as QueryChainConfigsRequest, query$9_QueryChainConfigsResponse as QueryChainConfigsResponse, QueryConfigRequest$1 as QueryConfigRequest, QueryConfigResponse$1 as QueryConfigResponse, QueryDefinition$9 as QueryDefinition, query$9_QueryOperationRequest as QueryOperationRequest, query$9_QueryOperationResponse as QueryOperationResponse, query$9_QueryOperationsRequest as QueryOperationsRequest, query$9_QueryOperationsResponse as QueryOperationsResponse, query$9_QueryValidatorRequest as QueryValidatorRequest, query$9_QueryValidatorResponse as QueryValidatorResponse, query$9_QueryValidatorsRequest as QueryValidatorsRequest, query$9_QueryValidatorsResponse as QueryValidatorsResponse, protobufPackage$9 as protobufPackage };
+declare const query$a_BridgeConfigView: typeof BridgeConfigView;
+declare const query$a_BridgeOperationView: typeof BridgeOperationView;
+declare const query$a_BridgeValidatorView: typeof BridgeValidatorView;
+declare const query$a_ChainConfigView: typeof ChainConfigView;
+declare const query$a_QueryChainConfigRequest: typeof QueryChainConfigRequest;
+declare const query$a_QueryChainConfigResponse: typeof QueryChainConfigResponse;
+declare const query$a_QueryChainConfigsRequest: typeof QueryChainConfigsRequest;
+declare const query$a_QueryChainConfigsResponse: typeof QueryChainConfigsResponse;
+declare const query$a_QueryOperationRequest: typeof QueryOperationRequest;
+declare const query$a_QueryOperationResponse: typeof QueryOperationResponse;
+declare const query$a_QueryOperationsRequest: typeof QueryOperationsRequest;
+declare const query$a_QueryOperationsResponse: typeof QueryOperationsResponse;
+declare const query$a_QueryValidatorRequest: typeof QueryValidatorRequest;
+declare const query$a_QueryValidatorResponse: typeof QueryValidatorResponse;
+declare const query$a_QueryValidatorsRequest: typeof QueryValidatorsRequest;
+declare const query$a_QueryValidatorsResponse: typeof QueryValidatorsResponse;
+declare namespace query$a {
+  export { query$a_BridgeConfigView as BridgeConfigView, query$a_BridgeOperationView as BridgeOperationView, query$a_BridgeValidatorView as BridgeValidatorView, query$a_ChainConfigView as ChainConfigView, type DeepPartial$a as DeepPartial, type MessageFns$a as MessageFns, query$a_QueryChainConfigRequest as QueryChainConfigRequest, query$a_QueryChainConfigResponse as QueryChainConfigResponse, query$a_QueryChainConfigsRequest as QueryChainConfigsRequest, query$a_QueryChainConfigsResponse as QueryChainConfigsResponse, QueryConfigRequest$1 as QueryConfigRequest, QueryConfigResponse$1 as QueryConfigResponse, QueryDefinition$a as QueryDefinition, query$a_QueryOperationRequest as QueryOperationRequest, query$a_QueryOperationResponse as QueryOperationResponse, query$a_QueryOperationsRequest as QueryOperationsRequest, query$a_QueryOperationsResponse as QueryOperationsResponse, query$a_QueryValidatorRequest as QueryValidatorRequest, query$a_QueryValidatorResponse as QueryValidatorResponse, query$a_QueryValidatorsRequest as QueryValidatorsRequest, query$a_QueryValidatorsResponse as QueryValidatorsResponse, protobufPackage$a as protobufPackage };
 }
 
-declare const protobufPackage$8 = "qorechain.crossvm.v1";
+declare const protobufPackage$9 = "qorechain.crossvm.v1";
 interface CrossVMMessageView {
     id: string;
     sourceVm: string;
@@ -6301,37 +7265,37 @@ interface CrossVMMessageView {
     executedHeight: string;
     error: string;
 }
-declare const CrossVMMessageView: MessageFns$8<CrossVMMessageView>;
+declare const CrossVMMessageView: MessageFns$9<CrossVMMessageView>;
 interface QueryParamsRequest$5 {
 }
-declare const QueryParamsRequest$5: MessageFns$8<QueryParamsRequest$5>;
+declare const QueryParamsRequest$5: MessageFns$9<QueryParamsRequest$5>;
 interface QueryParamsResponse$5 {
     maxMessageSize: string;
     maxQueueSize: number;
     queueTimeoutBlocks: string;
     enabled: boolean;
 }
-declare const QueryParamsResponse$5: MessageFns$8<QueryParamsResponse$5>;
+declare const QueryParamsResponse$5: MessageFns$9<QueryParamsResponse$5>;
 interface QueryPendingMessagesRequest {
 }
-declare const QueryPendingMessagesRequest: MessageFns$8<QueryPendingMessagesRequest>;
+declare const QueryPendingMessagesRequest: MessageFns$9<QueryPendingMessagesRequest>;
 interface QueryPendingMessagesResponse {
     messages: CrossVMMessageView[];
     count: number;
 }
-declare const QueryPendingMessagesResponse: MessageFns$8<QueryPendingMessagesResponse>;
+declare const QueryPendingMessagesResponse: MessageFns$9<QueryPendingMessagesResponse>;
 interface QueryMessageRequest {
     id: string;
 }
-declare const QueryMessageRequest: MessageFns$8<QueryMessageRequest>;
+declare const QueryMessageRequest: MessageFns$9<QueryMessageRequest>;
 interface QueryMessageResponse {
     message?: CrossVMMessageView | undefined;
     found: boolean;
 }
-declare const QueryMessageResponse: MessageFns$8<QueryMessageResponse>;
+declare const QueryMessageResponse: MessageFns$9<QueryMessageResponse>;
 /** Query defines the crossvm module's gRPC query service. */
-type QueryDefinition$8 = typeof QueryDefinition$8;
-declare const QueryDefinition$8: {
+type QueryDefinition$9 = typeof QueryDefinition$9;
+declare const QueryDefinition$9: {
     readonly name: "Query";
     readonly fullName: "qorechain.crossvm.v1.Query";
     readonly methods: {
@@ -6364,6 +7328,114 @@ declare const QueryDefinition$8: {
         };
     };
 };
+type Builtin$9 = Date | Function | Uint8Array | string | number | boolean | undefined;
+type DeepPartial$9<T> = T extends Builtin$9 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$9<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$9<U>> : T extends {} ? {
+    [K in keyof T]?: DeepPartial$9<T[K]>;
+} : Partial<T>;
+interface MessageFns$9<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+    fromJSON(object: any): T;
+    toJSON(message: T): unknown;
+    create(base?: DeepPartial$9<T>): T;
+    fromPartial(object: DeepPartial$9<T>): T;
+}
+
+declare const query$9_CrossVMMessageView: typeof CrossVMMessageView;
+declare const query$9_QueryMessageRequest: typeof QueryMessageRequest;
+declare const query$9_QueryMessageResponse: typeof QueryMessageResponse;
+declare const query$9_QueryPendingMessagesRequest: typeof QueryPendingMessagesRequest;
+declare const query$9_QueryPendingMessagesResponse: typeof QueryPendingMessagesResponse;
+declare namespace query$9 {
+  export { query$9_CrossVMMessageView as CrossVMMessageView, type DeepPartial$9 as DeepPartial, type MessageFns$9 as MessageFns, QueryDefinition$9 as QueryDefinition, query$9_QueryMessageRequest as QueryMessageRequest, query$9_QueryMessageResponse as QueryMessageResponse, QueryParamsRequest$5 as QueryParamsRequest, QueryParamsResponse$5 as QueryParamsResponse, query$9_QueryPendingMessagesRequest as QueryPendingMessagesRequest, query$9_QueryPendingMessagesResponse as QueryPendingMessagesResponse, protobufPackage$9 as protobufPackage };
+}
+
+declare const protobufPackage$8 = "qorechain.license.v1";
+/** LicenseView is the query-facing view of a license grant. */
+interface LicenseView {
+    grantee: string;
+    featureId: string;
+    expiresAt: string;
+    grantedAt: string;
+    grantedBy: string;
+    suspended: boolean;
+    metadata: string;
+}
+declare const LicenseView: MessageFns$8<LicenseView>;
+interface QueryCheckRequest {
+    grantee: string;
+    featureId: string;
+}
+declare const QueryCheckRequest: MessageFns$8<QueryCheckRequest>;
+interface QueryCheckResponse {
+    license?: LicenseView | undefined;
+    /** active is true when the grant exists and is not suspended. */
+    active: boolean;
+}
+declare const QueryCheckResponse: MessageFns$8<QueryCheckResponse>;
+interface QueryHoldersRequest {
+    featureId: string;
+}
+declare const QueryHoldersRequest: MessageFns$8<QueryHoldersRequest>;
+interface QueryHoldersResponse {
+    licenses: LicenseView[];
+}
+declare const QueryHoldersResponse: MessageFns$8<QueryHoldersResponse>;
+interface QueryListRequest {
+    grantee: string;
+}
+declare const QueryListRequest: MessageFns$8<QueryListRequest>;
+interface QueryListResponse {
+    licenses: LicenseView[];
+}
+declare const QueryListResponse: MessageFns$8<QueryListResponse>;
+/** Query defines the gRPC query service for the license module. */
+type QueryDefinition$8 = typeof QueryDefinition$8;
+declare const QueryDefinition$8: {
+    readonly name: "Query";
+    readonly fullName: "qorechain.license.v1.Query";
+    readonly methods: {
+        /** Check returns a single license grant for (grantee, feature_id). */
+        readonly check: {
+            readonly name: "Check";
+            readonly requestType: typeof QueryCheckRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryCheckResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
+        };
+        /** Holders lists every grantee holding a given feature license. */
+        readonly holders: {
+            readonly name: "Holders";
+            readonly requestType: typeof QueryHoldersRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryHoldersResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
+        };
+        /** List returns every license held by a grantee. */
+        readonly list: {
+            readonly name: "List";
+            readonly requestType: typeof QueryListRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryListResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
+        };
+    };
+};
 type Builtin$8 = Date | Function | Uint8Array | string | number | boolean | undefined;
 type DeepPartial$8<T> = T extends Builtin$8 ? T : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial$8<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial$8<U>> : T extends {} ? {
     [K in keyof T]?: DeepPartial$8<T[K]>;
@@ -6377,13 +7449,15 @@ interface MessageFns$8<T> {
     fromPartial(object: DeepPartial$8<T>): T;
 }
 
-declare const query$8_CrossVMMessageView: typeof CrossVMMessageView;
-declare const query$8_QueryMessageRequest: typeof QueryMessageRequest;
-declare const query$8_QueryMessageResponse: typeof QueryMessageResponse;
-declare const query$8_QueryPendingMessagesRequest: typeof QueryPendingMessagesRequest;
-declare const query$8_QueryPendingMessagesResponse: typeof QueryPendingMessagesResponse;
+declare const query$8_LicenseView: typeof LicenseView;
+declare const query$8_QueryCheckRequest: typeof QueryCheckRequest;
+declare const query$8_QueryCheckResponse: typeof QueryCheckResponse;
+declare const query$8_QueryHoldersRequest: typeof QueryHoldersRequest;
+declare const query$8_QueryHoldersResponse: typeof QueryHoldersResponse;
+declare const query$8_QueryListRequest: typeof QueryListRequest;
+declare const query$8_QueryListResponse: typeof QueryListResponse;
 declare namespace query$8 {
-  export { query$8_CrossVMMessageView as CrossVMMessageView, type DeepPartial$8 as DeepPartial, type MessageFns$8 as MessageFns, QueryDefinition$8 as QueryDefinition, query$8_QueryMessageRequest as QueryMessageRequest, query$8_QueryMessageResponse as QueryMessageResponse, QueryParamsRequest$5 as QueryParamsRequest, QueryParamsResponse$5 as QueryParamsResponse, query$8_QueryPendingMessagesRequest as QueryPendingMessagesRequest, query$8_QueryPendingMessagesResponse as QueryPendingMessagesResponse, protobufPackage$8 as protobufPackage };
+  export { type DeepPartial$8 as DeepPartial, query$8_LicenseView as LicenseView, type MessageFns$8 as MessageFns, query$8_QueryCheckRequest as QueryCheckRequest, query$8_QueryCheckResponse as QueryCheckResponse, QueryDefinition$8 as QueryDefinition, query$8_QueryHoldersRequest as QueryHoldersRequest, query$8_QueryHoldersResponse as QueryHoldersResponse, query$8_QueryListRequest as QueryListRequest, query$8_QueryListResponse as QueryListResponse, protobufPackage$8 as protobufPackage };
 }
 
 declare const protobufPackage$7 = "qorechain.lightnode.v1";
@@ -6463,7 +7537,11 @@ declare const QueryDefinition$7: {
             readonly requestStream: false;
             readonly responseType: typeof QueryLightNodeResponse;
             readonly responseStream: false;
-            readonly options: {};
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
         };
         /** LightNodes lists all registered light nodes. */
         readonly lightNodes: {
@@ -6472,7 +7550,11 @@ declare const QueryDefinition$7: {
             readonly requestStream: false;
             readonly responseType: typeof QueryLightNodesResponse;
             readonly responseStream: false;
-            readonly options: {};
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
         };
         /** Params returns the lightnode module parameters. */
         readonly params: {
@@ -6481,7 +7563,11 @@ declare const QueryDefinition$7: {
             readonly requestStream: false;
             readonly responseType: typeof QueryParamsResponse$4;
             readonly responseStream: false;
-            readonly options: {};
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
         };
         /** Rewards returns an operator's accumulated (claimable) rewards. */
         readonly rewards: {
@@ -6490,7 +7576,11 @@ declare const QueryDefinition$7: {
             readonly requestStream: false;
             readonly responseType: typeof QueryRewardsResponse;
             readonly responseStream: false;
-            readonly options: {};
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
         };
         /** Stats returns module-level light node statistics. */
         readonly stats: {
@@ -6499,7 +7589,11 @@ declare const QueryDefinition$7: {
             readonly requestStream: false;
             readonly responseType: typeof QueryStatsResponse;
             readonly responseStream: false;
-            readonly options: {};
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
         };
     };
 };
@@ -6587,6 +7681,42 @@ interface QueryLayersResponse {
     layers: LayerView[];
 }
 declare const QueryLayersResponse: MessageFns$6<QueryLayersResponse>;
+/**
+ * StateAnchorView is the queryable view of a subsidiary-layer state anchor
+ * committed to the Main Chain. The PQC (Dilithium-5) signature covers the
+ * canonical message: layer_id || layer_height(8-byte big-endian) ||
+ * state_root || validator_set_hash, signed by the layer creator's registered
+ * post-quantum key. This lets clients verify settlement anchors offline.
+ */
+interface StateAnchorView {
+    layerId: string;
+    layerHeight: string;
+    stateRoot: Uint8Array;
+    validatorSetHash: Uint8Array;
+    mainChainHeight: string;
+    /** unix seconds */
+    anchoredAt: string;
+    pqcAggregateSignature: Uint8Array;
+    transactionCount: string;
+    compressedStateProof: Uint8Array;
+}
+declare const StateAnchorView: MessageFns$6<StateAnchorView>;
+interface QueryAnchorRequest {
+    layerId: string;
+}
+declare const QueryAnchorRequest: MessageFns$6<QueryAnchorRequest>;
+interface QueryAnchorResponse {
+    anchor?: StateAnchorView | undefined;
+}
+declare const QueryAnchorResponse: MessageFns$6<QueryAnchorResponse>;
+interface QueryAnchorsRequest {
+    layerId: string;
+}
+declare const QueryAnchorsRequest: MessageFns$6<QueryAnchorsRequest>;
+interface QueryAnchorsResponse {
+    anchors: StateAnchorView[];
+}
+declare const QueryAnchorsResponse: MessageFns$6<QueryAnchorsResponse>;
 interface QueryRoutingStatsRequest {
 }
 declare const QueryRoutingStatsRequest: MessageFns$6<QueryRoutingStatsRequest>;
@@ -6607,7 +7737,11 @@ declare const QueryDefinition$6: {
             readonly requestStream: false;
             readonly responseType: typeof QueryParamsResponse$3;
             readonly responseStream: false;
-            readonly options: {};
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
         };
         /** Layer returns a single layer config by ID. */
         readonly layer: {
@@ -6616,7 +7750,11 @@ declare const QueryDefinition$6: {
             readonly requestStream: false;
             readonly responseType: typeof QueryLayerResponse;
             readonly responseStream: false;
-            readonly options: {};
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
         };
         /** Layers lists all layers. */
         readonly layers: {
@@ -6625,7 +7763,37 @@ declare const QueryDefinition$6: {
             readonly requestStream: false;
             readonly responseType: typeof QueryLayersResponse;
             readonly responseStream: false;
-            readonly options: {};
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
+        };
+        /** Anchor returns the latest state anchor for a layer. */
+        readonly anchor: {
+            readonly name: "Anchor";
+            readonly requestType: typeof QueryAnchorRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryAnchorResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
+        };
+        /** Anchors returns all state anchors for a layer (newest first). */
+        readonly anchors: {
+            readonly name: "Anchors";
+            readonly requestType: typeof QueryAnchorsRequest;
+            readonly requestStream: false;
+            readonly responseType: typeof QueryAnchorsResponse;
+            readonly responseStream: false;
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
         };
         /** RoutingStats returns the cross-layer routing statistics. */
         readonly routingStats: {
@@ -6634,7 +7802,11 @@ declare const QueryDefinition$6: {
             readonly requestStream: false;
             readonly responseType: typeof QueryRoutingStatsView;
             readonly responseStream: false;
-            readonly options: {};
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
         };
     };
 };
@@ -6652,6 +7824,10 @@ interface MessageFns$6<T> {
 }
 
 declare const query$6_LayerView: typeof LayerView;
+declare const query$6_QueryAnchorRequest: typeof QueryAnchorRequest;
+declare const query$6_QueryAnchorResponse: typeof QueryAnchorResponse;
+declare const query$6_QueryAnchorsRequest: typeof QueryAnchorsRequest;
+declare const query$6_QueryAnchorsResponse: typeof QueryAnchorsResponse;
 declare const query$6_QueryLayerRequest: typeof QueryLayerRequest;
 declare const query$6_QueryLayerResponse: typeof QueryLayerResponse;
 declare const query$6_QueryLayersRequest: typeof QueryLayersRequest;
@@ -6659,8 +7835,9 @@ declare const query$6_QueryLayersResponse: typeof QueryLayersResponse;
 declare const query$6_QueryRoutingStatsRequest: typeof QueryRoutingStatsRequest;
 declare const query$6_QueryRoutingStatsView: typeof QueryRoutingStatsView;
 declare const query$6_RoutingStatsView: typeof RoutingStatsView;
+declare const query$6_StateAnchorView: typeof StateAnchorView;
 declare namespace query$6 {
-  export { type DeepPartial$6 as DeepPartial, query$6_LayerView as LayerView, type MessageFns$6 as MessageFns, ParamsView$1 as ParamsView, QueryDefinition$6 as QueryDefinition, query$6_QueryLayerRequest as QueryLayerRequest, query$6_QueryLayerResponse as QueryLayerResponse, query$6_QueryLayersRequest as QueryLayersRequest, query$6_QueryLayersResponse as QueryLayersResponse, QueryParamsRequest$3 as QueryParamsRequest, QueryParamsResponse$3 as QueryParamsResponse, query$6_QueryRoutingStatsRequest as QueryRoutingStatsRequest, query$6_QueryRoutingStatsView as QueryRoutingStatsView, query$6_RoutingStatsView as RoutingStatsView, protobufPackage$6 as protobufPackage };
+  export { type DeepPartial$6 as DeepPartial, query$6_LayerView as LayerView, type MessageFns$6 as MessageFns, ParamsView$1 as ParamsView, query$6_QueryAnchorRequest as QueryAnchorRequest, query$6_QueryAnchorResponse as QueryAnchorResponse, query$6_QueryAnchorsRequest as QueryAnchorsRequest, query$6_QueryAnchorsResponse as QueryAnchorsResponse, QueryDefinition$6 as QueryDefinition, query$6_QueryLayerRequest as QueryLayerRequest, query$6_QueryLayerResponse as QueryLayerResponse, query$6_QueryLayersRequest as QueryLayersRequest, query$6_QueryLayersResponse as QueryLayersResponse, QueryParamsRequest$3 as QueryParamsRequest, QueryParamsResponse$3 as QueryParamsResponse, query$6_QueryRoutingStatsRequest as QueryRoutingStatsRequest, query$6_QueryRoutingStatsView as QueryRoutingStatsView, query$6_RoutingStatsView as RoutingStatsView, query$6_StateAnchorView as StateAnchorView, protobufPackage$6 as protobufPackage };
 }
 
 declare const protobufPackage$5 = "qorechain.pqc.v1";
@@ -6701,7 +7878,11 @@ declare const QueryDefinition$5: {
             readonly requestStream: false;
             readonly responseType: typeof QueryAccountResponse$1;
             readonly responseStream: false;
-            readonly options: {};
+            readonly options: {
+                readonly _unknownFields: {
+                    readonly 578365826: readonly [Uint8Array<ArrayBufferLike>];
+                };
+            };
         };
     };
 };
@@ -7273,11 +8454,11 @@ declare namespace query {
  */
 
 declare namespace index {
-  export { tx$2 as abstractaccount, tx$9 as amm, tx$a as bridge, query$9 as bridgeQuery, tx$1 as crossvm, query$8 as crossvmQuery, tx$3 as license, tx$4 as lightnode, query$7 as lightnodeQuery, tx$7 as multilayer, query$6 as multilayerQuery, tx$6 as pqc, query$5 as pqcQuery, query$4 as qcaQuery, tx$8 as rdk, query$3 as rdkQuery, query$2 as reputationQuery, tx as rlconsensus, query$1 as rlconsensusQuery, tx$5 as svm, query as svmQuery };
+  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 };
 }
 
 /**
- * Cosmos browser-wallet integration for QoreChain (Keplr and Leap).
+ * Native browser-wallet integration for QoreChain (Keplr and Leap).
  *
  * Keplr and Leap inject the same API shape under `window.keplr` / `window.leap`,
  * so this module targets both through a light structural interface — it does not
@@ -7293,11 +8474,11 @@ declare namespace index {
  * const { signer } = await getCosmosWallet({ wallet: "keplr", network });
  * const tx = await TxClient.connect({ rpcEndpoint: network.endpoints.rpc, signer });
  * // `signer` plugs straight into TxClient and can carry any registered message
- * // (standard Cosmos + QoreChain custom) via DIRECT signing.
+ * // (standard Native + QoreChain custom) via DIRECT signing.
  * ```
  */
 
-/** Supported Cosmos wallet providers (same injected API shape). */
+/** Supported Native wallet providers (same injected API shape). */
 type CosmosWalletName = "keplr" | "leap";
 /**
  * A bech32 address config for a single account type, matching the shape Keplr
@@ -7403,7 +8584,7 @@ declare function suggestChainInfo(network: NetworkConfig): KeplrChainInfo;
  *
  * The returned `signer` plugs straight into
  * `TxClient.connect(network.endpoints.rpc, signer)` and can send any registered
- * message — standard Cosmos *and* QoreChain custom messages — via DIRECT mode,
+ * message — standard Native *and* QoreChain custom messages — via DIRECT mode,
  * which both Keplr and Leap support. (Amino mode covers standard messages only
  * until custom-module Amino converters land; see `TxClient` `aminoTypes`.)
  *
@@ -7438,6 +8619,47 @@ interface CrossVmQueryClient {
 interface LightNodeQueryClient {
     lightNode(req: QueryLightNodeRequest): Promise<QueryLightNodeResponse>;
     lightNodes(req?: QueryLightNodesRequest): Promise<QueryLightNodesResponse>;
+    /** Module parameters (reward rates, heartbeat window, minimums). */
+    params(req?: QueryParamsRequest$4): Promise<QueryParamsResponse$4>;
+    /** Accrued, unclaimed rewards for a light node. */
+    rewards(req: QueryRewardsRequest): Promise<QueryRewardsResponse>;
+    /** Network-wide light-node statistics. */
+    stats(req?: QueryStatsRequest): Promise<QueryStatsResponse>;
+}
+/** Automated market maker (AMM) module query client. */
+interface AmmQueryClient {
+    /** Module parameters (fees, limits). */
+    params(req?: QueryParamsRequest$6): Promise<QueryParamsResponse$6>;
+    /** A single pool by ID. */
+    pool(req: QueryPoolRequest): Promise<QueryPoolResponse>;
+    /** All pools. */
+    pools(req?: QueryPoolsRequest): Promise<QueryPoolsResponse>;
+    /** A pool resolved by its two denoms. */
+    poolByDenoms(req: QueryPoolByDenomsRequest): Promise<QueryPoolByDenomsResponse>;
+    /** An address's LP-token balance in a pool. */
+    lpBalance(req: QueryLPBalanceRequest): Promise<QueryLPBalanceResponse>;
+    /** Quote an exact-in swap. */
+    quoteExactIn(req: QueryQuoteExactInRequest): Promise<QueryQuoteExactInResponse>;
+    /** Quote an exact-out swap. */
+    quoteExactOut(req: QueryQuoteExactOutRequest): Promise<QueryQuoteExactOutResponse>;
+}
+/** Feature-license module query client. */
+interface LicenseQueryClient {
+    /** Check whether a grantee holds a license for a feature. */
+    check(req: QueryCheckRequest): Promise<QueryCheckResponse>;
+    /** All holders of a feature's licenses. */
+    holders(req: QueryHoldersRequest): Promise<QueryHoldersResponse>;
+    /** All licenses held by a grantee. */
+    list(req: QueryListRequest): Promise<QueryListResponse>;
+}
+/** Abstract-account module query client. */
+interface AbstractAccountQueryClient {
+    /** Module config (max session TTL, allowed schemes, etc.). */
+    config(req?: QueryConfigRequest$2): Promise<QueryConfigResponse$2>;
+    /** A single abstract account by address. */
+    account(req: QueryAccountRequest$2): Promise<QueryAccountResponse$2>;
+    /** All abstract accounts. */
+    accounts(req?: QueryAccountsRequest): Promise<QueryAccountsResponse>;
 }
 /** Multilayer (sidechain / paychain) module query client. */
 interface MultilayerQueryClient {
@@ -7447,6 +8669,10 @@ interface MultilayerQueryClient {
     layer(req: QueryLayerRequest): Promise<QueryLayerResponse>;
     /** All registered layers. */
     layers(req?: QueryLayersRequest): Promise<QueryLayersResponse>;
+    /** The latest state anchor for a layer. */
+    anchor(req: QueryAnchorRequest): Promise<QueryAnchorResponse>;
+    /** All state anchors for a layer (newest first). */
+    anchors(req: QueryAnchorsRequest): Promise<QueryAnchorsResponse>;
     /** Cross-layer routing statistics (gas savings, latency, counts). */
     routingStats(req?: QueryRoutingStatsRequest): Promise<QueryRoutingStatsView>;
 }
@@ -7503,8 +8729,11 @@ interface SvmQueryClient {
 }
 /** All typed module query clients, grouped by module. */
 interface QoreChainQueryClients {
+    abstractaccount: AbstractAccountQueryClient;
+    amm: AmmQueryClient;
     bridge: BridgeQueryClient;
     crossvm: CrossVmQueryClient;
+    license: LicenseQueryClient;
     lightnode: LightNodeQueryClient;
     multilayer: MultilayerQueryClient;
     pqc: PqcQueryClient;
@@ -8239,6 +9468,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.5.0";
+declare const VERSION = "0.6.1";
 
-export { type Account, AlgorithmDilithium5, type AlgorithmID, AlgorithmMLKEM1024, AlgorithmUnspecified, type AllBalancesResponse, type AnchorStateOptions, type AttachHybridOptions, type AutoFeeOptions, type BalanceResponse, type BankSendOptions, type Bech32Config, type Bech32Prefixes, type BridgeQueryClient, type BroadcastMode, type BroadcastResult, type BuildHybridTxOptions, type BuiltHybridTx, type CallOptions, type ChallengeBatchOptions, type ClientFees, type CoinInfo, type ConnectTxOptions, type ContractMsg, type CosmWasmPayload, type CosmWasmReadClient, type CosmWasmSigningClient, type CosmosWalletConnection, type CosmosWalletName, type CreateClientOptions, type CreateCrossVMClientOptions, type CreateMultilayerClientOptions, type CreateRollupClientOptions, type CreateRollupOptions, type CrossVMAtomicResult, type CrossVMCallBase, type CrossVMCallOptions, type CrossVMCallResult, type CrossVMClient, type CrossVMWriteOptions, type CrossVmMessage, type CrossVmMessageResponse, type CrossVmParamsResponse, type CrossVmQueryClient, DEFAULT_GAS_MULTIPLIER, DEFAULT_GAS_PRICE, type DecodedTxError, type DenomOptions, type DerivationOptions, type Ed25519Account, type EnsurePqcRegisteredOptions, type EnsurePqcRegisteredResult, type EstimateFeeOptions, type EventFilters, type EventStream, type EvmPayload, type ExecuteWithdrawalOptions, type ExplorerConfig, type FaucetConfig, type FeeInput, type FeeUrgency, type FetchLike, GasPrice, type GetBlockResponse, type GetCosmosWalletOptions, type GetJsonOptions, type GetTxFn, type GetTxResponse, HYBRID_SIG_TYPE_URL, type Handler, type HashInput, type HttpOptions, type HybridBroadcaster, type HybridPlacement, type HybridSendPath, HybridSigner, type IncludedTx, type InjectedCosmosWallet, type InstantiateOpts, JsonRpcClient, type JsonRpcClientOptions, JsonRpcError, type JsonRpcErrorObject, type JsonRpcResponse, type KeplrChainInfo, type KeplrCurrency, type KeplrFeeCurrency, type KeyType, type LightNodeQueryClient, ML_DSA_87_PUBLIC_KEY_LENGTH, ML_DSA_87_SECRET_KEY_LENGTH, ML_DSA_87_SEED_LENGTH, ML_DSA_87_SIGNATURE_LENGTH, MSG_SEND_TYPE_URL, type MigratePqcKeyOptions, type MigrateToHybridOptions, type MultilayerClient, type MultilayerQueryClient, type MultilayerWriteOptions, NETWORKS, type NetworkConfig, type NetworkEndpoints, type NetworkName, type NewBlockEventLike, type PQCHybridSignature, PQC_KEY_STATUS_PRECOMPILE_ADDRESS, type PageResponse, type PaginatedOptions, type Pagination, type PayloadInput, type PendingCrossVmMessagesResponse, type PqcKeypair, type PqcQueryClient, type PqcSignaturePart, PqcSigner, type PqcStatus, type PqcStatusSource, type QcaQueryClient, QorClient, type QoreChainClient, type QoreChainQueryClients, QoreHttpError, QoreTxError, type QueryValue, type RawPayload, type RdkQueryClient, type RegisterPaychainOptions, type RegisterSidechainOptions, type ReputationQueryClient, type RequestFaucetOptions, type ResolveChallengeOptions, RestClient, type RestClientOptions, type RetryOptions, type RlConsensusQueryClient, type RollupClient, type RollupLifecycleOptions, type RollupWriteOptions, type RouteTransactionOptions, STATIC_FALLBACK, type SearchTxsOptions, type SearchTxsResponse, type Secp256k1Account, type SignAndBroadcastHybridOptions, type SignAndBroadcastOptions, type SignOutput, type SignatureMode, type Signer, type SigningClientLike, type SimulateOptions, type SubmitBatchOptions, type SubscriptionClient, type SvmPayload, type SvmQueryClient, type SyncBroadcaster, TxClient, type TxClientOptions, type TxConnectOptions, type TxErrorInput, type TxEventLike, type FeeInput$1 as TxFeeInput, type TxOrderBy, type TxQueryFilters, type TxResultLike, type Unsubscribe, VERSION, type VMType, VM_TYPES, type WaitForTxOptions, abstractaccount, algorithmName, amm, attachHybridExtension, authz, bank, bech32ToHex, bridge, broadcastAndWait, buildAminoTypes, buildEventsQuery, buildHybridSignatureExtension, buildHybridTx, buildRegisterPqcKeyMsg, buildTxQuery, buildUrl, bytesToBech32, calculateFee, clearAdmin, connectCosmWasmSigner, connectQueryClients, createClient, createCosmWasmClient, createCrossVMClient, createMultilayerClient, createQueryClients, createRollupClient, createSubscriptionClient, crossvm, decodeTxError, deriveEvmAccount, deriveNativeAccount, deriveSvmAccount, directSignerFromPrivateKey, distribution, encodeHybridExtension, ensurePqcRegistered, estimateFee, evmToQor, execute, explorerAddressUrl, explorerBlockUrl, explorerTxUrl, feegrant, formatUnits, fromBase, generateMnemonic, generatePqcKeypair, getBlock, getCodeDetails, getCodes, getContractInfo, getContracts, getCosmosWallet, getCrossVmMessage, getCrossVmParams, getJson, getLatestBlock, getNetwork, getPendingCrossVmMessages, getPqcStatus, getTx, gov, hexToBech32, ibc, instantiate, instantiate2, isChecksumAddress, isPqcRegistered, isSignatureAlgorithm, isTxFailure, isValidBech32, isValidEvmAddress, isValidSvmAddress, joinUrl, keccak256, keccak256Hex, license, lightnode, listNetworks, migrate, migratePqcKey, migrateToHybrid, msg, multilayer, parseUnits, postJsonRpc, pqc as pqcMsg, pqcSign, pqcVerify, qorToEvm, qorechainRegistry, qorechainRegistryTypes, index as qorechainTypes, queryContractSmart, rdk, requestFaucet, ripemd160, ripemd160Hex, rlconsensus, searchTxs, sha256, sha256Hex, signAndBroadcastHybrid, staking, subscribeNewBlocks, subscribeTx, suggestChainInfo, svm, toBase, toChecksumAddress, toHex, txErrorFrom, updateAdmin, uploadCode, validateMnemonic, waitForTx, withRetry };
+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 };