@chainstream-io/sdk 0.1.10 → 0.1.12

package/dist/stream/index.cjs

@@ -0,0 +1,1403 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/stream/index.ts
+var stream_exports = {};
+__export(stream_exports, {
+  CEL_FIELD_MAPPINGS: () => CEL_FIELD_MAPPINGS,
+  ChannelType: () => ChannelType,
+  Dex: () => Dex,
+  MetricType: () => MetricType,
+  RankingType: () => RankingType,
+  StreamApi: () => StreamApi,
+  TokenActivityType: () => TokenActivityType,
+  getAvailableFields: () => getAvailableFields,
+  getFieldMappings: () => getFieldMappings,
+  replaceFilterFields: () => replaceFilterFields
+});
+module.exports = __toCommonJS(stream_exports);
+
+// src/stream/stream.ts
+var import_centrifuge = require("@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",
+    "top100Amount": "t100a",
+    "top10Amount": "t10a",
+    "top100Holders": "t100h",
+    "top10Holders": "t10h",
+    "top100Ratio": "t100r",
+    "top10Ratio": "t10r",
+    "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"
+  }
+};
+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;
+}
+function getAvailableFields(methodName) {
+  const mappings = getFieldMappings(methodName);
+  return Object.keys(mappings);
+}
+
+// src/stream/stream.ts
+var StreamApi = class {
+  constructor(context) {
+    __publicField(this, "realtimeClient");
+    __publicField(this, "listenersMap");
+    const realtimeEndpoint = context.streamUrl;
+    this.realtimeClient = new import_centrifuge.Centrifuge(realtimeEndpoint, {
+      getToken: async (_ctx) => {
+        return typeof context.accessToken === "string" ? context.accessToken : await context.accessToken.getToken();
+      }
+    });
+    this.realtimeClient.on("connected", () => {
+      console.log("[streaming] connected");
+    }).on("disconnected", (err) => {
+      console.warn("[streaming] disconnected", err);
+    }).on("error", (err) => {
+      console.error("[streaming] error: ", err);
+    });
+    this.listenersMap = /* @__PURE__ */ new Map();
+  }
+  connect() {
+    this.realtimeClient.connect();
+  }
+  /**
+   * Start batching commands for efficient bulk operations
+   * All subscription commands after this call will be batched until stopBatching is called
+   */
+  startBatching() {
+    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() {
+    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 unsubscribles = batchFunction();
+    this.stopBatching();
+    return unsubscribles;
+  }
+  /**
+   * Batch unsubscribe method that accepts an array of unsubscribe functions
+   * All unsubscribe calls will be executed at once
+   * @param unsubscribles Array of unsubscribe functions to execute
+   */
+  batchUnsubscribe(unsubscribles) {
+    if (!unsubscribles || unsubscribles.length === 0) {
+      return;
+    }
+    unsubscribles.forEach((unsub) => {
+      if (unsub && typeof unsub.unsubscribe === "function") {
+        unsub.unsubscribe();
+      }
+    });
+  }
+  subscribe(channel, fn, filter, methodName) {
+    let sub = this.realtimeClient.getSubscription(channel);
+    let listeners = this.listenersMap.get(channel);
+    if (!sub) {
+      listeners = /* @__PURE__ */ new Set();
+      this.listenersMap.set(channel, listeners);
+      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) => {
+        listeners?.forEach((it) => it(ctx.data));
+      }).subscribe();
+    }
+    listeners?.add(fn);
+    return new StreamUnsubscrible(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);
+      const sub = this.realtimeClient.getSubscription(channel);
+      if (sub) {
+        sub.unsubscribe();
+        this.realtimeClient.removeSubscription(sub);
+      }
+      this.listenersMap.delete(channel);
+    }
+  }
+  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,
+      top100Amount: this.formatScientificNotation(data.t100a),
+      top10Amount: this.formatScientificNotation(data.t10a),
+      top100Holders: data.t100h,
+      top10Holders: data.t10h,
+      top100Ratio: this.formatScientificNotation(data.t100r),
+      top10Ratio: this.formatScientificNotation(data.t10r),
+      creatorsHolders: data.ch,
+      creatorsAmount: this.formatScientificNotation(data.ca),
+      creatorsRatio: this.formatScientificNotation(data.cr),
+      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) {
+        result.launchFrom = {};
+        if (data.lf.pa) {
+          result.launchFrom.programAddress = data.lf.pa;
+        }
+        if (data.lf.pf) {
+          result.launchFrom.protocolFamily = data.lf.pf;
+        }
+        if (data.lf.pn) {
+          result.launchFrom.protocolName = data.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 socialMedia = {};
+              if (it.sm?.tw) {
+                socialMedia.twitter = it.sm.tw;
+              }
+              if (it.sm?.tg) {
+                socialMedia.telegram = it.sm.tg;
+              }
+              if (it.sm?.w) {
+                socialMedia.website = it.sm.w;
+              }
+              if (it.sm?.tt) {
+                socialMedia.tiktok = it.sm.tt;
+              }
+              if (it.sm?.dc) {
+                socialMedia.discord = it.sm.dc;
+              }
+              if (it.sm?.fb) {
+                socialMedia.facebook = it.sm.fb;
+              }
+              if (it.sm?.gh) {
+                socialMedia.github = it.sm.gh;
+              }
+              if (it.sm?.ig) {
+                socialMedia.instagram = it.sm.ig;
+              }
+              if (it.sm?.li) {
+                socialMedia.linkedin = it.sm.li;
+              }
+              if (it.sm?.md) {
+                socialMedia.medium = it.sm.md;
+              }
+              if (it.sm?.rd) {
+                socialMedia.reddit = it.sm.rd;
+              }
+              if (it.sm?.yt) {
+                socialMedia.youtube = it.sm.yt;
+              }
+              if (it.sm?.bb) {
+                socialMedia.bitbucket = it.sm.bb;
+              }
+              return socialMedia;
+            })(),
+            createdAtMs: it.cts
+          })
+        )
+      )
+    );
+  }
+  // subscribeNewTokens({
+  //   chain,
+  //   callback,
+  // }: {
+  //   chain: string;
+  //   callback: (data: NewToken[]) => void;
+  // }): Unsubscrible {
+  //   const channel = `dex-new-tokens:${chain}`;
+  //   return this.subscribe(channel, (data: any[]) =>
+  //     callback(
+  //       data.map(
+  //         (it: any) =>
+  //           ({
+  //             tokenAddress: it.a,
+  //             name: it.n,
+  //             symbol: it.s,
+  //             description: it.de,
+  //             createdAtMs: it.cts,
+  //           }) as NewToken
+  //       )
+  //     )
+  //   );
+  // }
+  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");
+  }
+  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 = {};
+          if (item.t) {
+            result.metadata = {
+              tokenAddress: item.t.a
+            };
+            if (item.t.n) {
+              result.metadata.name = item.t.n;
+            }
+            if (item.t.s) {
+              result.metadata.symbol = item.t.s;
+            }
+            if (item.t.iu) {
+              result.metadata.imageUrl = item.t.iu;
+            }
+            if (item.t.de) {
+              result.metadata.description = item.t.de;
+            }
+            if (item.t.d) {
+              result.metadata.decimals = item.t.dec;
+            }
+            if (item.t.cts) {
+              result.metadata.createdAtMs = item.t.cts;
+            }
+            if (item.t.lf) {
+              result.metadata.launchFrom = {};
+              if (item.t.lf.pa) {
+                result.metadata.launchFrom.programAddress = item.t.lf.pa;
+              }
+              if (item.t.lf.pf) {
+                result.metadata.launchFrom.protocolFamily = item.t.lf.pf;
+              }
+              if (item.t.lf.pn) {
+                result.metadata.launchFrom.protocolName = item.t.lf.pn;
+              }
+            }
+            if (item.t.mt) {
+              result.metadata.migratedTo = {};
+              if (item.t.mt.pa) {
+                result.metadata.migratedTo.programAddress = item.t.mt.pa;
+              }
+              if (item.t.mt.pf) {
+                result.metadata.migratedTo.protocolFamily = item.t.mt.pf;
+              }
+              if (item.t.mt.pn) {
+                result.metadata.migratedTo.protocolName = item.t.mt.pn;
+              }
+            }
+            if (item.t.sm) {
+              result.metadata.socialMedia = {};
+              if (item.t.sm.tw) {
+                result.metadata.socialMedia.twitter = item.t.sm.tw;
+              }
+              if (item.t.sm.tg) {
+                result.metadata.socialMedia.telegram = item.t.sm.tg;
+              }
+              if (item.t.sm.w) {
+                result.metadata.socialMedia.website = item.t.sm.w;
+              }
+              if (item.t.sm.tt) {
+                result.metadata.socialMedia.tiktok = item.t.sm.tt;
+              }
+              if (item.t.sm.dc) {
+                result.metadata.socialMedia.discord = item.t.sm.dc;
+              }
+              if (item.t.sm.fb) {
+                result.metadata.socialMedia.facebook = item.t.sm.fb;
+              }
+              if (item.t.sm.gh) {
+                result.metadata.socialMedia.github = item.t.sm.gh;
+              }
+              if (item.t.sm.ig) {
+                result.metadata.socialMedia.instagram = item.t.sm.ig;
+              }
+              if (item.t.sm.li) {
+                result.metadata.socialMedia.linkedin = item.t.sm.li;
+              }
+              if (item.t.sm.md) {
+                result.metadata.socialMedia.medium = item.t.sm.md;
+              }
+              if (item.t.sm.rd) {
+                result.metadata.socialMedia.reddit = item.t.sm.rd;
+              }
+              if (item.t.sm.yt) {
+                result.metadata.socialMedia.youtube = item.t.sm.yt;
+              }
+              if (item.t.sm.bb) {
+                result.metadata.socialMedia.bitbucket = item.t.sm.bb;
+              }
+            }
+            if (item.t.cts) {
+              result.metadata.createdAtMs = item.t.cts;
+            }
+          }
+          if (item.bc) {
+            result.bondingCurve = {};
+            if (item.bc.pr) {
+              result.bondingCurve.progressRatio = this.formatScientificNotation(item.bc.pr);
+            }
+          }
+          if (item.h) {
+            result.holder = {
+              tokenAddress: item.h.a,
+              timestamp: item.h.ts || 0
+            };
+            if (item.h.h) {
+              result.holder.holders = item.h.h;
+            }
+            if (item.h.t100a) {
+              result.holder.top100Amount = this.formatScientificNotation(item.h.t100a);
+            }
+            if (item.h.t10a) {
+              result.holder.top10Amount = this.formatScientificNotation(item.h.t10a);
+            }
+            if (item.h.t100h) {
+              result.holder.top100Holders = item.h.t100h;
+            }
+            if (item.h.t10h) {
+              result.holder.top10Holders = item.h.t10h;
+            }
+            if (item.h.t100r) {
+              result.holder.top100Ratio = this.formatScientificNotation(item.h.t100r);
+            }
+            if (item.h.t10r) {
+              result.holder.top10Ratio = this.formatScientificNotation(item.h.t10r);
+            }
+          }
+          if (item.s) {
+            result.supply = {
+              tokenAddress: item.s.a,
+              timestamp: item.s.ts || 0
+            };
+            if (item.s.s) {
+              result.supply.supply = item.s.s;
+            }
+            if (item.s.mc) {
+              result.supply.marketCapInUsd = item.s.mc;
+            }
+          }
+          if (item.ts) {
+            result.stat = {
+              address: item.ts.a,
+              timestamp: item.ts.t || 0
+            };
+            if (item.ts.b1m) {
+              result.stat.buys1m = item.ts.b1m;
+            }
+            if (item.ts.s1m) {
+              result.stat.sells1m = item.ts.s1m;
+            }
+            if (item.ts.be1m) {
+              result.stat.buyers1m = item.ts.be1m;
+            }
+            if (item.ts.se1m) {
+              result.stat.sellers1m = item.ts.se1m;
+            }
+            if (item.ts.bviu1m) {
+              result.stat.buyVolumeInUsd1m = this.formatScientificNotation(item.ts.bviu1m);
+            }
+            if (item.ts.sviu1m) {
+              result.stat.sellVolumeInUsd1m = this.formatScientificNotation(item.ts.sviu1m);
+            }
+            if (item.ts.p1m) {
+              result.stat.price1m = this.formatScientificNotation(item.ts.p1m);
+            }
+            if (item.ts.oiu1m) {
+              result.stat.openInUsd1m = this.formatScientificNotation(item.ts.oiu1m);
+            }
+            if (item.ts.ciu1m) {
+              result.stat.closeInUsd1m = this.formatScientificNotation(item.ts.ciu1m);
+            }
+            if (item.ts.b5m) {
+              result.stat.buys5m = item.ts.b5m;
+            }
+            if (item.ts.s5m) {
+              result.stat.sells5m = item.ts.s5m;
+            }
+            if (item.ts.be5m) {
+              result.stat.buyers5m = item.ts.be5m;
+            }
+            if (item.ts.se5m) {
+              result.stat.sellers5m = item.ts.se5m;
+            }
+            if (item.ts.bviu5m) {
+              result.stat.buyVolumeInUsd5m = this.formatScientificNotation(item.ts.bviu5m);
+            }
+            if (item.ts.sviu5m) {
+              result.stat.sellVolumeInUsd5m = this.formatScientificNotation(item.ts.sviu5m);
+            }
+            if (item.ts.p5m) {
+              result.stat.price5m = this.formatScientificNotation(item.ts.p5m);
+            }
+            if (item.ts.oiu5m) {
+              result.stat.openInUsd5m = this.formatScientificNotation(item.ts.oiu5m);
+            }
+            if (item.ts.ciu5m) {
+              result.stat.closeInUsd5m = this.formatScientificNotation(item.ts.ciu5m);
+            }
+            if (item.ts.b15m) {
+              result.stat.buys15m = item.ts.b15m;
+            }
+            if (item.ts.s15m) {
+              result.stat.sells15m = item.ts.s15m;
+            }
+            if (item.ts.be15m) {
+              result.stat.buyers15m = item.ts.be15m;
+            }
+            if (item.ts.se15m) {
+              result.stat.sellers15m = item.ts.se15m;
+            }
+            if (item.ts.bviu15m) {
+              result.stat.buyVolumeInUsd15m = this.formatScientificNotation(item.ts.bviu15m);
+            }
+            if (item.ts.sviu15m) {
+              result.stat.sellVolumeInUsd15m = this.formatScientificNotation(item.ts.sviu15m);
+            }
+            if (item.ts.p15m) {
+              result.stat.price15m = this.formatScientificNotation(item.ts.p15m);
+            }
+            if (item.ts.oiu15m) {
+              result.stat.openInUsd15m = this.formatScientificNotation(item.ts.oiu15m);
+            }
+            if (item.ts.ciu15m) {
+              result.stat.closeInUsd15m = this.formatScientificNotation(item.ts.ciu15m);
+            }
+            if (item.ts.b30m) {
+              result.stat.buys30m = item.ts.b30m;
+            }
+            if (item.ts.s30m) {
+              result.stat.sells30m = item.ts.s30m;
+            }
+            if (item.ts.be30m) {
+              result.stat.buyers30m = item.ts.be30m;
+            }
+            if (item.ts.se30m) {
+              result.stat.sellers30m = item.ts.se30m;
+            }
+            if (item.ts.bviu30m) {
+              result.stat.buyVolumeInUsd30m = this.formatScientificNotation(item.ts.bviu30m);
+            }
+            if (item.ts.sviu30m) {
+              result.stat.sellVolumeInUsd30m = this.formatScientificNotation(item.ts.sviu30m);
+            }
+            if (item.ts.p30m) {
+              result.stat.price30m = this.formatScientificNotation(item.ts.p30m);
+            }
+            if (item.ts.oiu30m) {
+              result.stat.openInUsd30m = this.formatScientificNotation(item.ts.oiu30m);
+            }
+            if (item.ts.ciu30m) {
+              result.stat.closeInUsd30m = this.formatScientificNotation(item.ts.ciu30m);
+            }
+            if (item.ts.b1h) {
+              result.stat.buys1h = item.ts.b1h;
+            }
+            if (item.ts.s1h) {
+              result.stat.sells1h = item.ts.s1h;
+            }
+            if (item.ts.be1h) {
+              result.stat.buyers1h = item.ts.be1h;
+            }
+            if (item.ts.se1h) {
+              result.stat.sellers1h = item.ts.se1h;
+            }
+            if (item.ts.bviu1h) {
+              result.stat.buyVolumeInUsd1h = this.formatScientificNotation(item.ts.bviu1h);
+            }
+            if (item.ts.sviu1h) {
+              result.stat.sellVolumeInUsd1h = this.formatScientificNotation(item.ts.sviu1h);
+            }
+            if (item.ts.p1h) {
+              result.stat.price1h = this.formatScientificNotation(item.ts.p1h);
+            }
+            if (item.ts.oiu1h) {
+              result.stat.openInUsd1h = this.formatScientificNotation(item.ts.oiu1h);
+            }
+            if (item.ts.ciu1h) {
+              result.stat.closeInUsd1h = this.formatScientificNotation(item.ts.ciu1h);
+            }
+            if (item.ts.b4h) {
+              result.stat.buys4h = item.ts.b4h;
+            }
+            if (item.ts.s4h) {
+              result.stat.sells4h = item.ts.s4h;
+            }
+            if (item.ts.be4h) {
+              result.stat.buyers4h = item.ts.be4h;
+            }
+            if (item.ts.se4h) {
+              result.stat.sellers4h = item.ts.se4h;
+            }
+            if (item.ts.bviu4h) {
+              result.stat.buyVolumeInUsd4h = this.formatScientificNotation(item.ts.bviu4h);
+            }
+            if (item.ts.sviu4h) {
+              result.stat.sellVolumeInUsd4h = this.formatScientificNotation(item.ts.sviu4h);
+            }
+            if (item.ts.p4h) {
+              result.stat.price4h = this.formatScientificNotation(item.ts.p4h);
+            }
+            if (item.ts.oiu4h) {
+              result.stat.openInUsd4h = this.formatScientificNotation(item.ts.oiu4h);
+            }
+            if (item.ts.ciu4h) {
+              result.stat.closeInUsd4h = this.formatScientificNotation(item.ts.ciu4h);
+            }
+            if (item.ts.b24h) {
+              result.stat.buys24h = item.ts.b24h;
+            }
+            if (item.ts.s24h) {
+              result.stat.sells24h = item.ts.s24h;
+            }
+            if (item.ts.be24h) {
+              result.stat.buyers24h = item.ts.be24h;
+            }
+            if (item.ts.se24h) {
+              result.stat.sellers24h = item.ts.se24h;
+            }
+            if (item.ts.bviu24h) {
+              result.stat.buyVolumeInUsd24h = this.formatScientificNotation(item.ts.bviu24h);
+            }
+            if (item.ts.sviu24h) {
+              result.stat.sellVolumeInUsd24h = this.formatScientificNotation(item.ts.sviu24h);
+            }
+            if (item.ts.p24h) {
+              result.stat.price24h = this.formatScientificNotation(item.ts.p24h);
+            }
+            if (item.ts.oiu24h) {
+              result.stat.openInUsd24h = this.formatScientificNotation(item.ts.oiu24h);
+            }
+            if (item.ts.ciu24h) {
+              result.stat.closeInUsd24h = this.formatScientificNotation(item.ts.ciu24h);
+            }
+            if (item.ts.p) {
+              result.stat.price = this.formatScientificNotation(item.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),
+            buys15m: it.b15m,
+            sells15m: it.s15m,
+            buyers15m: it.be15m,
+            sellers15m: it.se15m,
+            buyVolumeInUsd15m: this.formatScientificNotation(it.bviu15m),
+            sellVolumeInUsd15m: this.formatScientificNotation(it.sviu15m),
+            price15m: this.formatScientificNotation(it.p15m),
+            openInUsd15m: this.formatScientificNotation(it.oiu15m),
+            closeInUsd15m: this.formatScientificNotation(it.ciu15m),
+            buys30m: it.b30m,
+            sells30m: it.s30m,
+            buyers30m: it.be30m,
+            sellers30m: it.se30m,
+            buyVolumeInUsd30m: this.formatScientificNotation(it.bviu30m),
+            sellVolumeInUsd30m: this.formatScientificNotation(it.sviu30m),
+            price30m: this.formatScientificNotation(it.p30m),
+            openInUsd30m: this.formatScientificNotation(it.oiu30m),
+            closeInUsd30m: this.formatScientificNotation(it.ciu30m),
+            buys1h: it.b1h,
+            sells1h: it.s1h,
+            buyers1h: it.be1h,
+            sellers1h: it.se1h,
+            buyVolumeInUsd1h: this.formatScientificNotation(it.bviu1h),
+            sellVolumeInUsd1h: this.formatScientificNotation(it.sviu1h),
+            price1h: this.formatScientificNotation(it.p1h),
+            openInUsd1h: this.formatScientificNotation(it.oiu1h),
+            closeInUsd1h: this.formatScientificNotation(it.ciu1h),
+            buys4h: it.b4h,
+            sells4h: it.s4h,
+            buyers4h: it.be4h,
+            sellers4h: it.se4h,
+            buyVolumeInUsd4h: this.formatScientificNotation(it.bviu4h),
+            sellVolumeInUsd4h: this.formatScientificNotation(it.sviu4h),
+            price4h: this.formatScientificNotation(it.p4h),
+            openInUsd4h: this.formatScientificNotation(it.oiu4h),
+            closeInUsd4h: this.formatScientificNotation(it.ciu4h),
+            buys24h: it.b24h,
+            sells24h: it.s24h,
+            buyers24h: it.be24h,
+            sellers24h: it.se24h,
+            buyVolumeInUsd24h: this.formatScientificNotation(it.bviu24h),
+            sellVolumeInUsd24h: this.formatScientificNotation(it.sviu24h),
+            price24h: this.formatScientificNotation(it.p24h),
+            price: this.formatScientificNotation(it.p),
+            openInUsd24h: this.formatScientificNotation(it.oiu24h),
+            closeInUsd24h: this.formatScientificNotation(it.ciu24h)
+          })
+        )
+      )
+    );
+  }
+  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,
+            top100Amount: this.formatScientificNotation(it.t100a),
+            top10Amount: this.formatScientificNotation(it.t10a),
+            top100Holders: it.t100h,
+            top10Holders: it.t10h,
+            top100Ratio: this.formatScientificNotation(it.t100r),
+            top10Ratio: 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
+          })
+        )
+      )
+    );
+  }
+  // subscribeTokenTrades({
+  //   chain,
+  //   tokenAddress,
+  //   callback,
+  // }: {
+  //   chain: string;
+  //   tokenAddress: string;
+  //   callback: (data: TradeEvent[]) => void;
+  // }): Unsubscrible {
+  //   const channel = `dex-trades:${chain}_${tokenAddress}`;
+  //   return this.subscribe(channel, (data: any[]) =>
+  //     callback(
+  //       data?.map(
+  //         (it: any) =>
+  //           ({
+  //             maker: it.bwa,
+  //             baseAmount: it.ba,
+  //             quoteAmount: it.sa,
+  //             // quoteSymbol: ,
+  //             quoteAddress: it.swa,
+  //             amountInUsd: it.baiu,
+  //             timestamp: it.t,
+  //             event: it.k,
+  //             txHash: it.h,
+  //             // priceInUsd: ,
+  //             // id: ,
+  //             // buyCostUsd: it.,
+  //             tokenAddress: it.a,
+  //           }) as TradeEvent
+  //       )
+  //     )
+  //   );
+  // }
+  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 StreamUnsubscrible = class {
+  constructor(streamApi, channel, fn) {
+    this.streamApi = streamApi;
+    this.channel = channel;
+    this.fn = fn;
+  }
+  unsubscribe() {
+    this.streamApi.unsubscribe(this.channel, this.fn);
+  }
+};
+
+// src/stream/stream.model.ts
+var TokenActivityType = /* @__PURE__ */ ((TokenActivityType2) => {
+  TokenActivityType2["Sell"] = "sell";
+  TokenActivityType2["Buy"] = "buy";
+  TokenActivityType2["AddLiquidity"] = "add_liquidity";
+  TokenActivityType2["RemoveLiquidity"] = "remove_liquidity";
+  return TokenActivityType2;
+})(TokenActivityType || {});
+var ChannelType = /* @__PURE__ */ ((ChannelType2) => {
+  ChannelType2["New"] = "new";
+  ChannelType2["HOT"] = "trending";
+  ChannelType2["US_STOCKS"] = "us_stocks";
+  ChannelType2["COMPLETED"] = "completed";
+  ChannelType2["GRADUATED"] = "graduated";
+  return ChannelType2;
+})(ChannelType || {});
+var MetricType = /* @__PURE__ */ ((MetricType2) => {
+  MetricType2["LIQUIDITY_IN_USD"] = "liquidity_in_usd";
+  MetricType2["MIGRATED_RATIO"] = "migrated_ratio";
+  return MetricType2;
+})(MetricType || {});
+var RankingType = /* @__PURE__ */ ((RankingType2) => {
+  RankingType2["NEW"] = "new";
+  RankingType2["HOT"] = "trending";
+  RankingType2["STOCKS"] = "stocks";
+  RankingType2["FINALSTRETCH"] = "completed";
+  RankingType2["MIGRATED"] = "graduated";
+  return RankingType2;
+})(RankingType || {});
+var Dex = /* @__PURE__ */ ((Dex2) => {
+  Dex2["PUMP_FUN"] = "pump_fun";
+  Dex2["RAYDIUM_LAUNCHPAD"] = "raydium_launchpad";
+  Dex2["METEOR_DYNAMIC_BOUNDING_CURVE"] = "meteora_dynamic_bounding_curve";
+  Dex2["BONK_FUN"] = "bonk_fun";
+  Dex2["BOOP_FUN"] = "boop_fun";
+  Dex2["MOONIT_FUN"] = "moonit_fun";
+  return Dex2;
+})(Dex || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CEL_FIELD_MAPPINGS,
+  ChannelType,
+  Dex,
+  MetricType,
+  RankingType,
+  StreamApi,
+  TokenActivityType,
+  getAvailableFields,
+  getFieldMappings,
+  replaceFilterFields
+});
+//# sourceMappingURL=index.cjs.map