wsbridge-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1207 @@
+'use strict';
+
+// src/transport/base.ts
+var TransportState = /* @__PURE__ */ ((TransportState3) => {
+  TransportState3["DISCONNECTED"] = "DISCONNECTED";
+  TransportState3["CONNECTING"] = "CONNECTING";
+  TransportState3["CONNECTED"] = "CONNECTED";
+  TransportState3["RECONNECTING"] = "RECONNECTING";
+  TransportState3["DESTROYED"] = "DESTROYED";
+  return TransportState3;
+})(TransportState || {});
+var AbstractTransport = class {
+  listeners = /* @__PURE__ */ new Map();
+  /** Whether the transport is currently connected. */
+  get isConnected() {
+    return this.state === "CONNECTED" /* CONNECTED */;
+  }
+  /** Register an event listener. */
+  on(event, listener) {
+    if (!this.listeners.has(event)) this.listeners.set(event, /* @__PURE__ */ new Set());
+    this.listeners.get(event).add(listener);
+    return this;
+  }
+  /** Remove an event listener. */
+  off(event, listener) {
+    this.listeners.get(event)?.delete(listener);
+    return this;
+  }
+  /** Register a one-shot event listener that auto-removes after the first call. */
+  once(event, listener) {
+    const wrapper = ((...args) => {
+      this.off(event, wrapper);
+      listener(...args);
+    });
+    return this.on(event, wrapper);
+  }
+  emit(event, ...args) {
+    const fns = this.listeners.get(event);
+    if (fns) for (const fn of fns) fn(...args);
+  }
+};
+
+// src/errors.ts
+var Web3SocketsError = class _Web3SocketsError extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "Web3SocketsError";
+    Object.setPrototypeOf(this, _Web3SocketsError.prototype);
+  }
+};
+var ConnectionError = class _ConnectionError extends Web3SocketsError {
+  constructor(message, url) {
+    super(message, "CONNECTION_ERROR");
+    this.url = url;
+    this.name = "ConnectionError";
+    Object.setPrototypeOf(this, _ConnectionError.prototype);
+  }
+};
+var ConnectionClosedError = class _ConnectionClosedError extends Web3SocketsError {
+  constructor(closeCode, reason) {
+    super(reason || `Connection closed with code ${closeCode}`, "CONNECTION_CLOSED");
+    this.closeCode = closeCode;
+    this.name = "ConnectionClosedError";
+    Object.setPrototypeOf(this, _ConnectionClosedError.prototype);
+  }
+};
+var RpcError = class _RpcError extends Web3SocketsError {
+  constructor(message, rpcCode) {
+    super(message, "RPC_ERROR");
+    this.rpcCode = rpcCode;
+    this.name = "RpcError";
+    Object.setPrototypeOf(this, _RpcError.prototype);
+  }
+};
+var TimeoutError = class _TimeoutError extends Web3SocketsError {
+  constructor(method, timeoutMs) {
+    super(`Request "${method}" timed out after ${timeoutMs}ms`, "TIMEOUT");
+    this.name = "TimeoutError";
+    Object.setPrototypeOf(this, _TimeoutError.prototype);
+  }
+};
+var ValidationError = class _ValidationError extends Web3SocketsError {
+  constructor(message) {
+    super(message, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+    Object.setPrototypeOf(this, _ValidationError.prototype);
+  }
+};
+
+// src/transport/ws-transport.ts
+var WsTransport = class extends AbstractTransport {
+  ws = null;
+  url;
+  autoReconnect;
+  reconnectDelay;
+  reconnectMaxDelay;
+  reconnectMaxRetries;
+  keepaliveInterval;
+  reconnectAttempt = 0;
+  reconnectTimer = null;
+  keepaliveTimer = null;
+  intentionalClose = false;
+  _state = "DISCONNECTED" /* DISCONNECTED */;
+  constructor(options = {}) {
+    super();
+    this.url = options.url ?? "ws://127.0.0.1:8081";
+    this.autoReconnect = options.autoReconnect ?? true;
+    this.reconnectDelay = options.reconnectDelay ?? 1e3;
+    this.reconnectMaxDelay = options.reconnectMaxDelay ?? 3e4;
+    this.reconnectMaxRetries = options.reconnectMaxRetries ?? Infinity;
+    this.keepaliveInterval = options.keepaliveInterval ?? 3e4;
+  }
+  /** Current transport state. */
+  get state() {
+    return this._state;
+  }
+  /** Open a WebSocket connection. Throws if already connecting or destroyed. */
+  async connect() {
+    if (this._state === "CONNECTED" /* CONNECTED */) return;
+    if (this._state === "CONNECTING" /* CONNECTING */ || this._state === "RECONNECTING" /* RECONNECTING */) {
+      throw new ConnectionError("Already connecting", this.url);
+    }
+    if (this._state === "DESTROYED" /* DESTROYED */) {
+      throw new ConnectionError("Transport destroyed", this.url);
+    }
+    this.intentionalClose = false;
+    this.setState("CONNECTING" /* CONNECTING */);
+    const WebSocketImpl = await this.getWebSocketImpl();
+    return new Promise((resolve, reject) => {
+      try {
+        this.ws = new WebSocketImpl(this.url);
+      } catch (err) {
+        this.setState("DISCONNECTED" /* DISCONNECTED */);
+        reject(new ConnectionError(err.message, this.url));
+        return;
+      }
+      this.ws.addEventListener("close", (event) => {
+        this.stopKeepalive();
+        this.emit("close", event.code, event.reason);
+        if (!this.intentionalClose && this.autoReconnect && this._state !== "DESTROYED" /* DESTROYED */) {
+          this.scheduleReconnect();
+        } else if (this._state !== "DESTROYED" /* DESTROYED */) {
+          this.setState("DISCONNECTED" /* DISCONNECTED */);
+        }
+      });
+      const onOpen = () => {
+        this.ws?.removeEventListener("error", onError);
+        this.reconnectAttempt = 0;
+        this.setState("CONNECTED" /* CONNECTED */);
+        this.setupListeners();
+        this.startKeepalive();
+        this.emit("open");
+        resolve();
+      };
+      const onError = (event) => {
+        this.ws?.removeEventListener("open", onOpen);
+        const err = new ConnectionError(
+          event.message || "WebSocket connection failed",
+          this.url
+        );
+        reject(err);
+      };
+      this.ws.addEventListener("open", onOpen);
+      this.ws.addEventListener("error", onError);
+    });
+  }
+  /** Close the connection without triggering auto-reconnect. */
+  disconnect() {
+    this.intentionalClose = true;
+    this.clearReconnectTimer();
+    this.stopKeepalive();
+    if (this.ws) {
+      this.ws.close(1e3, "client disconnect");
+      this.ws = null;
+    }
+    if (this._state !== "DESTROYED" /* DESTROYED */) {
+      this.setState("DISCONNECTED" /* DISCONNECTED */);
+    }
+  }
+  /** Permanently destroy the transport. No further connect() calls are allowed. */
+  destroy() {
+    this.disconnect();
+    this.setState("DESTROYED" /* DESTROYED */);
+    this.listeners.clear();
+  }
+  /** Send data over the WebSocket. Throws if not connected. */
+  send(data) {
+    if (this._state !== "CONNECTED" /* CONNECTED */ || !this.ws) {
+      throw new ConnectionError("Not connected", this.url);
+    }
+    this.ws.send(data);
+  }
+  // ── Private helpers ──────────────────────────────────────────────
+  setState(next) {
+    const prev = this._state;
+    if (prev === next) return;
+    this._state = next;
+    this.emit("stateChange", next, prev);
+  }
+  setupListeners() {
+    if (!this.ws) return;
+    this.ws.addEventListener("message", (event) => {
+      const data = typeof event.data === "string" ? event.data : event.data.toString();
+      this.emit("message", data);
+    });
+    this.ws.addEventListener("error", () => {
+      this.emit("error", new ConnectionError("WebSocket error", this.url));
+    });
+  }
+  scheduleReconnect() {
+    if (this.reconnectAttempt >= this.reconnectMaxRetries) {
+      this.setState("DISCONNECTED" /* DISCONNECTED */);
+      this.emit("reconnectFailed");
+      return;
+    }
+    this.setState("RECONNECTING" /* RECONNECTING */);
+    const delay = Math.min(
+      this.reconnectDelay * Math.pow(2, this.reconnectAttempt),
+      this.reconnectMaxDelay
+    );
+    this.reconnectAttempt++;
+    this.reconnectTimer = setTimeout(async () => {
+      this._state = "DISCONNECTED" /* DISCONNECTED */;
+      try {
+        await this.connect();
+      } catch {
+      }
+    }, delay);
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  startKeepalive() {
+    if (this.keepaliveInterval <= 0) return;
+    if (typeof globalThis.WebSocket !== "undefined" && this.ws instanceof globalThis.WebSocket) return;
+    this.keepaliveTimer = setInterval(() => {
+      if (this.ws && this._state === "CONNECTED" /* CONNECTED */) {
+        try {
+          this.ws.ping();
+        } catch {
+        }
+      }
+    }, this.keepaliveInterval);
+  }
+  stopKeepalive() {
+    if (this.keepaliveTimer) {
+      clearInterval(this.keepaliveTimer);
+      this.keepaliveTimer = null;
+    }
+  }
+  async getWebSocketImpl() {
+    if (typeof globalThis.WebSocket !== "undefined") {
+      return globalThis.WebSocket;
+    }
+    try {
+      const { default: WS } = await import('ws');
+      return WS;
+    } catch {
+      throw new ConnectionError(
+        'WebSocket implementation not found. Install the "ws" package for Node.js.',
+        this.url
+      );
+    }
+  }
+};
+
+// src/transport/ipc-transport.ts
+var IpcTransport = class extends AbstractTransport {
+  unsubscribe = null;
+  _state = "DISCONNECTED" /* DISCONNECTED */;
+  /** Current transport state. */
+  get state() {
+    return this._state;
+  }
+  /** Connect to the IPC bridge via `window.ton.adnl`. */
+  async connect() {
+    if (this._state === "CONNECTED" /* CONNECTED */) return;
+    if (this._state === "CONNECTING" /* CONNECTING */) {
+      throw new ConnectionError("Already connecting", "ipc");
+    }
+    if (this._state === "DESTROYED" /* DESTROYED */) {
+      throw new ConnectionError("Transport destroyed", "ipc");
+    }
+    if (typeof window === "undefined" || !window.ton?.adnl) {
+      throw new ConnectionError("window.ton.adnl not available", "ipc");
+    }
+    this.setState("CONNECTING" /* CONNECTING */);
+    this.unsubscribe = window.ton.adnl.onMessage((data) => {
+      this.emit("message", data);
+    });
+    this.setState("CONNECTED" /* CONNECTED */);
+    this.emit("open");
+  }
+  /** Disconnect from the IPC bridge. */
+  disconnect() {
+    if (this.unsubscribe) {
+      this.unsubscribe();
+      this.unsubscribe = null;
+    }
+    if (this._state !== "DESTROYED" /* DESTROYED */) {
+      this.setState("DISCONNECTED" /* DISCONNECTED */);
+    }
+    this.emit("close", 1e3, "client disconnect");
+  }
+  /** Permanently destroy the transport. */
+  destroy() {
+    this.disconnect();
+    this.setState("DESTROYED" /* DESTROYED */);
+    this.listeners.clear();
+  }
+  /** Send data over the IPC bridge. */
+  send(data) {
+    if (this._state !== "CONNECTED" /* CONNECTED */) {
+      throw new ConnectionError("IPC transport not connected", "ipc");
+    }
+    if (typeof window === "undefined" || !window.ton?.adnl) {
+      throw new ConnectionError("window.ton.adnl not available", "ipc");
+    }
+    window.ton.adnl.send(data);
+  }
+  setState(next) {
+    const prev = this._state;
+    if (prev === next) return;
+    this._state = next;
+    this.emit("stateChange", next, prev);
+  }
+};
+
+// src/transport/index.ts
+function createTransport(options) {
+  if (typeof window !== "undefined" && window.ton?.adnl) {
+    return new IpcTransport();
+  }
+  return new WsTransport(options);
+}
+
+// src/rpc/rpc-engine.ts
+var idCounter = 0;
+function generateId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  idCounter = (idCounter + 1) % 2147483648;
+  return String(idCounter);
+}
+var RpcEngine = class {
+  constructor(transport, options = {}) {
+    this.transport = transport;
+    this.requestTimeout = options.requestTimeout ?? 3e4;
+    this.logger = options.logger ?? null;
+    this.transport.on("message", (data) => this.handleMessage(data));
+    this.transport.on("close", () => this.rejectAll("Connection closed"));
+  }
+  pending = /* @__PURE__ */ new Map();
+  pushHandler = null;
+  requestTimeout;
+  logger;
+  /** Register a handler for push events (subscriptions, ADNL). */
+  setPushHandler(handler) {
+    this.pushHandler = handler;
+  }
+  /**
+   * 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(method, params, options) {
+    const id = generateId();
+    if (options?.signal?.aborted) {
+      return Promise.reject(new TimeoutError(method, 0));
+    }
+    return new Promise((resolve, reject) => {
+      const cleanup = () => {
+        const call2 = this.pending.get(id);
+        if (call2?.abortHandler && options?.signal) {
+          options.signal.removeEventListener("abort", call2.abortHandler);
+        }
+        this.pending.delete(id);
+      };
+      const timer = setTimeout(() => {
+        cleanup();
+        this.logger?.warn("RPC timeout", method, id);
+        reject(new TimeoutError(method, this.requestTimeout));
+      }, this.requestTimeout);
+      const call = {
+        resolve,
+        reject,
+        timer,
+        method
+      };
+      if (options?.signal) {
+        const abortHandler = () => {
+          clearTimeout(timer);
+          cleanup();
+          reject(new TimeoutError(method, 0));
+        };
+        call.abortHandler = abortHandler;
+        call.signal = options.signal;
+        options.signal.addEventListener("abort", abortHandler, { once: true });
+      }
+      this.pending.set(id, call);
+      const msg = JSON.stringify({ jsonrpc: "2.0", id, method, params: params ?? {} });
+      this.logger?.debug("RPC \u2192", method, id);
+      try {
+        this.transport.send(msg);
+      } catch (err) {
+        clearTimeout(timer);
+        cleanup();
+        reject(err);
+      }
+    });
+  }
+  handleMessage(raw) {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg.id != null && this.pending.has(String(msg.id))) {
+      const id = String(msg.id);
+      const call = this.pending.get(id);
+      clearTimeout(call.timer);
+      if (call.abortHandler && call.signal) {
+        call.signal.removeEventListener("abort", call.abortHandler);
+      }
+      this.pending.delete(id);
+      if (msg.error) {
+        this.logger?.error("RPC error", call.method, msg.error);
+        call.reject(new RpcError(msg.error.message, msg.error.code));
+      } else {
+        this.logger?.debug("RPC \u2190", call.method, id);
+        call.resolve(msg.result);
+      }
+      return;
+    }
+    if (msg.event && this.pushHandler) {
+      this.pushHandler(msg.event, msg.data);
+    }
+  }
+  rejectAll(reason) {
+    for (const [, call] of this.pending) {
+      clearTimeout(call.timer);
+      call.reject(new ConnectionClosedError(1006, `${reason} (pending: ${call.method})`));
+    }
+    this.pending.clear();
+  }
+  /** Destroy the engine, rejecting all pending calls. */
+  destroy() {
+    this.rejectAll("RPC engine destroyed");
+    this.pushHandler = null;
+  }
+};
+
+// src/subscription/subscription.ts
+var DEFAULT_HIGH_WATER_MARK = 1e3;
+var Subscription = class {
+  constructor(event, onUnsubscribe, options) {
+    this.event = event;
+    this.onUnsubscribe = onUnsubscribe;
+    this.highWaterMark = options?.highWaterMark ?? DEFAULT_HIGH_WATER_MARK;
+  }
+  listeners = /* @__PURE__ */ new Set();
+  errorListeners = /* @__PURE__ */ new Set();
+  _active = true;
+  _iteratorResolve = null;
+  highWaterMark;
+  /** Whether the subscription is still active. */
+  get active() {
+    return this._active;
+  }
+  on(event, listener) {
+    if (event === "data") this.listeners.add(listener);
+    else if (event === "error") this.errorListeners.add(listener);
+    return this;
+  }
+  off(event, listener) {
+    if (event === "data") this.listeners.delete(listener);
+    else if (event === "error") this.errorListeners.delete(listener);
+    return this;
+  }
+  /** @internal Called by SubscriptionManager to deliver push events. */
+  _deliver(data) {
+    if (!this._active) return;
+    for (const fn of this.listeners) fn(data);
+  }
+  /** @internal Called by SubscriptionManager on error. */
+  _error(error) {
+    for (const fn of this.errorListeners) fn(error);
+  }
+  /** Unsubscribe, releasing all listeners and unblocking any active async iterator. */
+  async unsubscribe() {
+    if (!this._active) return;
+    this._active = false;
+    this.listeners.clear();
+    this.errorListeners.clear();
+    if (this._iteratorResolve) {
+      this._iteratorResolve();
+      this._iteratorResolve = null;
+    }
+    this.onUnsubscribe();
+  }
+  /** Consume events as an async iterable. Respects backpressure via highWaterMark. */
+  async *[Symbol.asyncIterator]() {
+    const buffer = [];
+    let resolve = null;
+    const listener = (data) => {
+      buffer.push(data);
+      while (buffer.length > this.highWaterMark) {
+        buffer.shift();
+      }
+      if (resolve) {
+        resolve();
+        resolve = null;
+      }
+    };
+    this.on("data", listener);
+    try {
+      while (this._active) {
+        if (buffer.length > 0) {
+          yield buffer.shift();
+        } else {
+          await new Promise((r) => {
+            resolve = r;
+            this._iteratorResolve = r;
+          });
+        }
+      }
+    } finally {
+      this._iteratorResolve = null;
+      this.off("data", listener);
+      await this.unsubscribe();
+    }
+  }
+};
+
+// src/subscription/manager.ts
+var SubscriptionManager = class {
+  subscriptions = /* @__PURE__ */ new Map();
+  adnlListeners = /* @__PURE__ */ new Map();
+  subscriptionIds = /* @__PURE__ */ new Map();
+  /** Register a subscription for a push event type. */
+  register(eventType, onUnsubscribe, options) {
+    const sub = new Subscription(eventType, () => {
+      const subs = this.subscriptions.get(eventType);
+      if (subs) {
+        subs.delete(sub);
+        if (subs.size === 0) this.subscriptions.delete(eventType);
+      }
+      for (const [id, s] of this.subscriptionIds) {
+        if (s === sub) {
+          this.subscriptionIds.delete(id);
+          break;
+        }
+      }
+      onUnsubscribe();
+    }, options);
+    if (!this.subscriptions.has(eventType)) {
+      this.subscriptions.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.subscriptions.get(eventType).add(sub);
+    return sub;
+  }
+  /** Store the bridge-assigned subscription ID for a subscription. */
+  setSubscriptionId(subscriptionId, subscription) {
+    this.subscriptionIds.set(subscriptionId, subscription);
+  }
+  /** Get a subscription by its bridge-assigned ID. */
+  getBySubscriptionId(subscriptionId) {
+    return this.subscriptionIds.get(subscriptionId);
+  }
+  /** Route a push event to all matching subscriptions. */
+  handleEvent(event, data) {
+    const subs = this.subscriptions.get(event);
+    if (subs) {
+      for (const sub of subs) sub._deliver(data);
+    }
+    const listeners = this.adnlListeners.get(event);
+    if (listeners) {
+      for (const fn of listeners) fn(data);
+    }
+  }
+  /** Register an ADNL event listener. */
+  onAdnl(event, listener) {
+    if (!this.adnlListeners.has(event)) {
+      this.adnlListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.adnlListeners.get(event).add(listener);
+  }
+  /** Remove an ADNL event listener. */
+  offAdnl(event, listener) {
+    this.adnlListeners.get(event)?.delete(listener);
+  }
+  /**
+   * 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() {
+    const entries = [];
+    for (const [eventType, subs] of this.subscriptions) {
+      for (const sub of subs) {
+        if (sub.active) {
+          entries.push({ eventType, subscription: sub });
+        }
+      }
+    }
+    return entries;
+  }
+  /**
+   * 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.
+   */
+  async resubscribe(doSubscribe) {
+    this.subscriptionIds.clear();
+    const entries = this.getResubscribeEntries();
+    for (const { eventType, subscription } of entries) {
+      const newId = await doSubscribe(eventType);
+      this.subscriptionIds.set(newId, subscription);
+    }
+  }
+  /** Number of active subscriptions (for debugging). */
+  get activeCount() {
+    let count = 0;
+    for (const subs of this.subscriptions.values()) count += subs.size;
+    return count;
+  }
+  /** Clear all subscriptions and ADNL listeners (e.g. on disconnect). */
+  clear() {
+    for (const [, subs] of this.subscriptions) {
+      for (const sub of subs) {
+        sub._error(new Error("Connection closed"));
+      }
+    }
+    this.subscriptions.clear();
+    this.adnlListeners.clear();
+    this.subscriptionIds.clear();
+  }
+};
+
+// src/namespaces/base.ts
+var BaseNamespace = class {
+  constructor(rpc) {
+    this.rpc = rpc;
+  }
+  /** Send a typed JSON-RPC call through the engine. */
+  call(method, params, options) {
+    return this.rpc.call(method, params, options);
+  }
+};
+
+// src/namespaces/dht.ts
+var DhtNamespace = class extends BaseNamespace {
+  /** Look up ADNL addresses for a given key. */
+  findAddresses(params, options) {
+    return this.call("dht.findAddresses", params, options);
+  }
+  /** Find overlay nodes for a given overlay key. */
+  findOverlayNodes(params, options) {
+    return this.call("dht.findOverlayNodes", params, options);
+  }
+  /** Discover tunnel relay nodes from the DHT. */
+  findTunnelNodes(options) {
+    return this.call("dht.findTunnelNodes", void 0, options);
+  }
+  /** Look up an arbitrary value in the DHT. */
+  findValue(params, options) {
+    return this.call("dht.findValue", params, options);
+  }
+};
+
+// src/namespaces/lite.ts
+var LiteNamespace = class extends BaseNamespace {
+  manager;
+  constructor(rpc, manager) {
+    super(rpc);
+    this.manager = manager;
+  }
+  /** Get the latest masterchain block info. */
+  getMasterchainInfo(options) {
+    return this.call("lite.getMasterchainInfo", void 0, options);
+  }
+  /** Get the state of an account. */
+  getAccountState(params, options) {
+    return this.call("lite.getAccountState", params, options);
+  }
+  /** Run a get-method on a smart contract. */
+  runMethod(params, options) {
+    return this.call("lite.runMethod", params, options);
+  }
+  /** Send an external message (fire and forget). */
+  sendMessage(params, options) {
+    return this.call("lite.sendMessage", params, options);
+  }
+  /** Send an external message and wait for processing confirmation. */
+  sendMessageWait(params, options) {
+    return this.call("lite.sendMessageWait", params, options);
+  }
+  /** Get account transactions with optional pagination. */
+  getTransactions(params, options) {
+    return this.call("lite.getTransactions", params, options);
+  }
+  /** Get a single transaction by address and LT. */
+  getTransaction(params, options) {
+    return this.call("lite.getTransaction", params, options);
+  }
+  /** Find a transaction by its inbound message hash. */
+  findTxByInMsgHash(params, options) {
+    return this.call("lite.findTxByInMsgHash", params, options);
+  }
+  /** Find a transaction by its outbound message hash. */
+  findTxByOutMsgHash(params, options) {
+    return this.call("lite.findTxByOutMsgHash", params, options);
+  }
+  /** Get the current liteserver time. */
+  getTime(options) {
+    return this.call("lite.getTime", void 0, options);
+  }
+  /** Look up a block by workchain, shard, and seqno. */
+  lookupBlock(params, options) {
+    return this.call("lite.lookupBlock", params, options);
+  }
+  /** Get short transaction references from a block. */
+  getBlockTransactions(params, options) {
+    return this.call("lite.getBlockTransactions", params, options);
+  }
+  /** Get current shard descriptors. */
+  getShards(options) {
+    return this.call("lite.getShards", void 0, options);
+  }
+  /** Get blockchain configuration parameters. */
+  getBlockchainConfig(params, options) {
+    return this.call("lite.getBlockchainConfig", params, options);
+  }
+  /**
+   * Send a message and subscribe to tx_confirmed / tx_timeout events.
+   * Returns a Subscription that delivers {@link SendAndWatchEvent} push events.
+   */
+  async sendAndWatch(params, options) {
+    const confirmation = await this.call("lite.sendAndWatch", params, options);
+    if (!confirmation.watching) throw new Error("sendAndWatch rejected by bridge");
+    const subId = confirmation.subscription_id;
+    const sub = this.manager.register("tx_confirmed", () => {
+      this.rpc.call("subscribe.unsubscribe", { subscription_id: subId }).catch(() => {
+      });
+    });
+    this.manager.setSubscriptionId(subId, sub);
+    const timeoutSub = this.manager.register("tx_timeout", () => {
+    });
+    this.manager.setSubscriptionId(`${subId}:timeout`, timeoutSub);
+    timeoutSub.on("data", (data) => sub._deliver(data));
+    return { confirmation, subscription: sub };
+  }
+  /** Get the raw block BOC. */
+  getBlockData(params, options) {
+    return this.call("lite.getBlockData", params, options);
+  }
+  /** Get the block header proof BOC. */
+  getBlockHeader(params, options) {
+    return this.call("lite.getBlockHeader", params, options);
+  }
+  /** Get library cells by their hashes. */
+  getLibraries(params, options) {
+    return this.call("lite.getLibraries", params, options);
+  }
+};
+
+// src/namespaces/subscribe.ts
+var SubscribeNamespace = class extends BaseNamespace {
+  manager;
+  constructor(rpc, manager) {
+    super(rpc);
+    this.manager = manager;
+  }
+  /** Subscribe to transactions for a specific account. */
+  async transactions(params, options) {
+    const confirmation = await this.call("subscribe.transactions", params, options);
+    if (!confirmation.subscribed) throw new Error("Subscription rejected");
+    const subId = confirmation.subscription_id;
+    const sub = this.manager.register("transaction", () => {
+      this.rpc.call("subscribe.unsubscribe", { subscription_id: subId }).catch(() => {
+      });
+    });
+    this.manager.setSubscriptionId(subId, sub);
+    return sub;
+  }
+  /** Subscribe to new masterchain blocks. */
+  async blocks(options) {
+    const confirmation = await this.call("subscribe.blocks", void 0, options);
+    if (!confirmation.subscribed) throw new Error("Subscription rejected");
+    const subId = confirmation.subscription_id;
+    const sub = this.manager.register("block", () => {
+      this.rpc.call("subscribe.unsubscribe", { subscription_id: subId }).catch(() => {
+      });
+    });
+    this.manager.setSubscriptionId(subId, sub);
+    return sub;
+  }
+  /** Subscribe to account state changes. */
+  async accountState(params, options) {
+    const confirmation = await this.call("subscribe.accountState", params, options);
+    if (!confirmation.subscribed) throw new Error("Subscription rejected");
+    const subId = confirmation.subscription_id;
+    const sub = this.manager.register("account_state", () => {
+      this.rpc.call("subscribe.unsubscribe", { subscription_id: subId }).catch(() => {
+      });
+    });
+    this.manager.setSubscriptionId(subId, sub);
+    return sub;
+  }
+  /** Subscribe to all new transactions across the blockchain. */
+  async newTransactions(options) {
+    const confirmation = await this.call("subscribe.newTransactions", void 0, options);
+    if (!confirmation.subscribed) throw new Error("Subscription rejected");
+    const subId = confirmation.subscription_id;
+    const sub = this.manager.register("new_transaction", () => {
+      this.rpc.call("subscribe.unsubscribe", { subscription_id: subId }).catch(() => {
+      });
+    });
+    this.manager.setSubscriptionId(subId, sub);
+    return sub;
+  }
+  /** Subscribe to blockchain config parameter changes. */
+  async configChanges(params, options) {
+    const confirmation = await this.call("subscribe.configChanges", params, options);
+    if (!confirmation.subscribed) throw new Error("Subscription rejected");
+    const subId = confirmation.subscription_id;
+    const sub = this.manager.register("config_changed", () => {
+      this.rpc.call("subscribe.unsubscribe", { subscription_id: subId }).catch(() => {
+      });
+    });
+    this.manager.setSubscriptionId(subId, sub);
+    return sub;
+  }
+  /** Subscribe to transactions across multiple accounts. */
+  async multiAccount(params, options) {
+    const confirmation = await this.call("subscribe.multiAccount", params, options);
+    if (!confirmation.subscribed) throw new Error("Subscription rejected");
+    const subId = confirmation.subscription_id;
+    const sub = this.manager.register("transaction", () => {
+      this.rpc.call("subscribe.unsubscribe", { subscription_id: subId }).catch(() => {
+      });
+    });
+    this.manager.setSubscriptionId(subId, sub);
+    return sub;
+  }
+  /**
+   * Subscribe to transaction traces (internal message chains).
+   * Returns a subscription that delivers trace_started, trace_tx, trace_complete, and trace_timeout events.
+   */
+  async trace(params, options) {
+    const confirmation = await this.call("subscribe.trace", params, options);
+    if (!confirmation.subscribed) throw new Error("Subscription rejected");
+    const subId = confirmation.subscription_id;
+    const sub = this.manager.register("trace_started", () => {
+      this.rpc.call("subscribe.unsubscribe", { subscription_id: subId }).catch(() => {
+      });
+    });
+    this.manager.setSubscriptionId(subId, sub);
+    const traceEvents = ["trace_tx", "trace_complete", "trace_timeout"];
+    for (const evt of traceEvents) {
+      const aux = this.manager.register(evt, () => {
+      });
+      aux.on("data", (data) => sub._deliver(data));
+    }
+    return sub;
+  }
+};
+
+// src/namespaces/jetton.ts
+var JettonNamespace = class extends BaseNamespace {
+  /** Get jetton master data (supply, admin, content). */
+  getData(params, options) {
+    return this.call("jetton.getData", params, options);
+  }
+  /** Compute the jetton wallet address for an owner. */
+  getWalletAddress(params, options) {
+    return this.call("jetton.getWalletAddress", params, options);
+  }
+  /** Get balance of a jetton wallet. */
+  getBalance(params, options) {
+    return this.call("jetton.getBalance", params, options);
+  }
+};
+
+// src/namespaces/nft.ts
+var NftNamespace = class extends BaseNamespace {
+  /** Get individual NFT item data. */
+  getData(params, options) {
+    return this.call("nft.getData", params, options);
+  }
+  /** Get NFT collection data. */
+  getCollectionData(params, options) {
+    return this.call("nft.getCollectionData", params, options);
+  }
+  /** Get the NFT item address by collection index. */
+  getAddressByIndex(params, options) {
+    return this.call("nft.getAddressByIndex", params, options);
+  }
+  /** Get royalty parameters for a collection. */
+  getRoyaltyParams(params, options) {
+    return this.call("nft.getRoyaltyParams", params, options);
+  }
+  /** Resolve the full content URI for an NFT by combining collection and individual content. */
+  getContent(params, options) {
+    return this.call("nft.getContent", params, options);
+  }
+};
+
+// src/namespaces/dns.ts
+var DnsNamespace = class extends BaseNamespace {
+  /** Resolve a .ton domain to wallet, site ADNL, text records, etc. */
+  resolve(params, options) {
+    return this.call("dns.resolve", params, options);
+  }
+};
+
+// src/namespaces/adnl.ts
+var EVENT_LOOKUP = {
+  message: "adnl.message",
+  disconnected: "adnl.disconnected",
+  incomingConnection: "adnl.incomingConnection",
+  queryReceived: "adnl.queryReceived"
+};
+var AdnlNamespace = class extends BaseNamespace {
+  manager;
+  constructor(rpc, manager) {
+    super(rpc);
+    this.manager = manager;
+  }
+  /** Connect to a peer by IP address and public key. */
+  connect(params, options) {
+    return this.call("adnl.connect", params, options);
+  }
+  /** Connect to a peer by ADNL ID (resolved via DHT). */
+  connectByADNL(params, options) {
+    return this.call("adnl.connectByADNL", params, options);
+  }
+  /** Send an unreliable message to a connected peer. */
+  sendMessage(params, options) {
+    return this.call("adnl.sendMessage", params, options);
+  }
+  /** Ping a connected peer. */
+  ping(params, options) {
+    return this.call("adnl.ping", params, options);
+  }
+  /** Disconnect from a peer. */
+  disconnect(params, options) {
+    return this.call("adnl.disconnect", params, options);
+  }
+  /** List all connected ADNL peers. */
+  peers(options) {
+    return this.call("adnl.peers", void 0, options);
+  }
+  /** Send a TL query to a peer and wait for the response. */
+  query(params, options) {
+    return this.call("adnl.query", params, options);
+  }
+  /** Enable the query handler for a peer (receive queryReceived events). */
+  setQueryHandler(params, options) {
+    return this.call("adnl.setQueryHandler", params, options);
+  }
+  /** Answer a received query. */
+  answer(params, options) {
+    return this.call("adnl.answer", params, options);
+  }
+  /** Register a listener for ADNL push events. */
+  on(event, listener) {
+    this.manager.onAdnl(EVENT_LOOKUP[event], listener);
+    return this;
+  }
+  /** Remove a listener for ADNL push events. */
+  off(event, listener) {
+    this.manager.offAdnl(EVENT_LOOKUP[event], listener);
+    return this;
+  }
+};
+
+// src/namespaces/network.ts
+var NetworkNamespace = class extends BaseNamespace {
+  /** Get bridge network information (DHT status, connected WS clients). */
+  info(options) {
+    return this.call("network.info", void 0, options);
+  }
+};
+
+// src/namespaces/overlay.ts
+var EVENT_LOOKUP2 = {
+  broadcast: "overlay.broadcast",
+  message: "overlay.message",
+  queryReceived: "overlay.queryReceived"
+};
+var OverlayNamespace = class extends BaseNamespace {
+  manager;
+  constructor(rpc, manager) {
+    super(rpc);
+    this.manager = manager;
+  }
+  /** Join an overlay network. */
+  join(params, options) {
+    return this.call("overlay.join", params, options);
+  }
+  /** Leave an overlay network. */
+  leave(params, options) {
+    return this.call("overlay.leave", params, options);
+  }
+  /** Get peers in an overlay network. */
+  getPeers(params, options) {
+    return this.call("overlay.getPeers", params, options);
+  }
+  /** Send a broadcast message to all overlay peers. */
+  sendMessage(params, options) {
+    return this.call("overlay.sendMessage", params, options);
+  }
+  /** Send a TL query through the overlay and wait for the response. */
+  query(params, options) {
+    return this.call("overlay.query", params, options);
+  }
+  /** Enable the query handler for an overlay (receive queryReceived events). */
+  setQueryHandler(params, options) {
+    return this.call("overlay.setQueryHandler", params, options);
+  }
+  /** Answer a received overlay query. */
+  answer(params, options) {
+    return this.call("overlay.answer", params, options);
+  }
+  /** Register a listener for overlay push events. */
+  on(event, listener) {
+    this.manager.onAdnl(EVENT_LOOKUP2[event], listener);
+    return this;
+  }
+  /** Remove a listener for overlay push events. */
+  off(event, listener) {
+    this.manager.offAdnl(EVENT_LOOKUP2[event], listener);
+    return this;
+  }
+};
+
+// src/namespaces/wallet.ts
+var WalletNamespace = class extends BaseNamespace {
+  /** Get the current seqno of a wallet contract. */
+  getSeqno(params, options) {
+    return this.call("wallet.getSeqno", params, options);
+  }
+  /** Get the public key stored in a wallet contract. */
+  getPublicKey(params, options) {
+    return this.call("wallet.getPublicKey", params, options);
+  }
+};
+
+// src/namespaces/sbt.ts
+var SbtNamespace = class extends BaseNamespace {
+  /** Get the authority address of a soulbound token. */
+  getAuthorityAddress(params, options) {
+    return this.call("sbt.getAuthorityAddress", params, options);
+  }
+  /** Get the revocation timestamp of a soulbound token (0 = not revoked). */
+  getRevokedTime(params, options) {
+    return this.call("sbt.getRevokedTime", params, options);
+  }
+};
+
+// src/namespaces/payment.ts
+var PaymentNamespace = class extends BaseNamespace {
+  /** Get the state of a payment channel contract. */
+  getChannelState(params, options) {
+    return this.call("payment.getChannelState", params, options);
+  }
+};
+
+// src/client.ts
+var Web3SocketsClient = class {
+  transport;
+  rpc;
+  subscriptionManager;
+  clientListeners = /* @__PURE__ */ new Map();
+  /** DHT namespace — distributed hash table lookups. */
+  dht;
+  /** Liteserver namespace — blockchain queries and transaction submission. */
+  lite;
+  /** Subscribe namespace — real-time event subscriptions. */
+  subscribe;
+  /** Jetton namespace — fungible token queries. */
+  jetton;
+  /** NFT namespace — non-fungible token queries. */
+  nft;
+  /** DNS namespace — TON DNS domain resolution. */
+  dns;
+  /** ADNL namespace — low-level peer-to-peer messaging. */
+  adnl;
+  /** Network namespace — bridge status. */
+  network;
+  /** Overlay namespace — P2P pubsub overlay networks. */
+  overlay;
+  /** Wallet namespace — standard wallet contract queries. */
+  wallet;
+  /** SBT namespace — soulbound token queries. */
+  sbt;
+  /** Payment namespace — payment channel queries. */
+  payment;
+  constructor(options = {}) {
+    this.transport = options.transport ?? createTransport(options);
+    this.rpc = new RpcEngine(this.transport, {
+      requestTimeout: options.requestTimeout,
+      logger: options.logger
+    });
+    this.subscriptionManager = new SubscriptionManager();
+    this.rpc.setPushHandler((event, data) => {
+      this.subscriptionManager.handleEvent(event, data);
+    });
+    this.transport.on("open", () => this.emitClient("connected"));
+    this.transport.on("close", (code, reason) => {
+      this.subscriptionManager.clear();
+      this.emitClient("disconnected", code, reason);
+    });
+    this.transport.on("error", (err) => this.emitClient("error", err));
+    this.transport.on("stateChange", (newState, oldState) => {
+      this.emitClient("stateChange", newState, oldState);
+    });
+    this.dht = new DhtNamespace(this.rpc);
+    this.lite = new LiteNamespace(this.rpc, this.subscriptionManager);
+    this.subscribe = new SubscribeNamespace(this.rpc, this.subscriptionManager);
+    this.jetton = new JettonNamespace(this.rpc);
+    this.nft = new NftNamespace(this.rpc);
+    this.dns = new DnsNamespace(this.rpc);
+    this.adnl = new AdnlNamespace(this.rpc, this.subscriptionManager);
+    this.network = new NetworkNamespace(this.rpc);
+    this.overlay = new OverlayNamespace(this.rpc, this.subscriptionManager);
+    this.wallet = new WalletNamespace(this.rpc);
+    this.sbt = new SbtNamespace(this.rpc);
+    this.payment = new PaymentNamespace(this.rpc);
+  }
+  /** Open the transport connection. */
+  async connect() {
+    await this.transport.connect();
+  }
+  /** Gracefully close the transport connection. */
+  disconnect() {
+    this.transport.disconnect();
+  }
+  /** Whether the transport is currently connected. */
+  get isConnected() {
+    return this.transport.isConnected;
+  }
+  /** Current transport state. */
+  get state() {
+    return this.transport.state;
+  }
+  /** Permanently tear down the client, releasing all resources. */
+  destroy() {
+    this.rpc.destroy();
+    this.transport.destroy();
+    this.clientListeners.clear();
+  }
+  /** Register a client event listener. */
+  on(event, listener) {
+    if (!this.clientListeners.has(event)) {
+      this.clientListeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.clientListeners.get(event).add(listener);
+    return this;
+  }
+  /** Remove a client event listener. */
+  off(event, listener) {
+    this.clientListeners.get(event)?.delete(listener);
+    return this;
+  }
+  emitClient(event, ...args) {
+    const fns = this.clientListeners.get(event);
+    if (fns) for (const fn of fns) fn(...args);
+  }
+};
+
+exports.AbstractTransport = AbstractTransport;
+exports.AdnlNamespace = AdnlNamespace;
+exports.ConnectionClosedError = ConnectionClosedError;
+exports.ConnectionError = ConnectionError;
+exports.DhtNamespace = DhtNamespace;
+exports.DnsNamespace = DnsNamespace;
+exports.IpcTransport = IpcTransport;
+exports.JettonNamespace = JettonNamespace;
+exports.LiteNamespace = LiteNamespace;
+exports.NetworkNamespace = NetworkNamespace;
+exports.NftNamespace = NftNamespace;
+exports.OverlayNamespace = OverlayNamespace;
+exports.PaymentNamespace = PaymentNamespace;
+exports.RpcError = RpcError;
+exports.SbtNamespace = SbtNamespace;
+exports.SubscribeNamespace = SubscribeNamespace;
+exports.Subscription = Subscription;
+exports.TimeoutError = TimeoutError;
+exports.TransportState = TransportState;
+exports.ValidationError = ValidationError;
+exports.WalletNamespace = WalletNamespace;
+exports.Web3SocketsClient = Web3SocketsClient;
+exports.Web3SocketsError = Web3SocketsError;
+exports.WsTransport = WsTransport;
+exports.createTransport = createTransport;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map