wsbridge-sdk 0.1.0

package/dist/index.d.cts

@@ -0,0 +1,1764 @@
+/**
+ * Transport state machine.
+ * Transitions: DISCONNECTED → CONNECTING → CONNECTED → RECONNECTING → CONNECTED
+ *                                                    → DESTROYED (terminal)
+ */
+declare enum TransportState {
+    DISCONNECTED = "DISCONNECTED",
+    CONNECTING = "CONNECTING",
+    CONNECTED = "CONNECTED",
+    RECONNECTING = "RECONNECTING",
+    DESTROYED = "DESTROYED"
+}
+interface TransportEvents {
+    open: () => void;
+    close: (code: number, reason: string) => void;
+    error: (error: Error) => void;
+    message: (data: string) => void;
+    stateChange: (newState: TransportState, oldState: TransportState) => void;
+    reconnectFailed: () => void;
+}
+type TransportEventName = keyof TransportEvents;
+/**
+ * Base class for all transports. Provides a typed event emitter and lifecycle contract.
+ */
+declare abstract class AbstractTransport {
+    protected listeners: Map<keyof TransportEvents, Set<(() => void) | ((code: number, reason: string) => void) | ((error: Error) => void) | ((data: string) => void) | ((newState: TransportState, oldState: TransportState) => void) | (() => void)>>;
+    abstract connect(): Promise<void>;
+    abstract disconnect(): void;
+    abstract send(data: string): void;
+    abstract get state(): TransportState;
+    /** Whether the transport is currently connected. */
+    get isConnected(): boolean;
+    /** Register an event listener. */
+    on<E extends TransportEventName>(event: E, listener: TransportEvents[E]): this;
+    /** Remove an event listener. */
+    off<E extends TransportEventName>(event: E, listener: TransportEvents[E]): this;
+    /** Register a one-shot event listener that auto-removes after the first call. */
+    once<E extends TransportEventName>(event: E, listener: TransportEvents[E]): this;
+    /** Permanently tear down the transport. After this call, connect() will throw. */
+    abstract destroy(): void;
+    protected emit<E extends TransportEventName>(event: E, ...args: Parameters<TransportEvents[E]>): void;
+}
+
+interface WsTransportOptions {
+    url?: string;
+    autoReconnect?: boolean;
+    reconnectDelay?: number;
+    reconnectMaxDelay?: number;
+    reconnectMaxRetries?: number;
+    /** Keepalive ping interval in ms. 0 disables. Default: 30 000. Only works in Node.js. */
+    keepaliveInterval?: number;
+}
+/**
+ * WebSocket-based transport with auto-reconnect, keepalive, and state tracking.
+ */
+declare class WsTransport extends AbstractTransport {
+    private ws;
+    private readonly url;
+    private readonly autoReconnect;
+    private readonly reconnectDelay;
+    private readonly reconnectMaxDelay;
+    private readonly reconnectMaxRetries;
+    private readonly keepaliveInterval;
+    private reconnectAttempt;
+    private reconnectTimer;
+    private keepaliveTimer;
+    private intentionalClose;
+    private _state;
+    constructor(options?: WsTransportOptions);
+    /** Current transport state. */
+    get state(): TransportState;
+    /** Open a WebSocket connection. Throws if already connecting or destroyed. */
+    connect(): Promise<void>;
+    /** Close the connection without triggering auto-reconnect. */
+    disconnect(): void;
+    /** Permanently destroy the transport. No further connect() calls are allowed. */
+    destroy(): void;
+    /** Send data over the WebSocket. Throws if not connected. */
+    send(data: string): void;
+    private setState;
+    private setupListeners;
+    private scheduleReconnect;
+    private clearReconnectTimer;
+    private startKeepalive;
+    private stopKeepalive;
+    private getWebSocketImpl;
+}
+
+declare global {
+    interface Window {
+        ton?: {
+            adnl?: {
+                send: (data: string) => void;
+                onMessage: (callback: (data: string) => void) => () => void;
+            };
+        };
+    }
+}
+/**
+ * IPC transport for Electron/browser preload environments that expose `window.ton.adnl`.
+ */
+declare class IpcTransport extends AbstractTransport {
+    private unsubscribe;
+    private _state;
+    /** Current transport state. */
+    get state(): TransportState;
+    /** Connect to the IPC bridge via `window.ton.adnl`. */
+    connect(): Promise<void>;
+    /** Disconnect from the IPC bridge. */
+    disconnect(): void;
+    /** Permanently destroy the transport. */
+    destroy(): void;
+    /** Send data over the IPC bridge. */
+    send(data: string): void;
+    private setState;
+}
+
+/** Auto-detect the best transport: prefer IPC in Electron preload, otherwise WebSocket. */
+declare function createTransport(options?: WsTransportOptions): AbstractTransport;
+
+type PushHandler = (event: string, data: unknown) => void;
+/** Logger interface accepted by RpcEngine. */
+interface Logger {
+    debug: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+}
+interface RpcEngineOptions {
+    requestTimeout?: number;
+    logger?: Logger;
+}
+/** Options for individual RPC calls. */
+interface CallOptions {
+    signal?: AbortSignal;
+}
+/**
+ * JSON-RPC 2.0 engine over an AbstractTransport.
+ * Handles request/response correlation, timeouts, push events, and abort signals.
+ */
+declare class RpcEngine {
+    private transport;
+    private pending;
+    private pushHandler;
+    private readonly requestTimeout;
+    private readonly logger;
+    constructor(transport: AbstractTransport, options?: RpcEngineOptions);
+    /** Register a handler for push events (subscriptions, ADNL). */
+    setPushHandler(handler: PushHandler): void;
+    /**
+     * Send a JSON-RPC 2.0 request and return the result.
+     * @param method - The RPC method name.
+     * @param params - Optional parameters.
+     * @param options - Optional call options (abort signal).
+     */
+    call<T>(method: string, params?: unknown, options?: CallOptions): Promise<T>;
+    private handleMessage;
+    private rejectAll;
+    /** Destroy the engine, rejecting all pending calls. */
+    destroy(): void;
+}
+
+/** JSON-RPC 2.0 request sent over the WebSocket. */
+interface WSRequest {
+    jsonrpc: '2.0';
+    id: string;
+    method: string;
+    params?: unknown;
+}
+/** JSON-RPC 2.0 response received from the bridge. */
+interface WSResponse {
+    jsonrpc: string;
+    id: string;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+    } | null;
+}
+/** Server-pushed event for subscriptions and ADNL/overlay notifications. */
+interface WSEvent<T = unknown> {
+    event: string;
+    data: T;
+}
+/**
+ * TEP-64 content for NFTs. Serialized by Go `serializeContent`.
+ * Fields beyond `type`+`uri` are present only when the on-chain data includes them.
+ */
+type NftTepContent = {
+    type: 'offchain';
+    uri: string;
+} | {
+    type: 'semichain';
+    uri: string;
+    name?: string;
+    description?: string;
+    image?: string;
+    image_data?: string;
+} | {
+    type: 'onchain';
+    name?: string;
+    description?: string;
+    image?: string;
+    image_data?: string;
+} | {
+    type: 'unknown';
+};
+/**
+ * TEP-64 content for jettons. Serialized by Go `serializeJettonContent`.
+ * Includes `symbol` and `decimals` fields specific to fungible tokens.
+ */
+type JettonTepContent = {
+    type: 'offchain';
+    uri: string;
+} | {
+    type: 'semichain';
+    uri: string;
+    name?: string;
+    symbol?: string;
+    decimals?: string;
+    description?: string;
+    image?: string;
+} | {
+    type: 'onchain';
+    name?: string;
+    symbol?: string;
+    decimals?: string;
+    description?: string;
+    image?: string;
+    image_data?: string;
+} | {
+    type: 'unknown';
+};
+/** Params for `dht.findAddresses`. */
+interface DhtFindAddressesParams {
+    /** Base64-encoded ADNL ID to look up. */
+    key: string;
+}
+/** A single address returned by the DHT. */
+interface DhtAddress {
+    ip: string;
+    port: number;
+}
+/** Result of `dht.findAddresses`. */
+interface DhtFindAddressesResult {
+    addresses: DhtAddress[];
+    /** Base64-encoded ed25519 public key. */
+    pubkey: string;
+}
+/** Params for `dht.findOverlayNodes`. */
+interface DhtFindOverlayNodesParams {
+    /** Base64-encoded overlay key. */
+    overlay_key: string;
+}
+/** A single overlay node returned by the DHT. */
+interface OverlayNodeInfo {
+    /** Base64-encoded ed25519 public key. */
+    id: string;
+    /** Base64-encoded overlay ID. */
+    overlay: string;
+    version: number;
+}
+/** Result of `dht.findOverlayNodes`. */
+interface DhtFindOverlayNodesResult {
+    nodes: OverlayNodeInfo[];
+    count: number;
+}
+/** Params for `dht.findTunnelNodes`. */
+/** A single relay node returned by the DHT. */
+interface DhtRelayInfo {
+    /** Base64-encoded ADNL ID. */
+    adnl_id: string;
+    version: number;
+}
+/** Result of `dht.findTunnelNodes`. */
+interface DhtFindTunnelNodesResult {
+    relays: DhtRelayInfo[];
+    count: number;
+}
+/** Params for `dht.findValue`. */
+interface DhtFindValueParams {
+    /** Base64-encoded key ID. */
+    key_id: string;
+    name: string;
+    index: number;
+}
+/** Result of `dht.findValue`. */
+interface DhtFindValueResult {
+    /** Base64-encoded value bytes. */
+    data: string;
+    ttl: number;
+}
+/** Result of `lite.getMasterchainInfo` (no params). */
+interface LiteGetMasterchainInfoResult {
+    seqno: number;
+    workchain: number;
+    /** Hex-encoded shard ID. */
+    shard: string;
+    /** Hex-encoded root hash. */
+    root_hash: string;
+    /** Hex-encoded file hash. */
+    file_hash: string;
+}
+/** Params for `lite.getAccountState`. */
+interface LiteGetAccountStateParams {
+    address: string;
+}
+/** Result of `lite.getAccountState`. */
+interface LiteGetAccountStateResult {
+    /** One of "active", "frozen", "uninit". */
+    status: string;
+    /** Balance in nanotons. */
+    balance: string;
+    last_tx_lt: string;
+    /** Hex-encoded last transaction hash. */
+    last_tx_hash: string;
+    has_code: boolean;
+    has_data: boolean;
+    /** Base64 BOC of account code (present only when has_code is true). */
+    code?: string;
+    /** Base64 BOC of account data (present only when has_data is true). */
+    data?: string;
+}
+/** Params for `lite.runMethod`. */
+interface LiteRunMethodParams {
+    address: string;
+    method: string;
+    params: unknown[];
+}
+/** Result of `lite.runMethod`. */
+interface LiteRunMethodResult {
+    exit_code: number;
+    /** TVM stack items serialized as strings (big ints) or base64 (cells). */
+    stack: unknown[];
+}
+/** Params for `lite.sendMessage` and `lite.sendMessageWait`. */
+interface LiteSendMessageParams {
+    /** Base64-encoded external message BOC. */
+    boc: string;
+}
+/** Result of `lite.sendMessage` and `lite.sendMessageWait`. */
+interface LiteSendMessageResult {
+    /** Hex-encoded message cell hash. */
+    hash: string;
+    status: number;
+}
+/** Params for `lite.getTransactions`. */
+interface LiteGetTransactionsParams {
+    address: string;
+    limit?: number;
+    /** Optional LT for pagination (decimal string). */
+    last_lt?: string;
+    /** Optional hex-encoded hash for pagination. */
+    last_hash?: string;
+}
+/** A message inside a transaction (matches Go `serializeMessage`). */
+interface LiteTransactionMessage {
+    /** Sender address (empty string if external). */
+    source: string;
+    /** Destination address (empty string if external-out). */
+    destination: string;
+    /** Amount in nanotons ("0" for external messages). */
+    value: string;
+    /** Base64-encoded body BOC (empty string if no payload). */
+    body: string;
+}
+/** A single transaction (matches Go `serializeTransaction`). */
+interface LiteTransaction {
+    /** Hex-encoded transaction hash. */
+    hash: string;
+    /** Logical time (decimal string). */
+    lt: string;
+    /** Unix timestamp. */
+    now: number;
+    /** Total fees in nanotons. */
+    total_fees: string;
+    /** Previous transaction LT (decimal string). */
+    prev_tx_lt: string;
+    /** Hex-encoded previous transaction hash. */
+    prev_tx_hash: string;
+    in_msg?: LiteTransactionMessage;
+    out_msgs: LiteTransactionMessage[];
+}
+/** Result of `lite.getTransactions`. */
+interface LiteGetTransactionsResult {
+    transactions: LiteTransaction[];
+}
+/** Params for `lite.getTransaction`. */
+interface LiteGetTransactionParams {
+    address: string;
+    /** Logical time (decimal string). */
+    lt: string;
+}
+/** Params for `lite.findTxByInMsgHash`. */
+interface LiteFindTxByInMsgHashParams {
+    address: string;
+    /** Hex-encoded inbound message hash. */
+    msg_hash: string;
+}
+/** Params for `lite.findTxByOutMsgHash`. */
+interface LiteFindTxByOutMsgHashParams {
+    address: string;
+    /** Hex-encoded outbound message hash. */
+    msg_hash: string;
+}
+/** Result of `lite.getTime` (no params). */
+interface LiteGetTimeResult {
+    time: number;
+}
+/** Params for `lite.lookupBlock`. */
+interface LiteLookupBlockParams {
+    workchain: number;
+    /** Hex-encoded shard ID. */
+    shard: string;
+    seqno: number;
+}
+/** Result of `lite.lookupBlock`. */
+interface LiteLookupBlockResult {
+    workchain: number;
+    shard: string;
+    seqno: number;
+    root_hash: string;
+    file_hash: string;
+}
+/** Params for `lite.getBlockTransactions`. */
+interface LiteGetBlockTransactionsParams {
+    workchain: number;
+    shard: string;
+    seqno: number;
+    count?: number;
+}
+/** A short transaction reference from a block. */
+interface LiteBlockTransaction {
+    /** Hex-encoded account address. */
+    account: string;
+    lt: string;
+    /** Hex-encoded transaction hash. */
+    hash: string;
+}
+/** Result of `lite.getBlockTransactions`. */
+interface LiteGetBlockTransactionsResult {
+    transactions: LiteBlockTransaction[];
+    incomplete: boolean;
+}
+/** Result of `lite.getShards` (no params). */
+interface LiteShardInfo {
+    workchain: number;
+    shard: string;
+    seqno: number;
+}
+/** Result of `lite.getShards`. */
+interface LiteGetShardsResult {
+    shards: LiteShardInfo[];
+}
+/** Params for `lite.getBlockchainConfig`. */
+interface LiteGetBlockchainConfigParams {
+    params?: number[];
+}
+/** Result of `lite.getBlockchainConfig`. */
+interface LiteGetBlockchainConfigResult {
+    /** Key is param ID (decimal string), value is base64 BOC or null. */
+    params: Record<string, string | null>;
+}
+/** Params for `lite.getBlockData`. */
+interface LiteGetBlockDataParams {
+    workchain: number;
+    shard: string;
+    seqno: number;
+}
+/** Result of `lite.getBlockData`. */
+interface LiteGetBlockDataResult {
+    /** Base64-encoded block BOC. */
+    boc: string;
+}
+/** Params for `lite.getBlockHeader`. */
+interface LiteGetBlockHeaderParams {
+    workchain: number;
+    shard: string;
+    seqno: number;
+}
+/** Result of `lite.getBlockHeader`. */
+interface LiteGetBlockHeaderResult {
+    workchain: number;
+    shard: string;
+    seqno: number;
+    root_hash: string;
+    file_hash: string;
+    /** Base64-encoded header proof BOC. */
+    header_boc: string;
+}
+/** Params for `lite.getLibraries`. */
+interface LiteGetLibrariesParams {
+    /** Hex-encoded library cell hashes. */
+    hashes: string[];
+}
+/** A single library entry. */
+interface LiteLibraryEntry {
+    /** Hex-encoded hash. */
+    hash: string;
+    /** Base64-encoded BOC. */
+    boc: string;
+}
+/** Result of `lite.getLibraries`. */
+interface LiteGetLibrariesResult {
+    /** Array of library entries (null for missing hashes). */
+    libraries: (LiteLibraryEntry | null)[];
+}
+/** Params for `lite.sendAndWatch`. */
+interface LiteSendAndWatchParams {
+    /** Base64-encoded external message BOC. */
+    boc: string;
+}
+/** Confirmation result of `lite.sendAndWatch`. */
+interface LiteSendAndWatchResult {
+    watching: boolean;
+    subscription_id: string;
+    /** Hex-encoded message cell hash. */
+    msg_hash: string;
+}
+/** Params for `subscribe.transactions`. */
+interface SubscribeTransactionsParams {
+    address: string;
+    last_lt?: string;
+    /** Optional list of opcodes to filter incoming transactions. */
+    operations?: number[];
+}
+/** Confirmation of `subscribe.transactions`. */
+interface SubscribeTransactionsConfirmation {
+    subscribed: boolean;
+    address: string;
+    subscription_id: string;
+}
+/** Confirmation of `subscribe.blocks` (no params). */
+interface SubscribeBlocksConfirmation {
+    subscribed: boolean;
+    start_seqno: number;
+    subscription_id: string;
+}
+/** Push data for the "block" event. */
+interface SubscribeBlockEvent {
+    seqno: number;
+    workchain: number;
+    shard: string;
+    root_hash: string;
+    file_hash: string;
+    shards: LiteShardInfo[];
+}
+/** Params for `subscribe.accountState`. */
+interface SubscribeAccountStateParams {
+    address: string;
+}
+/** Confirmation of `subscribe.accountState`. */
+interface SubscribeAccountStateConfirmation {
+    subscribed: boolean;
+    address: string;
+    balance: string;
+    last_tx_lt: string;
+    subscription_id: string;
+}
+/** Push data for the "account_state" event. */
+interface SubscribeAccountStateEvent {
+    address: string;
+    balance: string;
+    status: string;
+    last_tx_lt: string;
+    last_tx_hash: string;
+    block_seqno: number;
+}
+/** Confirmation of `subscribe.newTransactions` (no params). */
+interface SubscribeNewTransactionsConfirmation {
+    subscribed: boolean;
+    start_seqno: number;
+    subscription_id: string;
+}
+/** Push data for the "new_transaction" event. */
+interface SubscribeNewTransactionEvent {
+    /** Hex-encoded account address. */
+    account: string;
+    lt: string;
+    hash: string;
+    block_workchain: number;
+    block_shard: string;
+    block_seqno: number;
+}
+/** Params for `subscribe.configChanges`. */
+interface SubscribeConfigChangesParams {
+    /** List of blockchain config param IDs to watch. */
+    params: number[];
+}
+/** Confirmation of `subscribe.configChanges`. */
+interface SubscribeConfigChangesConfirmation {
+    subscribed: boolean;
+    start_seqno: number;
+    subscription_id: string;
+}
+/** Push data for the "config_changed" event. */
+interface SubscribeConfigChangedEvent {
+    param_id: number;
+    block_seqno: number;
+    /** Base64-encoded BOC of the old value. */
+    old_value: string;
+    /** Base64-encoded BOC of the new value. */
+    new_value: string;
+}
+/** A single account entry for `subscribe.multiAccount`. */
+interface MultiAccountEntry {
+    address: string;
+    last_lt?: string;
+    operations?: number[];
+}
+/** Params for `subscribe.multiAccount`. */
+interface SubscribeMultiAccountParams {
+    accounts: MultiAccountEntry[];
+}
+/** Confirmation of `subscribe.multiAccount`. */
+interface SubscribeMultiAccountConfirmation {
+    subscribed: boolean;
+    account_count: number;
+    subscription_id: string;
+}
+/** Params for `subscribe.trace`. */
+interface SubscribeTraceParams {
+    address: string;
+    last_lt?: string;
+    /** Max depth of internal message chains (1-10, default 3). */
+    max_depth?: number;
+    /** Per-message timeout in seconds (1-120, default 10). */
+    msg_timeout_sec?: number;
+}
+/** Confirmation of `subscribe.trace`. */
+interface SubscribeTraceConfirmation {
+    subscribed: boolean;
+    address: string;
+    subscription_id: string;
+}
+/** Push data for the "trace_started" event. */
+interface TraceStartedEvent {
+    trace_id: string;
+    root_tx: LiteTransaction;
+    subscription_id: string;
+}
+/** Push data for the "trace_tx" event. */
+interface TraceTxEvent {
+    trace_id: string;
+    transaction: LiteTransaction & {
+        address: string;
+    };
+    depth: number;
+    address: string;
+}
+/** Push data for the "trace_complete" event. */
+interface TraceCompleteEvent {
+    trace_id: string;
+    total_txs: number;
+    max_depth_reached: number;
+    timed_out_count: number;
+}
+/** Push data for the "trace_timeout" event. */
+interface TraceTimeoutEvent {
+    trace_id: string;
+    address: string;
+    body_hash: string;
+    depth: number;
+}
+/** Params for `subscribe.unsubscribe`. */
+interface SubscribeUnsubscribeParams {
+    subscription_id: string;
+}
+/** Result of `subscribe.unsubscribe`. */
+interface SubscribeUnsubscribeResult {
+    unsubscribed: boolean;
+    subscription_id: string;
+}
+/** Push data for the "tx_confirmed" event (from `lite.sendAndWatch`). */
+interface TxConfirmedEvent {
+    msg_hash: string;
+    transaction: LiteTransaction;
+    block: {
+        seqno: number;
+        workchain: number;
+        shard: string;
+    };
+}
+/** Push data for the "tx_timeout" event (from `lite.sendAndWatch`). */
+interface TxTimeoutEvent {
+    msg_hash: string;
+    reason: string;
+}
+/** Params for `jetton.getData`. */
+interface JettonGetDataParams {
+    address: string;
+}
+/** Result of `jetton.getData`. */
+interface JettonGetDataResult {
+    total_supply: string;
+    mintable: boolean;
+    admin: string | null;
+    /** TEP-64 content from `serializeJettonContent`. */
+    content: JettonTepContent;
+}
+/** Params for `jetton.getWalletAddress`. */
+interface JettonGetWalletAddressParams {
+    jetton_master: string;
+    owner: string;
+}
+/** Result of `jetton.getWalletAddress`. */
+interface JettonGetWalletAddressResult {
+    wallet_address: string;
+}
+/** Params for `jetton.getBalance`. */
+interface JettonGetBalanceParams {
+    jetton_wallet: string;
+}
+/** Result of `jetton.getBalance`. */
+interface JettonGetBalanceResult {
+    balance: string;
+    owner: string | null;
+    jetton_master: string | null;
+}
+/** Params for `nft.getData`. */
+interface NftGetDataParams {
+    address: string;
+}
+/** Result of `nft.getData`. */
+interface NftGetDataResult {
+    initialized: boolean;
+    index: string;
+    collection: string | null;
+    owner: string | null;
+    /** TEP-64 content from `serializeContent`. */
+    content: NftTepContent;
+}
+/** Params for `nft.getCollectionData`. */
+interface NftGetCollectionDataParams {
+    address: string;
+}
+/** Result of `nft.getCollectionData`. */
+interface NftGetCollectionDataResult {
+    next_item_index: string;
+    owner: string | null;
+    /** TEP-64 content from `serializeContent`. */
+    content: NftTepContent;
+}
+/** Params for `nft.getAddressByIndex`. */
+interface NftGetAddressByIndexParams {
+    collection: string;
+    /** Decimal integer string. */
+    index: string;
+}
+/** Result of `nft.getAddressByIndex`. */
+interface NftGetAddressByIndexResult {
+    address: string;
+}
+/** Params for `nft.getRoyaltyParams`. */
+interface NftGetRoyaltyParamsParams {
+    collection: string;
+}
+/** Result of `nft.getRoyaltyParams`. */
+interface NftGetRoyaltyParamsResult {
+    factor: number;
+    base: number;
+    address: string | null;
+}
+/** Params for `nft.getContent`. */
+interface NftGetContentParams {
+    collection: string;
+    /** Decimal integer string. */
+    index: string;
+    /** Base64-encoded individual content BOC. */
+    individual_content: string;
+}
+/** Result of `nft.getContent`. */
+interface NftGetContentResult {
+    content: NftTepContent;
+}
+/** Params for `wallet.getSeqno`. */
+interface WalletGetSeqnoParams {
+    address: string;
+}
+/** Result of `wallet.getSeqno`. */
+interface WalletGetSeqnoResult {
+    seqno: number;
+}
+/** Params for `wallet.getPublicKey`. */
+interface WalletGetPublicKeyParams {
+    address: string;
+}
+/** Result of `wallet.getPublicKey`. */
+interface WalletGetPublicKeyResult {
+    /** Base64-encoded ed25519 public key. */
+    public_key: string;
+}
+/** Params for `sbt.getAuthorityAddress`. */
+interface SbtGetAuthorityAddressParams {
+    address: string;
+}
+/** Result of `sbt.getAuthorityAddress`. */
+interface SbtGetAuthorityAddressResult {
+    authority: string | null;
+}
+/** Params for `sbt.getRevokedTime`. */
+interface SbtGetRevokedTimeParams {
+    address: string;
+}
+/** Result of `sbt.getRevokedTime`. */
+interface SbtGetRevokedTimeResult {
+    /** Unix timestamp; 0 means not revoked. */
+    revoked_time: number;
+}
+/** Params for `payment.getChannelState`. */
+interface PaymentGetChannelStateParams {
+    address: string;
+}
+/** Semi-channel state within a quarantine record. */
+interface PaymentSemiChannelState {
+    seqno: number;
+    /** Nanotons sent. */
+    sent: string;
+}
+/** Quarantine info for a payment channel (null when no quarantine is active). */
+interface PaymentQuarantine {
+    quarantine_starts: number;
+    state_committed_by_a: boolean;
+    state_challenged: boolean;
+    state_a: PaymentSemiChannelState;
+    state_b: PaymentSemiChannelState;
+}
+/** Closing configuration of a payment channel. */
+interface PaymentClosingConfig {
+    quarantine_duration: number;
+    conditional_close_duration: number;
+    /** Misbehavior fine in nanotons. */
+    misbehavior_fine: string;
+}
+/** Result of `payment.getChannelState`. */
+interface PaymentGetChannelStateResult {
+    status: number;
+    initialized: boolean;
+    /** Balance of party A in nanotons. */
+    balance_a: string;
+    /** Balance of party B in nanotons. */
+    balance_b: string;
+    /** Base64-encoded ed25519 public key of party A. */
+    key_a: string;
+    /** Base64-encoded ed25519 public key of party B. */
+    key_b: string;
+    /** Hex-encoded channel ID. */
+    channel_id: string;
+    committed_seqno_a: number;
+    committed_seqno_b: number;
+    quarantine: PaymentQuarantine | null;
+    dest_a: string | null;
+    dest_b: string | null;
+    /** Excess fee in nanotons. */
+    excess_fee: string;
+    closing_config: PaymentClosingConfig;
+}
+/** Params for `dns.resolve`. */
+interface DnsResolveParams {
+    domain: string;
+}
+/** Result of `dns.resolve`. */
+interface DnsResolveResult {
+    wallet: string | null;
+    /** Hex-encoded ADNL address of the site record. */
+    site_adnl: string | null;
+    has_storage: boolean;
+    owner: string | null;
+    nft_address: string | null;
+    collection: string | null;
+    editor: string | null;
+    initialized: boolean;
+    /** Unix timestamp or null if unknown. */
+    expiring_at: number | null;
+    /** Map of sha256(name) hex keys to text values (category 0x1eda). */
+    text_records?: Record<string, string>;
+}
+/** Params for `adnl.connect`. */
+interface AdnlConnectParams {
+    address: string;
+    /** Base64-encoded ed25519 public key. */
+    key: string;
+}
+/** Result of `adnl.connect` and `adnl.connectByADNL`. */
+interface AdnlConnectResult {
+    connected: boolean;
+    /** Base64-encoded peer ID. */
+    peer_id: string;
+    remote_addr: string;
+}
+/** Params for `adnl.connectByADNL`. */
+interface AdnlConnectByAdnlParams {
+    /** Base64-encoded ADNL ID. */
+    adnl_id: string;
+}
+/** Params for `adnl.sendMessage`. */
+interface AdnlSendMessageParams {
+    /** Base64-encoded peer ID. */
+    peer_id: string;
+    /** Base64-encoded message data. */
+    data: string;
+}
+/** Result of `adnl.sendMessage`. */
+interface AdnlSendMessageResult {
+    sent: boolean;
+}
+/** Params for `adnl.ping`. */
+interface AdnlPingParams {
+    /** Base64-encoded peer ID. */
+    peer_id: string;
+}
+/** Result of `adnl.ping`. */
+interface AdnlPingResult {
+    latency_ms: number;
+}
+/** Params for `adnl.disconnect`. */
+interface AdnlDisconnectParams {
+    /** Base64-encoded peer ID. */
+    peer_id: string;
+}
+/** Result of `adnl.disconnect`. */
+interface AdnlDisconnectResult {
+    disconnected: boolean;
+}
+/** Result of `adnl.peers` (no params). */
+interface AdnlPeerInfo {
+    /** Base64-encoded peer ID. */
+    id: string;
+    addr: string;
+}
+/** Result of `adnl.peers`. */
+interface AdnlPeersResult {
+    peers: AdnlPeerInfo[];
+}
+/** Params for `adnl.query`. */
+interface AdnlQueryParams {
+    /** Base64-encoded peer ID. */
+    peer_id: string;
+    /** Base64-encoded TL-serialized request. */
+    data: string;
+    /** Optional timeout in seconds (1-60, default 15). */
+    timeout?: number;
+}
+/** Result of `adnl.query`. */
+interface AdnlQueryResult {
+    /** Base64-encoded TL-serialized response. */
+    data: string;
+}
+/** Params for `adnl.setQueryHandler`. */
+interface AdnlSetQueryHandlerParams {
+    /** Base64-encoded peer ID. */
+    peer_id: string;
+}
+/** Result of `adnl.setQueryHandler`. */
+interface AdnlSetQueryHandlerResult {
+    enabled: boolean;
+}
+/** Params for `adnl.answer`. */
+interface AdnlAnswerParams {
+    /** Hex-encoded query ID. */
+    query_id: string;
+    /** Base64-encoded TL-serialized response. */
+    data: string;
+}
+/** Result of `adnl.answer`. */
+interface AdnlAnswerResult {
+    answered: boolean;
+}
+/** Push data for the "adnl.message" event. */
+interface AdnlMessageEvent {
+    /** Base64-encoded peer ID. */
+    from: string;
+    /** Base64-encoded message data. */
+    message: string;
+}
+/** Push data for the "adnl.disconnected" event. */
+interface AdnlDisconnectedEvent {
+    /** Base64-encoded peer ID. */
+    peer: string;
+}
+/** Push data for the "adnl.incomingConnection" event. */
+interface AdnlIncomingConnectionEvent {
+    /** Base64-encoded peer ID. */
+    peer_id: string;
+    remote_addr: string;
+}
+/** Push data for the "adnl.queryReceived" event. */
+interface AdnlQueryReceivedEvent {
+    /** Base64-encoded peer ID. */
+    peer_id: string;
+    /** Hex-encoded query ID. */
+    query_id: string;
+    /** Base64-encoded query data. */
+    data: string;
+}
+/** Params for `overlay.join`. */
+interface OverlayJoinParams {
+    /** Base64-encoded overlay ID. */
+    overlay_id: string;
+    /** Base64-encoded ADNL peer ID. */
+    peer_id: string;
+}
+/** Result of `overlay.join`. */
+interface OverlayJoinResult {
+    joined: boolean;
+    overlay_id: string;
+}
+/** Params for `overlay.leave`. */
+interface OverlayLeaveParams {
+    overlay_id: string;
+}
+/** Result of `overlay.leave`. */
+interface OverlayLeaveResult {
+    left: boolean;
+}
+/** Params for `overlay.getPeers`. */
+interface OverlayGetPeersParams {
+    overlay_id: string;
+}
+/** A single peer inside an overlay. */
+interface OverlayPeerInfo {
+    /** Base64-encoded ed25519 public key. */
+    id: string;
+    /** Base64-encoded overlay ID. */
+    overlay: string;
+}
+/** Result of `overlay.getPeers`. */
+interface OverlayGetPeersResult {
+    peers: OverlayPeerInfo[];
+}
+/** Params for `overlay.sendMessage`. */
+interface OverlaySendMessageParams {
+    overlay_id: string;
+    /** Base64-encoded message data. */
+    data: string;
+}
+/** Result of `overlay.sendMessage`. */
+interface OverlaySendMessageResult {
+    sent: boolean;
+}
+/** Params for `overlay.query`. */
+interface OverlayQueryParams {
+    overlay_id: string;
+    /** Base64-encoded TL-serialized request. */
+    data: string;
+    /** Optional timeout in seconds (1-60, default 15). */
+    timeout?: number;
+}
+/** Result of `overlay.query`. */
+interface OverlayQueryResult {
+    /** Base64-encoded TL-serialized response. */
+    data: string;
+}
+/** Params for `overlay.setQueryHandler`. */
+interface OverlaySetQueryHandlerParams {
+    overlay_id: string;
+    /** Base64-encoded ADNL peer ID that owns this overlay. */
+    peer_id: string;
+}
+/** Result of `overlay.setQueryHandler`. */
+interface OverlaySetQueryHandlerResult {
+    enabled: boolean;
+}
+/** Params for `overlay.answer`. */
+interface OverlayAnswerParams {
+    /** Hex-encoded query ID. */
+    query_id: string;
+    /** Base64-encoded TL-serialized response. */
+    data: string;
+}
+/** Result of `overlay.answer`. */
+interface OverlayAnswerResult {
+    answered: boolean;
+}
+/** Push data for the "overlay.broadcast" event. */
+interface OverlayBroadcastEvent {
+    overlay_id: string;
+    /** Base64-encoded broadcast data. */
+    message: string;
+    trusted: boolean;
+}
+/** Push data for the "overlay.message" event. */
+interface OverlayMessageEvent {
+    overlay_id: string;
+    /** Base64-encoded message data. */
+    message: string;
+}
+/** Push data for the "overlay.queryReceived" event. */
+interface OverlayQueryReceivedEvent {
+    overlay_id: string;
+    /** Hex-encoded query ID. */
+    query_id: string;
+    /** Base64-encoded query data. */
+    data: string;
+}
+/** Result of `network.info` (no params). */
+interface NetworkInfoResult {
+    dht_connected: boolean;
+    ws_clients: number;
+}
+interface MethodMap {
+    'dht.findAddresses': {
+        params: DhtFindAddressesParams;
+        result: DhtFindAddressesResult;
+    };
+    'dht.findOverlayNodes': {
+        params: DhtFindOverlayNodesParams;
+        result: DhtFindOverlayNodesResult;
+    };
+    'dht.findTunnelNodes': {
+        params: undefined;
+        result: DhtFindTunnelNodesResult;
+    };
+    'dht.findValue': {
+        params: DhtFindValueParams;
+        result: DhtFindValueResult;
+    };
+    'lite.getMasterchainInfo': {
+        params: undefined;
+        result: LiteGetMasterchainInfoResult;
+    };
+    'lite.getAccountState': {
+        params: LiteGetAccountStateParams;
+        result: LiteGetAccountStateResult;
+    };
+    'lite.runMethod': {
+        params: LiteRunMethodParams;
+        result: LiteRunMethodResult;
+    };
+    'lite.sendMessage': {
+        params: LiteSendMessageParams;
+        result: LiteSendMessageResult;
+    };
+    'lite.sendMessageWait': {
+        params: LiteSendMessageParams;
+        result: LiteSendMessageResult;
+    };
+    'lite.getTransactions': {
+        params: LiteGetTransactionsParams;
+        result: LiteGetTransactionsResult;
+    };
+    'lite.getTransaction': {
+        params: LiteGetTransactionParams;
+        result: LiteTransaction;
+    };
+    'lite.findTxByInMsgHash': {
+        params: LiteFindTxByInMsgHashParams;
+        result: LiteTransaction;
+    };
+    'lite.findTxByOutMsgHash': {
+        params: LiteFindTxByOutMsgHashParams;
+        result: LiteTransaction;
+    };
+    'lite.getTime': {
+        params: undefined;
+        result: LiteGetTimeResult;
+    };
+    'lite.lookupBlock': {
+        params: LiteLookupBlockParams;
+        result: LiteLookupBlockResult;
+    };
+    'lite.getBlockTransactions': {
+        params: LiteGetBlockTransactionsParams;
+        result: LiteGetBlockTransactionsResult;
+    };
+    'lite.getShards': {
+        params: undefined;
+        result: LiteGetShardsResult;
+    };
+    'lite.getBlockchainConfig': {
+        params: LiteGetBlockchainConfigParams;
+        result: LiteGetBlockchainConfigResult;
+    };
+    'lite.sendAndWatch': {
+        params: LiteSendAndWatchParams;
+        result: LiteSendAndWatchResult;
+    };
+    'lite.getBlockData': {
+        params: LiteGetBlockDataParams;
+        result: LiteGetBlockDataResult;
+    };
+    'lite.getBlockHeader': {
+        params: LiteGetBlockHeaderParams;
+        result: LiteGetBlockHeaderResult;
+    };
+    'lite.getLibraries': {
+        params: LiteGetLibrariesParams;
+        result: LiteGetLibrariesResult;
+    };
+    'subscribe.transactions': {
+        params: SubscribeTransactionsParams;
+        result: SubscribeTransactionsConfirmation;
+    };
+    'subscribe.blocks': {
+        params: undefined;
+        result: SubscribeBlocksConfirmation;
+    };
+    'subscribe.accountState': {
+        params: SubscribeAccountStateParams;
+        result: SubscribeAccountStateConfirmation;
+    };
+    'subscribe.newTransactions': {
+        params: undefined;
+        result: SubscribeNewTransactionsConfirmation;
+    };
+    'subscribe.configChanges': {
+        params: SubscribeConfigChangesParams;
+        result: SubscribeConfigChangesConfirmation;
+    };
+    'subscribe.multiAccount': {
+        params: SubscribeMultiAccountParams;
+        result: SubscribeMultiAccountConfirmation;
+    };
+    'subscribe.trace': {
+        params: SubscribeTraceParams;
+        result: SubscribeTraceConfirmation;
+    };
+    'subscribe.unsubscribe': {
+        params: SubscribeUnsubscribeParams;
+        result: SubscribeUnsubscribeResult;
+    };
+    'jetton.getData': {
+        params: JettonGetDataParams;
+        result: JettonGetDataResult;
+    };
+    'jetton.getWalletAddress': {
+        params: JettonGetWalletAddressParams;
+        result: JettonGetWalletAddressResult;
+    };
+    'jetton.getBalance': {
+        params: JettonGetBalanceParams;
+        result: JettonGetBalanceResult;
+    };
+    'nft.getData': {
+        params: NftGetDataParams;
+        result: NftGetDataResult;
+    };
+    'nft.getCollectionData': {
+        params: NftGetCollectionDataParams;
+        result: NftGetCollectionDataResult;
+    };
+    'nft.getAddressByIndex': {
+        params: NftGetAddressByIndexParams;
+        result: NftGetAddressByIndexResult;
+    };
+    'nft.getRoyaltyParams': {
+        params: NftGetRoyaltyParamsParams;
+        result: NftGetRoyaltyParamsResult;
+    };
+    'nft.getContent': {
+        params: NftGetContentParams;
+        result: NftGetContentResult;
+    };
+    'wallet.getSeqno': {
+        params: WalletGetSeqnoParams;
+        result: WalletGetSeqnoResult;
+    };
+    'wallet.getPublicKey': {
+        params: WalletGetPublicKeyParams;
+        result: WalletGetPublicKeyResult;
+    };
+    'sbt.getAuthorityAddress': {
+        params: SbtGetAuthorityAddressParams;
+        result: SbtGetAuthorityAddressResult;
+    };
+    'sbt.getRevokedTime': {
+        params: SbtGetRevokedTimeParams;
+        result: SbtGetRevokedTimeResult;
+    };
+    'payment.getChannelState': {
+        params: PaymentGetChannelStateParams;
+        result: PaymentGetChannelStateResult;
+    };
+    'dns.resolve': {
+        params: DnsResolveParams;
+        result: DnsResolveResult;
+    };
+    'adnl.connect': {
+        params: AdnlConnectParams;
+        result: AdnlConnectResult;
+    };
+    'adnl.connectByADNL': {
+        params: AdnlConnectByAdnlParams;
+        result: AdnlConnectResult;
+    };
+    'adnl.sendMessage': {
+        params: AdnlSendMessageParams;
+        result: AdnlSendMessageResult;
+    };
+    'adnl.ping': {
+        params: AdnlPingParams;
+        result: AdnlPingResult;
+    };
+    'adnl.disconnect': {
+        params: AdnlDisconnectParams;
+        result: AdnlDisconnectResult;
+    };
+    'adnl.peers': {
+        params: undefined;
+        result: AdnlPeersResult;
+    };
+    'adnl.query': {
+        params: AdnlQueryParams;
+        result: AdnlQueryResult;
+    };
+    'adnl.setQueryHandler': {
+        params: AdnlSetQueryHandlerParams;
+        result: AdnlSetQueryHandlerResult;
+    };
+    'adnl.answer': {
+        params: AdnlAnswerParams;
+        result: AdnlAnswerResult;
+    };
+    'overlay.join': {
+        params: OverlayJoinParams;
+        result: OverlayJoinResult;
+    };
+    'overlay.leave': {
+        params: OverlayLeaveParams;
+        result: OverlayLeaveResult;
+    };
+    'overlay.getPeers': {
+        params: OverlayGetPeersParams;
+        result: OverlayGetPeersResult;
+    };
+    'overlay.sendMessage': {
+        params: OverlaySendMessageParams;
+        result: OverlaySendMessageResult;
+    };
+    'overlay.query': {
+        params: OverlayQueryParams;
+        result: OverlayQueryResult;
+    };
+    'overlay.setQueryHandler': {
+        params: OverlaySetQueryHandlerParams;
+        result: OverlaySetQueryHandlerResult;
+    };
+    'overlay.answer': {
+        params: OverlayAnswerParams;
+        result: OverlayAnswerResult;
+    };
+    'network.info': {
+        params: undefined;
+        result: NetworkInfoResult;
+    };
+}
+interface SubscriptionEventMap {
+    'transaction': LiteTransaction;
+    'block': SubscribeBlockEvent;
+    'account_state': SubscribeAccountStateEvent;
+    'new_transaction': SubscribeNewTransactionEvent;
+    'config_changed': SubscribeConfigChangedEvent;
+    'trace_started': TraceStartedEvent;
+    'trace_tx': TraceTxEvent;
+    'trace_complete': TraceCompleteEvent;
+    'trace_timeout': TraceTimeoutEvent;
+    'tx_confirmed': TxConfirmedEvent;
+    'tx_timeout': TxTimeoutEvent;
+    'adnl.message': AdnlMessageEvent;
+    'adnl.disconnected': AdnlDisconnectedEvent;
+    'adnl.incomingConnection': AdnlIncomingConnectionEvent;
+    'adnl.queryReceived': AdnlQueryReceivedEvent;
+    'overlay.broadcast': OverlayBroadcastEvent;
+    'overlay.message': OverlayMessageEvent;
+    'overlay.queryReceived': OverlayQueryReceivedEvent;
+}
+
+/**
+ * Base class for all namespace implementations.
+ * Provides a type-safe `call` helper wired to the MethodMap.
+ */
+declare abstract class BaseNamespace {
+    protected rpc: RpcEngine;
+    constructor(rpc: RpcEngine);
+    /** Send a typed JSON-RPC call through the engine. */
+    protected call<M extends keyof MethodMap>(method: M, params?: MethodMap[M]['params'], options?: CallOptions): Promise<MethodMap[M]['result']>;
+}
+
+/** DHT namespace — distributed hash table lookups. */
+declare class DhtNamespace extends BaseNamespace {
+    /** Look up ADNL addresses for a given key. */
+    findAddresses(params: DhtFindAddressesParams, options?: CallOptions): Promise<DhtFindAddressesResult>;
+    /** Find overlay nodes for a given overlay key. */
+    findOverlayNodes(params: DhtFindOverlayNodesParams, options?: CallOptions): Promise<DhtFindOverlayNodesResult>;
+    /** Discover tunnel relay nodes from the DHT. */
+    findTunnelNodes(options?: CallOptions): Promise<DhtFindTunnelNodesResult>;
+    /** Look up an arbitrary value in the DHT. */
+    findValue(params: DhtFindValueParams, options?: CallOptions): Promise<DhtFindValueResult>;
+}
+
+interface SubscriptionOptions {
+    /** Maximum buffered events for the async iterator. Oldest are dropped when exceeded. Default: 1000. */
+    highWaterMark?: number;
+}
+/**
+ * A typed subscription to push events from the bridge.
+ * Supports both listener-based and async-iterator consumption.
+ */
+declare class Subscription<T> {
+    readonly event: string;
+    private onUnsubscribe;
+    private listeners;
+    private errorListeners;
+    private _active;
+    private _iteratorResolve;
+    private readonly highWaterMark;
+    constructor(event: string, onUnsubscribe: () => void, options?: SubscriptionOptions);
+    /** Whether the subscription is still active. */
+    get active(): boolean;
+    /** Register a data or error listener. */
+    on(event: 'data', listener: (data: T) => void): this;
+    on(event: 'error', listener: (error: Error) => void): this;
+    /** Remove a data or error listener. */
+    off(event: 'data', listener: (data: T) => void): this;
+    off(event: 'error', listener: (error: Error) => void): this;
+    /** @internal Called by SubscriptionManager to deliver push events. */
+    _deliver(data: T): void;
+    /** @internal Called by SubscriptionManager on error. */
+    _error(error: Error): void;
+    /** Unsubscribe, releasing all listeners and unblocking any active async iterator. */
+    unsubscribe(): Promise<void>;
+    /** Consume events as an async iterable. Respects backpressure via highWaterMark. */
+    [Symbol.asyncIterator](): AsyncIterableIterator<T>;
+}
+
+/** Listener type for raw ADNL events. */
+type AdnlListener = (data: unknown) => void;
+/**
+ * Manages subscriptions and ADNL event listeners.
+ * Routes push events from the RPC engine to the correct subscription or listener.
+ */
+declare class SubscriptionManager {
+    private subscriptions;
+    private adnlListeners;
+    private subscriptionIds;
+    /** Register a subscription for a push event type. */
+    register<T>(eventType: string, onUnsubscribe: () => void, options?: SubscriptionOptions): Subscription<T>;
+    /** Store the bridge-assigned subscription ID for a subscription. */
+    setSubscriptionId(subscriptionId: string, subscription: Subscription<unknown>): void;
+    /** Get a subscription by its bridge-assigned ID. */
+    getBySubscriptionId(subscriptionId: string): Subscription<unknown> | undefined;
+    /** Route a push event to all matching subscriptions. */
+    handleEvent(event: string, data: unknown): void;
+    /** Register an ADNL event listener. */
+    onAdnl(event: string, listener: AdnlListener): void;
+    /** Remove an ADNL event listener. */
+    offAdnl(event: string, listener: AdnlListener): void;
+    /**
+     * Returns all active subscriptions as event-type entries for resubscription after reconnect.
+     * The caller (typically the client) should iterate this list and re-send subscribe RPCs
+     * to the bridge, then update subscription IDs via setSubscriptionId().
+     */
+    getResubscribeEntries(): Array<{
+        eventType: string;
+        subscription: Subscription<unknown>;
+    }>;
+    /**
+     * Resubscribe all active subscriptions after a reconnect.
+     * Accepts a callback that performs the actual RPC subscribe call for each entry
+     * and returns the new subscription_id from the bridge.
+     * Old subscription IDs are cleared and replaced with new ones.
+     */
+    resubscribe(doSubscribe: (eventType: string) => Promise<string>): Promise<void>;
+    /** Number of active subscriptions (for debugging). */
+    get activeCount(): number;
+    /** Clear all subscriptions and ADNL listeners (e.g. on disconnect). */
+    clear(): void;
+}
+
+/** Union of events delivered to a sendAndWatch subscription. */
+type SendAndWatchEvent = TxConfirmedEvent | TxTimeoutEvent;
+/** Liteserver namespace — blockchain queries and transaction submission. */
+declare class LiteNamespace extends BaseNamespace {
+    private manager;
+    constructor(rpc: RpcEngine, manager: SubscriptionManager);
+    /** Get the latest masterchain block info. */
+    getMasterchainInfo(options?: CallOptions): Promise<LiteGetMasterchainInfoResult>;
+    /** Get the state of an account. */
+    getAccountState(params: LiteGetAccountStateParams, options?: CallOptions): Promise<LiteGetAccountStateResult>;
+    /** Run a get-method on a smart contract. */
+    runMethod(params: LiteRunMethodParams, options?: CallOptions): Promise<LiteRunMethodResult>;
+    /** Send an external message (fire and forget). */
+    sendMessage(params: LiteSendMessageParams, options?: CallOptions): Promise<LiteSendMessageResult>;
+    /** Send an external message and wait for processing confirmation. */
+    sendMessageWait(params: LiteSendMessageParams, options?: CallOptions): Promise<LiteSendMessageResult>;
+    /** Get account transactions with optional pagination. */
+    getTransactions(params: LiteGetTransactionsParams, options?: CallOptions): Promise<LiteGetTransactionsResult>;
+    /** Get a single transaction by address and LT. */
+    getTransaction(params: LiteGetTransactionParams, options?: CallOptions): Promise<LiteTransaction>;
+    /** Find a transaction by its inbound message hash. */
+    findTxByInMsgHash(params: LiteFindTxByInMsgHashParams, options?: CallOptions): Promise<LiteTransaction>;
+    /** Find a transaction by its outbound message hash. */
+    findTxByOutMsgHash(params: LiteFindTxByOutMsgHashParams, options?: CallOptions): Promise<LiteTransaction>;
+    /** Get the current liteserver time. */
+    getTime(options?: CallOptions): Promise<LiteGetTimeResult>;
+    /** Look up a block by workchain, shard, and seqno. */
+    lookupBlock(params: LiteLookupBlockParams, options?: CallOptions): Promise<LiteLookupBlockResult>;
+    /** Get short transaction references from a block. */
+    getBlockTransactions(params: LiteGetBlockTransactionsParams, options?: CallOptions): Promise<LiteGetBlockTransactionsResult>;
+    /** Get current shard descriptors. */
+    getShards(options?: CallOptions): Promise<LiteGetShardsResult>;
+    /** Get blockchain configuration parameters. */
+    getBlockchainConfig(params?: LiteGetBlockchainConfigParams, options?: CallOptions): Promise<LiteGetBlockchainConfigResult>;
+    /**
+     * Send a message and subscribe to tx_confirmed / tx_timeout events.
+     * Returns a Subscription that delivers {@link SendAndWatchEvent} push events.
+     */
+    sendAndWatch(params: LiteSendAndWatchParams, options?: CallOptions): Promise<{
+        confirmation: LiteSendAndWatchResult;
+        subscription: Subscription<SendAndWatchEvent>;
+    }>;
+    /** Get the raw block BOC. */
+    getBlockData(params: LiteGetBlockDataParams, options?: CallOptions): Promise<LiteGetBlockDataResult>;
+    /** Get the block header proof BOC. */
+    getBlockHeader(params: LiteGetBlockHeaderParams, options?: CallOptions): Promise<LiteGetBlockHeaderResult>;
+    /** Get library cells by their hashes. */
+    getLibraries(params: LiteGetLibrariesParams, options?: CallOptions): Promise<LiteGetLibrariesResult>;
+}
+
+/** Union of all trace push events. */
+type TraceEvent = TraceStartedEvent | TraceTxEvent | TraceCompleteEvent | TraceTimeoutEvent;
+/** Subscribe namespace — real-time event subscriptions. */
+declare class SubscribeNamespace extends BaseNamespace {
+    private manager;
+    constructor(rpc: RpcEngine, manager: SubscriptionManager);
+    /** Subscribe to transactions for a specific account. */
+    transactions(params: SubscribeTransactionsParams, options?: CallOptions): Promise<Subscription<LiteTransaction>>;
+    /** Subscribe to new masterchain blocks. */
+    blocks(options?: CallOptions): Promise<Subscription<SubscribeBlockEvent>>;
+    /** Subscribe to account state changes. */
+    accountState(params: SubscribeAccountStateParams, options?: CallOptions): Promise<Subscription<SubscribeAccountStateEvent>>;
+    /** Subscribe to all new transactions across the blockchain. */
+    newTransactions(options?: CallOptions): Promise<Subscription<SubscribeNewTransactionEvent>>;
+    /** Subscribe to blockchain config parameter changes. */
+    configChanges(params: SubscribeConfigChangesParams, options?: CallOptions): Promise<Subscription<SubscribeConfigChangedEvent>>;
+    /** Subscribe to transactions across multiple accounts. */
+    multiAccount(params: SubscribeMultiAccountParams, options?: CallOptions): Promise<Subscription<LiteTransaction>>;
+    /**
+     * Subscribe to transaction traces (internal message chains).
+     * Returns a subscription that delivers trace_started, trace_tx, trace_complete, and trace_timeout events.
+     */
+    trace(params: SubscribeTraceParams, options?: CallOptions): Promise<Subscription<TraceEvent>>;
+}
+
+/** Jetton namespace — fungible token queries (TEP-74). */
+declare class JettonNamespace extends BaseNamespace {
+    /** Get jetton master data (supply, admin, content). */
+    getData(params: JettonGetDataParams, options?: CallOptions): Promise<JettonGetDataResult>;
+    /** Compute the jetton wallet address for an owner. */
+    getWalletAddress(params: JettonGetWalletAddressParams, options?: CallOptions): Promise<JettonGetWalletAddressResult>;
+    /** Get balance of a jetton wallet. */
+    getBalance(params: JettonGetBalanceParams, options?: CallOptions): Promise<JettonGetBalanceResult>;
+}
+
+/** NFT namespace — non-fungible token queries (TEP-62). */
+declare class NftNamespace extends BaseNamespace {
+    /** Get individual NFT item data. */
+    getData(params: NftGetDataParams, options?: CallOptions): Promise<NftGetDataResult>;
+    /** Get NFT collection data. */
+    getCollectionData(params: NftGetCollectionDataParams, options?: CallOptions): Promise<NftGetCollectionDataResult>;
+    /** Get the NFT item address by collection index. */
+    getAddressByIndex(params: NftGetAddressByIndexParams, options?: CallOptions): Promise<NftGetAddressByIndexResult>;
+    /** Get royalty parameters for a collection. */
+    getRoyaltyParams(params: NftGetRoyaltyParamsParams, options?: CallOptions): Promise<NftGetRoyaltyParamsResult>;
+    /** Resolve the full content URI for an NFT by combining collection and individual content. */
+    getContent(params: NftGetContentParams, options?: CallOptions): Promise<NftGetContentResult>;
+}
+
+/** DNS namespace — TON DNS domain resolution. */
+declare class DnsNamespace extends BaseNamespace {
+    /** Resolve a .ton domain to wallet, site ADNL, text records, etc. */
+    resolve(params: DnsResolveParams, options?: CallOptions): Promise<DnsResolveResult>;
+}
+
+/** Map of friendly event names to their wire event names and data types. */
+type AdnlEventMap = {
+    'message': AdnlMessageEvent;
+    'disconnected': AdnlDisconnectedEvent;
+    'incomingConnection': AdnlIncomingConnectionEvent;
+    'queryReceived': AdnlQueryReceivedEvent;
+};
+/** ADNL namespace — low-level peer-to-peer messaging. */
+declare class AdnlNamespace extends BaseNamespace {
+    private manager;
+    constructor(rpc: RpcEngine, manager: SubscriptionManager);
+    /** Connect to a peer by IP address and public key. */
+    connect(params: AdnlConnectParams, options?: CallOptions): Promise<AdnlConnectResult>;
+    /** Connect to a peer by ADNL ID (resolved via DHT). */
+    connectByADNL(params: AdnlConnectByAdnlParams, options?: CallOptions): Promise<AdnlConnectResult>;
+    /** Send an unreliable message to a connected peer. */
+    sendMessage(params: AdnlSendMessageParams, options?: CallOptions): Promise<AdnlSendMessageResult>;
+    /** Ping a connected peer. */
+    ping(params: AdnlPingParams, options?: CallOptions): Promise<AdnlPingResult>;
+    /** Disconnect from a peer. */
+    disconnect(params: AdnlDisconnectParams, options?: CallOptions): Promise<AdnlDisconnectResult>;
+    /** List all connected ADNL peers. */
+    peers(options?: CallOptions): Promise<AdnlPeersResult>;
+    /** Send a TL query to a peer and wait for the response. */
+    query(params: AdnlQueryParams, options?: CallOptions): Promise<AdnlQueryResult>;
+    /** Enable the query handler for a peer (receive queryReceived events). */
+    setQueryHandler(params: AdnlSetQueryHandlerParams, options?: CallOptions): Promise<AdnlSetQueryHandlerResult>;
+    /** Answer a received query. */
+    answer(params: AdnlAnswerParams, options?: CallOptions): Promise<AdnlAnswerResult>;
+    /** Register a listener for ADNL push events. */
+    on<K extends keyof AdnlEventMap>(event: K, listener: (data: AdnlEventMap[K]) => void): this;
+    /** Remove a listener for ADNL push events. */
+    off<K extends keyof AdnlEventMap>(event: K, listener: (data: AdnlEventMap[K]) => void): this;
+}
+
+/** Network namespace — bridge and DHT status. */
+declare class NetworkNamespace extends BaseNamespace {
+    /** Get bridge network information (DHT status, connected WS clients). */
+    info(options?: CallOptions): Promise<NetworkInfoResult>;
+}
+
+/** Map of friendly event names to their wire event names and data types. */
+type OverlayEventMap = {
+    'broadcast': OverlayBroadcastEvent;
+    'message': OverlayMessageEvent;
+    'queryReceived': OverlayQueryReceivedEvent;
+};
+/** Overlay namespace — P2P pubsub overlay networks. */
+declare class OverlayNamespace extends BaseNamespace {
+    private manager;
+    constructor(rpc: RpcEngine, manager: SubscriptionManager);
+    /** Join an overlay network. */
+    join(params: OverlayJoinParams, options?: CallOptions): Promise<OverlayJoinResult>;
+    /** Leave an overlay network. */
+    leave(params: OverlayLeaveParams, options?: CallOptions): Promise<OverlayLeaveResult>;
+    /** Get peers in an overlay network. */
+    getPeers(params: OverlayGetPeersParams, options?: CallOptions): Promise<OverlayGetPeersResult>;
+    /** Send a broadcast message to all overlay peers. */
+    sendMessage(params: OverlaySendMessageParams, options?: CallOptions): Promise<OverlaySendMessageResult>;
+    /** Send a TL query through the overlay and wait for the response. */
+    query(params: OverlayQueryParams, options?: CallOptions): Promise<OverlayQueryResult>;
+    /** Enable the query handler for an overlay (receive queryReceived events). */
+    setQueryHandler(params: OverlaySetQueryHandlerParams, options?: CallOptions): Promise<OverlaySetQueryHandlerResult>;
+    /** Answer a received overlay query. */
+    answer(params: OverlayAnswerParams, options?: CallOptions): Promise<OverlayAnswerResult>;
+    /** Register a listener for overlay push events. */
+    on<K extends keyof OverlayEventMap>(event: K, listener: (data: OverlayEventMap[K]) => void): this;
+    /** Remove a listener for overlay push events. */
+    off<K extends keyof OverlayEventMap>(event: K, listener: (data: OverlayEventMap[K]) => void): this;
+}
+
+/** Wallet namespace — standard wallet contract queries. */
+declare class WalletNamespace extends BaseNamespace {
+    /** Get the current seqno of a wallet contract. */
+    getSeqno(params: WalletGetSeqnoParams, options?: CallOptions): Promise<WalletGetSeqnoResult>;
+    /** Get the public key stored in a wallet contract. */
+    getPublicKey(params: WalletGetPublicKeyParams, options?: CallOptions): Promise<WalletGetPublicKeyResult>;
+}
+
+/** SBT namespace — soulbound token queries (TEP-85). */
+declare class SbtNamespace extends BaseNamespace {
+    /** Get the authority address of a soulbound token. */
+    getAuthorityAddress(params: SbtGetAuthorityAddressParams, options?: CallOptions): Promise<SbtGetAuthorityAddressResult>;
+    /** Get the revocation timestamp of a soulbound token (0 = not revoked). */
+    getRevokedTime(params: SbtGetRevokedTimeParams, options?: CallOptions): Promise<SbtGetRevokedTimeResult>;
+}
+
+/** Payment namespace — payment channel queries. */
+declare class PaymentNamespace extends BaseNamespace {
+    /** Get the state of a payment channel contract. */
+    getChannelState(params: PaymentGetChannelStateParams, options?: CallOptions): Promise<PaymentGetChannelStateResult>;
+}
+
+/** Options for creating a {@link Web3SocketsClient}. */
+interface ClientOptions extends WsTransportOptions {
+    /** Pre-built transport instance (overrides URL-based auto-detection). */
+    transport?: AbstractTransport;
+    /** RPC request timeout in milliseconds (default: 30 000). */
+    requestTimeout?: number;
+    /** Optional logger for debug/warn/error output. */
+    logger?: Logger;
+}
+/** Typed client event map. */
+interface ClientEventMap {
+    connected: () => void;
+    disconnected: (code: number, reason: string) => void;
+    error: (err: Error) => void;
+    stateChange: (newState: TransportState, oldState: TransportState) => void;
+}
+type ClientEventName = keyof ClientEventMap;
+/**
+ * High-level client for the TON WebSocket JSON-RPC bridge.
+ * Provides typed namespace accessors for all 58+ bridge methods.
+ */
+declare class Web3SocketsClient {
+    private transport;
+    private rpc;
+    private subscriptionManager;
+    private clientListeners;
+    /** DHT namespace — distributed hash table lookups. */
+    readonly dht: DhtNamespace;
+    /** Liteserver namespace — blockchain queries and transaction submission. */
+    readonly lite: LiteNamespace;
+    /** Subscribe namespace — real-time event subscriptions. */
+    readonly subscribe: SubscribeNamespace;
+    /** Jetton namespace — fungible token queries. */
+    readonly jetton: JettonNamespace;
+    /** NFT namespace — non-fungible token queries. */
+    readonly nft: NftNamespace;
+    /** DNS namespace — TON DNS domain resolution. */
+    readonly dns: DnsNamespace;
+    /** ADNL namespace — low-level peer-to-peer messaging. */
+    readonly adnl: AdnlNamespace;
+    /** Network namespace — bridge status. */
+    readonly network: NetworkNamespace;
+    /** Overlay namespace — P2P pubsub overlay networks. */
+    readonly overlay: OverlayNamespace;
+    /** Wallet namespace — standard wallet contract queries. */
+    readonly wallet: WalletNamespace;
+    /** SBT namespace — soulbound token queries. */
+    readonly sbt: SbtNamespace;
+    /** Payment namespace — payment channel queries. */
+    readonly payment: PaymentNamespace;
+    constructor(options?: ClientOptions);
+    /** Open the transport connection. */
+    connect(): Promise<void>;
+    /** Gracefully close the transport connection. */
+    disconnect(): void;
+    /** Whether the transport is currently connected. */
+    get isConnected(): boolean;
+    /** Current transport state. */
+    get state(): TransportState;
+    /** Permanently tear down the client, releasing all resources. */
+    destroy(): void;
+    /** Register a client event listener. */
+    on<E extends ClientEventName>(event: E, listener: ClientEventMap[E]): this;
+    /** Remove a client event listener. */
+    off<E extends ClientEventName>(event: E, listener: ClientEventMap[E]): this;
+    private emitClient;
+}
+
+/** Base error class for all SDK errors. */
+declare class Web3SocketsError extends Error {
+    code: string;
+    constructor(message: string, code: string);
+}
+/** Thrown when the WebSocket connection cannot be established. */
+declare class ConnectionError extends Web3SocketsError {
+    url: string;
+    constructor(message: string, url: string);
+}
+/** Thrown when the WebSocket connection is closed unexpectedly. */
+declare class ConnectionClosedError extends Web3SocketsError {
+    closeCode: number;
+    constructor(closeCode: number, reason: string);
+}
+/** Thrown when the bridge returns a JSON-RPC error response. */
+declare class RpcError extends Web3SocketsError {
+    rpcCode?: number | undefined;
+    constructor(message: string, rpcCode?: number | undefined);
+}
+/** Thrown when a JSON-RPC request exceeds its deadline. */
+declare class TimeoutError extends Web3SocketsError {
+    constructor(method: string, timeoutMs: number);
+}
+/** Thrown when request parameters fail client-side validation. */
+declare class ValidationError extends Web3SocketsError {
+    constructor(message: string);
+}
+
+export { AbstractTransport, type AdnlAnswerParams, type AdnlAnswerResult, type AdnlConnectByAdnlParams, type AdnlConnectParams, type AdnlConnectResult, type AdnlDisconnectParams, type AdnlDisconnectResult, type AdnlDisconnectedEvent, type AdnlIncomingConnectionEvent, type AdnlMessageEvent, AdnlNamespace, type AdnlPeerInfo, type AdnlPeersResult, type AdnlPingParams, type AdnlPingResult, type AdnlQueryParams, type AdnlQueryReceivedEvent, type AdnlQueryResult, type AdnlSendMessageParams, type AdnlSendMessageResult, type AdnlSetQueryHandlerParams, type AdnlSetQueryHandlerResult, type CallOptions, type ClientOptions, ConnectionClosedError, ConnectionError, type DhtAddress, type DhtFindAddressesParams, type DhtFindAddressesResult, type DhtFindOverlayNodesParams, type DhtFindOverlayNodesResult, type DhtFindTunnelNodesResult, type DhtFindValueParams, type DhtFindValueResult, DhtNamespace, type DhtRelayInfo, DnsNamespace, type DnsResolveParams, type DnsResolveResult, IpcTransport, type JettonGetBalanceParams, type JettonGetBalanceResult, type JettonGetDataParams, type JettonGetDataResult, type JettonGetWalletAddressParams, type JettonGetWalletAddressResult, JettonNamespace, type JettonTepContent, type LiteBlockTransaction, type LiteFindTxByInMsgHashParams, type LiteFindTxByOutMsgHashParams, type LiteGetAccountStateParams, type LiteGetAccountStateResult, type LiteGetBlockDataParams, type LiteGetBlockDataResult, type LiteGetBlockHeaderParams, type LiteGetBlockHeaderResult, type LiteGetBlockTransactionsParams, type LiteGetBlockTransactionsResult, type LiteGetBlockchainConfigParams, type LiteGetBlockchainConfigResult, type LiteGetLibrariesParams, type LiteGetLibrariesResult, type LiteGetMasterchainInfoResult, type LiteGetShardsResult, type LiteGetTimeResult, type LiteGetTransactionParams, type LiteGetTransactionsParams, type LiteGetTransactionsResult, type LiteLibraryEntry, type LiteLookupBlockParams, type LiteLookupBlockResult, LiteNamespace, type LiteRunMethodParams, type LiteRunMethodResult, type LiteSendAndWatchParams, type LiteSendAndWatchResult, type LiteSendMessageParams, type LiteSendMessageResult, type LiteShardInfo, type LiteTransaction, type LiteTransactionMessage, type Logger, type MethodMap, type MultiAccountEntry, type NetworkInfoResult, NetworkNamespace, type NftGetAddressByIndexParams, type NftGetAddressByIndexResult, type NftGetCollectionDataParams, type NftGetCollectionDataResult, type NftGetContentParams, type NftGetContentResult, type NftGetDataParams, type NftGetDataResult, type NftGetRoyaltyParamsParams, type NftGetRoyaltyParamsResult, NftNamespace, type NftTepContent, type OverlayAnswerParams, type OverlayAnswerResult, type OverlayBroadcastEvent, type OverlayGetPeersParams, type OverlayGetPeersResult, type OverlayJoinParams, type OverlayJoinResult, type OverlayLeaveParams, type OverlayLeaveResult, type OverlayMessageEvent, OverlayNamespace, type OverlayNodeInfo, type OverlayPeerInfo, type OverlayQueryParams, type OverlayQueryReceivedEvent, type OverlayQueryResult, type OverlaySendMessageParams, type OverlaySendMessageResult, type OverlaySetQueryHandlerParams, type OverlaySetQueryHandlerResult, type PaymentClosingConfig, type PaymentGetChannelStateParams, type PaymentGetChannelStateResult, PaymentNamespace, type PaymentQuarantine, type PaymentSemiChannelState, type RpcEngineOptions, RpcError, type SbtGetAuthorityAddressParams, type SbtGetAuthorityAddressResult, type SbtGetRevokedTimeParams, type SbtGetRevokedTimeResult, SbtNamespace, type SendAndWatchEvent, type SubscribeAccountStateConfirmation, type SubscribeAccountStateEvent, type SubscribeAccountStateParams, type SubscribeBlockEvent, type SubscribeBlocksConfirmation, type SubscribeConfigChangedEvent, type SubscribeConfigChangesConfirmation, type SubscribeConfigChangesParams, type SubscribeMultiAccountConfirmation, type SubscribeMultiAccountParams, SubscribeNamespace, type SubscribeNewTransactionEvent, type SubscribeNewTransactionsConfirmation, type SubscribeTraceConfirmation, type SubscribeTraceParams, type SubscribeTransactionsConfirmation, type SubscribeTransactionsParams, type SubscribeUnsubscribeParams, type SubscribeUnsubscribeResult, Subscription, type SubscriptionEventMap, type SubscriptionOptions, TimeoutError, type TraceCompleteEvent, type TraceEvent, type TraceStartedEvent, type TraceTimeoutEvent, type TraceTxEvent, type TransportEventName, type TransportEvents, TransportState, type TxConfirmedEvent, type TxTimeoutEvent, ValidationError, type WSEvent, type WSRequest, type WSResponse, type WalletGetPublicKeyParams, type WalletGetPublicKeyResult, type WalletGetSeqnoParams, type WalletGetSeqnoResult, WalletNamespace, Web3SocketsClient, Web3SocketsError, WsTransport, type WsTransportOptions, createTransport };