@chainstream-io/sdk 0.0.12 → 0.1.5

package/dist/{src → esm}/api/stream.d.ts

@@ -1,6 +1,6 @@
 import { DexRequestContext } from "..";
 import { Resolution } from "../openapi";
-import { DexPoolBalance, NewToken, TokenMetadata, TokenHolder, TokenStat, TokenLiquidity, WalletBalance, TokenSupply, WalletPnl, ChannelType, TokenCandle, TradeActivity, WalletTokenPnl, RankingType, Dex, RankingTokenList } from "./stream.model";
+import { DexPoolBalance, NewToken, TokenMetadata, TokenHolder, TokenStat, TokenLiquidity, WalletBalance, TokenSupply, WalletPnl, ChannelType, TokenCandle, TradeActivity, WalletTokenPnl, RankingType, Dex, RankingTokenList, TokenBondingCurve } from "./stream.model";
 export interface Unsubscrible {
     unsubscribe(): void;
 }
@@ -9,9 +9,29 @@ export declare class StreamApi {
     private listenersMap;
     constructor(context: DexRequestContext);
     connect(): void;
+    /**
+     * Start batching commands for efficient bulk operations
+     * All subscription commands after this call will be batched until stopBatching is called
+     */
     startBatching(): void;
+    /**
+     * Stop batching and flush all collected commands to the server
+     * This will send all batched subscription commands in a single network request
+     */
     stopBatching(): void;
+    /**
+     * 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: () => Unsubscrible[]): Unsubscrible[];
+    /**
+     * 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: Unsubscrible[]): void;
     subscribe<T = any>(channel: string, fn: (data: T) => void, filter?: string, methodName?: string): Unsubscrible;
     unsubscribe<T = any>(channel: string, fn: (data: T) => void): void;
     private formatScientificNotation;
@@ -28,86 +48,85 @@ export declare class StreamApi {
         callback: (data: TokenStat) => void;
         filter?: string;
     }): Unsubscrible;
-    subscribeRankingTokensStats({ chain, channelType, callback, }: {
-        chain: string;
-        channelType: ChannelType;
-        callback: (data: TokenStat[]) => void;
-    }): Unsubscrible;
     subscribeTokenHolders({ chain, tokenAddress, callback, filter, }: {
         chain: string;
         tokenAddress: string;
         callback: (data: TokenHolder) => void;
         filter?: string;
     }): Unsubscrible;
-    subscribeRankingTokensHolders({ chain, channelType, callback, }: {
+    subscribeNewToken({ chain, callback, filter, }: {
         chain: string;
-        channelType: ChannelType;
-        callback: (data: TokenHolder[]) => void;
+        callback: (data: NewToken) => void;
+        filter?: string;
     }): Unsubscrible;
-    subscribeTokenTrades({ chain, tokenAddress, callback, filter, }: {
+    subscribeNewTokensMetadata({ chain, callback, }: {
         chain: string;
-        tokenAddress: string;
-        callback: (data: TradeActivity) => void;
-        filter?: string;
+        callback: (data: TokenMetadata[]) => void;
     }): Unsubscrible;
-    subscribeWalletBalance({ chain, walletAddress, callback, filter, }: {
+    subscribeTokenSupply({ chain, tokenAddress, callback, filter, }: {
         chain: string;
-        walletAddress: string;
-        callback: (data: WalletBalance[]) => void;
+        tokenAddress: string;
+        callback: (data: TokenSupply) => void;
         filter?: string;
     }): Unsubscrible;
-    subscribeWalletPnl({ chain, walletAddress, callback, filter, }: {
+    subscribeTokenLiquidity({ chain, tokenAddress, callback, filter, }: {
         chain: string;
-        walletAddress: string;
-        callback: (data: WalletTokenPnl) => void;
+        tokenAddress: string;
+        callback: (data: TokenLiquidity) => void;
         filter?: string;
     }): Unsubscrible;
-    subscribeWalletPnlList({ chain, walletAddress, callback, }: {
+    subscribeRankingTokensLiquidity({ chain, channelType, callback, }: {
         chain: string;
-        walletAddress: string;
-        callback: (data: WalletPnl[]) => void;
+        channelType: ChannelType;
+        callback: (data: TokenLiquidity[]) => void;
     }): Unsubscrible;
-    subscribeNewTokensMetadata({ chain, callback, }: {
+    subscribeRankingTokensList({ chain, ranking_type, dex, callback, }: {
         chain: string;
-        callback: (data: TokenMetadata[]) => void;
+        ranking_type: RankingType;
+        dex?: Dex;
+        callback: (data: RankingTokenList[]) => void;
     }): Unsubscrible;
-    subscribeNewToken({ chain, callback, filter, }: {
+    subscribeRankingTokensStats({ chain, channelType, callback, }: {
         chain: string;
-        callback: (data: NewToken) => void;
-        filter?: string;
+        channelType: ChannelType;
+        callback: (data: TokenStat[]) => void;
     }): Unsubscrible;
-    subscribeTokenSupply({ chain, tokenAddress, callback, filter, }: {
+    subscribeRankingTokensHolders({ chain, channelType, callback, }: {
         chain: string;
-        tokenAddress: string;
-        callback: (data: TokenSupply) => void;
-        filter?: string;
+        channelType: ChannelType;
+        callback: (data: TokenHolder[]) => void;
     }): Unsubscrible;
     subscribeRankingTokensSupply({ chain, channelType, callback, }: {
         chain: string;
         channelType: ChannelType;
         callback: (data: TokenSupply[]) => void;
     }): Unsubscrible;
-    subscribeDexPoolBalance({ chain, poolAddress, callback, }: {
+    subscribeRankingTokensBondingCurve({ chain, callback, }: {
         chain: string;
-        poolAddress: string;
-        callback: (data: DexPoolBalance) => void;
+        callback: (data: TokenBondingCurve[]) => void;
     }): Unsubscrible;
-    subscribeTokenLiquidity({ chain, tokenAddress, callback, filter, }: {
+    subscribeWalletBalance({ chain, walletAddress, callback, filter, }: {
         chain: string;
-        tokenAddress: string;
-        callback: (data: TokenLiquidity) => void;
+        walletAddress: string;
+        callback: (data: WalletBalance[]) => void;
         filter?: string;
     }): Unsubscrible;
-    subscribeRankingTokensLiquidity({ chain, channelType, callback, }: {
+    subscribeWalletPnl({ chain, walletAddress, callback, filter, }: {
         chain: string;
-        channelType: ChannelType;
-        callback: (data: TokenLiquidity[]) => void;
+        walletAddress: string;
+        callback: (data: WalletTokenPnl) => void;
+        filter?: string;
     }): Unsubscrible;
-    subscribeRankingTokensList({ chain, ranking_type, dex, callback, }: {
+    subscribeWalletPnlList({ chain, walletAddress, callback, }: {
         chain: string;
-        ranking_type: RankingType;
-        dex?: Dex;
-        callback: (data: RankingTokenList[]) => void;
+        walletAddress: string;
+        callback: (data: WalletPnl[]) => void;
+    }): Unsubscrible;
+    subscribeTokenTrade({ chain, tokenAddress, callback, filter, }: {
+        chain: string;
+        tokenAddress: string;
+        callback: (data: TradeActivity) => void;
+        filter?: string;
     }): Unsubscrible;
     subscribeWalletTrade({ chain, walletAddress, callback, filter, }: {
         chain: string;
@@ -115,4 +134,9 @@ export declare class StreamApi {
         callback: (data: TradeActivity) => void;
         filter?: string;
     }): Unsubscrible;
+    subscribeDexPoolBalance({ chain, poolAddress, callback, }: {
+        chain: string;
+        poolAddress: string;
+        callback: (data: DexPoolBalance) => void;
+    }): Unsubscrible;
 }

package/dist/esm/api/stream.fields.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Field mappings for CEL filter expressions
+ * Maps human-readable field names to short field names used in the API
+ * Organized by subscription method to handle field name conflicts
+ */
+export interface FieldMapping {
+    readonly [key: string]: string;
+}
+export interface MethodFieldMappings {
+    readonly [methodName: string]: FieldMapping;
+}
+/**
+ * Field mappings organized by subscription method
+ * Each method can have its own field mappings to handle conflicts
+ */
+export declare const CEL_FIELD_MAPPINGS: MethodFieldMappings;
+/**
+ * Get field mappings for a specific subscription method
+ * @param methodName - The name of the subscription method
+ * @returns Field mapping object for the method, or empty object if not found
+ */
+export declare function getFieldMappings(methodName: string): FieldMapping;
+/**
+ * Replace long field names with short field names in a filter expression
+ * Automatically adds meta. prefix if not present
+ * @param filter - Original filter expression
+ * @param methodName - The name of the subscription method
+ * @returns Filter expression with short field names and meta. prefix
+ */
+export declare function replaceFilterFields(filter: string, methodName: string): string;
+/**
+ * Type-safe field mapping for specific subscription methods
+ */
+export type SubscriptionMethod = keyof typeof CEL_FIELD_MAPPINGS;
+/**
+ * Get available field names for a specific subscription method
+ * @param methodName - The name of the subscription method
+ * @returns Array of available field names
+ */
+export declare function getAvailableFields(methodName: string): string[];

package/dist/{src → esm}/api/stream.fields.js

@@ -1,7 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getAvailableFields = exports.replaceFilterFields = exports.getFieldMappings = exports.CEL_FIELD_MAPPINGS = void 0;
-exports.CEL_FIELD_MAPPINGS = {
+/**
+ * Field mappings for CEL filter expressions
+ * Maps human-readable field names to short field names used in the API
+ * Organized by subscription method to handle field name conflicts
+ */
+/**
+ * Field mappings organized by subscription method
+ * Each method can have its own field mappings to handle conflicts
+ */
+export const CEL_FIELD_MAPPINGS = {
+    // Wallet balance subscription fields
     "subscribeWalletBalance": {
         "walletAddress": "a",
         "tokenAddress": "ta",
@@ -9,6 +16,7 @@ exports.CEL_FIELD_MAPPINGS = {
         "balance": "b",
         "timestamp": "t",
     },
+    // Token candles subscription fields
     "subscribeTokenCandles": {
         "open": "o",
         "close": "c",
@@ -19,6 +27,7 @@ exports.CEL_FIELD_MAPPINGS = {
         "time": "t",
         "number": "n",
     },
+    // Token stats subscription fields
     "subscribeTokenStats": {
         "address": "a",
         "timestamp": "t",
@@ -87,6 +96,7 @@ exports.CEL_FIELD_MAPPINGS = {
         "openInUsd24h": "oiu24h",
         "closeInUsd24h": "ciu24h",
     },
+    // Token holder subscription fields
     "subscribeTokenHolders": {
         "tokenAddress": "a",
         "holders": "h",
@@ -98,17 +108,20 @@ exports.CEL_FIELD_MAPPINGS = {
         "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",
@@ -116,12 +129,14 @@ exports.CEL_FIELD_MAPPINGS = {
         "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",
@@ -131,6 +146,7 @@ exports.CEL_FIELD_MAPPINGS = {
         "socialMedia": "sm",
         "createdAtMs": "cts",
     },
+    // Token trades subscription fields
     "subscribeTokenTrades": {
         "tokenAddress": "a",
         "timestamp": "t",
@@ -149,6 +165,7 @@ exports.CEL_FIELD_MAPPINGS = {
         "sellWalletAddress": "swa",
         "txHash": "h",
     },
+    // Wallet token PnL subscription fields
     "subscribeWalletPnl": {
         "walletAddress": "a",
         "tokenAddress": "ta",
@@ -178,19 +195,34 @@ exports.CEL_FIELD_MAPPINGS = {
         "totalRealizedProfitRatio": "trr",
     },
 };
-function getFieldMappings(methodName) {
-    return exports.CEL_FIELD_MAPPINGS[methodName] || {};
+/**
+ * Get field mappings for a specific subscription method
+ * @param methodName - The name of the subscription method
+ * @returns Field mapping object for the method, or empty object if not found
+ */
+export function getFieldMappings(methodName) {
+    return CEL_FIELD_MAPPINGS[methodName] || {};
 }
-exports.getFieldMappings = getFieldMappings;
-function replaceFilterFields(filter, methodName) {
+/**
+ * Replace long field names with short field names in a filter expression
+ * Automatically adds meta. prefix if not present
+ * @param filter - Original filter expression
+ * @param methodName - The name of the subscription method
+ * @returns Filter expression with short field names and meta. prefix
+ */
+export function replaceFilterFields(filter, methodName) {
     if (!filter) {
         return filter;
     }
     const fieldMappings = getFieldMappings(methodName);
     let result = filter;
+    // Replace all long field names with short field names
     for (const [longField, shortField] of Object.entries(fieldMappings)) {
+        // Handle both cases: with and without meta. prefix
         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) => {
@@ -199,10 +231,12 @@ function replaceFilterFields(filter, methodName) {
     }
     return result;
 }
-exports.replaceFilterFields = replaceFilterFields;
-function getAvailableFields(methodName) {
+/**
+ * Get available field names for a specific subscription method
+ * @param methodName - The name of the subscription method
+ * @returns Array of available field names
+ */
+export function getAvailableFields(methodName) {
     const mappings = getFieldMappings(methodName);
     return Object.keys(mappings);
 }
-exports.getAvailableFields = getAvailableFields;
-//# sourceMappingURL=stream.fields.js.map