@qorechain/sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1532 @@
+import { EncodeObject, OfflineDirectSigner, GeneratedType, OfflineSigner, Registry } from '@cosmjs/proto-signing';
+import { Coin, StdFee } from '@cosmjs/amino';
+export { Coin, StdFee } from '@cosmjs/amino';
+import { DeliverTxResponse, SigningStargateClientOptions } from '@cosmjs/stargate';
+import { CosmWasmClient, SigningCosmWasmClient } from '@cosmjs/cosmwasm-stargate';
+import { Any } from 'cosmjs-types/google/protobuf/any';
+import { TxBody, TxRaw } from 'cosmjs-types/cosmos/tx/v1beta1/tx';
+
+/**
+ * Network presets for the QoreChain SDK.
+ *
+ * Both the `testnet` and `mainnet` presets are fully populated and live. Their
+ * endpoints default to localhost ports so the SDK works out of the box against a
+ * locally running node; callers override these with real hostnames when creating
+ * a client. {@link getNetwork} returns either preset.
+ */
+/** Bech32 human-readable prefixes used across QoreChain address types. */
+interface Bech32Prefixes {
+    /** Prefix for account addresses (e.g. `qor1...`). */
+    account: string;
+    /** Prefix for validator operator addresses (e.g. `qorvaloper1...`). */
+    validator: string;
+    /** Prefix for validator consensus addresses (e.g. `qorvalcons1...`). */
+    consensus: string;
+}
+/** Display and base denomination metadata for the network's staking coin. */
+interface CoinInfo {
+    /** Human-facing denomination (e.g. `QOR`). */
+    display: string;
+    /** Base (smallest) denomination used on-chain (e.g. `uqor`). */
+    base: string;
+    /** Decimal exponent relating base to display (1 display = 10^exponent base). */
+    exponent: number;
+}
+/** Service endpoints for talking to a network across its supported VMs. */
+interface NetworkEndpoints {
+    /** Cosmos SDK REST (LCD) endpoint. */
+    rest: string;
+    /** Cosmos SDK gRPC endpoint. */
+    grpc: string;
+    /** Consensus RPC endpoint. */
+    rpc: string;
+    /** EVM JSON-RPC HTTP endpoint. */
+    evmRpc: string;
+    /** EVM JSON-RPC WebSocket endpoint. */
+    evmWs: string;
+    /** SVM JSON-RPC endpoint. */
+    svmRpc: string;
+}
+/** A fully described network preset. */
+interface NetworkConfig {
+    /** Canonical preset name. */
+    name: string;
+    /** Whether the network is live and usable without custom endpoints. */
+    live: boolean;
+    /** Chain ID. */
+    chainId: string;
+    /** Bech32 prefixes for address encoding. */
+    bech32: Bech32Prefixes;
+    /** Staking coin metadata. */
+    coin: CoinInfo;
+    /** Default endpoints. */
+    endpoints: NetworkEndpoints;
+}
+/** Known network preset names. */
+type NetworkName = "testnet" | "mainnet";
+/** The set of built-in network presets, keyed by name. */
+declare const NETWORKS: Record<NetworkName, NetworkConfig>;
+/**
+ * Resolve a network preset by name.
+ *
+ * @returns The requested {@link NetworkConfig}, guaranteed to be live and usable.
+ */
+declare function getNetwork(name: NetworkName): NetworkConfig;
+/** List the known network preset names without triggering any liveness check. */
+declare function listNetworks(): NetworkName[];
+
+/**
+ * Shared HTTP transport for the read/query clients.
+ *
+ * Provides two primitives — {@link getJson} for REST GETs and
+ * {@link postJsonRpc} for JSON-RPC POSTs — both built on the global `fetch`.
+ * `fetch` is injectable so tests can mock the network entirely; nothing here
+ * ever performs a real request on its own.
+ *
+ * Failures surface as a typed {@link QoreHttpError} (non-2xx HTTP responses).
+ * Transient transport failures (5xx and network errors) are retried with a
+ * small fixed backoff up to a configurable count; 4xx responses are never
+ * retried. Each attempt is bounded by an `AbortSignal`-driven timeout.
+ */
+/** A `fetch`-compatible function. Defaults to `globalThis.fetch`. */
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+/** A JSON-serializable value usable as a query-string parameter. */
+type QueryValue = string | number | boolean | undefined | null;
+/** Options shared by all HTTP helpers. */
+interface HttpOptions {
+    /** Injectable `fetch`. Defaults to `globalThis.fetch`. */
+    fetch?: FetchLike;
+    /** Per-attempt timeout in milliseconds. Defaults to 30000. `0` disables it. */
+    timeoutMs?: number;
+    /** Number of retries after the initial attempt for retryable errors. Defaults to 2. */
+    retries?: number;
+    /** Fixed delay between retries in milliseconds. Defaults to 250. */
+    retryDelayMs?: number;
+    /** Extra request headers, merged over the defaults. */
+    headers?: Record<string, string>;
+}
+/** Options for {@link getJson}, adding query-string parameters. */
+interface GetJsonOptions extends HttpOptions {
+    /** Query parameters; `undefined`/`null` values are omitted. */
+    query?: Record<string, QueryValue>;
+}
+/** Thrown when an HTTP response has a non-2xx status. */
+declare class QoreHttpError extends Error {
+    /** HTTP status code of the failing response. */
+    readonly status: number;
+    /** The URL that was requested. */
+    readonly url: string;
+    /** Raw response body text, when available. */
+    readonly body?: string;
+    constructor(status: number, url: string, body?: string);
+}
+/** Append query params to a URL, skipping `undefined`/`null` values. */
+declare function buildUrl(base: string, query?: Record<string, QueryValue>): string;
+/** Join a base URL and a path without producing double slashes. */
+declare function joinUrl(base: string, path: string): string;
+/**
+ * Perform a GET request and parse the JSON response.
+ *
+ * @param url - Fully-qualified URL (without query string).
+ * @param opts - Query params, injectable `fetch`, timeout, and retry settings.
+ * @throws {@link QoreHttpError} on a non-2xx response.
+ */
+declare function getJson<T>(url: string, opts?: GetJsonOptions): Promise<T>;
+/**
+ * POST a JSON-RPC body and parse the JSON response.
+ *
+ * This handles only the HTTP layer; JSON-RPC error envelopes are interpreted by
+ * the {@link JsonRpcClient}.
+ *
+ * @throws {@link QoreHttpError} on a non-2xx response.
+ */
+declare function postJsonRpc<T>(url: string, body: unknown, opts?: HttpOptions): Promise<T>;
+
+/**
+ * REST (LCD) read client for QoreChain.
+ *
+ * Wraps the standard Cosmos SDK 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}.
+ *
+ * Response shapes are modeled only where they are simple and stable (e.g. bank
+ * balances); richer module responses are returned as a caller-supplied generic
+ * defaulting to {@link Record}<string, unknown> rather than over-modeled here.
+ */
+
+/** Cosmos pagination response metadata. */
+interface PageResponse {
+    next_key: string | null;
+    total?: string;
+}
+/** Response of the all-balances endpoint. */
+interface AllBalancesResponse {
+    balances: Coin[];
+    pagination?: PageResponse;
+}
+/** Response of the single-denom balance endpoint. */
+interface BalanceResponse {
+    balance: Coin;
+}
+/** Cosmos-style key/limit pagination input. */
+interface Pagination {
+    key?: string;
+    limit?: number;
+}
+/** Options accepted by paginated list endpoints. */
+interface PaginatedOptions {
+    pagination?: Pagination;
+}
+/** Options for {@link RestClient}. */
+type RestClientOptions = HttpOptions;
+/** Relative urgency of a fee estimate. */
+type FeeUrgency = "fast" | "normal" | "slow";
+/** Cosmos + QoreChain REST read client. */
+declare class RestClient {
+    private readonly baseUrl;
+    private readonly opts;
+    /**
+     * @param baseUrl - The network's REST endpoint (e.g. `endpoints.rest`).
+     * @param opts - Injectable `fetch`, timeout, and retry settings.
+     */
+    constructor(baseUrl: string, opts?: RestClientOptions);
+    /** Injectable fetch passthrough so the escape hatch reuses the same transport. */
+    private get fetchImpl();
+    /**
+     * Generic GET escape hatch for any documented REST route.
+     *
+     * @param path - Path beginning with `/` (e.g. `/qorechain/foo/v1/bar`).
+     *   Embedded path params must be URL-encoded by the caller.
+     * @param query - Optional query parameters.
+     */
+    get<T = Record<string, unknown>>(path: string, query?: Record<string, QueryValue>): Promise<T>;
+    /** All balances of `address` (`/cosmos/bank/v1beta1/balances/{address}`). */
+    getAllBalances(address: string, opts?: PaginatedOptions): Promise<AllBalancesResponse>;
+    /** Balance of `address` in `denom` (`.../balances/{address}/by_denom`). */
+    getBalance(address: string, denom: string): Promise<BalanceResponse>;
+    /** QCAI fee/network stats (`/qorechain/ai/v1/stats`). */
+    getAiStats<T = Record<string, unknown>>(): Promise<T>;
+    /** QCAI fee estimate for an urgency level (`/qorechain/ai/v1/fee-estimate`). */
+    getFeeEstimate<T = Record<string, unknown>>(urgency: FeeUrgency): Promise<T>;
+    /** Supported bridge chains (`/qorechain/bridge/v1/chains`). */
+    getBridgeChains<T = Record<string, unknown>>(): Promise<T>;
+    /** PQC account record (`/qorechain/pqc/v1/accounts/{address}`). */
+    getPqcAccount<T = Record<string, unknown>>(address: string): Promise<T>;
+    /** Validator reputation (`/qorechain/reputation/v1/validators/{address}`). */
+    getReputation<T = Record<string, unknown>>(validatorAddress: string): Promise<T>;
+    /** Token burn statistics (`/qorechain/burn/v1/stats`). */
+    getBurnStats<T = Record<string, unknown>>(): Promise<T>;
+    /** xQORE staking position (`/qorechain/xqore/v1/position/{address}`). */
+    getXqorePosition<T = Record<string, unknown>>(address: string): Promise<T>;
+    /** Current inflation rate (`/qorechain/inflation/v1/rate`). */
+    getInflationRate<T = Record<string, unknown>>(): Promise<T>;
+}
+
+/**
+ * Generic JSON-RPC 2.0 client.
+ *
+ * Manages request ids (auto-incrementing per client), serializes the standard
+ * `{ jsonrpc, id, method, params }` envelope, and maps JSON-RPC error responses
+ * to a typed {@link JsonRpcError}. It is the transport base for both the EVM
+ * `eth_*`/`net_*`/`web3_*` methods and the QoreChain `qor_*` namespace.
+ *
+ * The underlying `fetch` is injectable via {@link HttpOptions} so callers and
+ * tests can supply their own transport.
+ */
+
+/** A JSON-RPC 2.0 error object. */
+interface JsonRpcErrorObject {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+/** A JSON-RPC 2.0 response envelope. */
+interface JsonRpcResponse<T> {
+    jsonrpc: "2.0";
+    id: number | string | null;
+    result?: T;
+    error?: JsonRpcErrorObject;
+}
+/** Thrown when a JSON-RPC response carries an `error` member. */
+declare class JsonRpcError extends Error {
+    /** JSON-RPC error code. */
+    readonly code: number;
+    /** Optional implementation-defined error data. */
+    readonly data?: unknown;
+    constructor(code: number, message: string, data?: unknown);
+}
+/** Options for {@link JsonRpcClient}. */
+type JsonRpcClientOptions = HttpOptions;
+/** A minimal JSON-RPC 2.0 client over HTTP POST. */
+declare class JsonRpcClient {
+    protected readonly url: string;
+    protected readonly opts: JsonRpcClientOptions;
+    private nextId;
+    constructor(url: string, opts?: JsonRpcClientOptions);
+    /**
+     * Invoke a JSON-RPC method and return its `result`.
+     *
+     * @param method - Wire method name (e.g. `"eth_chainId"`).
+     * @param params - Positional params; defaults to an empty array.
+     * @throws {@link JsonRpcError} when the response contains an `error`.
+     * @throws {@link QoreHttpError} on a non-2xx transport response.
+     */
+    call<T>(method: string, params?: unknown[]): Promise<T>;
+    /** `eth_chainId` — the chain id as a hex quantity string. */
+    ethChainId(): Promise<string>;
+    /** `eth_blockNumber` — the latest block height as a hex quantity string. */
+    ethBlockNumber(): Promise<string>;
+    /** `eth_getBalance` — wei balance of `address` as a hex quantity string. */
+    ethGetBalance(address: string, block?: string): Promise<string>;
+    /** `net_version` — the network id as a decimal string. */
+    netVersion(): Promise<string>;
+    /** `web3_clientVersion` — the node client version string. */
+    web3ClientVersion(): Promise<string>;
+}
+
+/**
+ * Typed wrappers for the QoreChain `qor_*` JSON-RPC namespace.
+ *
+ * Each method maps one-to-one to a chain RPC method, exposed against the EVM
+ * JSON-RPC endpoint (`endpoints.evmRpc`). The on-the-wire method names use the
+ * chain's exact casing (e.g. `qor_getPQCKeyStatus`, `qor_getAIStats`) and must
+ * not be altered.
+ *
+ * Results are intentionally returned as generics defaulting to
+ * {@link Record}<string, unknown>: the chain returns rich, evolving JSON and the
+ * SDK does not model every field. Callers pass a concrete type argument when
+ * they know the shape.
+ */
+
+/** Convenience default for unmodeled `qor_*` responses. */
+type Json = Record<string, unknown>;
+/**
+ * Client for the QoreChain `qor_*` JSON-RPC namespace.
+ *
+ * Built on {@link JsonRpcClient}; point it at the network's `evmRpc` endpoint.
+ */
+declare class QorClient extends JsonRpcClient {
+    constructor(url: string, opts?: JsonRpcClientOptions);
+    /** `qor_getPQCKeyStatus` — PQC key registration status for an address. */
+    getPqcKeyStatus<T = Json>(address: string): Promise<T>;
+    /** `qor_getHybridSignatureMode` — active hybrid-signature policy. */
+    getHybridSignatureMode<T = Json>(): Promise<T>;
+    /** `qor_getAIStats` — QCAI engine statistics. */
+    getAiStats<T = Json>(): Promise<T>;
+    /** `qor_getCrossVMMessage` — a cross-VM message by id. */
+    getCrossVmMessage<T = Json>(messageId: string): Promise<T>;
+    /** `qor_getReputationScore` — reputation score for a validator. */
+    getReputationScore<T = Json>(validator: string): Promise<T>;
+    /** `qor_getLayerInfo` — info about a chain layer. */
+    getLayerInfo<T = Json>(layerId: string): Promise<T>;
+    /** `qor_getBridgeStatus` — bridge status for a remote chain id. */
+    getBridgeStatus<T = Json>(chainId: string): Promise<T>;
+    /** `qor_getRLAgentStatus` — reinforcement-learning agent status. */
+    getRlAgentStatus<T = Json>(): Promise<T>;
+    /** `qor_getRLObservation` — latest RL observation vector. */
+    getRlObservation<T = Json>(): Promise<T>;
+    /** `qor_getRLReward` — latest RL reward signal. */
+    getRlReward<T = Json>(): Promise<T>;
+    /** `qor_getPoolClassification` — validator pool classification. */
+    getPoolClassification<T = Json>(validator: string): Promise<T>;
+    /** `qor_getBurnStats` — token burn statistics. */
+    getBurnStats<T = Json>(): Promise<T>;
+    /** `qor_getXQOREPosition` — xQORE staking position for an address. */
+    getXqorePosition<T = Json>(address: string): Promise<T>;
+    /** `qor_getInflationRate` — current inflation rate. */
+    getInflationRate<T = Json>(): Promise<T>;
+    /** `qor_getTokenomicsOverview` — aggregate tokenomics snapshot. */
+    getTokenomicsOverview<T = Json>(): Promise<T>;
+    /** `qor_getRollupStatus` — status of a rollup. */
+    getRollupStatus<T = Json>(rollupId: string): Promise<T>;
+    /** `qor_listRollups` — all known rollups. */
+    listRollups<T = Json>(): Promise<T>;
+    /** `qor_getSettlementBatch` — a settlement batch by rollup and index. */
+    getSettlementBatch<T = Json>(rollupId: string, batchIndex: number): Promise<T>;
+    /** `qor_suggestRollupProfile` — a suggested rollup profile for a use case. */
+    suggestRollupProfile<T = Json>(useCase: string): Promise<T>;
+    /** `qor_getDABlobStatus` — data-availability blob status by rollup and index. */
+    getDaBlobStatus<T = Json>(rollupId: string, blobIndex: number): Promise<T>;
+    /** `qor_getBTCStakingPosition` — BTC staking position for an address. */
+    getBtcStakingPosition<T = Json>(address: string): Promise<T>;
+    /** `qor_getAbstractAccount` — account-abstraction record for an address. */
+    getAbstractAccount<T = Json>(address: string): Promise<T>;
+    /** `qor_getFairBlockStatus` — fair-ordering / fair-block status. */
+    getFairBlockStatus<T = Json>(): Promise<T>;
+    /** `qor_getGasAbstractionConfig` — gas-abstraction configuration. */
+    getGasAbstractionConfig<T = Json>(): Promise<T>;
+    /** `qor_getLaneConfiguration` — mempool lane configuration. */
+    getLaneConfiguration<T = Json>(): Promise<T>;
+}
+
+/**
+ * Native-transaction fee estimation for QoreChain.
+ *
+ * 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`
+ * (`{ amount: Coin[]; gas: string }`).
+ *
+ * The oracle can be unavailable (node still syncing, sidecar down, custom RPC
+ * without the AI module). To keep transaction building robust, this falls back
+ * to a deterministic static fee computed from a configurable gas price in the
+ * base denom — `ceil(gas * gasPrice)` — exactly as a wallet would compute a
+ * minimum-gas-price fee. The fallback is transparent and never throws on a
+ * missing/erroring endpoint; only a successful response is preferred.
+ */
+
+/**
+ * Default static-fallback parameters, used when the AI fee oracle is
+ * unavailable. The gas price (`uqor` per unit of gas) is intentionally
+ * conservative and matches the relayer default in the core repo
+ * (`gas_price = 0.025 uqor`).
+ */
+declare const STATIC_FALLBACK: {
+    /** Fallback gas price, in base denom per unit of gas. */
+    readonly gasPrice: "0.025";
+    /** Base denomination fees are paid in. */
+    readonly denom: "uqor";
+    /** Default gas limit when the caller does not supply one. */
+    readonly gas: "200000";
+};
+/** Options for {@link estimateFee}. */
+interface EstimateFeeOptions {
+    /** Relative urgency tier passed to the oracle. Defaults to `"normal"`. */
+    urgency?: FeeUrgency;
+    /**
+     * Gas limit to request, as a number or decimal string. Defaults to
+     * {@link STATIC_FALLBACK.gas}. The oracle only suggests a *fee amount*; the
+     * gas limit is chosen by the caller (or via {@link TxClient.simulate}).
+     */
+    gas?: number | string;
+    /**
+     * Static-fallback gas price (base denom per gas unit) used only when the
+     * oracle is unavailable. Defaults to {@link STATIC_FALLBACK.gasPrice}.
+     */
+    fallbackGasPrice?: string;
+    /** Base denomination for the fee. Defaults to {@link STATIC_FALLBACK.denom}. */
+    denom?: string;
+}
+/**
+ * Estimate a transaction fee for the given urgency.
+ *
+ * Queries the QoreChain AI fee oracle and returns a Cosmos `StdFee`. If the
+ * oracle is unavailable or returns no usable fee, falls back to a deterministic
+ * static fee computed from {@link EstimateFeeOptions.fallbackGasPrice}.
+ *
+ * @param rest - A {@link RestClient} bound to the network's REST endpoint.
+ * @param opts - Urgency, gas limit, and static-fallback parameters.
+ */
+declare function estimateFee(rest: RestClient, opts?: EstimateFeeOptions): Promise<StdFee>;
+
+/**
+ * Broadcast-mode definitions and the broadcast result shape for native txs.
+ *
+ * Cosmos 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
+ *   `CheckTx`; fire-and-forget.
+ * - `commit` — wait until the tx is included in a block; you get the full
+ *   delivery result (height, gas used, events). This is the default and is what
+ *   cosmjs's `signAndBroadcast` does.
+ *
+ * cosmjs surfaces only two transport methods: `signAndBroadcast` (poll-to-commit)
+ * and `signAndBroadcastSync` (return after `CheckTx`). We map `sync` and `async`
+ * onto `signAndBroadcastSync` (both return after submission without polling for a
+ * block) and `commit` onto `signAndBroadcast`.
+ */
+/** Broadcast mode for a signed transaction. */
+type BroadcastMode = "sync" | "async" | "commit";
+/**
+ * The normalized result of broadcasting a transaction.
+ *
+ * For `commit` mode all fields are populated from the delivery result. For
+ * `sync`/`async` mode only `transactionHash` (and `code = 0`) is known, since
+ * the tx has not yet been included in a block.
+ */
+interface BroadcastResult {
+    /** The transaction hash (uppercase hex). */
+    transactionHash: string;
+    /**
+     * The ABCI result code. `0` means success. For `sync`/`async` this is `0`
+     * once the tx is accepted into the mempool (a non-zero `CheckTx` code throws).
+     */
+    code: number;
+    /** Block height the tx was included in (only for `commit`). */
+    height?: number;
+    /** Gas used by the tx (only for `commit`). */
+    gasUsed?: bigint;
+    /** Gas wanted by the tx (only for `commit`). */
+    gasWanted?: bigint;
+    /** Raw ABCI log, when present. */
+    rawLog?: 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
+ * the common transfer case. It is constructed in two ways:
+ *
+ *  - {@link TxClient.connect} — the production path: connect to the network's
+ *    consensus RPC with an offline signer (see {@link directSignerFromPrivateKey})
+ *    and an optional custom message {@link Registry}.
+ *  - `new TxClient({ signingClient, senderAddress })` — the testable path: inject
+ *    any object satisfying {@link SigningClientLike}, so unit tests never touch
+ *    the network.
+ *
+ * Custom QoreChain module messages are out of scope for v0.1 codegen; instead,
+ * callers may register their own protobuf types by passing `registryTypes` to
+ * {@link TxClient.connect} (added to cosmjs's default bank/staking/gov/etc.
+ * registry), then build `{ typeUrl, value }` messages for them.
+ */
+
+/** The `/cosmos.bank.v1beta1.MsgSend` type URL. */
+declare const MSG_SEND_TYPE_URL = "/cosmos.bank.v1beta1.MsgSend";
+/**
+ * The subset of `SigningStargateClient` that {@link TxClient} depends on.
+ * Declaring it explicitly lets unit tests inject a lightweight fake.
+ */
+interface SigningClientLike {
+    simulate(signerAddress: string, messages: readonly EncodeObject[], memo: string | undefined): Promise<number>;
+    signAndBroadcast(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo?: string): Promise<DeliverTxResponse>;
+    signAndBroadcastSync(signerAddress: string, messages: readonly EncodeObject[], fee: StdFee, memo?: string): Promise<string>;
+    disconnect?(): void;
+}
+/** Options for constructing a {@link TxClient} directly (testing/advanced). */
+interface TxClientOptions {
+    /** The underlying signing client (real or fake). */
+    signingClient: SigningClientLike;
+    /** The bech32 address transactions are signed and sent from. */
+    senderAddress: string;
+}
+/** Options for {@link TxClient.connect}. */
+interface TxConnectOptions {
+    /** Consensus RPC endpoint (e.g. `endpoints.rpc`). */
+    rpcEndpoint: string;
+    /** An offline direct signer (see {@link directSignerFromPrivateKey}). */
+    signer: OfflineDirectSigner;
+    /**
+     * Extra protobuf message types to register, as `[typeUrl, GeneratedType]`
+     * pairs. Added to cosmjs's default registry (bank/staking/gov/distribution/…).
+     * Use this to support custom QoreChain module messages without bundling full
+     * codegen into the SDK.
+     */
+    registryTypes?: ReadonlyArray<[string, GeneratedType]>;
+    /** Additional cosmjs `SigningStargateClientOptions` (gas price, etc.). */
+    clientOptions?: SigningStargateClientOptions;
+}
+/** Options accepted when signing and broadcasting. */
+interface SignAndBroadcastOptions {
+    /** Broadcast mode. Defaults to `"commit"`. */
+    mode?: BroadcastMode;
+}
+/** Options for {@link TxClient.simulate}. */
+interface SimulateOptions {
+    /** Optional tx memo to include in the simulation. */
+    memo?: string;
+}
+/** Options for {@link TxClient.bankSend}. */
+interface BankSendOptions extends SignAndBroadcastOptions {
+    /** The fee to pay. Required (estimate via `estimateFee`). */
+    fee: StdFee;
+    /** Optional memo. */
+    memo?: string;
+}
+/**
+ * A native-transaction client: simulate, sign, broadcast, and send tokens.
+ */
+declare class TxClient {
+    private readonly client;
+    /** The signing/sending bech32 address. */
+    readonly senderAddress: string;
+    constructor(opts: TxClientOptions);
+    /**
+     * Connect to a network's consensus RPC and build a {@link TxClient}.
+     *
+     * Resolves the signer's first account as the sender address and merges any
+     * `registryTypes` into cosmjs's default message registry.
+     */
+    static connect(opts: TxConnectOptions): Promise<TxClient>;
+    /**
+     * Simulate the given messages and return the estimated gas units.
+     *
+     * Use the result (with a safety multiplier) as the `gas` for `estimateFee`.
+     */
+    simulate(messages: readonly EncodeObject[], opts?: SimulateOptions): Promise<number>;
+    /**
+     * Sign and broadcast the given messages with an explicit fee.
+     *
+     * Broadcast mode maps onto cosmjs transports:
+     * - `commit` (default): polls until the tx lands in a block; returns the full
+     *   result and throws on a non-zero delivery code.
+     * - `sync` / `async`: returns after mempool submission with just the tx hash.
+     */
+    signAndBroadcast(messages: readonly EncodeObject[], fee: StdFee, memo?: string, opts?: SignAndBroadcastOptions): Promise<BroadcastResult>;
+    /**
+     * Send `amount` to `toAddress` via a bank `MsgSend`, then broadcast.
+     *
+     * Constructs `/cosmos.bank.v1beta1.MsgSend` from this client's sender address.
+     */
+    bankSend(toAddress: string, amount: Coin[], opts: BankSendOptions): Promise<BroadcastResult>;
+    /** Disconnect the underlying client's transport, if it supports it. */
+    disconnect(): void;
+}
+
+/**
+ * Cross-VM read helpers for QoreChain's `x/crossvm` module.
+ *
+ * These are thin, typed wrappers over {@link RestClient} for the module's REST
+ * routes under `/qorechain/crossvm/v1/...`. They are standalone functions taking
+ * a {@link RestClient} so they compose with the existing read surface without
+ * widening the `RestClient` class itself.
+ *
+ * Responses are returned as generics defaulting to small interfaces / {@link
+ * Record}<string, unknown>: the module returns rich, evolving JSON and the SDK
+ * does not model every field.
+ *
+ * Note on direction: these helpers READ cross-VM message state. The actual
+ * EVM→native routing — e.g. an EVM contract triggering a native AMM swap — is
+ * performed on-chain via the cross-VM bridge precompile exposed in the
+ * `@qorechain/evm` package (not duplicated here). Once a message is in flight,
+ * track its status either through these REST reads or via the
+ * `qor_getCrossVMMessage` JSON-RPC method already wrapped on `QorClient`.
+ */
+
+/** A single cross-VM message record (unmodeled fields surface as-is). */
+interface CrossVmMessage {
+    [key: string]: unknown;
+}
+/** Response of the single-message-by-id route. */
+interface CrossVmMessageResponse {
+    message?: CrossVmMessage;
+    [key: string]: unknown;
+}
+/** Response of the pending-messages route. */
+interface PendingCrossVmMessagesResponse {
+    messages?: CrossVmMessage[];
+    [key: string]: unknown;
+}
+/** Response of the module params route. */
+interface CrossVmParamsResponse {
+    params?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Fetch a cross-VM message by id.
+ *
+ * GET `/qorechain/crossvm/v1/message/{id}`.
+ */
+declare function getCrossVmMessage<T = CrossVmMessageResponse>(rest: RestClient, id: string): Promise<T>;
+/**
+ * Fetch all currently pending cross-VM messages.
+ *
+ * GET `/qorechain/crossvm/v1/pending`.
+ */
+declare function getPendingCrossVmMessages<T = PendingCrossVmMessagesResponse>(rest: RestClient): Promise<T>;
+/**
+ * Fetch the `x/crossvm` module parameters.
+ *
+ * GET `/qorechain/crossvm/v1/params`.
+ */
+declare function getCrossVmParams<T = CrossVmParamsResponse>(rest: RestClient): Promise<T>;
+
+/**
+ * Top-level `createClient` factory for the QoreChain SDK.
+ *
+ * {@link createClient} resolves a {@link NetworkConfig} (applying any endpoint
+ * overrides) and composes the read clients ({@link RestClient}, the EVM
+ * {@link JsonRpcClient}, and the `qor_` {@link QorClient}) plus a fee-estimate
+ * convenience over {@link estimateFee}. Signing is opt-in: call
+ * {@link QoreChainClient.connectTx} with an offline signer to get a
+ * {@link TxClient}.
+ *
+ * Network resolution rules:
+ *  - The default network is `testnet`. Both `testnet` and `mainnet` are live and
+ *    ship localhost endpoint defaults; pass `endpoints` to point at real
+ *    hostnames.
+ *
+ * Read sub-clients are lazy getters: each only needs its own endpoint, so
+ * accessing one whose endpoint is missing throws a clear, actionable error
+ * naming the missing endpoint rather than failing later with an opaque request.
+ */
+
+/** Options for {@link createClient}. */
+interface CreateClientOptions {
+    /** Network preset to target. Defaults to `"testnet"`. */
+    network?: NetworkName;
+    /**
+     * Endpoint overrides, merged over the preset's defaults. Both `testnet` and
+     * `mainnet` default to localhost; pass real hostnames here to override them.
+     */
+    endpoints?: Partial<NetworkEndpoints>;
+    /**
+     * Chain ID override. Both presets ship a live chain ID, so this is only needed
+     * to point at a non-standard chain.
+     */
+    chainId?: string;
+    /** Injectable `fetch` for the read clients (used by tests). */
+    fetch?: FetchLike;
+    /**
+     * Additional HTTP transport options (timeout, retries, headers) shared by the
+     * read clients.
+     */
+    http?: Omit<HttpOptions, "fetch">;
+}
+/** Options for {@link QoreChainClient.connectTx}. */
+interface ConnectTxOptions {
+    /**
+     * Extra protobuf message types to register, as `[typeUrl, GeneratedType]`
+     * pairs (forwarded to {@link TxClient.connect}).
+     */
+    registryTypes?: ReadonlyArray<[string, GeneratedType]>;
+}
+/** Fee convenience surface exposed by {@link QoreChainClient}. */
+interface ClientFees {
+    /**
+     * Estimate a fee for the given urgency via the AI fee oracle (with a static
+     * fallback). See {@link estimateFee}.
+     */
+    estimate(urgency?: FeeUrgency): Promise<StdFee>;
+}
+/** Cross-VM read convenience surface, bound to the client's REST endpoint. */
+interface ClientCrossVm {
+    /** A cross-VM message by id (`/qorechain/crossvm/v1/message/{id}`). */
+    message(id: string): Promise<CrossVmMessageResponse>;
+    /** Currently pending cross-VM messages (`/qorechain/crossvm/v1/pending`). */
+    pending(): Promise<PendingCrossVmMessagesResponse>;
+    /** Cross-VM module params (`/qorechain/crossvm/v1/params`). */
+    params(): Promise<CrossVmParamsResponse>;
+}
+/**
+ * A composed QoreChain client: resolved config, read clients, fee helper, and a
+ * lazy signing entrypoint.
+ */
+interface QoreChainClient {
+    /** The resolved network config (with any endpoint/chain-id overrides applied). */
+    readonly network: NetworkConfig;
+    /** Cosmos + QoreChain REST read client (uses `endpoints.rest`). */
+    readonly rest: RestClient;
+    /** EVM JSON-RPC client (uses `endpoints.evmRpc`). */
+    readonly evm: JsonRpcClient;
+    /** QoreChain `qor_` namespace client (uses `endpoints.evmRpc`). */
+    readonly qor: QorClient;
+    /** Fee-estimate convenience over the REST client. */
+    readonly fees: ClientFees;
+    /** Cross-VM read helpers over the REST client. */
+    readonly crossvm: ClientCrossVm;
+    /**
+     * Connect a read-only CosmWasm client at `endpoints.rpc`.
+     *
+     * Async (the cosmjs client opens an RPC connection on connect), so this is a
+     * method rather than a lazy getter; the result is memoized across calls.
+     */
+    cosmwasm(): Promise<CosmWasmClient>;
+    /**
+     * Connect a signer and return a {@link TxClient} bound to `endpoints.rpc`.
+     * The heavy lifting lives in {@link TxClient.connect}.
+     */
+    connectTx(signer: OfflineDirectSigner, opts?: ConnectTxOptions): Promise<TxClient>;
+}
+/**
+ * Create a composed {@link QoreChainClient}.
+ *
+ * @param opts - Network selection, endpoint overrides, and transport options.
+ */
+declare function createClient(opts?: CreateClientOptions): QoreChainClient;
+
+/**
+ * Conversion between human display amounts (e.g. `"1.5"` QOR) and integer base
+ * amounts (e.g. `"1500000"` uqor).
+ *
+ * All value math is performed with {@link BigInt} on decimal strings — there is
+ * no floating-point arithmetic anywhere in this module, so conversions are exact
+ * for any magnitude and never drift (e.g. `toBase("0.1")` is exactly
+ * `"100000"`).
+ *
+ * QoreChain's staking coin uses a default exponent of `6` (1 QOR = 10^6 uqor),
+ * but every function accepts a custom `exponent` for other denominations.
+ */
+/** Options shared by the denom conversion helpers. */
+interface DenomOptions {
+    /** Decimal exponent relating base to display (1 display = 10^exponent base). Defaults to 6. */
+    exponent?: number;
+}
+/**
+ * Convert a human display amount to its integer base amount string.
+ *
+ * @param amount - A non-negative decimal string, e.g. `"1.5"`. Surrounding
+ *   whitespace and a single leading `+` are tolerated. Scientific notation,
+ *   thousands separators, and other formatting are rejected.
+ * @param opts - Optional `exponent` (defaults to 6).
+ * @returns The integer base amount as a string with no leading zeros, e.g.
+ *   `"1500000"`.
+ * @throws If `amount` is not a valid decimal string, is negative, or has more
+ *   fractional digits than `exponent` allows.
+ */
+declare function toBase(amount: string, opts?: DenomOptions): string;
+/**
+ * Convert an integer base amount string to a normalized display string.
+ *
+ * @param base - A non-negative integer string, e.g. `"1500000"`.
+ * @param opts - Optional `exponent` (defaults to 6).
+ * @returns The display amount with no trailing zeros and no trailing dot, e.g.
+ *   `"1.5"`. `"1000000"` becomes `"1"`, `"1"` becomes `"0.000001"`, `"0"`
+ *   becomes `"0"`.
+ * @throws If `base` is not a valid non-negative integer string.
+ */
+declare function fromBase(base: string, opts?: DenomOptions): string;
+
+/**
+ * Conversion and validation for QoreChain bech32 addresses (e.g. `qor1...`) and
+ * their underlying byte payloads expressed as `0x`-prefixed hex.
+ *
+ * bech32 stores data as 5-bit groups ("words"), so encoding/decoding goes
+ * through {@link bech32.toWords}/{@link bech32.fromWords} to convert to and from
+ * the 8-bit byte representation that callers work with as hex.
+ */
+/**
+ * Decode a bech32 address to a `0x`-prefixed hex string of its byte payload.
+ *
+ * @param addr - A bech32 address, e.g. `qor1...`.
+ * @returns The underlying bytes as lowercase `0x`-prefixed hex.
+ * @throws If `addr` is not a valid bech32 string.
+ */
+declare function bech32ToHex(addr: string): string;
+/**
+ * Encode raw bytes to a bech32 address with the given prefix.
+ *
+ * This is the primitive encoder; callers holding a `Uint8Array` payload (e.g.
+ * the 20-byte `ripemd160(sha256(pubkey))` account hash) should use this
+ * directly rather than round-tripping through hex.
+ *
+ * @param bytes - The raw byte payload.
+ * @param prefix - The bech32 human-readable prefix. Defaults to `"qor"`.
+ * @returns The bech32-encoded address, e.g. `qor1...`.
+ */
+declare function bytesToBech32(bytes: Uint8Array, prefix?: string): string;
+/**
+ * Encode hex bytes to a bech32 address with the given prefix.
+ *
+ * @param hex - The byte payload as hex, with or without a `0x` prefix.
+ * @param prefix - The bech32 human-readable prefix. Defaults to `"qor"`.
+ * @returns The bech32-encoded address, e.g. `qor1...`.
+ * @throws If `hex` is not a valid hex string.
+ */
+declare function hexToBech32(hex: string, prefix?: string): string;
+/**
+ * Validate a bech32 address, optionally requiring a specific prefix.
+ *
+ * @param addr - The candidate address string.
+ * @param prefix - If given, the decoded prefix must match exactly.
+ * @returns `true` if `addr` is a structurally valid bech32 string (correct
+ *   checksum) and, when `prefix` is supplied, its prefix matches; `false`
+ *   otherwise. Never throws.
+ */
+declare function isValidBech32(addr: string, prefix?: string): boolean;
+
+/**
+ * Account and key types for the three address schemes QoreChain supports.
+ *
+ * All three derive from a single BIP-39 mnemonic via separate BIP-44 / SLIP-0010
+ * paths, so one seed phrase yields a native QoreChain account, an EVM account,
+ * and an SVM account independently.
+ */
+/** The address/key scheme an {@link Account} belongs to. */
+type KeyType = "native" | "evm" | "svm";
+/**
+ * A derived account, without secret material.
+ *
+ * `publicKey` is the compressed 33-byte secp256k1 public key for `native`/`evm`
+ * accounts, or the bare 32-byte ed25519 public key for `svm` accounts.
+ */
+interface Account {
+    /** Which address scheme this account uses. */
+    type: KeyType;
+    /**
+     * The encoded address:
+     * - `native`: bech32 with the `qor` prefix (e.g. `qor1...`)
+     * - `evm`: `0x`-prefixed, EIP-55 mixed-case checksummed hex
+     * - `svm`: base58-encoded 32-byte ed25519 public key
+     */
+    address: string;
+    /** Compressed secp256k1 (native/evm) or 32-byte ed25519 (svm) public key. */
+    publicKey: Uint8Array;
+}
+/** Options controlling which account in the wallet to derive. */
+interface DerivationOptions {
+    /**
+     * Zero-based address index, varying the last path segment. Defaults to `0`.
+     * - native/evm: `m/44'/{118|60}'/0'/0/{index}`
+     * - svm: `m/44'/501'/{index}'/0'`
+     */
+    accountIndex?: number;
+}
+/**
+ * A native QoreChain or EVM account including its 32-byte secp256k1 private key.
+ * Callers need the private key for signing; it is returned explicitly and never
+ * logged by the SDK.
+ */
+interface Secp256k1Account extends Account {
+    /** Raw 32-byte secp256k1 private key. Handle as a secret. */
+    privateKey: Uint8Array;
+}
+/**
+ * An SVM account including its ed25519 secret key.
+ *
+ * `secretKey` follows the Solana convention of 64 bytes (`seed32 || pubkey32`),
+ * which is what `@solana/web3.js` `Keypair.fromSecretKey` expects. Handle as a
+ * secret; it is never logged by the SDK.
+ */
+interface Ed25519Account extends Account {
+    /** 64-byte Solana-style secret key (`privateSeed32 || publicKey32`). */
+    secretKey: Uint8Array;
+}
+
+/**
+ * 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}`,
+ *    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:]),
+ *    rendered with an EIP-55 mixed-case checksum.
+ * 3. svm    — ed25519, SLIP-0010 path `m/44'/501'/{index}'/0'` (all hardened,
+ *    the Solana standard), address = base58(32-byte ed25519 public key).
+ *
+ * Derivation uses audited primitives: @scure/bip39 (mnemonic + seed), @scure/bip32
+ * (secp256k1 HD), micro-key-producer SLIP-0010 (ed25519 HD), @noble/hashes and
+ * @noble/curves. Secret material is returned explicitly from the derive functions
+ * and is never logged.
+ *
+ * Dependency note: this module pins @noble/hashes/@noble/curves/@scure/base on
+ * the 1.x line, while `micro-key-producer` brings its own 2.x copies of those
+ * packages. The two majors are installed side by side intentionally. They never
+ * exchange hash or curve instances across the boundary — micro-key-producer is
+ * used only as a self-contained SLIP-0010 derivation black box (seed in, ed25519
+ * node out), so the duplicate copies are isolated and harmless. Do not force a
+ * `pnpm.overrides` that drags micro-key-producer onto a different major; that
+ * would risk breaking its internals for no behavioural gain here.
+ */
+
+/**
+ * Generate a fresh BIP-39 mnemonic.
+ *
+ * @param strength - Entropy in bits: `128` → 12 words (default), `256` → 24 words.
+ * @returns A space-separated English mnemonic phrase.
+ */
+declare function generateMnemonic(strength?: 128 | 256): string;
+/**
+ * Validate a BIP-39 mnemonic against the English wordlist and its checksum.
+ *
+ * @param mnemonic - The candidate phrase.
+ * @returns `true` if the phrase is a structurally valid, checksum-correct
+ *   English BIP-39 mnemonic; `false` otherwise. Never throws.
+ */
+declare function validateMnemonic(mnemonic: string): boolean;
+/**
+ * Derive a native QoreChain account (Cosmos-style secp256k1) from a mnemonic.
+ *
+ * Path: `m/44'/118'/0'/0/{accountIndex}`. The address is the bech32 (`qor`)
+ * encoding of `ripemd160(sha256(compressedPublicKey))`.
+ *
+ * @returns The account including its 32-byte secp256k1 private key.
+ */
+declare function deriveNativeAccount(mnemonic: string, opts?: DerivationOptions): Promise<Secp256k1Account>;
+/**
+ * Derive an EVM account from a mnemonic.
+ *
+ * Path: `m/44'/60'/0'/0/{accountIndex}`. The address is the last 20 bytes of
+ * `keccak256(uncompressedPublicKey[1:])`, EIP-55 checksummed.
+ *
+ * @returns The account including its 32-byte secp256k1 private key.
+ */
+declare function deriveEvmAccount(mnemonic: string, opts?: DerivationOptions): Promise<Secp256k1Account>;
+/**
+ * Derive an SVM (Solana-style ed25519) account from a mnemonic.
+ *
+ * Path: `m/44'/501'/{accountIndex}'/0'` — the conventional Solana derivation,
+ * all segments hardened (SLIP-0010 for ed25519 supports hardened keys only).
+ * The address is the base58 encoding of the 32-byte ed25519 public key.
+ *
+ * @returns The account including its 64-byte Solana-style secret key
+ *   (`privateSeed32 || publicKey32`).
+ */
+declare function deriveSvmAccount(mnemonic: string, opts?: DerivationOptions): Promise<Ed25519Account>;
+
+/**
+ * PQC algorithm identifiers, mirroring the chain's `x/pqc` cryptographic-agility
+ * framework (core `x/pqc/types/algorithm.go`).
+ *
+ * These numeric IDs are the on-the-wire values the chain expects in
+ * `MsgRegisterPQCKeyV2.algorithm_id` and in the `PQCHybridSignature` TX
+ * extension's `algorithm_id` field, so they MUST stay in sync with the core enum.
+ */
+/**
+ * Identifies a PQC algorithm. Numeric to match the chain's `uint32 AlgorithmID`.
+ * IDs 1–2 are the initial algorithms; 3–255 are reserved for future
+ * governance-approved algorithms.
+ */
+type AlgorithmID = number;
+/** Unset / invalid algorithm (core: `AlgorithmUnspecified`). */
+declare const AlgorithmUnspecified: AlgorithmID;
+/** Dilithium-5 = ML-DSA-87, NIST FIPS 204 signatures (core: `AlgorithmDilithium5`). */
+declare const AlgorithmDilithium5: AlgorithmID;
+/** ML-KEM-1024, NIST FIPS 203 key encapsulation (core: `AlgorithmMLKEM1024`). */
+declare const AlgorithmMLKEM1024: AlgorithmID;
+/** Human-readable name for an algorithm ID (matches core `AlgorithmID.String()`). */
+declare function algorithmName(id: AlgorithmID): string;
+/** True if the algorithm is a digital-signature scheme (core `IsSignature`). */
+declare function isSignatureAlgorithm(id: AlgorithmID): boolean;
+
+/**
+ * Pluggable signer abstraction.
+ *
+ * QoreChain supports three signature postures, mirroring the chain's `x/pqc`
+ * key types (see the core `PQC_INTEGRATION.md`):
+ *
+ * - `classical` — a single classical signature (secp256k1 / ed25519). Backward
+ *   compatible; no post-quantum material.
+ * - `pqc` — an ML-DSA-87 (Dilithium-5) signature only. Maximum quantum safety.
+ * - `hybrid` — a classical signature PLUS an ML-DSA-87 signature carried as a TX
+ *   extension, so quantum-safe wallets interoperate with classical verification.
+ *
+ * This module defines only the SIGNING primitives and the shape of their output.
+ * Wiring a {@link SignOutput} into a real transaction (attaching the PQC
+ * extension to the signed body, fees, broadcast) is the tx-builder's job, not
+ * the signer's.
+ */
+
+/** Which signature posture a {@link Signer} implements. */
+type SignatureMode = "classical" | "pqc" | "hybrid";
+/**
+ * The post-quantum portion of a signature, present for `pqc` and `hybrid` modes.
+ *
+ * Field shapes are chosen so this can be handed straight to
+ * `buildHybridSignatureExtension` to produce the on-chain
+ * `PQCHybridSignature` TX extension.
+ */
+interface PqcSignaturePart {
+    /** The PQC signature algorithm. For Dilithium-5 this is {@link AlgorithmID}. */
+    algorithmId: AlgorithmID;
+    /** Raw PQC signature bytes (ML-DSA-87 / Dilithium-5: 4627 bytes). */
+    signature: Uint8Array;
+    /**
+     * The PQC public key, included so the chain can auto-register it on first use.
+     * ML-DSA-87 / Dilithium-5: 2592 bytes.
+     */
+    publicKey?: Uint8Array;
+}
+/**
+ * The result of signing a message.
+ *
+ * - `classical` mode: only {@link classicalSignature} is set.
+ * - `pqc` mode: only {@link pqc} is set.
+ * - `hybrid` mode: BOTH are set.
+ */
+interface SignOutput {
+    /** Classical signature bytes (present for `classical` and `hybrid`). */
+    classicalSignature?: Uint8Array;
+    /** Post-quantum signature part (present for `pqc` and `hybrid`). */
+    pqc?: PqcSignaturePart;
+}
+/**
+ * A pluggable signer over arbitrary message bytes.
+ *
+ * `sign` is always asynchronous and returns a `Promise<SignOutput>`. Some
+ * signers are inherently async (hardware/remote classical signers) while the
+ * in-process PQC path is synchronous, but the interface normalizes both to a
+ * Promise so callers never have to remember to `await` conditionally.
+ */
+interface Signer {
+    /** The signature posture this signer implements. */
+    readonly mode: SignatureMode;
+    /**
+     * The public key that identifies the signing account:
+     * - `classical` / `hybrid`: the classical public key.
+     * - `pqc`: the PQC public key.
+     */
+    publicKey(): Uint8Array;
+    /** Sign the given message bytes. Always resolves to a {@link SignOutput}. */
+    sign(message: Uint8Array): Promise<SignOutput>;
+}
+
+/**
+ * Post-quantum (PQC) signing for QoreChain, using ML-DSA-87 (Dilithium-5,
+ * NIST FIPS 204) for digital signatures.
+ *
+ * QoreChain treats PQC as a first-class signature scheme via a hybrid
+ * architecture (see the core `PQC_INTEGRATION.md`): a transaction carries the
+ * usual classical (secp256k1 / ed25519) signature PLUS an ML-DSA-87 signature
+ * attached as a `PQCHybridSignature` TX extension. The chain's ante handler
+ * verifies both, so quantum-safe wallets stay compatible with classical
+ * verification.
+ *
+ * Scope: this module provides the signing PRIMITIVES (keygen / sign / verify),
+ * a pluggable {@link Signer} for the `pqc` and `hybrid` postures, and a builder
+ * for the on-chain hybrid-signature extension OBJECT. It deliberately does NOT
+ * assemble or broadcast transactions — the tx-builder attaches the extension
+ * the {@link buildHybridSignatureExtension} result describes.
+ *
+ * Crypto is delegated entirely to the audited, pure-TS `@noble/post-quantum`
+ * (`ml_dsa87`). No primitives are reimplemented here.
+ */
+
+/**
+ * ML-DSA-87 (Dilithium-5) byte lengths.
+ *
+ * These are fixed by NIST FIPS 204 and match the chain's `x/pqc` constants
+ * exactly. The installed `@noble/post-quantum` `ml_dsa87` does not expose these
+ * as runtime properties, so we encode the standard's values directly; the test
+ * suite asserts that the library actually produces keys/signatures of these
+ * lengths, guarding against any future library drift.
+ */
+/** ML-DSA-87 public-key length, in bytes (FIPS 204 / core: 2592). */
+declare const ML_DSA_87_PUBLIC_KEY_LENGTH = 2592;
+/** ML-DSA-87 secret-key length, in bytes (FIPS 204 / core: 4896). */
+declare const ML_DSA_87_SECRET_KEY_LENGTH = 4896;
+/** ML-DSA-87 signature length, in bytes (FIPS 204 / core: 4627). */
+declare const ML_DSA_87_SIGNATURE_LENGTH = 4627;
+/** Length, in bytes, of the deterministic-keygen seed (xi) per FIPS 204. */
+declare const ML_DSA_87_SEED_LENGTH = 32;
+/**
+ * The TX-extension type URL for the on-chain `PQCHybridSignature` message
+ * (core: `HybridSigTypeURL`). The tx-builder uses this as the extension's
+ * type URL when packing the object from {@link buildHybridSignatureExtension}.
+ */
+declare const HYBRID_SIG_TYPE_URL = "/qorechain.pqc.v1.PQCHybridSignature";
+/** An ML-DSA-87 (Dilithium-5) keypair. Treat `secretKey` as a secret. */
+interface PqcKeypair {
+    /** 2592-byte ML-DSA-87 public key. */
+    publicKey: Uint8Array;
+    /** 4896-byte ML-DSA-87 secret key. Handle as a secret; never logged. */
+    secretKey: Uint8Array;
+}
+/**
+ * Generate an ML-DSA-87 (Dilithium-5) keypair.
+ *
+ * @param seed Optional 32-byte seed for deterministic keygen (e.g. derived from
+ *   a wallet). When omitted, a cryptographically random keypair is produced.
+ *   Must be exactly {@link ML_DSA_87_SEED_LENGTH} bytes if provided.
+ */
+declare function generatePqcKeypair(seed?: Uint8Array): PqcKeypair;
+/** Sign a message with an ML-DSA-87 (Dilithium-5) secret key. */
+declare function pqcSign(secretKey: Uint8Array, message: Uint8Array): Uint8Array;
+/** Verify an ML-DSA-87 (Dilithium-5) signature over a message. */
+declare function pqcVerify(publicKey: Uint8Array, message: Uint8Array, signature: Uint8Array): boolean;
+/**
+ * The on-chain `PQCHybridSignature` TX extension, as a plain object whose keys
+ * mirror the core struct's JSON field tags EXACTLY
+ * (`x/pqc/types/hybrid.go`):
+ *
+ * ```go
+ * type PQCHybridSignature struct {
+ *   AlgorithmID  AlgorithmID `json:"algorithm_id"`
+ *   PQCSignature []byte      `json:"pqc_signature"`
+ *   PQCPublicKey []byte      `json:"pqc_public_key,omitempty"`
+ * }
+ * ```
+ *
+ * The tx-builder is responsible for encoding this and attaching it under
+ * {@link HYBRID_SIG_TYPE_URL}.
+ */
+interface PQCHybridSignature {
+    /** PQC algorithm ID (core `AlgorithmID`). */
+    algorithm_id: AlgorithmID;
+    /** Raw PQC signature bytes. */
+    pqc_signature: Uint8Array;
+    /** Optional PQC public key for auto-registration on first use. */
+    pqc_public_key?: Uint8Array;
+}
+/**
+ * Build the on-chain `PQCHybridSignature` extension object from a signature.
+ *
+ * Validation mirrors the core `PQCHybridSignature.Validate()`: the algorithm
+ * must be a signature scheme, the signature must be non-empty, and for
+ * Dilithium-5 the signature/public-key lengths are enforced.
+ *
+ * `pqc_public_key` is omitted entirely when no public key is supplied, matching
+ * the `omitempty` JSON tag on the core struct.
+ */
+declare function buildHybridSignatureExtension(args: {
+    algorithmId: AlgorithmID;
+    signature: Uint8Array;
+    publicKey?: Uint8Array;
+}): PQCHybridSignature;
+/**
+ * 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.
+ */
+declare class PqcSigner implements Signer {
+    readonly mode: "pqc";
+    private readonly keypair;
+    private readonly algorithmId;
+    constructor(keypair: PqcKeypair, algorithmId?: AlgorithmID);
+    /** The PQC public key (the signing identity in pqc-only mode). */
+    publicKey(): Uint8Array;
+    sign(message: Uint8Array): Promise<SignOutput>;
+}
+/**
+ * A hybrid {@link Signer}: wraps a classical signer and an ML-DSA-87 keypair,
+ * producing BOTH a classical signature and a PQC signature over the same
+ * message. Corresponds to the chain's `hybrid` key type.
+ *
+ * The account identity is the wrapped classical signer's public key, so a
+ * hybrid account is indistinguishable from a classical one to wallets that do
+ * not understand the PQC extension.
+ */
+declare class HybridSigner implements Signer {
+    readonly mode: "hybrid";
+    private readonly classical;
+    private readonly keypair;
+    private readonly algorithmId;
+    /**
+     * @param classical The wrapped classical signer. Must be a `classical`-mode
+     *   signer; its `classicalSignature` output is passed through unchanged.
+     * @param keypair The ML-DSA-87 keypair used for the PQC half.
+     * @throws if `classical` is not a `classical`-mode signer.
+     */
+    constructor(classical: Signer, keypair: PqcKeypair, algorithmId?: AlgorithmID);
+    /** The classical public key — the on-chain account identity. */
+    publicKey(): Uint8Array;
+    sign(message: Uint8Array): Promise<SignOutput>;
+}
+
+/**
+ * CosmWasm contract interaction for QoreChain.
+ *
+ * This module rounds out the triple-VM surface (native + EVM + SVM + CosmWasm)
+ * with thin, type-safe conveniences over `@cosmjs/cosmwasm-stargate`. It does
+ * NOT reimplement cosmjs: the wrappers forward to a `CosmWasmClient` (reads) or
+ * `SigningCosmWasmClient` (writes) with QoreChain-friendly defaults.
+ *
+ * Two construction helpers ({@link createCosmWasmClient}, {@link
+ * connectCosmWasmSigner}) build the cosmjs clients against a network's `rpc`
+ * endpoint. The wrapper functions, however, accept an already-built client so
+ * they are unit-testable with a stubbed fake — no real connection required.
+ */
+
+/**
+ * Arbitrary JSON value accepted/returned by contract calls. Mirrors cosmjs's
+ * `JsonObject` (which is `any`) but keeps our public types honest.
+ */
+type ContractMsg = Record<string, unknown>;
+/** A `StdFee`, or cosmjs's `"auto"` (simulate) / a raw gas multiplier number. */
+type FeeInput = StdFee | "auto" | number;
+/**
+ * Read-only slice of `CosmWasmClient` used by the read wrappers. Declaring the
+ * methods we use (rather than importing the concrete class) lets tests inject a
+ * minimal fake.
+ */
+interface CosmWasmReadClient {
+    queryContractSmart(address: string, queryMsg: ContractMsg): Promise<unknown>;
+    getContract(address: string): Promise<unknown>;
+}
+/** Signing slice of `SigningCosmWasmClient` used by the write wrappers. */
+interface CosmWasmSigningClient {
+    upload(senderAddress: string, wasmCode: Uint8Array, fee: FeeInput, memo?: string): Promise<unknown>;
+    instantiate(senderAddress: string, codeId: number, msg: ContractMsg, label: string, fee: FeeInput, options?: InstantiateOpts): Promise<unknown>;
+    execute(senderAddress: string, contractAddress: string, msg: ContractMsg, fee: FeeInput, memo?: string, funds?: readonly Coin[]): Promise<unknown>;
+}
+/** Options for {@link instantiate}: cosmjs `InstantiateOptions` plus the fee. */
+interface InstantiateOpts {
+    /** Fee for the instantiate tx. Defaults to `"auto"` (simulate). */
+    fee?: FeeInput;
+    /** Optional memo. */
+    memo?: string;
+    /** Native funds sent to the new contract on instantiation. */
+    funds?: readonly Coin[];
+    /** Optional admin address (can migrate the contract). */
+    admin?: string;
+}
+/**
+ * Connect a read-only {@link CosmWasmClient} to a network's RPC endpoint.
+ *
+ * @param rpcUrl - The network's `rpc` endpoint (e.g. `endpoints.rpc`).
+ */
+declare function createCosmWasmClient(rpcUrl: string): Promise<CosmWasmClient>;
+/**
+ * Connect a {@link SigningCosmWasmClient} for contract writes.
+ *
+ * @param rpcUrl - The network's `rpc` endpoint.
+ * @param signer - An offline signer (e.g. from `@cosmjs/proto-signing`).
+ */
+declare function connectCosmWasmSigner(rpcUrl: string, signer: OfflineSigner): Promise<SigningCosmWasmClient>;
+/** Run a contract's smart query (`queryContractSmart`). */
+declare function queryContractSmart<T = unknown>(client: CosmWasmReadClient, contractAddress: string, queryMsg: ContractMsg): Promise<T>;
+/** Fetch a contract's on-chain metadata (`getContract`). */
+declare function getContractInfo<T = unknown>(client: CosmWasmReadClient, contractAddress: string): Promise<T>;
+/**
+ * Instantiate a contract from an uploaded code id.
+ *
+ * Forwards to `SigningCosmWasmClient.instantiate`, splitting our {@link
+ * InstantiateOpts} into cosmjs's positional `fee` (default `"auto"`) and its
+ * `InstantiateOptions` (`memo`/`funds`/`admin`).
+ */
+declare function instantiate<T = unknown>(client: CosmWasmSigningClient, sender: string, codeId: number, initMsg: ContractMsg, label: string, opts?: InstantiateOpts): Promise<T>;
+/** Execute a message against an instantiated contract. */
+declare function execute<T = unknown>(client: CosmWasmSigningClient, sender: string, contractAddress: string, msg: ContractMsg, fee: FeeInput, funds?: readonly Coin[]): Promise<T>;
+/** Upload (store) WASM bytecode, returning the assigned code id in the result. */
+declare function uploadCode<T = unknown>(client: CosmWasmSigningClient, sender: string, wasmBytes: Uint8Array, fee: FeeInput): Promise<T>;
+
+/**
+ * Adapter from a native QoreChain secp256k1 key to a cosmjs signer.
+ *
+ * The accounts module (`deriveNativeAccount`, Task 13) yields a raw 32-byte
+ * secp256k1 private key. The transaction layer signs through cosmjs's
+ * `SigningStargateClient`, which expects an `OfflineDirectSigner`. This module
+ * bridges the two via `@cosmjs/proto-signing`'s `DirectSecp256k1Wallet`, binding
+ * the key to the network's bech32 account prefix (`qor`).
+ *
+ * The signer performs SIGN_MODE_DIRECT (protobuf) signing — the native chain's
+ * default — so the produced address and signatures match what the node's ante
+ * handler verifies for a classical secp256k1 account.
+ */
+
+/**
+ * Adapt a raw secp256k1 private key into a cosmjs {@link OfflineDirectSigner}.
+ *
+ * @param privateKey - Raw 32-byte secp256k1 private key (e.g. the `privateKey`
+ *   field of a {@link Secp256k1Account} from `deriveNativeAccount`).
+ * @param prefix - Bech32 account prefix for the network (QoreChain: `"qor"`).
+ * @returns A direct (protobuf) offline signer whose single account address is
+ *   the bech32 encoding of the key under `prefix`.
+ */
+declare function directSignerFromPrivateKey(privateKey: Uint8Array, prefix: string): Promise<OfflineDirectSigner>;
+
+/**
+ * Encoding and attachment of the QoreChain PQC hybrid-signature extension to a
+ * native tx.
+ *
+ * ──────────────────────────────────────────────────────────────────────────
+ *  The wallet ↔ chain contract (now known and enforced)
+ * ──────────────────────────────────────────────────────────────────────────
+ * These are low-level encode/attach primitives. The full, contract-correct
+ * hybrid build sequence lives in {@link ../tx/hybrid-tx} ({@link buildHybridTx}
+ * / {@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
+ *    `/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}).
+ *  - 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
+ *    {@link AttachHybridOptions.placement} for callers with other needs, but the
+ *    chain reads the critical slot.
+ *  - SIGNED BYTES: the ML-DSA-87 signature is computed over the tx body WITH the
+ *    PQC extension REMOVED, framed with the authInfo bytes:
+ *    `BE32(len(B0)) || B0 || BE32(len(A)) || A` (see {@link buildHybridTx} for
+ *    the full contract). This module does not decide what the PQC signature
+ *    signs — {@link buildHybridTx} does.
+ *
+ * Cross-implementation proto byte-determinism (cosmjs encode vs. the chain's
+ * re-marshal) is confirmed on the live testnet for the default registry message
+ * types.
+ */
+
+/** Where the hybrid-signature extension is placed within the `TxBody`. */
+type HybridPlacement = "non_critical_extension_options" | "extension_options";
+/** Options for {@link attachHybridExtension}. */
+interface AttachHybridOptions {
+    /**
+     * Which `TxBody` extension list to attach the extension to. Defaults to
+     * `"non_critical_extension_options"`. See the module header: the exact slot
+     * the ante handler reads is not determinable from public core and needs
+     * live-testnet verification.
+     */
+    placement?: HybridPlacement;
+}
+/**
+ * Encode a {@link PQCHybridSignature} into a protobuf `Any` for use as a
+ * `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).
+ */
+declare function encodeHybridExtension(ext: PQCHybridSignature): Any;
+/**
+ * Return a copy of `body` with the encoded hybrid-signature extension attached.
+ *
+ * The input `body` is not mutated. By default the extension is added to
+ * `non_critical_extension_options`; pass `placement` to use `extension_options`
+ * instead.
+ *
+ * @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;
+
+/**
+ * End-to-end hybrid (classical + post-quantum) transaction signing for
+ * QoreChain.
+ *
+ * A hybrid transaction carries the usual classical secp256k1 signature in
+ * `TxRaw.signatures` PLUS an ML-DSA-87 (Dilithium-5) signature attached to the
+ * `TxBody` as a `PQCHybridSignature` extension. The chain's ante handler
+ * verifies BOTH, so a hybrid account stays interoperable with classical
+ * verification while gaining quantum safety.
+ *
+ * ──────────────────────────────────────────────────────────────────────────
+ *  The wallet ↔ chain contract (enforced by the chain)
+ * ──────────────────────────────────────────────────────────────────────────
+ * The chain verifies the ML-DSA-87 signature over the tx body WITH the PQC
+ * extension REMOVED. Concretely:
+ *
+ *  - `B0` = canonical protobuf bytes of the `TxBody` containing the
+ *    messages/memo/timeoutHeight but NOT the `PQCHybridSignature` extension.
+ *  - `A`  = the tx `authInfoBytes`, verbatim — the same bytes that are
+ *    broadcast.
+ *  - PQC signed message = `BE32(len(B0)) || B0 || BE32(len(A)) || A`
+ *    (4-byte big-endian length prefixes; NO hashing, NO domain prefix).
+ *  - PQC signature       = `ml_dsa87.sign(pqcSecretKey, message)` (pure
+ *    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).
+ *  - 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
+ *    no self-reference: the classical signature never signs itself.
+ *
+ * The signer's PQC key must be registered on-chain (via `MsgRegisterPQCKey`)
+ * before hybrid txs PQC-verify — unless `includePqcPublicKey` is set, which
+ * embeds the key for auto-registration on first use. Registering the key is the
+ * caller's responsibility.
+ *
+ * Determinism note: the framing above is byte-for-byte deterministic on the
+ * wallet side. Cross-implementation determinism (this `cosmjs`/`cosmjs-types`
+ * proto encoding vs. the chain's re-marshal of the same `TxBody`) is confirmed
+ * against the live testnet; if a custom message type with non-canonical field
+ * ordering were used, callers must ensure their `Registry` encodes canonically.
+ */
+
+/** The fields shared by {@link buildHybridTx} and {@link signAndBroadcastHybrid}. */
+interface BuildHybridTxOptions {
+    /**
+     * The protobuf message {@link Registry} used to encode the messages into the
+     * `TxBody`. Use cosmjs's `defaultRegistryTypes` (plus any custom QoreChain
+     * message types) — the same registry the network's `TxClient` is built with.
+     */
+    registry: Registry;
+    /**
+     * The classical secp256k1 direct signer (e.g. from
+     * `directSignerFromPrivateKey`). Its first account is used as the signer
+     * identity and to produce the SIGN_MODE_DIRECT classical signature.
+     */
+    signer: OfflineDirectSigner;
+    /** The ML-DSA-87 (Dilithium-5) keypair providing the post-quantum half. */
+    pqcKeypair: PqcKeypair;
+    /** The transaction messages, as `{ typeUrl, value }` encode objects. */
+    messages: readonly EncodeObject[];
+    /** The fee to pay. */
+    fee: StdFee;
+    /** Optional memo. Defaults to `""`. */
+    memo?: string;
+    /** The chain id (e.g. `"qorechain-diana"`). */
+    chainId: string;
+    /** The on-chain account number of the signer. */
+    accountNumber: number | bigint;
+    /** The signer's current account sequence (nonce). */
+    sequence: number | bigint;
+    /** Optional `timeoutHeight` for the tx body. */
+    timeoutHeight?: bigint;
+    /**
+     * When `true`, embed the 2592-byte ML-DSA-87 public key in the extension so
+     * the chain can auto-register it on first use. Defaults to `false` (the key
+     * is expected to already be registered via `MsgRegisterPQCKey`).
+     */
+    includePqcPublicKey?: boolean;
+}
+/** The fully assembled hybrid transaction and the intermediate artifacts. */
+interface BuiltHybridTx {
+    /** The assembled `TxRaw` (final body + authInfo + classical signature). */
+    txRaw: TxRaw;
+    /** Encoded `TxRaw` bytes, ready to broadcast. */
+    txRawBytes: Uint8Array;
+    /** The `authInfoBytes` (`A`) — identical in the PQC framing and the SignDoc. */
+    authInfoBytes: Uint8Array;
+    /** The exact bytes the ML-DSA-87 signature was computed over (the framing). */
+    pqcSignedMessage: Uint8Array;
+    /** The raw ML-DSA-87 signature (Dilithium-5: 4627 bytes). */
+    pqcSignature: Uint8Array;
+}
+/**
+ * Build a fully signed hybrid transaction following the chain contract.
+ *
+ * The build sequence (see the module header for the exact contract):
+ *  1. Encode `B0` — the `TxBody` WITHOUT the PQC extension.
+ *  2. Encode `A`  — the single-signer `AuthInfo` (SIGN_MODE_DIRECT).
+ *  3. Compute `message = BE32(len B0) || B0 || BE32(len A) || A`; ML-DSA-87
+ *     sign it.
+ *  4. Build the PQC extension `Any` and attach it to a NEW body identical to
+ *     step 1 but with `extensionOptions = [ext]`; encode → final body bytes.
+ *  5. SIGN_MODE_DIRECT classical sign over `SignDoc{ finalBody, A, chainId,
+ *     accountNumber }`.
+ *  6. Assemble `TxRaw{ finalBody, A, [classicalSig] }`.
+ *
+ * The returned {@link BuiltHybridTx} exposes the intermediate artifacts so the
+ * contract can be asserted/audited.
+ */
+declare function buildHybridTx(opts: BuildHybridTxOptions): Promise<BuiltHybridTx>;
+/**
+ * A minimal broadcast transport for raw tx bytes. cosmjs's `StargateClient`
+ * (and `SigningStargateClient`) satisfy this shape via `broadcastTx` /
+ * `broadcastTxSync`, so production callers can pass an existing client; unit
+ * tests can inject a fake.
+ */
+interface HybridBroadcaster {
+    /** Poll-to-commit broadcast: returns the delivery result. */
+    broadcastTx(tx: Uint8Array, timeoutMs?: number, pollIntervalMs?: number): Promise<{
+        code: number;
+        transactionHash: string;
+        height?: number;
+        gasUsed?: bigint;
+        gasWanted?: bigint;
+        rawLog?: string;
+    }>;
+    /** Submit and return after CheckTx: returns the tx hash. */
+    broadcastTxSync(tx: Uint8Array): Promise<string>;
+}
+/** Options for {@link signAndBroadcastHybrid}. */
+interface SignAndBroadcastHybridOptions extends BuildHybridTxOptions {
+    /** The broadcast transport (e.g. a connected `StargateClient`). */
+    transport: HybridBroadcaster;
+    /** Broadcast mode. Defaults to `"commit"`. */
+    mode?: BroadcastMode;
+}
+/**
+ * Build, sign, and broadcast a hybrid transaction.
+ *
+ * Broadcast mode maps onto the transport:
+ * - `commit` (default): polls until the tx lands in a block; throws on a
+ *   non-zero delivery code.
+ * - `sync` / `async`: returns after mempool submission with just the tx hash.
+ */
+declare function signAndBroadcastHybrid(opts: SignAndBroadcastHybridOptions): Promise<BroadcastResult>;
+
+/**
+ * `@qorechain/sdk` public API.
+ *
+ * The exports below are the deliberate, supported surface of the SDK. Start with
+ * {@link createClient} for the high-level composed client; the individual
+ * networks, accounts, query clients, and tx primitives are also exported for
+ * callers who want to compose them directly. Internal helpers are not exported.
+ */
+/** SDK version. */
+declare const VERSION = "0.1.0";
+
+export { type Account, AlgorithmDilithium5, type AlgorithmID, AlgorithmMLKEM1024, AlgorithmUnspecified, type AllBalancesResponse, type AttachHybridOptions, type BalanceResponse, type BankSendOptions, type Bech32Prefixes, type BroadcastMode, type BroadcastResult, type BuildHybridTxOptions, type BuiltHybridTx, type ClientFees, type CoinInfo, type ConnectTxOptions, type ContractMsg, type CosmWasmReadClient, type CosmWasmSigningClient, type CreateClientOptions, type CrossVmMessage, type CrossVmMessageResponse, type CrossVmParamsResponse, type DenomOptions, type DerivationOptions, type Ed25519Account, type EstimateFeeOptions, type FeeInput, type FeeUrgency, type FetchLike, type GetJsonOptions, HYBRID_SIG_TYPE_URL, type HttpOptions, type HybridBroadcaster, type HybridPlacement, HybridSigner, type InstantiateOpts, JsonRpcClient, type JsonRpcClientOptions, JsonRpcError, type JsonRpcErrorObject, type JsonRpcResponse, type KeyType, ML_DSA_87_PUBLIC_KEY_LENGTH, ML_DSA_87_SECRET_KEY_LENGTH, ML_DSA_87_SEED_LENGTH, ML_DSA_87_SIGNATURE_LENGTH, MSG_SEND_TYPE_URL, NETWORKS, type NetworkConfig, type NetworkEndpoints, type NetworkName, type PQCHybridSignature, type PageResponse, type PaginatedOptions, type Pagination, type PendingCrossVmMessagesResponse, type PqcKeypair, type PqcSignaturePart, PqcSigner, QorClient, type QoreChainClient, QoreHttpError, type QueryValue, RestClient, type RestClientOptions, STATIC_FALLBACK, type Secp256k1Account, type SignAndBroadcastHybridOptions, type SignAndBroadcastOptions, type SignOutput, type SignatureMode, type Signer, type SigningClientLike, type SimulateOptions, TxClient, type TxClientOptions, type TxConnectOptions, VERSION, algorithmName, attachHybridExtension, bech32ToHex, buildHybridSignatureExtension, buildHybridTx, buildUrl, bytesToBech32, connectCosmWasmSigner, createClient, createCosmWasmClient, deriveEvmAccount, deriveNativeAccount, deriveSvmAccount, directSignerFromPrivateKey, encodeHybridExtension, estimateFee, execute, fromBase, generateMnemonic, generatePqcKeypair, getContractInfo, getCrossVmMessage, getCrossVmParams, getJson, getNetwork, getPendingCrossVmMessages, hexToBech32, instantiate, isSignatureAlgorithm, isValidBech32, joinUrl, listNetworks, postJsonRpc, pqcSign, pqcVerify, queryContractSmart, signAndBroadcastHybrid, toBase, uploadCode, validateMnemonic };