@chainstream-io/sdk 0.1.25 → 0.2.1

package/dist/chainstream.mjs

@@ -0,0 +1,2234 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/chainstream.ts
+import { EventSourcePolyfill } from "event-source-polyfill";
+
+// src/openapi-client/chainstreamApiClient.ts
+import Axios from "axios";
+import axiosRetry, { exponentialDelay } from "axios-retry";
+var axiosInstance;
+var currentOptions = void 0;
+var configure = (options) => {
+  const baseURL = options.basePath || "https://api-dex.chainstream.io";
+  currentOptions = {
+    ...options,
+    basePath: baseURL
+  };
+  axiosInstance = Axios.create({
+    baseURL
+  });
+  axiosRetry(axiosInstance, {
+    retryDelay: exponentialDelay
+  });
+  axiosInstance.interceptors.request.use(async (config) => {
+    const token = typeof options.accessToken === "string" ? options.accessToken : await options.accessToken.getToken();
+    config.headers.Authorization = `Bearer ${token}`;
+    config.headers["Content-Type"] = "application/json";
+    if (options.source) {
+      config.headers["X-Source"] = options.source;
+    }
+    if (options.sourceVersion) {
+      config.headers["X-Source-Version"] = options.sourceVersion;
+    }
+    if (options.debugging) {
+      console.log(`[ChainStream API] ${config.method?.toUpperCase()} ${config.url}`);
+    }
+    return config;
+  });
+  if (options.debugging) {
+    axiosInstance.interceptors.response.use(
+      (response) => {
+        console.log(`[ChainStream API] Response:`, response.status, response.data);
+        return response;
+      },
+      (error) => {
+        console.error(`[ChainStream API] Error:`, error.response?.status, error.response?.data);
+        return Promise.reject(error);
+      }
+    );
+  }
+};
+var addIdempotencyKey = (config, idempotencyKey) => {
+  if (!idempotencyKey) {
+    return config;
+  }
+  return {
+    ...config,
+    headers: {
+      ...config.headers || {},
+      "X-Idempotency-Key": idempotencyKey
+    }
+  };
+};
+var chainstreamApiClient = async (config, idempotencyKey) => {
+  if (!axiosInstance) {
+    throw new Error("ChainStream API client not configured. Call configure() first.");
+  }
+  if (!config.url || config.url === "") {
+    throw new Error("AxiosRequestConfig URL is empty.");
+  }
+  if (!config.method || config.method === "") {
+    throw new Error("AxiosRequestConfig method is empty.");
+  }
+  const configWithIdempotencyKey = addIdempotencyKey(config, idempotencyKey);
+  try {
+    const response = await axiosInstance(configWithIdempotencyKey);
+    return response.data;
+  } catch (error) {
+    if (Axios.isAxiosError(error) && error.response) {
+      const statusCode = error.response.status;
+      const responseData = error.response.data;
+      throw new Error(
+        `ChainStream API error (${statusCode}): ${typeof responseData === "string" ? responseData : JSON.stringify(responseData)}`
+      );
+    }
+    throw error;
+  }
+};
+
+// src/stream/stream.ts
+import { Centrifuge } from "@chainstream-io/centrifuge";
+
+// src/stream/stream.fields.ts
+var CEL_FIELD_MAPPINGS = {
+  // Wallet balance subscription fields
+  subscribeWalletBalance: {
+    walletAddress: "a",
+    tokenAddress: "ta",
+    tokenPriceInUsd: "tpiu",
+    balance: "b",
+    timestamp: "t"
+  },
+  // Token candles subscription fields
+  subscribeTokenCandles: {
+    open: "o",
+    close: "c",
+    high: "h",
+    low: "l",
+    volume: "v",
+    resolution: "r",
+    time: "t",
+    number: "n"
+  },
+  // Token stats subscription fields
+  subscribeTokenStats: {
+    address: "a",
+    timestamp: "t",
+    buys1m: "b1m",
+    sells1m: "s1m",
+    buyers1m: "be1m",
+    sellers1m: "se1m",
+    buyVolumeInUsd1m: "bviu1m",
+    sellVolumeInUsd1m: "sviu1m",
+    price1m: "p1m",
+    openInUsd1m: "oiu1m",
+    closeInUsd1m: "ciu1m",
+    buys5m: "b5m",
+    sells5m: "s5m",
+    buyers5m: "be5m",
+    sellers5m: "se5m",
+    buyVolumeInUsd5m: "bviu5m",
+    sellVolumeInUsd5m: "sviu5m",
+    price5m: "p5m",
+    openInUsd5m: "oiu5m",
+    closeInUsd5m: "ciu5m",
+    buys15m: "b15m",
+    sells15m: "s15m",
+    buyers15m: "be15m",
+    sellers15m: "se15m",
+    buyVolumeInUsd15m: "bviu15m",
+    sellVolumeInUsd15m: "sviu15m",
+    price15m: "p15m",
+    openInUsd15m: "oiu15m",
+    closeInUsd15m: "ciu15m",
+    buys30m: "b30m",
+    sells30m: "s30m",
+    buyers30m: "be30m",
+    sellers30m: "se30m",
+    buyVolumeInUsd30m: "bviu30m",
+    sellVolumeInUsd30m: "sviu30m",
+    price30m: "p30m",
+    openInUsd30m: "oiu30m",
+    closeInUsd30m: "ciu30m",
+    buys1h: "b1h",
+    sells1h: "s1h",
+    buyers1h: "be1h",
+    sellers1h: "se1h",
+    buyVolumeInUsd1h: "bviu1h",
+    sellVolumeInUsd1h: "sviu1h",
+    price1h: "p1h",
+    openInUsd1h: "oiu1h",
+    closeInUsd1h: "ciu1h",
+    buys4h: "b4h",
+    sells4h: "s4h",
+    buyers4h: "be4h",
+    sellers4h: "se4h",
+    buyVolumeInUsd4h: "bviu4h",
+    sellVolumeInUsd4h: "sviu4h",
+    price4h: "p4h",
+    openInUsd4h: "oiu4h",
+    closeInUsd4h: "ciu4h",
+    buys24h: "b24h",
+    sells24h: "s24h",
+    buyers24h: "be24h",
+    sellers24h: "se24h",
+    buyVolumeInUsd24h: "bviu24h",
+    sellVolumeInUsd24h: "sviu24h",
+    price24h: "p24h",
+    price: "p",
+    openInUsd24h: "oiu24h",
+    closeInUsd24h: "ciu24h"
+  },
+  // Token holder subscription fields
+  subscribeTokenHolders: {
+    tokenAddress: "a",
+    holders: "h",
+    top100HoldersAmount: "t100a",
+    top50HoldersAmount: "t50a",
+    top10HoldersAmount: "t10a",
+    top100Holders: "t100h",
+    top50Holders: "t50h",
+    top10Holders: "t10h",
+    top100HoldersRatio: "t100r",
+    top50HoldersRatio: "t50r",
+    top10HoldersRatio: "t10r",
+    creatorsHolders: "ch",
+    creatorsAmount: "ca",
+    creatorsRatio: "cr",
+    balanceTagFreshHolders: "btfh",
+    balanceTagFreshAmount: "btfa",
+    balanceTagFreshRatio: "btfr",
+    balanceTagSandwichHolders: "btsh",
+    balanceTagSandwichAmount: "btsa",
+    balanceTagSandwichRatio: "btsr",
+    balanceTagBundleHolders: "btbh",
+    balanceTagBundleAmount: "btba",
+    balanceTagBundleRatio: "btbr",
+    balanceTagSniperHolders: "btsnh",
+    balanceTagSniperAmount: "btsna",
+    balanceTagSniperRatio: "btsnr",
+    balanceTagDevHolders: "btdh",
+    balanceTagDevAmount: "btda",
+    balanceTagDevRatio: "btdr",
+    balanceTagProHolders: "btph",
+    balanceTagProAmount: "btpa",
+    balanceTagProRatio: "btpr",
+    balanceTagInsiderHolders: "btih",
+    balanceTagInsiderAmount: "btia",
+    balanceTagInsiderRatio: "btir",
+    balanceTagSmartHolders: "btsmh",
+    balanceTagSmartAmount: "btsma",
+    balanceTagSmartRatio: "btsmr",
+    balanceTagKolHolders: "btkh",
+    balanceTagKolAmount: "btka",
+    balanceTagKolRatio: "btkr",
+    balanceTagPhishingHolders: "btphh",
+    balanceTagPhishingAmount: "btpha",
+    balanceTagPhishingRatio: "btphr",
+    balanceTagBluechipHolders: "btblh",
+    balanceTagBluechipAmount: "btbla",
+    balanceTagBluechipRatio: "btblr",
+    balanceTagRatHolders: "btrh",
+    balanceTagRatAmount: "btra",
+    balanceTagRatRatio: "btrr",
+    timestamp: "ts"
+  },
+  // New token subscription fields
+  subscribeNewToken: {
+    tokenAddress: "a",
+    name: "n",
+    symbol: "s",
+    createdAtMs: "cts"
+  },
+  // Token supply subscription fields
+  subscribeTokenSupply: {
+    tokenAddress: "a",
+    supply: "s",
+    timestamp: "ts"
+  },
+  // Dex pool balance subscription fields
+  subscribeDexPoolBalance: {
+    poolAddress: "a",
+    tokenAAddress: "taa",
+    tokenALiquidityInUsd: "taliu",
+    tokenBAddress: "tba",
+    tokenBLiquidityInUsd: "tbliu"
+  },
+  // Token liquidity subscription fields
+  subscribeTokenLiquidity: {
+    tokenAddress: "a",
+    metricType: "t",
+    value: "v",
+    timestamp: "ts"
+  },
+  // New token metadata subscription fields
+  subscribeNewTokensMetadata: {
+    tokenAddress: "a",
+    name: "n",
+    symbol: "s",
+    imageUrl: "iu",
+    description: "de",
+    socialMedia: "sm",
+    createdAtMs: "cts"
+  },
+  // Token trades subscription fields
+  subscribeTokenTrades: {
+    tokenAddress: "a",
+    timestamp: "t",
+    kind: "k",
+    buyAmount: "ba",
+    buyAmountInUsd: "baiu",
+    buyTokenAddress: "btma",
+    buyTokenName: "btn",
+    buyTokenSymbol: "bts",
+    buyWalletAddress: "bwa",
+    sellAmount: "sa",
+    sellAmountInUsd: "saiu",
+    sellTokenAddress: "stma",
+    sellTokenName: "stn",
+    sellTokenSymbol: "sts",
+    sellWalletAddress: "swa",
+    txHash: "h"
+  },
+  // Wallet token PnL subscription fields
+  subscribeWalletPnl: {
+    walletAddress: "a",
+    tokenAddress: "ta",
+    tokenPriceInUsd: "tpiu",
+    timestamp: "t",
+    opentime: "ot",
+    lasttime: "lt",
+    closetime: "ct",
+    buyAmount: "ba",
+    buyAmountInUsd: "baiu",
+    buyCount: "bs",
+    buyCount30d: "bs30d",
+    buyCount7d: "bs7d",
+    sellAmount: "sa",
+    sellAmountInUsd: "saiu",
+    sellCount: "ss",
+    sellCount30d: "ss30d",
+    sellCount7d: "ss7d",
+    heldDurationTimestamp: "hdts",
+    averageBuyPriceInUsd: "abpiu",
+    averageSellPriceInUsd: "aspiu",
+    unrealizedProfitInUsd: "upiu",
+    unrealizedProfitRatio: "upr",
+    realizedProfitInUsd: "rpiu",
+    realizedProfitRatio: "rpr",
+    totalRealizedProfitInUsd: "trpiu",
+    totalRealizedProfitRatio: "trr"
+  },
+  // Token max liquidity subscription fields
+  subscribeTokenMaxLiquidity: {
+    tokenAddress: "a",
+    poolAddress: "p",
+    liquidityInUsd: "liu",
+    liquidityInNative: "lin",
+    timestamp: "ts"
+  },
+  // Token total liquidity subscription fields
+  subscribeTokenTotalLiquidity: {
+    tokenAddress: "a",
+    liquidityInUsd: "liu",
+    liquidityInNative: "lin",
+    poolCount: "pc",
+    timestamp: "ts"
+  }
+};
+function getFieldMappings(methodName) {
+  return CEL_FIELD_MAPPINGS[methodName] || {};
+}
+function replaceFilterFields(filter, methodName) {
+  if (!filter) {
+    return filter;
+  }
+  const fieldMappings = getFieldMappings(methodName);
+  let result = filter;
+  for (const [longField, shortField] of Object.entries(fieldMappings)) {
+    const patterns = [
+      // Pattern 1: fieldName (without meta. prefix)
+      new RegExp(`\\b${longField}\\b`, "g"),
+      // Pattern 2: meta.fieldName (with meta. prefix)
+      new RegExp(`\\bmeta\\.${longField}\\b`, "g")
+    ];
+    patterns.forEach((pattern) => {
+      result = result.replace(pattern, `meta.${shortField}`);
+    });
+  }
+  return result;
+}
+
+// src/stream/stream.ts
+var StreamApi = class {
+  constructor(context) {
+    __publicField(this, "realtimeClient");
+    __publicField(this, "listenersMap");
+    __publicField(this, "context");
+    __publicField(this, "initPromise", null);
+    this.context = context;
+    this.listenersMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Initialize Centrifuge client with current token
+   * This is called lazily when connect() is called
+   */
+  async initClient() {
+    if (this.realtimeClient) {
+      return;
+    }
+    const token = await this.getTokenValue();
+    const realtimeEndpoint = this.buildWsUrl(this.context.streamUrl, token);
+    this.realtimeClient = new Centrifuge(realtimeEndpoint, {
+      getToken: async (_ctx) => {
+        return this.getTokenValue();
+      }
+    });
+    this.realtimeClient.on("connected", () => {
+      console.log("[streaming] connected");
+    }).on("disconnected", (ctx) => {
+      console.warn("[streaming] disconnected", ctx);
+    }).on("error", (err) => {
+      console.error("[streaming] error: ", err);
+    });
+  }
+  /**
+   * Wait for initialization to complete
+   * If not initialized, auto-connect first
+   */
+  async ensureInitialized() {
+    if (!this.initPromise) {
+      this.connect();
+    }
+    await this.initPromise;
+  }
+  /**
+   * Get token value from string or TokenProvider
+   */
+  async getTokenValue() {
+    return typeof this.context.accessToken === "string" ? this.context.accessToken : await this.context.accessToken.getToken();
+  }
+  /**
+   * Build WebSocket URL with token as query parameter
+   */
+  buildWsUrl(endpoint, token) {
+    const url = new URL(endpoint);
+    url.searchParams.set("token", token);
+    return url.toString();
+  }
+  /**
+   * Connect to the WebSocket server.
+   * This is automatically called when you use subscribe methods if not already connected.
+   * You can also call this method manually for explicit control.
+   */
+  connect() {
+    this.initPromise = this.initClient().then(() => {
+      this.realtimeClient.connect();
+    });
+  }
+  /**
+   * Disconnect from the WebSocket server.
+   * All subscriptions will be automatically removed.
+   */
+  disconnect() {
+    if (this.realtimeClient) {
+      this.realtimeClient.disconnect();
+    }
+  }
+  /**
+   * Check if the WebSocket is currently connected.
+   */
+  isConnected() {
+    return this.realtimeClient?.state === "connected";
+  }
+  /**
+   * Start batching commands for efficient bulk operations
+   * All subscription commands after this call will be batched until stopBatching is called
+   */
+  startBatching() {
+    if (this.realtimeClient) {
+      this.realtimeClient.startBatching();
+    }
+  }
+  /**
+   * Stop batching and flush all collected commands to the server
+   * This will send all batched subscription commands in a single network request
+   */
+  stopBatching() {
+    if (this.realtimeClient) {
+      this.realtimeClient.stopBatching();
+    }
+  }
+  /**
+   * Batch subscribe method that accepts a function containing subscription calls
+   * All subscription methods called within the function will be batched
+   * @param batchFunction Function containing subscription method calls
+   * @returns Array of unsubscribe functions
+   */
+  batchSubscribe(batchFunction) {
+    this.startBatching();
+    const unsubscribables = batchFunction();
+    this.stopBatching();
+    return unsubscribables;
+  }
+  /**
+   * Batch unsubscribe method that accepts an array of unsubscribe functions
+   * All unsubscribe calls will be executed at once
+   * @param unsubscribables Array of unsubscribe functions to execute
+   */
+  batchUnsubscribe(unsubscribables) {
+    if (!unsubscribables || unsubscribables.length === 0) {
+      return;
+    }
+    unsubscribables.forEach((unsub) => {
+      if (unsub && typeof unsub.unsubscribe === "function") {
+        unsub.unsubscribe();
+      }
+    });
+  }
+  subscribe(channel, fn, filter, methodName) {
+    let listeners = this.listenersMap.get(channel);
+    if (!listeners) {
+      listeners = /* @__PURE__ */ new Set();
+      this.listenersMap.set(channel, listeners);
+    }
+    listeners.add(fn);
+    this.ensureInitialized().then(() => {
+      let sub = this.realtimeClient.getSubscription(channel);
+      if (!sub) {
+        console.log("[xrealtime] create new sub: ", channel);
+        const processedFilter = filter && methodName ? replaceFilterFields(filter, methodName) : filter;
+        sub = this.realtimeClient.newSubscription(channel, {
+          delta: "fossil",
+          ...processedFilter && { filter: processedFilter }
+        });
+        sub.on("subscribed", () => {
+          console.log("[xrealtime] subscribed", channel);
+        }).on("unsubscribed", () => {
+          console.log("[xrealtime] unsubscribed", channel);
+        }).on("publication", (ctx) => {
+          const currentListeners = this.listenersMap.get(channel);
+          currentListeners?.forEach((it) => it(ctx.data));
+        }).subscribe();
+      }
+    });
+    return new StreamUnsubscribable(this, channel, fn);
+  }
+  unsubscribe(channel, fn) {
+    const listeners = this.listenersMap.get(channel);
+    if (!listeners) {
+      return;
+    }
+    listeners.delete(fn);
+    console.log("unsubscribe, remain listeners: ", listeners.size);
+    if (listeners.size === 0) {
+      console.log("unsubscribe channel: ", channel);
+      this.listenersMap.delete(channel);
+      this.ensureInitialized().then(() => {
+        const sub = this.realtimeClient.getSubscription(channel);
+        if (sub) {
+          sub.unsubscribe();
+          this.realtimeClient.removeSubscription(sub);
+        }
+      });
+    }
+  }
+  formatScientificNotation(value) {
+    if (value === null || value === void 0) {
+      return "0";
+    }
+    const strValue = value.toString();
+    if (strValue.includes("e-") || strValue.includes("E-")) {
+      return Number(value).toFixed(20).replace(/\.?0+$/, "");
+    }
+    return strValue;
+  }
+  subscribeTokenCandles({
+    chain,
+    tokenAddress,
+    resolution,
+    callback,
+    filter
+  }) {
+    const channel = `dex-candle:${chain}_${tokenAddress}_${resolution}`;
+    return this.subscribe(
+      channel,
+      (data) => {
+        callback({
+          open: data.o,
+          close: data.c,
+          high: data.h,
+          low: data.l,
+          volume: data.v,
+          resolution: data.r,
+          time: data.t,
+          number: data.n
+        });
+      },
+      filter,
+      "subscribeTokenCandles"
+    );
+  }
+  subscribeTokenStats({
+    chain,
+    tokenAddress,
+    callback,
+    filter
+  }) {
+    const channel = `dex-token-stats:${chain}_${tokenAddress}`;
+    return this.subscribe(
+      channel,
+      (data) => callback({
+        address: data.a,
+        timestamp: data.t,
+        buys1m: data.b1m,
+        sells1m: data.s1m,
+        buyers1m: data.be1m,
+        sellers1m: data.se1m,
+        buyVolumeInUsd1m: this.formatScientificNotation(data.bviu1m),
+        sellVolumeInUsd1m: this.formatScientificNotation(data.sviu1m),
+        price1m: this.formatScientificNotation(data.p1m),
+        openInUsd1m: this.formatScientificNotation(data.oiu1m),
+        closeInUsd1m: this.formatScientificNotation(data.ciu1m),
+        buys5m: data.b5m,
+        sells5m: data.s5m,
+        buyers5m: data.be5m,
+        sellers5m: data.se5m,
+        buyVolumeInUsd5m: this.formatScientificNotation(data.bviu5m),
+        sellVolumeInUsd5m: this.formatScientificNotation(data.sviu5m),
+        price5m: this.formatScientificNotation(data.p5m),
+        openInUsd5m: this.formatScientificNotation(data.oiu5m),
+        closeInUsd5m: this.formatScientificNotation(data.ciu5m),
+        buys15m: data.b15m,
+        sells15m: data.s15m,
+        buyers15m: data.be15m,
+        sellers15m: data.se15m,
+        buyVolumeInUsd15m: this.formatScientificNotation(data.bviu15m),
+        sellVolumeInUsd15m: this.formatScientificNotation(data.sviu15m),
+        price15m: this.formatScientificNotation(data.p15m),
+        openInUsd15m: this.formatScientificNotation(data.oiu15m),
+        closeInUsd15m: this.formatScientificNotation(data.ciu15m),
+        buys30m: data.b30m,
+        sells30m: data.s30m,
+        buyers30m: data.be30m,
+        sellers30m: data.se30m,
+        buyVolumeInUsd30m: this.formatScientificNotation(data.bviu30m),
+        sellVolumeInUsd30m: this.formatScientificNotation(data.sviu30m),
+        price30m: this.formatScientificNotation(data.p30m),
+        openInUsd30m: this.formatScientificNotation(data.oiu30m),
+        closeInUsd30m: this.formatScientificNotation(data.ciu30m),
+        buys1h: data.b1h,
+        sells1h: data.s1h,
+        buyers1h: data.be1h,
+        sellers1h: data.se1h,
+        buyVolumeInUsd1h: this.formatScientificNotation(data.bviu1h),
+        sellVolumeInUsd1h: this.formatScientificNotation(data.sviu1h),
+        price1h: this.formatScientificNotation(data.p1h),
+        openInUsd1h: this.formatScientificNotation(data.oiu1h),
+        closeInUsd1h: this.formatScientificNotation(data.ciu1h),
+        buys4h: data.b4h,
+        sells4h: data.s4h,
+        buyers4h: data.be4h,
+        sellers4h: data.se4h,
+        buyVolumeInUsd4h: this.formatScientificNotation(data.bviu4h),
+        sellVolumeInUsd4h: this.formatScientificNotation(data.sviu4h),
+        price4h: this.formatScientificNotation(data.p4h),
+        openInUsd4h: this.formatScientificNotation(data.oiu4h),
+        closeInUsd4h: this.formatScientificNotation(data.ciu4h),
+        buys24h: data.b24h,
+        sells24h: data.s24h,
+        buyers24h: data.be24h,
+        sellers24h: data.se24h,
+        buyVolumeInUsd24h: this.formatScientificNotation(data.bviu24h),
+        sellVolumeInUsd24h: this.formatScientificNotation(data.sviu24h),
+        price24h: this.formatScientificNotation(data.p24h),
+        openInUsd24h: this.formatScientificNotation(data.oiu24h),
+        closeInUsd24h: this.formatScientificNotation(data.ciu24h),
+        price: this.formatScientificNotation(data.p)
+      }),
+      filter,
+      "subscribeTokenStats"
+    );
+  }
+  subscribeTokenHolders({
+    chain,
+    tokenAddress,
+    callback,
+    filter
+  }) {
+    const channel = `dex-token-holding:${chain}_${tokenAddress}`;
+    return this.subscribe(
+      channel,
+      (data) => callback({
+        tokenAddress: data.a,
+        holders: data.h,
+        top100HoldersAmount: this.formatScientificNotation(data.t100a),
+        top50HoldersAmount: this.formatScientificNotation(data.t50a),
+        top10HoldersAmount: this.formatScientificNotation(data.t10a),
+        top100Holders: data.t100h,
+        top50Holders: data.t50h,
+        top10Holders: data.t10h,
+        top100HoldersRatio: this.formatScientificNotation(data.t100r),
+        top50HoldersRatio: this.formatScientificNotation(data.t50r),
+        top10HoldersRatio: this.formatScientificNotation(data.t10r),
+        creatorsHolders: data.ch,
+        creatorsAmount: this.formatScientificNotation(data.ca),
+        creatorsRatio: this.formatScientificNotation(data.cr),
+        balanceTagFreshHolders: data.btfh,
+        balanceTagFreshAmount: this.formatScientificNotation(data.btfa),
+        balanceTagFreshRatio: this.formatScientificNotation(data.btfr),
+        balanceTagSandwichHolders: data.btsh,
+        balanceTagSandwichAmount: this.formatScientificNotation(data.btsa),
+        balanceTagSandwichRatio: this.formatScientificNotation(data.btsr),
+        balanceTagBundleHolders: data.btbh,
+        balanceTagBundleAmount: this.formatScientificNotation(data.btba),
+        balanceTagBundleRatio: this.formatScientificNotation(data.btbr),
+        balanceTagSniperHolders: data.btsnh,
+        balanceTagSniperAmount: this.formatScientificNotation(data.btsna),
+        balanceTagSniperRatio: this.formatScientificNotation(data.btsnr),
+        balanceTagDevHolders: data.btdh,
+        balanceTagDevAmount: this.formatScientificNotation(data.btda),
+        balanceTagDevRatio: this.formatScientificNotation(data.btdr),
+        balanceTagProHolders: data.btph,
+        balanceTagProAmount: this.formatScientificNotation(data.btpa),
+        balanceTagProRatio: this.formatScientificNotation(data.btpr),
+        balanceTagInsiderHolders: data.btih,
+        balanceTagInsiderAmount: this.formatScientificNotation(data.btia),
+        balanceTagInsiderRatio: this.formatScientificNotation(data.btir),
+        balanceTagSmartHolders: data.btsmh,
+        balanceTagSmartAmount: this.formatScientificNotation(data.btsma),
+        balanceTagSmartRatio: this.formatScientificNotation(data.btsmr),
+        balanceTagKolHolders: data.btkh,
+        balanceTagKolAmount: this.formatScientificNotation(data.btka),
+        balanceTagKolRatio: this.formatScientificNotation(data.btkr),
+        balanceTagPhishingHolders: data.btphh,
+        balanceTagPhishingAmount: this.formatScientificNotation(data.btpha),
+        balanceTagPhishingRatio: this.formatScientificNotation(data.btphr),
+        balanceTagBluechipHolders: data.btblh,
+        balanceTagBluechipAmount: this.formatScientificNotation(data.btbla),
+        balanceTagBluechipRatio: this.formatScientificNotation(data.btblr),
+        balanceTagRatHolders: data.btrh,
+        balanceTagRatAmount: this.formatScientificNotation(data.btra),
+        balanceTagRatRatio: this.formatScientificNotation(data.btrr),
+        timestamp: data.ts
+      }),
+      filter,
+      "subscribeTokenHolders"
+    );
+  }
+  subscribeNewToken({
+    chain,
+    callback,
+    filter
+  }) {
+    const channel = `dex-new-token:${chain}`;
+    return this.subscribe(
+      channel,
+      (data) => {
+        const result = {
+          tokenAddress: data.a,
+          name: data.n,
+          symbol: data.s,
+          createdAtMs: data.cts
+        };
+        if (data.dec) {
+          result.decimals = data.dec;
+        }
+        if (data.lf) {
+          const lf = data.lf;
+          result.launchFrom = {};
+          if (lf.pa) {
+            result.launchFrom.programAddress = lf.pa;
+          }
+          if (lf.pf) {
+            result.launchFrom.protocolFamily = lf.pf;
+          }
+          if (lf.pn) {
+            result.launchFrom.protocolName = lf.pn;
+          }
+        }
+        callback(result);
+      },
+      filter,
+      "subscribeNewToken"
+    );
+  }
+  subscribeNewTokensMetadata({
+    chain,
+    callback
+  }) {
+    const channel = `dex-new-tokens-metadata:${chain}`;
+    return this.subscribe(
+      channel,
+      (data) => callback(
+        data.map((it) => ({
+          tokenAddress: it.a,
+          name: it.n,
+          symbol: it.s,
+          imageUrl: it.iu,
+          description: it.de,
+          socialMedia: (() => {
+            const sm = it.sm;
+            if (!sm) return void 0;
+            return {
+              twitter: sm.tw,
+              telegram: sm.tg,
+              website: sm.w,
+              tiktok: sm.tt,
+              discord: sm.dc,
+              facebook: sm.fb,
+              github: sm.gh,
+              instagram: sm.ig,
+              linkedin: sm.li,
+              medium: sm.md,
+              reddit: sm.rd,
+              youtube: sm.yt,
+              bitbucket: sm.bb
+            };
+          })(),
+          createdAtMs: it.cts
+        }))
+      )
+    );
+  }
+  subscribeTokenSupply({
+    chain,
+    tokenAddress,
+    callback,
+    filter
+  }) {
+    const channel = `dex-token-supply:${chain}_${tokenAddress}`;
+    return this.subscribe(
+      channel,
+      (data) => callback({
+        tokenAddress: data.a,
+        supply: data.s,
+        marketCapInUsd: data.mc,
+        timestamp: data.ts
+      }),
+      filter,
+      "subscribeTokenSupply"
+    );
+  }
+  subscribeTokenLiquidity({
+    chain,
+    tokenAddress,
+    callback,
+    filter
+  }) {
+    const channel = `dex-token-general-stat-num:${chain}_${tokenAddress}`;
+    return this.subscribe(
+      channel,
+      (data) => callback({
+        tokenAddress: data.a,
+        metricType: data.t,
+        value: data.v,
+        timestamp: data.ts
+      }),
+      filter,
+      "subscribeTokenLiquidity"
+    );
+  }
+  /**
+   * Subscribe to token max liquidity updates
+   * Pushes the max liquidity info of a token in a single pool
+   * Channel: dex-token-liquidity:{chain}_{token_address}
+   */
+  subscribeTokenMaxLiquidity({
+    chain,
+    tokenAddress,
+    callback,
+    filter
+  }) {
+    const channel = `dex-token-liquidity:${chain}_${tokenAddress}`;
+    return this.subscribe(
+      channel,
+      (data) => callback({
+        tokenAddress: data.a,
+        poolAddress: data.p,
+        liquidityInUsd: data.liu,
+        liquidityInNative: data.lin,
+        timestamp: data.ts
+      }),
+      filter,
+      "subscribeTokenMaxLiquidity"
+    );
+  }
+  /**
+   * Subscribe to token total liquidity updates
+   * Pushes the total liquidity info of a token across all pools
+   * Channel: dex-token-total-liquidity:{chain}_{token_address}
+   */
+  subscribeTokenTotalLiquidity({
+    chain,
+    tokenAddress,
+    callback,
+    filter
+  }) {
+    const channel = `dex-token-total-liquidity:${chain}_${tokenAddress}`;
+    return this.subscribe(
+      channel,
+      (data) => callback({
+        tokenAddress: data.a,
+        liquidityInUsd: data.liu,
+        liquidityInNative: data.lin,
+        poolCount: data.pc,
+        timestamp: data.ts
+      }),
+      filter,
+      "subscribeTokenTotalLiquidity"
+    );
+  }
+  subscribeRankingTokensLiquidity({
+    chain,
+    channelType,
+    callback
+  }) {
+    const channel = `dex-ranking-token-general_stat_num-list:${chain}_${channelType}`;
+    return this.subscribe(
+      channel,
+      (data) => callback(
+        data?.map((it) => ({
+          tokenAddress: it.a,
+          metricType: it.t,
+          value: it.v,
+          timestamp: it.ts
+        }))
+      )
+    );
+  }
+  subscribeRankingTokensList({
+    chain,
+    ranking_type,
+    dex,
+    callback
+  }) {
+    const channel = dex ? `dex-ranking-list:${chain}_${ranking_type}_${dex}` : `dex-ranking-list:${chain}_${ranking_type}`;
+    return this.subscribe(
+      channel,
+      (data) => callback(
+        data?.map((item) => {
+          const result = {};
+          const t = item.t;
+          const bc = item.bc;
+          const h = item.h;
+          const s = item.s;
+          const ts = item.ts;
+          if (t) {
+            result.metadata = {
+              tokenAddress: t.a
+            };
+            if (t.n) {
+              result.metadata.name = t.n;
+            }
+            if (t.s) {
+              result.metadata.symbol = t.s;
+            }
+            if (t.iu) {
+              result.metadata.imageUrl = t.iu;
+            }
+            if (t.de) {
+              result.metadata.description = t.de;
+            }
+            if (t.dec) {
+              result.metadata.decimals = t.dec;
+            }
+            if (t.cts) {
+              result.metadata.createdAtMs = t.cts;
+            }
+            if (t.lf) {
+              const lf = t.lf;
+              result.metadata.launchFrom = {};
+              if (lf.pa) {
+                result.metadata.launchFrom.programAddress = lf.pa;
+              }
+              if (lf.pf) {
+                result.metadata.launchFrom.protocolFamily = lf.pf;
+              }
+              if (lf.pn) {
+                result.metadata.launchFrom.protocolName = lf.pn;
+              }
+            }
+            if (t.mt) {
+              const mt = t.mt;
+              result.metadata.migratedTo = {};
+              if (mt.pa) {
+                result.metadata.migratedTo.programAddress = mt.pa;
+              }
+              if (mt.pf) {
+                result.metadata.migratedTo.protocolFamily = mt.pf;
+              }
+              if (mt.pn) {
+                result.metadata.migratedTo.protocolName = mt.pn;
+              }
+            }
+            if (t.sm) {
+              const sm = t.sm;
+              result.metadata.socialMedia = {};
+              if (sm.tw) {
+                result.metadata.socialMedia.twitter = sm.tw;
+              }
+              if (sm.tg) {
+                result.metadata.socialMedia.telegram = sm.tg;
+              }
+              if (sm.w) {
+                result.metadata.socialMedia.website = sm.w;
+              }
+              if (sm.tt) {
+                result.metadata.socialMedia.tiktok = sm.tt;
+              }
+              if (sm.dc) {
+                result.metadata.socialMedia.discord = sm.dc;
+              }
+              if (sm.fb) {
+                result.metadata.socialMedia.facebook = sm.fb;
+              }
+              if (sm.gh) {
+                result.metadata.socialMedia.github = sm.gh;
+              }
+              if (sm.ig) {
+                result.metadata.socialMedia.instagram = sm.ig;
+              }
+              if (sm.li) {
+                result.metadata.socialMedia.linkedin = sm.li;
+              }
+              if (sm.md) {
+                result.metadata.socialMedia.medium = sm.md;
+              }
+              if (sm.rd) {
+                result.metadata.socialMedia.reddit = sm.rd;
+              }
+              if (sm.yt) {
+                result.metadata.socialMedia.youtube = sm.yt;
+              }
+              if (sm.bb) {
+                result.metadata.socialMedia.bitbucket = sm.bb;
+              }
+            }
+          }
+          if (bc) {
+            result.bondingCurve = {};
+            if (bc.pr) {
+              result.bondingCurve.progressRatio = this.formatScientificNotation(bc.pr);
+            }
+          }
+          if (h) {
+            result.holder = {
+              tokenAddress: h.a,
+              timestamp: h.ts || 0
+            };
+            if (h.h) {
+              result.holder.holders = h.h;
+            }
+            if (h.t100a) {
+              result.holder.top100HoldersAmount = this.formatScientificNotation(h.t100a);
+            }
+            if (h.t50a) {
+              result.holder.top50HoldersAmount = this.formatScientificNotation(h.t50a);
+            }
+            if (h.t10a) {
+              result.holder.top10HoldersAmount = this.formatScientificNotation(h.t10a);
+            }
+            if (h.t100h) {
+              result.holder.top100Holders = h.t100h;
+            }
+            if (h.t50h) {
+              result.holder.top50Holders = h.t50h;
+            }
+            if (h.t10h) {
+              result.holder.top10Holders = h.t10h;
+            }
+            if (h.t100r) {
+              result.holder.top100HoldersRatio = this.formatScientificNotation(h.t100r);
+            }
+            if (h.t50r) {
+              result.holder.top50HoldersRatio = this.formatScientificNotation(h.t50r);
+            }
+            if (h.t10r) {
+              result.holder.top10HoldersRatio = this.formatScientificNotation(h.t10r);
+            }
+          }
+          if (s) {
+            result.supply = {
+              tokenAddress: s.a,
+              timestamp: s.ts || 0
+            };
+            if (s.s) {
+              result.supply.supply = s.s;
+            }
+            if (s.mc) {
+              result.supply.marketCapInUsd = s.mc;
+            }
+          }
+          if (ts) {
+            result.stat = {
+              address: ts.a,
+              timestamp: ts.t || 0
+            };
+            if (ts.b1m) {
+              result.stat.buys1m = ts.b1m;
+            }
+            if (ts.s1m) {
+              result.stat.sells1m = ts.s1m;
+            }
+            if (ts.be1m) {
+              result.stat.buyers1m = ts.be1m;
+            }
+            if (ts.se1m) {
+              result.stat.sellers1m = ts.se1m;
+            }
+            if (ts.bviu1m) {
+              result.stat.buyVolumeInUsd1m = this.formatScientificNotation(ts.bviu1m);
+            }
+            if (ts.sviu1m) {
+              result.stat.sellVolumeInUsd1m = this.formatScientificNotation(ts.sviu1m);
+            }
+            if (ts.p1m) {
+              result.stat.price1m = this.formatScientificNotation(ts.p1m);
+            }
+            if (ts.p) {
+              result.stat.price = this.formatScientificNotation(ts.p);
+            }
+          }
+          return result;
+        })
+      )
+    );
+  }
+  subscribeRankingTokensStats({
+    chain,
+    channelType,
+    callback
+  }) {
+    const channel = `dex-ranking-token-stats-list:${chain}_${channelType}`;
+    return this.subscribe(
+      channel,
+      (data) => callback(
+        data?.map(
+          (it) => ({
+            address: it.a,
+            timestamp: it.t,
+            buys1m: it.b1m,
+            sells1m: it.s1m,
+            buyers1m: it.be1m,
+            sellers1m: it.se1m,
+            buyVolumeInUsd1m: this.formatScientificNotation(it.bviu1m),
+            sellVolumeInUsd1m: this.formatScientificNotation(it.sviu1m),
+            price1m: this.formatScientificNotation(it.p1m),
+            openInUsd1m: this.formatScientificNotation(it.oiu1m),
+            closeInUsd1m: this.formatScientificNotation(it.ciu1m),
+            buys5m: it.b5m,
+            sells5m: it.s5m,
+            buyers5m: it.be5m,
+            sellers5m: it.se5m,
+            buyVolumeInUsd5m: this.formatScientificNotation(it.bviu5m),
+            sellVolumeInUsd5m: this.formatScientificNotation(it.sviu5m),
+            price5m: this.formatScientificNotation(it.p5m),
+            openInUsd5m: this.formatScientificNotation(it.oiu5m),
+            closeInUsd5m: this.formatScientificNotation(it.ciu5m),
+            price: this.formatScientificNotation(it.p)
+          })
+        )
+      )
+    );
+  }
+  subscribeRankingTokensHolders({
+    chain,
+    channelType,
+    callback
+  }) {
+    const channel = `dex-ranking-token-holding-list:${chain}_${channelType}`;
+    return this.subscribe(
+      channel,
+      (data) => callback(
+        data?.map(
+          (it) => ({
+            tokenAddress: it.a,
+            holders: it.h,
+            top100HoldersAmount: this.formatScientificNotation(it.t100a),
+            top50HoldersAmount: this.formatScientificNotation(it.t50a),
+            top10HoldersAmount: this.formatScientificNotation(it.t10a),
+            top100Holders: it.t100h,
+            top50Holders: it.t50h,
+            top10Holders: it.t10h,
+            top100HoldersRatio: this.formatScientificNotation(it.t100r),
+            top50HoldersRatio: this.formatScientificNotation(it.t50r),
+            top10HoldersRatio: this.formatScientificNotation(it.t10r),
+            timestamp: it.ts
+          })
+        )
+      )
+    );
+  }
+  subscribeRankingTokensSupply({
+    chain,
+    channelType,
+    callback
+  }) {
+    const channel = `dex-ranking-token-supply-list:${chain}_${channelType}`;
+    return this.subscribe(
+      channel,
+      (data) => callback(
+        data?.map((it) => ({
+          tokenAddress: it.a,
+          supply: it.s,
+          marketCapInUsd: it.mc,
+          timestamp: it.ts
+        }))
+      )
+    );
+  }
+  subscribeRankingTokensBondingCurve({
+    chain,
+    callback
+  }) {
+    const channel = `dex-ranking-token-bounding-curve-list:${chain}_new`;
+    return this.subscribe(
+      channel,
+      (data) => callback(
+        data?.map((it) => ({
+          tokenAddress: it.a,
+          progressRatio: it.pr
+        }))
+      )
+    );
+  }
+  subscribeWalletBalance({
+    chain,
+    walletAddress,
+    callback,
+    filter
+  }) {
+    const channel = `dex-wallet-balance:${chain}_${walletAddress}`;
+    return this.subscribe(
+      channel,
+      (data) => callback([
+        {
+          walletAddress: data.a,
+          tokenAddress: data.ta,
+          tokenPriceInUsd: data.tpiu,
+          balance: data.b,
+          timestamp: data.t
+        }
+      ]),
+      filter,
+      "subscribeWalletBalance"
+    );
+  }
+  subscribeWalletPnl({
+    chain,
+    walletAddress,
+    callback,
+    filter
+  }) {
+    const channel = `dex-wallet-token-pnl:${chain}_${walletAddress}`;
+    return this.subscribe(
+      channel,
+      (data) => callback({
+        walletAddress: data.a,
+        tokenAddress: data.ta,
+        tokenPriceInUsd: data.tpiu,
+        timestamp: data.t,
+        opentime: data.ot,
+        lasttime: data.lt,
+        closetime: data.ct,
+        buyAmount: data.ba,
+        buyAmountInUsd: data.baiu,
+        buyCount: data.bs,
+        buyCount30d: data.bs30d,
+        buyCount7d: data.bs7d,
+        sellAmount: data.sa,
+        sellAmountInUsd: data.saiu,
+        sellCount: data.ss,
+        sellCount30d: data.ss30d,
+        sellCount7d: data.ss7d,
+        heldDurationTimestamp: data.hdts,
+        averageBuyPriceInUsd: data.abpiu,
+        averageSellPriceInUsd: data.aspiu,
+        unrealizedProfitInUsd: data.upiu,
+        unrealizedProfitRatio: data.upr,
+        realizedProfitInUsd: data.rpiu,
+        realizedProfitRatio: data.rpr,
+        totalRealizedProfitInUsd: data.trpiu,
+        totalRealizedProfitRatio: data.trr
+      }),
+      filter,
+      "subscribeWalletPnl"
+    );
+  }
+  subscribeWalletPnlList({
+    chain,
+    walletAddress,
+    callback
+  }) {
+    const channel = `dex-wallet-pnl-list:${chain}_${walletAddress}`;
+    return this.subscribe(
+      channel,
+      (data) => callback(
+        data?.map(
+          (it) => ({
+            walletAddress: it.a,
+            buys: it.bs,
+            buyAmount: it.ba,
+            buyAmountInUsd: it.baiu,
+            averageBuyPriceInUsd: it.abpiu,
+            sellAmount: it.sa,
+            sellAmountInUsd: it.saiu,
+            sells: it.ss,
+            wins: it.ws,
+            winRatio: it.wr,
+            pnlInUsd: it.piu,
+            averagePnlInUsd: it.apiu,
+            pnlRatio: it.pr,
+            profitableDays: it.pd,
+            losingDays: it.ld,
+            tokens: it.ts,
+            resolution: it.r
+          })
+        )
+      )
+    );
+  }
+  subscribeTokenTrade({
+    chain,
+    tokenAddress,
+    callback,
+    filter
+  }) {
+    const channel = `dex-trade:${chain}_${tokenAddress}`;
+    return this.subscribe(
+      channel,
+      (data) => callback({
+        tokenAddress: data.a,
+        timestamp: data.t,
+        kind: data.k,
+        buyAmount: data.ba,
+        buyAmountInUsd: data.baiu,
+        buyTokenAddress: data.btma,
+        buyTokenName: data.btn,
+        buyTokenSymbol: data.bts,
+        buyWalletAddress: data.bwa,
+        sellAmount: data.sa,
+        sellAmountInUsd: data.saiu,
+        sellTokenAddress: data.stma,
+        sellTokenName: data.stn,
+        sellTokenSymbol: data.sts,
+        sellWalletAddress: data.swa,
+        txHash: data.h
+      }),
+      filter,
+      "subscribeTokenTrades"
+    );
+  }
+  subscribeWalletTrade({
+    chain,
+    walletAddress,
+    callback,
+    filter
+  }) {
+    const channel = `dex-wallet-trade:${chain}_${walletAddress}`;
+    return this.subscribe(
+      channel,
+      (data) => callback({
+        tokenAddress: data.a,
+        timestamp: data.t,
+        kind: data.k,
+        buyAmount: data.ba,
+        buyAmountInUsd: data.baiu,
+        buyTokenAddress: data.btma,
+        buyTokenName: data.btn,
+        buyTokenSymbol: data.bts,
+        buyWalletAddress: data.bwa,
+        sellAmount: data.sa,
+        sellAmountInUsd: data.saiu,
+        sellTokenAddress: data.stma,
+        sellTokenName: data.stn,
+        sellTokenSymbol: data.sts,
+        sellWalletAddress: data.swa,
+        txHash: data.h
+      }),
+      filter,
+      "subscribeTokenTrades"
+    );
+  }
+  subscribeDexPoolBalance({
+    chain,
+    poolAddress,
+    callback
+  }) {
+    const channel = `dex-pool-balance:${chain}_${poolAddress}`;
+    return this.subscribe(
+      channel,
+      (data) => callback({
+        poolAddress: data.a,
+        tokenAAddress: data.taa,
+        tokenALiquidityInUsd: data.taliu,
+        tokenBAddress: data.tba,
+        tokenBLiquidityInUsd: data.tbliu
+      })
+    );
+  }
+};
+var StreamUnsubscribable = class {
+  constructor(streamApi, channel, fn) {
+    this.streamApi = streamApi;
+    this.channel = channel;
+    this.fn = fn;
+  }
+  unsubscribe() {
+    this.streamApi.unsubscribe(this.channel, this.fn);
+  }
+};
+
+// src/openapi-client/generated/blockchain/blockchain.ts
+var blockchain_exports = {};
+__export(blockchain_exports, {
+  getLatestBlock: () => getLatestBlock,
+  getSupportedBlockchains: () => getSupportedBlockchains
+});
+var getSupportedBlockchains = (options) => {
+  return chainstreamApiClient({ url: `/v1/blockchain`, method: "GET" }, options);
+};
+var getLatestBlock = (chain, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/blockchain/${chain}/latest_block`, method: "GET" },
+    options
+  );
+};
+
+// src/openapi-client/generated/defi-sol-moonshot/defi-sol-moonshot.ts
+var defi_sol_moonshot_exports = {};
+__export(defi_sol_moonshot_exports, {
+  moonshotCreateToken: () => moonshotCreateToken,
+  moonshotSubmitCreateToken: () => moonshotSubmitCreateToken
+});
+var moonshotCreateToken = (moonshotCreateTokenInput, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/sol/moonshot/create`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: moonshotCreateTokenInput
+    },
+    options
+  );
+};
+var moonshotSubmitCreateToken = (moonshotSubmitCreateTokenInput, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/sol/moonshot/submitCreateToken`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: moonshotSubmitCreateTokenInput
+    },
+    options
+  );
+};
+
+// src/openapi-client/generated/defi-sol-pumpfun/defi-sol-pumpfun.ts
+var defi_sol_pumpfun_exports = {};
+__export(defi_sol_pumpfun_exports, {
+  pumpfunCreateToken: () => pumpfunCreateToken
+});
+var pumpfunCreateToken = (pumpCreateTokenInput, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/sol/pumpfun/create`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: pumpCreateTokenInput
+    },
+    options
+  );
+};
+
+// src/openapi-client/generated/dex-pool/dex-pool.ts
+var dex_pool_exports = {};
+__export(dex_pool_exports, {
+  getDexpool: () => getDexpool,
+  getDexpoolSnapshots: () => getDexpoolSnapshots
+});
+var getDexpool = (chain, poolAddress, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/dexpools/${chain}/${poolAddress}`, method: "GET" },
+    options
+  );
+};
+var getDexpoolSnapshots = (chain, poolAddress, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/dexpools/${chain}/${poolAddress}/snapshots`, method: "GET", params },
+    options
+  );
+};
+
+// src/openapi-client/generated/dex/dex.ts
+var dex_exports = {};
+__export(dex_exports, {
+  createToken: () => createToken,
+  listDex: () => listDex,
+  quote: () => quote,
+  route: () => route,
+  swap: () => swap
+});
+var swap = (chain, swapInput, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/dex/${chain}/swap`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: swapInput
+    },
+    options
+  );
+};
+var route = (chain, swapRouteInput, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/dex/${chain}/route`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: swapRouteInput
+    },
+    options
+  );
+};
+var quote = (chain, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/dex/${chain}/quote`, method: "GET", params },
+    options
+  );
+};
+var createToken = (chain, createTokenInput, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/dex/${chain}/create`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: createTokenInput
+    },
+    options
+  );
+};
+var listDex = (params, options) => {
+  return chainstreamApiClient({ url: `/v1/dex`, method: "GET", params }, options);
+};
+
+// src/openapi-client/generated/endpoint/endpoint.ts
+var endpoint_exports = {};
+__export(endpoint_exports, {
+  createEndpoint: () => createEndpoint,
+  deleteEndpoint: () => deleteEndpoint,
+  getEndpoint: () => getEndpoint,
+  getEndpointSecret: () => getEndpointSecret,
+  listEndpoints: () => listEndpoints,
+  rotateEndpointSecret: () => rotateEndpointSecret,
+  updateEndpoint: () => updateEndpoint
+});
+var listEndpoints = (params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/webhook/endpoint`, method: "GET", params },
+    options
+  );
+};
+var createEndpoint = (createEndpointInput, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/webhook/endpoint`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: createEndpointInput
+    },
+    options
+  );
+};
+var updateEndpoint = (updateEndpointInput, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/webhook/endpoint`,
+      method: "PATCH",
+      headers: { "Content-Type": "application/json" },
+      data: updateEndpointInput
+    },
+    options
+  );
+};
+var getEndpoint = (id, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/webhook/endpoint/${id}`, method: "GET" },
+    options
+  );
+};
+var deleteEndpoint = (id, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/webhook/endpoint/${id}`, method: "DELETE" },
+    options
+  );
+};
+var getEndpointSecret = (id, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/webhook/endpoint/${id}/secret`, method: "GET" },
+    options
+  );
+};
+var rotateEndpointSecret = (id, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/webhook/endpoint/${id}/secret/rotate`, method: "POST" },
+    options
+  );
+};
+
+// src/openapi-client/generated/ipfs/ipfs.ts
+var ipfs_exports = {};
+__export(ipfs_exports, {
+  presign: () => presign
+});
+var presign = (options) => {
+  return chainstreamApiClient({ url: `/v1/ipfs/presign`, method: "POST" }, options);
+};
+
+// src/openapi-client/generated/jobs/jobs.ts
+var jobs_exports = {};
+__export(jobs_exports, {
+  get: () => get,
+  streaming: () => streaming
+});
+var get = (id, options) => {
+  return chainstreamApiClient({ url: `/jobs/${id}`, method: "GET" }, options);
+};
+var streaming = (id, options) => {
+  return chainstreamApiClient(
+    { url: `/jobs/${id}/streaming`, method: "GET" },
+    options
+  );
+};
+
+// src/openapi-client/generated/kyt/kyt.ts
+var kyt_exports = {};
+__export(kyt_exports, {
+  getAddressRisk: () => getAddressRisk,
+  getTransferAlerts: () => getTransferAlerts,
+  getTransferDirectExposure: () => getTransferDirectExposure,
+  getTransferNetworkIdentifications: () => getTransferNetworkIdentifications,
+  getTransferSummary: () => getTransferSummary,
+  getWithdrawalAddressIdentifications: () => getWithdrawalAddressIdentifications,
+  getWithdrawalAlerts: () => getWithdrawalAlerts,
+  getWithdrawalDirectExposure: () => getWithdrawalDirectExposure,
+  getWithdrawalFraudAssessment: () => getWithdrawalFraudAssessment,
+  getWithdrawalNetworkIdentifications: () => getWithdrawalNetworkIdentifications,
+  getWithdrawalSummary: () => getWithdrawalSummary,
+  registerAddress: () => registerAddress,
+  registerTransfer: () => registerTransfer,
+  registerWithdrawal: () => registerWithdrawal
+});
+var registerTransfer = (kYTRegisterTransferRequest, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/kyt/transfer`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: kYTRegisterTransferRequest
+    },
+    options
+  );
+};
+var getTransferSummary = (transferId, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/kyt/transfers/${transferId}/summary`, method: "GET" },
+    options
+  );
+};
+var getTransferDirectExposure = (transferId, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/kyt/transfers/${transferId}/exposures/direct`, method: "GET" },
+    options
+  );
+};
+var getTransferAlerts = (transferId, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/kyt/transfers/${transferId}/alerts`, method: "GET" },
+    options
+  );
+};
+var getTransferNetworkIdentifications = (transferId, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/kyt/transfers/${transferId}/network-identifications`, method: "GET" },
+    options
+  );
+};
+var registerWithdrawal = (kYTRegisterWithdrawalRequest, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/kyt/withdrawal`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: kYTRegisterWithdrawalRequest
+    },
+    options
+  );
+};
+var getWithdrawalSummary = (withdrawalId, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/kyt/withdrawal/${withdrawalId}/summary`, method: "GET" },
+    options
+  );
+};
+var getWithdrawalDirectExposure = (withdrawalId, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/kyt/withdrawal/${withdrawalId}/exposures/direct`, method: "GET" },
+    options
+  );
+};
+var getWithdrawalAlerts = (withdrawalId, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/kyt/withdrawal/${withdrawalId}/alerts`, method: "GET" },
+    options
+  );
+};
+var getWithdrawalAddressIdentifications = (withdrawalId, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/kyt/withdrawal/${withdrawalId}/address-identifications`, method: "GET" },
+    options
+  );
+};
+var getWithdrawalNetworkIdentifications = (withdrawalId, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/kyt/withdrawal/${withdrawalId}/network-identifications`, method: "GET" },
+    options
+  );
+};
+var getWithdrawalFraudAssessment = (withdrawalId, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/kyt/withdrawal/${withdrawalId}/fraud-assessment`, method: "GET" },
+    options
+  );
+};
+var registerAddress = (registerAddressRequest, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/kyt/address`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: registerAddressRequest
+    },
+    options
+  );
+};
+var getAddressRisk = (address, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/kyt/addresses/${address}/risk`, method: "GET" },
+    options
+  );
+};
+
+// src/openapi-client/generated/ranking/ranking.ts
+var ranking_exports = {};
+__export(ranking_exports, {
+  getFinalStretchTokens: () => getFinalStretchTokens,
+  getHotTokens: () => getHotTokens,
+  getMigratedTokens: () => getMigratedTokens,
+  getNewTokens: () => getNewTokens,
+  getStocksTokens: () => getStocksTokens
+});
+var getHotTokens = (chain, duration, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/ranking/${chain}/hotTokens/${duration}`, method: "GET", params },
+    options
+  );
+};
+var getNewTokens = (chain, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/ranking/${chain}/newTokens`, method: "GET", params },
+    options
+  );
+};
+var getStocksTokens = (chain, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/ranking/${chain}/stocks`, method: "GET", params },
+    options
+  );
+};
+var getFinalStretchTokens = (chain, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/ranking/${chain}/finalStretch`, method: "GET", params },
+    options
+  );
+};
+var getMigratedTokens = (chain, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/ranking/${chain}/migrated`, method: "GET", params },
+    options
+  );
+};
+
+// src/openapi-client/generated/red-packet/red-packet.ts
+var red_packet_exports = {};
+__export(red_packet_exports, {
+  claimRedpacket: () => claimRedpacket,
+  createRedpacket: () => createRedpacket,
+  getClaims: () => getClaims,
+  getClaimsByAddress: () => getClaimsByAddress,
+  getRedpacket: () => getRedpacket,
+  getRedpackets: () => getRedpackets,
+  getRedpacketsByAddress: () => getRedpacketsByAddress,
+  redpacketSend: () => redpacketSend
+});
+var createRedpacket = (chain, createRedPacketInput, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/redpacket/${chain}/create`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: createRedPacketInput
+    },
+    options
+  );
+};
+var claimRedpacket = (chain, claimRedPacketInput, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/redpacket/${chain}/claim`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: claimRedPacketInput
+    },
+    options
+  );
+};
+var getRedpacket = (id, options) => {
+  return chainstreamApiClient({ url: `/v1/redpacket/${id}`, method: "GET" }, options);
+};
+var getClaims = (id, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/redpacket/${id}/claims`, method: "GET", params },
+    options
+  );
+};
+var getRedpackets = (params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/redpacket`, method: "GET", params },
+    options
+  );
+};
+var getClaimsByAddress = (address, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/redpacket/wallet/${address}/claims`, method: "GET", params },
+    options
+  );
+};
+var getRedpacketsByAddress = (address, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/redpacket/wallet/${address}/redpackets`, method: "GET", params },
+    options
+  );
+};
+var redpacketSend = (chain, redPacketSendTxInput, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/redpacket/${chain}/send`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: redPacketSendTxInput
+    },
+    options
+  );
+};
+
+// src/openapi-client/generated/token/token.ts
+var token_exports = {};
+__export(token_exports, {
+  getCandles: () => getCandles,
+  getCreation: () => getCreation,
+  getDevTokens: () => getDevTokens,
+  getHolders: () => getHolders,
+  getHoldersMulti: () => getHoldersMulti,
+  getMarketData: () => getMarketData,
+  getMarketDataMulti: () => getMarketDataMulti,
+  getMetadata: () => getMetadata,
+  getMetadataMulti: () => getMetadataMulti,
+  getMintAndBurn: () => getMintAndBurn,
+  getPools: () => getPools,
+  getPriceByTime: () => getPriceByTime,
+  getPrices: () => getPrices,
+  getSecurity: () => getSecurity,
+  getStats: () => getStats,
+  getStatsMulti: () => getStatsMulti,
+  getToken: () => getToken,
+  getTokenLiquiditySnapshots: () => getTokenLiquiditySnapshots,
+  getTokenTraders: () => getTokenTraders,
+  getTokens: () => getTokens,
+  getTopHolders: () => getTopHolders,
+  listToken: () => listToken,
+  search: () => search
+});
+var search = (params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/search`, method: "GET", params },
+    options
+  );
+};
+var getTokens = (chain, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/multi`, method: "GET", params },
+    options
+  );
+};
+var getToken = (chain, tokenAddress, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}`, method: "GET" },
+    options
+  );
+};
+var getMetadata = (chain, tokenAddress, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/metadata`, method: "GET" },
+    options
+  );
+};
+var getMetadataMulti = (chain, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/metadata/multi`, method: "GET", params },
+    options
+  );
+};
+var getPools = (chain, tokenAddress, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/pools`, method: "GET", params },
+    options
+  );
+};
+var getStats = (chain, tokenAddress, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/stats`, method: "GET" },
+    options
+  );
+};
+var getStatsMulti = (chain, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/stats/multi`, method: "GET", params },
+    options
+  );
+};
+var getHolders = (chain, tokenAddress, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/holders`, method: "GET", params },
+    options
+  );
+};
+var getHoldersMulti = (chain, tokenAddress, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/holders/multi`, method: "GET", params },
+    options
+  );
+};
+var getCandles = (chain, tokenAddress, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/candles`, method: "GET", params },
+    options
+  );
+};
+var getTopHolders = (chain, tokenAddress, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/topHolders`, method: "GET" },
+    options
+  );
+};
+var getMarketData = (chain, tokenAddress, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/marketData`, method: "GET" },
+    options
+  );
+};
+var getMarketDataMulti = (chain, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/marketData/multi`, method: "GET", params },
+    options
+  );
+};
+var getPrices = (chain, tokenAddress, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/prices`, method: "GET", params },
+    options
+  );
+};
+var getPriceByTime = (chain, tokenAddress, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/price`, method: "GET", params },
+    options
+  );
+};
+var getCreation = (chain, tokenAddress, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/creation`, method: "GET" },
+    options
+  );
+};
+var getMintAndBurn = (chain, tokenAddress, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/mintAndBurn`, method: "GET", params },
+    options
+  );
+};
+var listToken = (chain, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/list`, method: "GET", params },
+    options
+  );
+};
+var getSecurity = (chain, tokenAddress, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/security`, method: "GET" },
+    options
+  );
+};
+var getDevTokens = (chain, devAddress, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/dev/${devAddress}/tokens`, method: "GET" },
+    options
+  );
+};
+var getTokenTraders = (chain, tokenAddress, tag, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/traders/${tag}`, method: "GET" },
+    options
+  );
+};
+var getTokenLiquiditySnapshots = (chain, tokenAddress, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/token/${chain}/${tokenAddress}/liquiditySnapshots`, method: "GET", params },
+    options
+  );
+};
+
+// src/openapi-client/generated/trade/trade.ts
+var trade_exports = {};
+__export(trade_exports, {
+  getActivities: () => getActivities,
+  getTopTraders: () => getTopTraders,
+  getTrades: () => getTrades
+});
+var getTrades = (chain, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/trade/${chain}`, method: "GET", params },
+    options
+  );
+};
+var getActivities = (chain, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/trade/${chain}/activities`, method: "GET", params },
+    options
+  );
+};
+var getTopTraders = (chain, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/trade/${chain}/top-traders`, method: "GET", params },
+    options
+  );
+};
+
+// src/openapi-client/generated/transaction/transaction.ts
+var transaction_exports = {};
+__export(transaction_exports, {
+  getGasLimit: () => getGasLimit,
+  getGasPrice: () => getGasPrice,
+  send: () => send
+});
+var send = (chain, sendTxInput, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/transaction/${chain}/send`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: sendTxInput
+    },
+    options
+  );
+};
+var getGasPrice = (chain, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/transaction/${chain}/gas-price`, method: "GET" },
+    options
+  );
+};
+var getGasLimit = (chain, estimateGasLimitInput, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/transaction/${chain}/estimate-gas-limit`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: estimateGasLimitInput
+    },
+    options
+  );
+};
+
+// src/openapi-client/generated/wallet/wallet.ts
+var wallet_exports = {};
+__export(wallet_exports, {
+  calculatePnl: () => calculatePnl,
+  getBalance: () => getBalance,
+  getBalanceUpdates: () => getBalanceUpdates,
+  getPnl: () => getPnl,
+  getPnlStats: () => getPnlStats
+});
+var getPnl = (chain, walletAddress, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/wallet/${chain}/${walletAddress}`, method: "GET", params },
+    options
+  );
+};
+var getPnlStats = (chain, walletAddress, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/wallet/${chain}/${walletAddress}/stats`, method: "GET" },
+    options
+  );
+};
+var getBalance = (chain, walletAddress, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/wallet/${chain}/${walletAddress}/balance`, method: "GET", params },
+    options
+  );
+};
+var calculatePnl = (chain, walletAddress, calculatePnlInput, options) => {
+  return chainstreamApiClient(
+    {
+      url: `/v1/wallet/${chain}/${walletAddress}/calculate-pnl`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: calculatePnlInput
+    },
+    options
+  );
+};
+var getBalanceUpdates = (chain, walletAddress, params, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/wallet/${chain}/${walletAddress}/balance-updates`, method: "GET", params },
+    options
+  );
+};
+
+// src/openapi-client/generated/watchlist/watchlist.ts
+var watchlist_exports = {};
+__export(watchlist_exports, {
+  watchlistAdd: () => watchlistAdd
+});
+var watchlistAdd = (chain, walletAddress, options) => {
+  return chainstreamApiClient(
+    { url: `/v1/watchlist/${chain}/${walletAddress}`, method: "POST" },
+    options
+  );
+};
+
+// src/chainstream.ts
+var ChainStreamClient = class {
+  constructor(accessToken, options = {}) {
+    __publicField(this, "requestCtx");
+    // WebSocket streaming client
+    __publicField(this, "stream");
+    // REST API modules
+    __publicField(this, "token");
+    __publicField(this, "dex");
+    __publicField(this, "dexpool");
+    __publicField(this, "trade");
+    __publicField(this, "ranking");
+    __publicField(this, "transaction");
+    __publicField(this, "moonshot");
+    __publicField(this, "pumpfun");
+    __publicField(this, "wallet");
+    __publicField(this, "redPacket");
+    __publicField(this, "ipfs");
+    __publicField(this, "blockchain");
+    __publicField(this, "watchlist");
+    __publicField(this, "jobs");
+    __publicField(this, "kyt");
+    __publicField(this, "endpoint");
+    const baseUrl = options.serverUrl ?? "https://api-dex.chainstream.io";
+    const streamUrl = options.streamUrl ?? "wss://realtime-dex.chainstream.io/connection/websocket";
+    this.requestCtx = { baseUrl, streamUrl, accessToken };
+    configure({
+      accessToken,
+      basePath: baseUrl,
+      debugging: options.debug
+    });
+    this.token = token_exports;
+    this.dex = dex_exports;
+    this.dexpool = dex_pool_exports;
+    this.trade = trade_exports;
+    this.ranking = ranking_exports;
+    this.transaction = transaction_exports;
+    this.moonshot = defi_sol_moonshot_exports;
+    this.pumpfun = defi_sol_pumpfun_exports;
+    this.wallet = wallet_exports;
+    this.redPacket = red_packet_exports;
+    this.ipfs = ipfs_exports;
+    this.blockchain = blockchain_exports;
+    this.watchlist = watchlist_exports;
+    this.jobs = jobs_exports;
+    this.kyt = kyt_exports;
+    this.endpoint = endpoint_exports;
+    this.stream = new StreamApi(this.requestCtx);
+    if (options.autoConnectWebSocket === true) {
+      this.stream.connect();
+    }
+  }
+  /**
+   * Wait for a job to complete using Server-Sent Events (SSE)
+   * @param jobId - The job ID to wait for
+   * @param timeout - Timeout in milliseconds (default: 60000)
+   * @returns Promise that resolves with the job result
+   */
+  async waitForJob(jobId, timeout = 6e4) {
+    const accessToken = typeof this.requestCtx.accessToken === "string" ? this.requestCtx.accessToken : await this.requestCtx.accessToken.getToken();
+    return new Promise((resolve, reject) => {
+      const sse = new EventSourcePolyfill(`${this.requestCtx.baseUrl}/jobs/${jobId}/streaming`, {
+        headers: {
+          Authorization: `Bearer ${accessToken}`
+        }
+      });
+      const timeoutId = setTimeout(() => {
+        sse.close();
+        reject(new Error(`Job ${jobId} timed out after ${timeout}ms`));
+      }, timeout);
+      sse.onmessage = (event) => {
+        try {
+          console.log("event.data: ", event.data);
+          const data = JSON.parse(event.data);
+          if (data.status === "error") {
+            sse.close();
+            reject(new Error(`Error: ${data.message}`));
+          } else if (data.status === "completed") {
+            clearTimeout(timeoutId);
+            sse.close();
+            resolve(data);
+          }
+        } catch {
+          clearTimeout(timeoutId);
+          sse.close();
+          reject(new Error("Error parsing event data"));
+        }
+      };
+      sse.onopen = () => {
+        console.log("SSE connection opened");
+      };
+      sse.onerror = (error) => {
+        const errorEvent = error;
+        if (errorEvent.message?.includes("No activity within")) {
+          console.log("SSE reconnecting due to inactivity...");
+          return;
+        }
+        clearTimeout(timeoutId);
+        sse.close();
+        reject(new Error(`Error in SSE connection: ${error}`));
+      };
+    });
+  }
+};
+export {
+  ChainStreamClient
+};
+//# sourceMappingURL=chainstream.mjs.map