@covalenthq/client-sdk 2.2.6 → 2.3.0

package/dist/cjs/index.js

@@ -1,6 +1,6 @@
 'use strict';
 
-var version = "2.2.6";
+var version = "2.3.0";
 
 const bigIntParser = (val) => {
     if (val === null || val === undefined) {
@@ -2410,6 +2410,1238 @@ class SecurityService {
     }
 }
 
+function extendedTypeof(val) {
+  if (val === null) {
+    return "null";
+  }
+  if (Array.isArray(val)) {
+    return "array";
+  }
+  return typeof val;
+}
+function isObject(val) {
+  return extendedTypeof(val) === "object";
+}
+function areGraphQLFormattedErrors(obj) {
+  return Array.isArray(obj) && // must be at least one error
+  obj.length > 0 && // error has at least a message
+  obj.every((ob) => "message" in ob);
+}
+function limitCloseReason(reason, whenTooLong) {
+  return reason.length < 124 ? reason : whenTooLong;
+}
+
+const GRAPHQL_TRANSPORT_WS_PROTOCOL = "graphql-transport-ws";
+var CloseCode = /* @__PURE__ */ ((CloseCode2) => {
+  CloseCode2[CloseCode2["InternalServerError"] = 4500] = "InternalServerError";
+  CloseCode2[CloseCode2["InternalClientError"] = 4005] = "InternalClientError";
+  CloseCode2[CloseCode2["BadRequest"] = 4400] = "BadRequest";
+  CloseCode2[CloseCode2["BadResponse"] = 4004] = "BadResponse";
+  CloseCode2[CloseCode2["Unauthorized"] = 4401] = "Unauthorized";
+  CloseCode2[CloseCode2["Forbidden"] = 4403] = "Forbidden";
+  CloseCode2[CloseCode2["SubprotocolNotAcceptable"] = 4406] = "SubprotocolNotAcceptable";
+  CloseCode2[CloseCode2["ConnectionInitialisationTimeout"] = 4408] = "ConnectionInitialisationTimeout";
+  CloseCode2[CloseCode2["ConnectionAcknowledgementTimeout"] = 4504] = "ConnectionAcknowledgementTimeout";
+  CloseCode2[CloseCode2["SubscriberAlreadyExists"] = 4409] = "SubscriberAlreadyExists";
+  CloseCode2[CloseCode2["TooManyInitialisationRequests"] = 4429] = "TooManyInitialisationRequests";
+  return CloseCode2;
+})(CloseCode || {});
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2["ConnectionInit"] = "connection_init";
+  MessageType2["ConnectionAck"] = "connection_ack";
+  MessageType2["Ping"] = "ping";
+  MessageType2["Pong"] = "pong";
+  MessageType2["Subscribe"] = "subscribe";
+  MessageType2["Next"] = "next";
+  MessageType2["Error"] = "error";
+  MessageType2["Complete"] = "complete";
+  return MessageType2;
+})(MessageType || {});
+function validateMessage(val) {
+  if (!isObject(val)) {
+    throw new Error(
+      `Message is expected to be an object, but got ${extendedTypeof(val)}`
+    );
+  }
+  if (!val.type) {
+    throw new Error(`Message is missing the 'type' property`);
+  }
+  if (typeof val.type !== "string") {
+    throw new Error(
+      `Message is expects the 'type' property to be a string, but got ${extendedTypeof(
+        val.type
+      )}`
+    );
+  }
+  switch (val.type) {
+    case "connection_init" /* ConnectionInit */:
+    case "connection_ack" /* ConnectionAck */:
+    case "ping" /* Ping */:
+    case "pong" /* Pong */: {
+      if (val.payload != null && !isObject(val.payload)) {
+        throw new Error(
+          `"${val.type}" message expects the 'payload' property to be an object or nullish or missing, but got "${val.payload}"`
+        );
+      }
+      break;
+    }
+    case "subscribe" /* Subscribe */: {
+      if (typeof val.id !== "string") {
+        throw new Error(
+          `"${val.type}" message expects the 'id' property to be a string, but got ${extendedTypeof(
+            val.id
+          )}`
+        );
+      }
+      if (!val.id) {
+        throw new Error(
+          `"${val.type}" message requires a non-empty 'id' property`
+        );
+      }
+      if (!isObject(val.payload)) {
+        throw new Error(
+          `"${val.type}" message expects the 'payload' property to be an object, but got ${extendedTypeof(
+            val.payload
+          )}`
+        );
+      }
+      if (typeof val.payload.query !== "string") {
+        throw new Error(
+          `"${val.type}" message payload expects the 'query' property to be a string, but got ${extendedTypeof(
+            val.payload.query
+          )}`
+        );
+      }
+      if (val.payload.variables != null && !isObject(val.payload.variables)) {
+        throw new Error(
+          `"${val.type}" message payload expects the 'variables' property to be a an object or nullish or missing, but got ${extendedTypeof(
+            val.payload.variables
+          )}`
+        );
+      }
+      if (val.payload.operationName != null && extendedTypeof(val.payload.operationName) !== "string") {
+        throw new Error(
+          `"${val.type}" message payload expects the 'operationName' property to be a string or nullish or missing, but got ${extendedTypeof(
+            val.payload.operationName
+          )}`
+        );
+      }
+      if (val.payload.extensions != null && !isObject(val.payload.extensions)) {
+        throw new Error(
+          `"${val.type}" message payload expects the 'extensions' property to be a an object or nullish or missing, but got ${extendedTypeof(
+            val.payload.extensions
+          )}`
+        );
+      }
+      break;
+    }
+    case "next" /* Next */: {
+      if (typeof val.id !== "string") {
+        throw new Error(
+          `"${val.type}" message expects the 'id' property to be a string, but got ${extendedTypeof(
+            val.id
+          )}`
+        );
+      }
+      if (!val.id) {
+        throw new Error(
+          `"${val.type}" message requires a non-empty 'id' property`
+        );
+      }
+      if (!isObject(val.payload)) {
+        throw new Error(
+          `"${val.type}" message expects the 'payload' property to be an object, but got ${extendedTypeof(
+            val.payload
+          )}`
+        );
+      }
+      break;
+    }
+    case "error" /* Error */: {
+      if (typeof val.id !== "string") {
+        throw new Error(
+          `"${val.type}" message expects the 'id' property to be a string, but got ${extendedTypeof(
+            val.id
+          )}`
+        );
+      }
+      if (!val.id) {
+        throw new Error(
+          `"${val.type}" message requires a non-empty 'id' property`
+        );
+      }
+      if (!areGraphQLFormattedErrors(val.payload)) {
+        throw new Error(
+          `"${val.type}" message expects the 'payload' property to be an array of GraphQL errors, but got ${JSON.stringify(
+            val.payload
+          )}`
+        );
+      }
+      break;
+    }
+    case "complete" /* Complete */: {
+      if (typeof val.id !== "string") {
+        throw new Error(
+          `"${val.type}" message expects the 'id' property to be a string, but got ${extendedTypeof(
+            val.id
+          )}`
+        );
+      }
+      if (!val.id) {
+        throw new Error(
+          `"${val.type}" message requires a non-empty 'id' property`
+        );
+      }
+      break;
+    }
+    default:
+      throw new Error(`Invalid message 'type' property "${val.type}"`);
+  }
+  return val;
+}
+function parseMessage(data, reviver) {
+  return validateMessage(
+    typeof data === "string" ? JSON.parse(data, reviver) : data
+  );
+}
+function stringifyMessage(msg, replacer) {
+  validateMessage(msg);
+  return JSON.stringify(msg, replacer);
+}
+
+function createClient(options) {
+  const {
+    url,
+    connectionParams,
+    lazy = true,
+    onNonLazyError = console.error,
+    lazyCloseTimeout: lazyCloseTimeoutMs = 0,
+    keepAlive = 0,
+    disablePong,
+    connectionAckWaitTimeout = 0,
+    retryAttempts = 5,
+    retryWait = async function randomisedExponentialBackoff(retries2) {
+      const retryDelaySeconds = Math.pow(2, retries2);
+      await new Promise(
+        (resolve) => setTimeout(
+          resolve,
+          retryDelaySeconds * 1e3 + // add random timeout from 300ms to 3s
+          Math.floor(Math.random() * (3e3 - 300) + 300)
+        )
+      );
+    },
+    shouldRetry = isLikeCloseEvent,
+    on,
+    webSocketImpl,
+    /**
+     * Generates a v4 UUID to be used as the ID using `Math`
+     * as the random number generator. Supply your own generator
+     * in case you need more uniqueness.
+     *
+     * Reference: https://gist.github.com/jed/982883
+     */
+    generateID = function generateUUID() {
+      return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+        const r = Math.random() * 16 | 0, v = c == "x" ? r : r & 3 | 8;
+        return v.toString(16);
+      });
+    },
+    jsonMessageReplacer: replacer,
+    jsonMessageReviver: reviver
+  } = options;
+  let ws;
+  if (webSocketImpl) {
+    if (!isWebSocket(webSocketImpl)) {
+      throw new Error("Invalid WebSocket implementation provided");
+    }
+    ws = webSocketImpl;
+  } else if (typeof WebSocket !== "undefined") {
+    ws = WebSocket;
+  } else if (typeof global !== "undefined") {
+    ws = global.WebSocket || // @ts-expect-error: Support more browsers
+    global.MozWebSocket;
+  } else if (typeof window !== "undefined") {
+    ws = window.WebSocket || // @ts-expect-error: Support more browsers
+    window.MozWebSocket;
+  }
+  if (!ws)
+    throw new Error(
+      "WebSocket implementation missing; on Node you can `import WebSocket from 'ws';` and pass `webSocketImpl: WebSocket` to `createClient`"
+    );
+  const WebSocketImpl = ws;
+  const emitter = (() => {
+    const message = /* @__PURE__ */ (() => {
+      const listeners2 = {};
+      return {
+        on(id, listener) {
+          listeners2[id] = listener;
+          return () => {
+            delete listeners2[id];
+          };
+        },
+        emit(message2) {
+          if ("id" in message2) listeners2[message2.id]?.(message2);
+        }
+      };
+    })();
+    const listeners = {
+      connecting: on?.connecting ? [on.connecting] : [],
+      opened: on?.opened ? [on.opened] : [],
+      connected: on?.connected ? [on.connected] : [],
+      ping: on?.ping ? [on.ping] : [],
+      pong: on?.pong ? [on.pong] : [],
+      message: on?.message ? [message.emit, on.message] : [message.emit],
+      closed: on?.closed ? [on.closed] : [],
+      error: on?.error ? [on.error] : []
+    };
+    return {
+      onMessage: message.on,
+      on(event, listener) {
+        const l = listeners[event];
+        l.push(listener);
+        return () => {
+          l.splice(l.indexOf(listener), 1);
+        };
+      },
+      emit(event, ...args) {
+        for (const listener of [...listeners[event]]) {
+          listener(...args);
+        }
+      }
+    };
+  })();
+  function errorOrClosed(cb) {
+    const listening = [
+      // errors are fatal and more critical than close events, throw them first
+      emitter.on("error", (err) => {
+        listening.forEach((unlisten) => unlisten());
+        cb(err);
+      }),
+      // closes can be graceful and not fatal, throw them second (if error didnt throw)
+      emitter.on("closed", (event) => {
+        listening.forEach((unlisten) => unlisten());
+        cb(event);
+      })
+    ];
+  }
+  let connecting, locks = 0, lazyCloseTimeout, retrying = false, retries = 0, disposed = false;
+  async function connect() {
+    clearTimeout(lazyCloseTimeout);
+    const [socket, throwOnClose] = await (connecting ?? (connecting = new Promise(
+      (connected, denied) => (async () => {
+        if (retrying) {
+          await retryWait(retries);
+          if (!locks) {
+            connecting = undefined;
+            return denied({ code: 1e3, reason: "All Subscriptions Gone" });
+          }
+          retries++;
+        }
+        emitter.emit("connecting", retrying);
+        const socket2 = new WebSocketImpl(
+          typeof url === "function" ? await url() : url,
+          GRAPHQL_TRANSPORT_WS_PROTOCOL
+        );
+        let connectionAckTimeout, queuedPing;
+        function enqueuePing() {
+          if (isFinite(keepAlive) && keepAlive > 0) {
+            clearTimeout(queuedPing);
+            queuedPing = setTimeout(() => {
+              if (socket2.readyState === WebSocketImpl.OPEN) {
+                socket2.send(stringifyMessage({ type: MessageType.Ping }));
+                emitter.emit("ping", false, undefined);
+              }
+            }, keepAlive);
+          }
+        }
+        errorOrClosed((errOrEvent) => {
+          connecting = undefined;
+          clearTimeout(connectionAckTimeout);
+          clearTimeout(queuedPing);
+          denied(errOrEvent);
+          if (errOrEvent instanceof TerminatedCloseEvent) {
+            socket2.close(4499, "Terminated");
+            socket2.onerror = null;
+            socket2.onclose = null;
+          }
+        });
+        socket2.onerror = (err) => emitter.emit("error", err);
+        socket2.onclose = (event) => emitter.emit("closed", event);
+        socket2.onopen = async () => {
+          try {
+            emitter.emit("opened", socket2);
+            const payload = typeof connectionParams === "function" ? await connectionParams() : connectionParams;
+            if (socket2.readyState !== WebSocketImpl.OPEN) return;
+            socket2.send(
+              stringifyMessage(
+                payload ? {
+                  type: MessageType.ConnectionInit,
+                  payload
+                } : {
+                  type: MessageType.ConnectionInit
+                  // payload is completely absent if not provided
+                },
+                replacer
+              )
+            );
+            if (isFinite(connectionAckWaitTimeout) && connectionAckWaitTimeout > 0) {
+              connectionAckTimeout = setTimeout(() => {
+                socket2.close(
+                  CloseCode.ConnectionAcknowledgementTimeout,
+                  "Connection acknowledgement timeout"
+                );
+              }, connectionAckWaitTimeout);
+            }
+            enqueuePing();
+          } catch (err) {
+            emitter.emit("error", err);
+            socket2.close(
+              CloseCode.InternalClientError,
+              limitCloseReason(
+                err instanceof Error ? err.message : String(err),
+                "Internal client error"
+              )
+            );
+          }
+        };
+        let acknowledged = false;
+        socket2.onmessage = ({ data }) => {
+          try {
+            const message = parseMessage(data, reviver);
+            emitter.emit("message", message);
+            if (message.type === "ping" || message.type === "pong") {
+              emitter.emit(message.type, true, message.payload);
+              if (message.type === "pong") {
+                enqueuePing();
+              } else if (!disablePong) {
+                socket2.send(
+                  stringifyMessage(
+                    message.payload ? {
+                      type: MessageType.Pong,
+                      payload: message.payload
+                    } : {
+                      type: MessageType.Pong
+                      // payload is completely absent if not provided
+                    }
+                  )
+                );
+                emitter.emit("pong", false, message.payload);
+              }
+              return;
+            }
+            if (acknowledged) return;
+            if (message.type !== MessageType.ConnectionAck)
+              throw new Error(
+                `First message cannot be of type ${message.type}`
+              );
+            clearTimeout(connectionAckTimeout);
+            acknowledged = true;
+            emitter.emit("connected", socket2, message.payload, retrying);
+            retrying = false;
+            retries = 0;
+            connected([
+              socket2,
+              new Promise((_, reject) => errorOrClosed(reject))
+            ]);
+          } catch (err) {
+            socket2.onmessage = null;
+            emitter.emit("error", err);
+            socket2.close(
+              CloseCode.BadResponse,
+              limitCloseReason(
+                err instanceof Error ? err.message : String(err),
+                "Bad response"
+              )
+            );
+          }
+        };
+      })()
+    )));
+    if (socket.readyState === WebSocketImpl.CLOSING) await throwOnClose;
+    let release = () => {
+    };
+    const released = new Promise((resolve) => release = resolve);
+    return [
+      socket,
+      release,
+      Promise.race([
+        // wait for
+        released.then(() => {
+          if (!locks) {
+            const complete = () => socket.close(1e3, "Normal Closure");
+            if (isFinite(lazyCloseTimeoutMs) && lazyCloseTimeoutMs > 0) {
+              lazyCloseTimeout = setTimeout(() => {
+                if (socket.readyState === WebSocketImpl.OPEN) complete();
+              }, lazyCloseTimeoutMs);
+            } else {
+              complete();
+            }
+          }
+        }),
+        // or
+        throwOnClose
+      ])
+    ];
+  }
+  function shouldRetryConnectOrThrow(errOrCloseEvent) {
+    if (isLikeCloseEvent(errOrCloseEvent) && (isFatalInternalCloseCode(errOrCloseEvent.code) || [
+      CloseCode.InternalServerError,
+      CloseCode.InternalClientError,
+      CloseCode.BadRequest,
+      CloseCode.BadResponse,
+      CloseCode.Unauthorized,
+      // CloseCode.Forbidden, might grant access out after retry
+      CloseCode.SubprotocolNotAcceptable,
+      // CloseCode.ConnectionInitialisationTimeout, might not time out after retry
+      // CloseCode.ConnectionAcknowledgementTimeout, might not time out after retry
+      CloseCode.SubscriberAlreadyExists,
+      CloseCode.TooManyInitialisationRequests
+      // 4499, // Terminated, probably because the socket froze, we want to retry
+    ].includes(errOrCloseEvent.code)))
+      throw errOrCloseEvent;
+    if (disposed) return false;
+    if (isLikeCloseEvent(errOrCloseEvent) && errOrCloseEvent.code === 1e3)
+      return locks > 0;
+    if (!retryAttempts || retries >= retryAttempts) throw errOrCloseEvent;
+    if (!shouldRetry(errOrCloseEvent)) throw errOrCloseEvent;
+    return retrying = true;
+  }
+  if (!lazy) {
+    (async () => {
+      locks++;
+      for (; ; ) {
+        try {
+          const [, , throwOnClose] = await connect();
+          await throwOnClose;
+        } catch (errOrCloseEvent) {
+          try {
+            if (!shouldRetryConnectOrThrow(errOrCloseEvent)) return;
+          } catch (errOrCloseEvent2) {
+            return onNonLazyError?.(errOrCloseEvent2);
+          }
+        }
+      }
+    })();
+  }
+  function subscribe(payload, sink) {
+    const id = generateID(payload);
+    let done = false, errored = false, releaser = () => {
+      locks--;
+      done = true;
+    };
+    (async () => {
+      locks++;
+      for (; ; ) {
+        try {
+          const [socket, release, waitForReleaseOrThrowOnClose] = await connect();
+          if (done) return release();
+          const unlisten = emitter.onMessage(id, (message) => {
+            switch (message.type) {
+              case MessageType.Next: {
+                sink.next(message.payload);
+                return;
+              }
+              case MessageType.Error: {
+                errored = true, done = true;
+                sink.error(message.payload);
+                releaser();
+                return;
+              }
+              case MessageType.Complete: {
+                done = true;
+                releaser();
+                return;
+              }
+            }
+          });
+          socket.send(
+            stringifyMessage(
+              {
+                id,
+                type: MessageType.Subscribe,
+                payload
+              },
+              replacer
+            )
+          );
+          releaser = () => {
+            if (!done && socket.readyState === WebSocketImpl.OPEN)
+              socket.send(
+                stringifyMessage(
+                  {
+                    id,
+                    type: MessageType.Complete
+                  },
+                  replacer
+                )
+              );
+            locks--;
+            done = true;
+            release();
+          };
+          await waitForReleaseOrThrowOnClose.finally(unlisten);
+          return;
+        } catch (errOrCloseEvent) {
+          if (!shouldRetryConnectOrThrow(errOrCloseEvent)) return;
+        }
+      }
+    })().then(() => {
+      if (!errored) sink.complete();
+    }).catch((err) => {
+      sink.error(err);
+    });
+    return () => {
+      if (!done) releaser();
+    };
+  }
+  return {
+    on: emitter.on,
+    subscribe,
+    iterate(request) {
+      const pending = [];
+      const deferred = {
+        done: false,
+        error: null,
+        resolve: () => {
+        }
+      };
+      const dispose = subscribe(request, {
+        next(val) {
+          pending.push(val);
+          deferred.resolve();
+        },
+        error(err) {
+          deferred.done = true;
+          deferred.error = err;
+          deferred.resolve();
+        },
+        complete() {
+          deferred.done = true;
+          deferred.resolve();
+        }
+      });
+      const iterator = async function* iterator2() {
+        for (; ; ) {
+          if (!pending.length) {
+            await new Promise((resolve) => deferred.resolve = resolve);
+          }
+          while (pending.length) {
+            yield pending.shift();
+          }
+          if (deferred.error) {
+            throw deferred.error;
+          }
+          if (deferred.done) {
+            return;
+          }
+        }
+      }();
+      iterator.throw = async (err) => {
+        if (!deferred.done) {
+          deferred.done = true;
+          deferred.error = err;
+          deferred.resolve();
+        }
+        return { done: true, value: undefined };
+      };
+      iterator.return = async () => {
+        dispose();
+        return { done: true, value: undefined };
+      };
+      return iterator;
+    },
+    async dispose() {
+      disposed = true;
+      if (connecting) {
+        const [socket] = await connecting;
+        socket.close(1e3, "Normal Closure");
+      }
+    },
+    terminate() {
+      if (connecting) {
+        emitter.emit("closed", new TerminatedCloseEvent());
+      }
+    }
+  };
+}
+class TerminatedCloseEvent extends Error {
+  name = "TerminatedCloseEvent";
+  message = "4499: Terminated";
+  code = 4499;
+  reason = "Terminated";
+  wasClean = false;
+}
+function isLikeCloseEvent(val) {
+  return isObject(val) && "code" in val && "reason" in val;
+}
+function isFatalInternalCloseCode(code) {
+  if ([
+    1e3,
+    // Normal Closure is not an erroneous close code
+    1001,
+    // Going Away
+    1006,
+    // Abnormal Closure
+    1005,
+    // No Status Received
+    1012,
+    // Service Restart
+    1013,
+    // Try Again Later
+    1014
+    // Bad Gateway
+  ].includes(code))
+    return false;
+  return code >= 1e3 && code <= 1999;
+}
+function isWebSocket(val) {
+  return typeof val === "function" && "constructor" in val && "CLOSED" in val && "CLOSING" in val && "CONNECTING" in val && "OPEN" in val;
+}
+
+/**
+ * Streaming API Service
+ *
+ */
+class StreamingService {
+    constructor(apiKey, config) {
+        this.defaultConfig = {
+            shouldRetry: (retries) => retries < 5,
+            maxReconnectAttempts: 5,
+            onConnecting: () => {
+                console.info("StreamingService Connection Connecting...");
+            },
+            onOpened: () => {
+                console.info("StreamingService Connection Established Successfully!");
+            },
+            onClosed: () => {
+                console.info("StreamingService Connection Closed");
+            },
+            onError: (err) => {
+                console.error("StreamingService Connection Error:", err);
+            },
+        };
+        StreamingWebSocketClient.configure(apiKey, {
+            ...this.defaultConfig,
+            ...config,
+        });
+        StreamingWebSocketClient.getInstance();
+    }
+    /**
+     * Initialize the streaming connection
+     */
+    getClient() {
+        return StreamingWebSocketClient.getClient();
+    }
+    /**
+     * Disconnect from the streaming service
+     */
+    async disconnect() {
+        await StreamingWebSocketClient.disconnect();
+    }
+    /**
+     * Check if the client is connected
+     */
+    get isConnected() {
+        return StreamingWebSocketClient.isConnected;
+    }
+    /**
+     * Subscribe to a custom GraphQL subscription
+     * This allows for advanced usage and future extensibility
+     *
+     * @param query - GraphQL subscription query
+     * @param variables - Query variables
+     * @param callbacks - Subscription callbacks
+     * @returns Unsubscribe function
+     */
+    rawQuery(query, variables, callbacks) {
+        const client = StreamingWebSocketClient.getClient();
+        return client.subscribe({
+            query,
+            variables,
+        }, {
+            next: (data) => callbacks.next(data),
+            error: callbacks.error || (() => { }),
+            complete: callbacks.complete || (() => { }),
+        });
+    }
+    /**
+     * Subscribe to OHLCV data for specific pairs
+     *
+     * @param params - Parameters for the OHLCV pairs stream
+     * @param callbacks - Subscription callbacks
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = streamingService.subscribeToOHLCVPairs(
+     *   {
+     *     chain_name: StreamingChain.BASE_MAINNET,
+     *     pair_addresses: ["0x9c087Eb773291e50CF6c6a90ef0F4500e349B903"],
+     *     interval: StreamingInterval.ONE_MINUTE,
+     *     timeframe: StreamingTimeframe.ONE_HOUR
+     *   },
+     *   {
+     *     next: (data) => console.log("OHLCV Data:", data),
+     *     error: (err) => console.error("Error:", err),
+     *     complete: () => console.log("Stream completed")
+     *   }
+     * );
+     * ```
+     */
+    subscribeToOHLCVPairs(params, callbacks) {
+        // Format the pair addresses array for the query
+        const pairAddressesString = params.pair_addresses
+            .map((addr) => `"${addr}"`)
+            .join(", ");
+        const query = `
+      subscription {
+        ohlcvCandlesForPair(
+          chain_name: ${params.chain_name}
+          pair_addresses: [${pairAddressesString}]
+          interval: ${params.interval}
+          timeframe: ${params.timeframe}
+          ${params.limit ? `limit: ${params.limit}` : ""}
+        ) {
+          open
+          high
+          low
+          close
+          volume
+          price_usd
+          volume_usd
+          chain_name
+          pair_address
+          interval
+          timeframe
+          timestamp
+          base_token {
+            contract_name
+            contract_address
+            contract_decimals
+            contract_ticker_symbol
+          }
+          quote_token {
+            contract_name
+            contract_address
+            contract_decimals
+            contract_ticker_symbol
+          }
+        }
+      }
+    `;
+        const client = StreamingWebSocketClient.getClient();
+        return client.subscribe({
+            query,
+        }, {
+            next: (data) => {
+                if (data.data) {
+                    const ohlcvData = data.data.ohlcvCandlesForPair;
+                    if (ohlcvData) {
+                        callbacks.next(ohlcvData);
+                    }
+                }
+                else if (data.errors) {
+                    callbacks.error?.(data.errors);
+                }
+            },
+            error: callbacks.error || (() => { }),
+            complete: callbacks.complete || (() => { }),
+        });
+    }
+    /**
+     * Subscribe to OHLCV data for specific tokens
+     *
+     * @param params - Parameters for the OHLCV tokens stream
+     * @param callbacks - Subscription callbacks
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = streamingService.subscribeToOHLCVTokens(
+     *   {
+     *     chain_name: StreamingChain.BASE_MAINNET,
+     *     token_addresses: ["0x4B6104755AfB5Da4581B81C552DA3A25608c73B8"],
+     *     interval: StreamingInterval.ONE_MINUTE,
+     *     timeframe: StreamingTimeframe.ONE_HOUR
+     *   },
+     *   {
+     *     next: (data) => console.log("OHLCV Token Data:", data),
+     *     error: (err) => console.error("Error:", err),
+     *     complete: () => console.log("Stream completed")
+     *   }
+     * );
+     * ```
+     */
+    subscribeToOHLCVTokens(params, callbacks) {
+        // Format the token addresses array for the query
+        const tokenAddressesString = params.token_addresses
+            .map((addr) => `"${addr}"`)
+            .join(", ");
+        const query = `
+      subscription {
+        ohlcvCandlesForToken(
+          chain_name: ${params.chain_name}
+          token_addresses: [${tokenAddressesString}]
+          interval: ${params.interval}
+          timeframe: ${params.timeframe}
+          ${params.limit ? `limit: ${params.limit}` : ""}
+        ) {
+          chain_name
+          pair_address
+          interval
+          timeframe
+          timestamp
+          open
+          high
+          low
+          close
+          volume
+          volume_usd
+          quote_rate
+          quote_rate_usd
+          base_token {
+            contract_name
+            contract_address
+            contract_decimals
+            contract_ticker_symbol
+          }
+          quote_token {
+            contract_name
+            contract_address
+            contract_decimals
+            contract_ticker_symbol
+          }
+        }
+      }
+    `;
+        const client = StreamingWebSocketClient.getClient();
+        return client.subscribe({
+            query,
+        }, {
+            next: (data) => {
+                if (data.data) {
+                    const ohlcvData = data.data.ohlcvCandlesForToken;
+                    if (ohlcvData) {
+                        callbacks.next(ohlcvData);
+                    }
+                }
+                else if (data.errors) {
+                    callbacks.error?.(data.errors);
+                }
+            },
+            error: callbacks.error || (() => { }),
+            complete: callbacks.complete || (() => { }),
+        });
+    }
+    /**
+     * Subscribe to new DEX pairs created on supported decentralized exchanges
+     *
+     * @param params - Parameters for the new pairs stream
+     * @param callbacks - Subscription callbacks
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = streamingService.subscribeToNewPairs(
+     *   {
+     *     chain_name: StreamingChain.BASE_MAINNET,
+     *     protocols: [StreamingProtocol.UNISWAP_V2, StreamingProtocol.UNISWAP_V3]
+     *   },
+     *   {
+     *     next: (data) => console.log("New Pairs:", data),
+     *     error: (err) => console.error("Error:", err),
+     *     complete: () => console.log("Stream completed")
+     *   }
+     * );
+     * ```
+     */
+    subscribeToNewPairs(params, callbacks) {
+        const query = `
+      subscription {
+        newPairs(
+          chain_name: ${params.chain_name},
+          protocols: [${params.protocols.join(", ")}]
+        ) {
+          chain_name
+          protocol
+          protocol_version
+          pair_address
+          deployer_address
+          tx_hash
+          block_signed_at
+          liquidity
+          supply
+          market_cap
+          event_name
+          quote_rate
+          quote_rate_usd
+          base_token_metadata {
+            contract_address
+            contract_decimals
+            contract_name
+            contract_ticker_symbol
+          }
+          pair_metadata {
+            contract_address
+            contract_decimals
+            contract_name
+            contract_ticker_symbol
+          }
+          quote_token_metadata {
+            contract_address
+            contract_decimals
+            contract_name
+            contract_ticker_symbol
+          }
+          prices {
+            last_5m
+            last_1hr
+            last_6hr
+            last_24hr
+          }
+          swaps {
+            last_5m
+            last_1hr
+            last_6hr
+            last_24hr
+          }
+        }
+      }
+    `;
+        const client = StreamingWebSocketClient.getClient();
+        return client.subscribe({
+            query,
+        }, {
+            next: (data) => {
+                if (data.data) {
+                    const newPairsData = data.data.newPairs;
+                    if (newPairsData) {
+                        callbacks.next(newPairsData);
+                    }
+                }
+                else if (data.errors) {
+                    callbacks.error?.(data.errors);
+                }
+            },
+            error: callbacks.error || (() => { }),
+            complete: callbacks.complete || (() => { }),
+        });
+    }
+    /**
+     * Subscribe to real-time token balance updates for a specific wallet address
+     *
+     * @param params - Parameters for the token balances stream
+     * @param callbacks - Subscription callbacks
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = streamingService.subscribeToTokenBalances(
+     *   {
+     *     chain_name: StreamingChain.BASE_MAINNET,
+     *     wallet_address: "0x198ef79f1f515f02dfe9e3115ed9fc07183f02fc"
+     *   },
+     *   {
+     *     next: (data) => console.log("Token Balances:", data),
+     *     error: (err) => console.error("Error:", err),
+     *     complete: () => console.log("Stream completed")
+     *   }
+     * );
+     * ```
+     */
+    subscribeToTokenBalances(params, callbacks) {
+        const query = `
+      subscription {
+        tokenBalancesForWalletAddress(
+          chain_name: ${params.chain_name},
+          wallet_address: "${params.wallet_address}"
+        ) {
+          wallet_address
+          chain_name
+          last_block
+          items {
+            balance
+            balance_pretty
+            quote_rate_usd
+            quote_usd
+            metadata {
+              contract_name
+              contract_address
+              contract_decimals
+              contract_ticker_symbol
+            }
+            is_native
+          }
+        }
+      }
+    `;
+        const client = StreamingWebSocketClient.getClient();
+        return client.subscribe({
+            query,
+        }, {
+            next: (data) => {
+                if (data.data) {
+                    const tokenBalancesData = data.data.tokenBalancesForWalletAddress;
+                    if (tokenBalancesData) {
+                        callbacks.next(tokenBalancesData);
+                    }
+                }
+                else if (data.errors) {
+                    callbacks.error?.(data.errors);
+                }
+            },
+            error: callbacks.error || (() => { }),
+            complete: callbacks.complete || (() => { }),
+        });
+    }
+    /**
+     * Subscribe to real-time wallet activity including transactions, token transfers, and smart contract interactions
+     *
+     * @param params - Parameters for the wallet activity stream
+     * @param callbacks - Subscription callbacks
+     * @returns Unsubscribe function
+     *
+     * @example
+     * ```typescript
+     * const unsubscribe = streamingService.subscribeToWalletActivity(
+     *   {
+     *     chain_name: StreamingChain.BASE_MAINNET,
+     *     wallet_addresses: ["0x198ef79f1f515f02dfe9e3115ed9fc07183f02fc"]
+     *   },
+     *   {
+     *     next: (data) => console.log("Wallet Activity:", data),
+     *     error: (err) => console.error("Error:", err),
+     *     complete: () => console.log("Stream completed")
+     *   }
+     * );
+     * ```
+     */
+    subscribeToWalletActivity(params, callbacks) {
+        // Format the wallet addresses array for the query
+        const walletAddressesString = params.wallet_addresses
+            .map((addr) => `"${addr}"`)
+            .join(", ");
+        const query = `
+      subscription {
+        walletTxs(
+          chain_name: ${params.chain_name},
+          wallet_addresses: [${walletAddressesString}]
+        ) {
+          tx_hash
+          from_address
+          to_address
+          value
+          chain_name
+          block_signed_at
+          block_height
+          block_hash
+          miner_address
+          gas_used
+          tx_offset
+          successful
+          decoded_type
+          logs {
+            emitter_address
+            log_offset
+            data
+            topics
+          }
+        }
+      }
+    `;
+        const client = StreamingWebSocketClient.getClient();
+        return client.subscribe({
+            query,
+        }, {
+            next: (data) => {
+                if (data.data) {
+                    const walletActivityData = data.data.walletTxs;
+                    if (walletActivityData) {
+                        callbacks.next(walletActivityData);
+                    }
+                }
+                else if (data.errors) {
+                    callbacks.error?.(data.errors);
+                }
+            },
+            error: callbacks.error || (() => { }),
+            complete: callbacks.complete || (() => { }),
+        });
+    }
+}
+/**
+ * Singleton WebSocket Client for GoldRush Streaming
+ *
+ */
+class StreamingWebSocketClient {
+    constructor() { }
+    static getInstance() {
+        if (!StreamingWebSocketClient.instance) {
+            StreamingWebSocketClient.instance = new StreamingWebSocketClient();
+        }
+        return StreamingWebSocketClient.instance;
+    }
+    static configure(apiKey, config) {
+        StreamingWebSocketClient.apiKey = apiKey;
+        StreamingWebSocketClient.config = config;
+    }
+    static getClient() {
+        if (!StreamingWebSocketClient.client ||
+            !StreamingWebSocketClient.connected) {
+            StreamingWebSocketClient.connect();
+        }
+        return StreamingWebSocketClient.client;
+    }
+    static connect() {
+        if (StreamingWebSocketClient.client)
+            return;
+        StreamingWebSocketClient.client = createClient({
+            url: "wss://gr-staging.streaming.covalenthq.com/graphql",
+            connectionParams: {
+                GOLDRUSH_API_KEY: StreamingWebSocketClient.apiKey,
+            },
+            shouldRetry: () => StreamingWebSocketClient.config.shouldRetry(StreamingWebSocketClient.reconnectAttempts),
+            on: {
+                connecting: () => {
+                    StreamingWebSocketClient.config.onConnecting();
+                },
+                opened: () => {
+                    StreamingWebSocketClient.config.onOpened();
+                    StreamingWebSocketClient.reconnectAttempts = 0;
+                    StreamingWebSocketClient.connected = true;
+                },
+                closed: () => {
+                    StreamingWebSocketClient.config.onClosed();
+                    StreamingWebSocketClient.connected = false;
+                },
+                error: (err) => {
+                    StreamingWebSocketClient.config.onError(err);
+                    StreamingWebSocketClient.connected = false;
+                },
+            },
+        });
+    }
+    static get isConnected() {
+        return StreamingWebSocketClient.connected;
+    }
+    static async disconnect() {
+        if (!StreamingWebSocketClient.client)
+            return;
+        if (!StreamingWebSocketClient.connected)
+            return;
+        // * INFO: Is a fire & forget
+        await StreamingWebSocketClient.client.dispose();
+        StreamingWebSocketClient.client = null;
+        StreamingWebSocketClient.connected = false;
+        // * INFO: Wait for the client to disconnect
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+    }
+}
+StreamingWebSocketClient.instance = null;
+StreamingWebSocketClient.client = null;
+StreamingWebSocketClient.connected = false;
+StreamingWebSocketClient.reconnectAttempts = 0;
+
 /**
  * Transactions API
  *
@@ -3219,7 +4451,7 @@ const isValidApiKey = (apiKey) => {
  * GoldRushClient Class
  */
 class GoldRushClient {
-    constructor(apiKey, settings = {}) {
+    constructor(apiKey, settings = {}, streamingConfig = {}) {
         this.userAgent = `com.covalenthq.sdk.typescript/${version}`;
         const validKey = isValidApiKey(apiKey);
         if (!validKey) {
@@ -3244,6 +4476,7 @@ class GoldRushClient {
         this.PricingService = new PricingService(execution);
         this.SecurityService = new SecurityService(execution);
         this.TransactionService = new TransactionService(execution);
+        this.StreamingService = new StreamingService(apiKey, streamingConfig);
     }
 }
 
@@ -4422,6 +5655,45 @@ const timestampParser = (timestamp, type) => {
     }
 };
 
+/**
+ * Common enums and types for Streaming API
+ */
+exports.StreamingChain = void 0;
+(function (StreamingChain) {
+    StreamingChain["BASE_MAINNET"] = "BASE_MAINNET";
+    StreamingChain["ETH_MAINNET"] = "ETH_MAINNET";
+    StreamingChain["BSC_MAINNET"] = "BSC_MAINNET";
+})(exports.StreamingChain || (exports.StreamingChain = {}));
+exports.StreamingInterval = void 0;
+(function (StreamingInterval) {
+    StreamingInterval["FIFTEEN_SECONDS"] = "FIFTEEN_SECONDS";
+    StreamingInterval["THIRTY_SECONDS"] = "THIRTY_SECONDS";
+    StreamingInterval["ONE_MINUTE"] = "ONE_MINUTE";
+    StreamingInterval["FIVE_MINUTES"] = "FIVE_MINUTES";
+    StreamingInterval["FIFTEEN_MINUTES"] = "FIFTEEN_MINUTES";
+    StreamingInterval["THIRTY_MINUTES"] = "THIRTY_MINUTES";
+    StreamingInterval["ONE_HOUR"] = "ONE_HOUR";
+    StreamingInterval["FOUR_HOURS"] = "FOUR_HOURS";
+    StreamingInterval["ONE_DAY"] = "ONE_DAY";
+})(exports.StreamingInterval || (exports.StreamingInterval = {}));
+exports.StreamingTimeframe = void 0;
+(function (StreamingTimeframe) {
+    StreamingTimeframe["ONE_MINUTE"] = "ONE_MINUTE";
+    StreamingTimeframe["FIVE_MINUTES"] = "FIVE_MINUTES";
+    StreamingTimeframe["FIFTEEN_MINUTES"] = "FIFTEEN_MINUTES";
+    StreamingTimeframe["THIRTY_MINUTES"] = "THIRTY_MINUTES";
+    StreamingTimeframe["ONE_HOUR"] = "ONE_HOUR";
+    StreamingTimeframe["FOUR_HOURS"] = "FOUR_HOURS";
+    StreamingTimeframe["ONE_DAY"] = "ONE_DAY";
+    StreamingTimeframe["ONE_WEEK"] = "ONE_WEEK";
+    StreamingTimeframe["ONE_MONTH"] = "ONE_MONTH";
+})(exports.StreamingTimeframe || (exports.StreamingTimeframe = {}));
+exports.StreamingProtocol = void 0;
+(function (StreamingProtocol) {
+    StreamingProtocol["UNISWAP_V2"] = "UNISWAP_V2";
+    StreamingProtocol["UNISWAP_V3"] = "UNISWAP_V3";
+})(exports.StreamingProtocol || (exports.StreamingProtocol = {}));
+
 exports.GoldRushClient = GoldRushClient;
 exports.bigIntParser = bigIntParser;
 exports.calculatePrettyBalance = calculatePrettyBalance;