@pear-protocol/exchanges-sdk 0.0.10 → 0.0.12

package/dist/account/exchanges/binance/types.d.ts

@@ -1,77 +1,4 @@
-import { MarginMode } from '../../types.js';
+export { f as BinanceAccountType, l as BinanceAssetIndex, o as BinanceMultiAssetsMarginResponse, j as BinanceRawAccountStatus, p as BinanceRawAsset, k as BinanceRawPositionRisk, m as BinanceRawUserDataEvent, n as BinanceWsHandlers } from '../../../types-D2dbAtin.js';
 import '@pear-protocol/types';
-
-interface BinanceRawPositionRisk {
-    symbol: string;
-    leverage: string;
-    marginType: MarginMode;
-    isAutoAddMargin: string;
-    isolatedMargin: string;
-    positionAmt: string;
-    entryPrice: string;
-    breakEvenPrice: string;
-    unRealizedProfit: string;
-    liquidationPrice: string;
-    markPrice: string;
-    maxNotionalValue: string;
-    positionSide: string;
-    notional: string;
-    isolatedWallet: string;
-    updateTime: number;
-}
-interface BinanceRawAsset {
-    asset: string;
-    walletBalance: string;
-    availableBalance: string;
-    unrealizedProfit: string;
-    marginBalance: string;
-    initialMargin: string;
-    maintMargin: string;
-    marginAvailable: boolean;
-}
-interface BinanceRawAccountStatus {
-    totalWalletBalance: string;
-    totalMarginBalance: string;
-    availableBalance: string;
-    totalUnrealizedProfit: string;
-    totalInitialMargin: string;
-    totalMaintMargin: string;
-    multiAssetsMargin: boolean;
-    assets?: BinanceRawAsset[];
-}
-interface BinanceAssetIndex {
-    symbol: string;
-    time: number;
-    index: string;
-    bidBuffer: string;
-    askBuffer: string;
-    bidRate: string;
-    askRate: string;
-    autoExchangeBidBuffer: string;
-    autoExchangeAskBuffer: string;
-    autoExchangeBidRate: string;
-    autoExchangeAskRate: string;
-}
-interface BinanceRawUserDataEvent {
-    e?: string;
-    ac?: {
-        s: string;
-        l: string;
-    };
-    a?: {
-        B?: unknown[];
-        P?: unknown[];
-    };
-}
-interface BinanceRawLeverageResponse {
-    leverage: string;
-    maxNotionalValue: string;
-    symbol: string;
-}
-interface BinanceWsHandlers {
-    onUserDataEvent: (event: unknown) => void;
-    onWsApiResponse: (id: number, result: unknown) => void;
-    onClose: () => void;
-}
-
-export type { BinanceAssetIndex, BinanceRawAccountStatus, BinanceRawAsset, BinanceRawLeverageResponse, BinanceRawPositionRisk, BinanceRawUserDataEvent, BinanceWsHandlers };
+import '../bybit/types.js';
+import '../hyperliquid/types.js';

package/dist/account/exchanges/binance/types.js

@@ -1 +1,7 @@
+var BinanceAccountType = /* @__PURE__ */ ((BinanceAccountType2) => {
+  BinanceAccountType2["MULTI_ASSET"] = "MULTI_ASSET";
+  BinanceAccountType2["SINGLE_ASSET"] = "SINGLE_ASSET";
+  return BinanceAccountType2;
+})(BinanceAccountType || {});
 
+export { BinanceAccountType };

package/dist/account/exchanges/binance/ws.d.ts

@@ -1,6 +1,7 @@
 import { BinanceCredentialsDTO } from '@pear-protocol/types';
-import { BinanceWsHandlers } from './types.js';
-import '../../types.js';
+import { n as BinanceWsHandlers } from '../../../types-D2dbAtin.js';
+import '../bybit/types.js';
+import '../hyperliquid/types.js';
 
 declare class BinanceWs {
     private userDataWs;

package/dist/account/exchanges/binance/ws.js

@@ -1,5 +1,5 @@
 import { hmacSha256Hex } from '../../../utils/hmac';
-import { connectWs, sendWs } from '../../../utils/ws';
+import { createWs, waitForOpen, sendWs, ReconnectingWebSocket } from '../../../utils/ws';
 import { USER_DATA_STREAM_URL_TESTNET, USER_DATA_STREAM_URL, WS_API_URL_TESTNET, WS_API_URL } from './const';
 
 class BinanceWs {
@@ -15,26 +15,19 @@ class BinanceWs {
   }
   async connectUserDataStream(listenKey) {
     const url = this.demo ? USER_DATA_STREAM_URL_TESTNET : USER_DATA_STREAM_URL;
-    this.userDataWs = await connectWs(`${url}/${listenKey}`);
+    this.userDataWs = createWs(`${url}/${listenKey}`);
     this.userDataWs.addEventListener("message", (event) => {
       try {
         this.handlers.onUserDataEvent(JSON.parse(event.data));
       } catch {
       }
     });
-    this.userDataWs.onclose = () => {
-      if (this.userDataWs) {
-        this.userDataWs = null;
-        this.handlers.onClose();
-      }
-    };
-    this.userDataWs.onerror = () => {
-    };
+    await waitForOpen(this.userDataWs);
   }
   async connectWsApi(creds) {
     this.creds = creds;
     const url = this.demo ? WS_API_URL_TESTNET : WS_API_URL;
-    this.wsApiWs = await connectWs(url);
+    this.wsApiWs = createWs(url);
     this.wsApiWs.addEventListener("message", (event) => {
       try {
         const msg = JSON.parse(event.data);
@@ -44,14 +37,7 @@ class BinanceWs {
       } catch {
       }
     });
-    this.wsApiWs.onclose = () => {
-      if (this.wsApiWs) {
-        this.wsApiWs = null;
-        this.handlers.onClose();
-      }
-    };
-    this.wsApiWs.onerror = () => {
-    };
+    await waitForOpen(this.wsApiWs);
   }
   nextRequestId() {
     return this.requestId++;
@@ -67,18 +53,16 @@ class BinanceWs {
   close() {
     this.creds = null;
     if (this.userDataWs) {
-      this.userDataWs.onclose = null;
       this.userDataWs.close();
       this.userDataWs = null;
     }
     if (this.wsApiWs) {
-      this.wsApiWs.onclose = null;
       this.wsApiWs.close();
       this.wsApiWs = null;
     }
   }
   get isConnected() {
-    return this.userDataWs?.readyState === WebSocket.OPEN && this.wsApiWs?.readyState === WebSocket.OPEN;
+    return this.userDataWs?.readyState === ReconnectingWebSocket.OPEN && this.wsApiWs?.readyState === ReconnectingWebSocket.OPEN;
   }
 }
 

package/dist/account/exchanges/bybit/asset-tracker.d.ts

@@ -0,0 +1,25 @@
+import { BybitCredentialsDTO } from '@pear-protocol/types';
+import { S as StateUpdate, h as TrackedAssetInfo } from '../../../types-D2dbAtin.js';
+import './types.js';
+import '../hyperliquid/types.js';
+
+type OnStateUpdate = (update: StateUpdate) => void;
+type OnError = (error: Error) => void;
+declare class BybitAssetTracker {
+    private onStateUpdate;
+    private onError;
+    private getCreds;
+    private getDemo;
+    private trackedAssetInfos;
+    constructor(deps: {
+        onStateUpdate: OnStateUpdate;
+        onError: OnError;
+        getCreds: () => BybitCredentialsDTO;
+        getDemo: () => boolean;
+    });
+    getInfos(): Map<string, TrackedAssetInfo>;
+    onAssetTracked(coin: string): void;
+    onAssetUntracked(coin: string): void;
+}
+
+export { BybitAssetTracker };

package/dist/account/exchanges/bybit/asset-tracker.js

@@ -0,0 +1,37 @@
+import { fetchPositionLeverage } from './rest';
+
+class BybitAssetTracker {
+  onStateUpdate;
+  onError;
+  getCreds;
+  getDemo;
+  trackedAssetInfos = /* @__PURE__ */ new Map();
+  constructor(deps) {
+    this.onStateUpdate = deps.onStateUpdate;
+    this.onError = deps.onError;
+    this.getCreds = deps.getCreds;
+    this.getDemo = deps.getDemo;
+  }
+  getInfos() {
+    return this.trackedAssetInfos;
+  }
+  onAssetTracked(coin) {
+    fetchPositionLeverage(this.getCreds(), coin, this.getDemo()).then((pos) => {
+      const leverage = pos?.leverage || "1";
+      const marginType = pos?.tradeMode === "1" ? "isolated" : "cross";
+      const info = { coin, leverage, marginType };
+      this.trackedAssetInfos.set(coin, info);
+      const trackedAssets = /* @__PURE__ */ new Map();
+      trackedAssets.set(coin, info);
+      this.onStateUpdate({ trackedAssets });
+    }).catch((err) => {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    });
+  }
+  onAssetUntracked(coin) {
+    this.trackedAssetInfos.delete(coin);
+    this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
+  }
+}
+
+export { BybitAssetTracker };

package/dist/account/exchanges/bybit/mapper.d.ts

@@ -1,8 +1,9 @@
-import { AccountBalance, AccountPosition } from '../../types.js';
-import { BybitRawWallet, BybitRawCoin, BybitRawPosition } from './types.js';
+import { a as AccountBalance, c as AccountPosition } from '../../../types-D2dbAtin.js';
+import { BybitRawWallet, BybitRawCoin, BybitAccountType, BybitRawPosition } from './types.js';
 import '@pear-protocol/types';
+import '../hyperliquid/types.js';
 
-declare function buildBalance(raw: BybitRawWallet, coins: Map<string, BybitRawCoin>, marginMode: string): AccountBalance;
+declare function buildBalance(raw: BybitRawWallet, coins: Map<string, BybitRawCoin>, accountType: BybitAccountType | null): AccountBalance | null;
 declare function mergeRawCoins(existing: Map<string, BybitRawCoin>, incoming: BybitRawCoin[]): Map<string, BybitRawCoin>;
 declare function mapSinglePosition(p: BybitRawPosition, size: string): AccountPosition;
 declare function mapPositions(raw: BybitRawPosition[]): Map<string, AccountPosition>;

package/dist/account/exchanges/bybit/mapper.js

@@ -1,12 +1,14 @@
 import '../../types';
 import { positionKey } from '../../utils';
+import { BybitAccountType } from './types';
 
-function buildBalance(raw, coins, marginMode) {
+function buildBalance(raw, coins, accountType) {
+  if (!accountType) return null;
   const free = {};
   const used = {};
   const total = {};
   const assets = [];
-  const isPortfolio = marginMode === "portfolio";
+  const isPortfolio = accountType === BybitAccountType.PORTFOLIO_MARGIN;
   for (const [, c] of coins) {
     const equity = c.equity ?? "0";
     const positionInitialMargin = c.totalPositionIM === "" ? "0" : c.totalPositionIM ?? "0";
@@ -39,7 +41,7 @@ function buildBalance(raw, coins, marginMode) {
     });
   }
   return {
-    accountType: "UNIFIED",
+    accountType,
     free,
     used,
     total,

package/dist/account/exchanges/bybit/orchestrator.d.ts

@@ -1,22 +1,21 @@
-import { SupportedCredentials } from '../../types.js';
-import { BaseOrchestrator } from '../base.js';
+import { g as SupportedCredentials } from '../../../types-D2dbAtin.js';
+import { BaseOrchestrator, OrchestratorConfig } from '../base.js';
 import '@pear-protocol/types';
+import './types.js';
+import '../hyperliquid/types.js';
 
 declare class BybitOrchestrator extends BaseOrchestrator {
     private ws;
-    private rawCoins;
-    private lastWallet;
-    private trackedAssetInfos;
-    private marginMode;
-    start(credentials: SupportedCredentials): Promise<void>;
-    stop(): void;
+    private creds;
+    private stateHandler;
+    private assetTracker;
+    constructor(config: OrchestratorConfig, credentials: SupportedCredentials);
+    protected initAsync(): Promise<void>;
+    protected cleanupConnections(): void;
+    stop(): Promise<void>;
     get isConnected(): boolean;
     onAssetTracked(coin: string): void;
     onAssetUntracked(coin: string): void;
-    setLeverage(symbol: string, leverage: string): Promise<void>;
-    private stopAll;
-    private handleMessage;
-    private handleWalletUpdate;
 }
 
 export { BybitOrchestrator };

package/dist/account/exchanges/bybit/orchestrator.js

@@ -1,151 +1,65 @@
 import { BaseOrchestrator } from '../base';
-import { mergeRawCoins, buildBalance, mapPositions, mapPositionUpdates } from './mapper';
-import { fetchWalletBalance, fetchPositions, fetchAccountInfo, fetchPositionLeverage, setLeverage } from './rest';
+import { fetchWalletBalance, fetchPositions, fetchAccountInfo } from './rest';
+import './types';
 import { BybitWs } from './ws';
+import { BybitStateHandler } from './state-handler';
+import { BybitAssetTracker } from './asset-tracker';
 
 class BybitOrchestrator extends BaseOrchestrator {
   ws = null;
-  rawCoins = /* @__PURE__ */ new Map();
-  lastWallet = null;
-  trackedAssetInfos = /* @__PURE__ */ new Map();
-  marginMode = "cross";
-  async start(credentials) {
-    const gen = ++this.startGeneration;
-    this.manualClose = false;
+  creds;
+  stateHandler;
+  assetTracker;
+  constructor(config, credentials) {
+    super(config);
     this.credentials = credentials;
-    const creds = credentials;
-    this.stopAll();
-    try {
-      const [wallet, positions, accountInfo] = await Promise.all([
-        fetchWalletBalance(creds, this.demo),
-        fetchPositions(creds, this.demo),
-        fetchAccountInfo(creds, this.demo)
-      ]);
-      if (gen !== this.startGeneration) return;
-      const MARGIN_MODE_MAP = {
-        ISOLATED_MARGIN: "isolated",
-        PORTFOLIO_MARGIN: "portfolio",
-        REGULAR_MARGIN: "cross"
-      };
-      const rawMode = accountInfo?.marginMode ?? "REGULAR_MARGIN";
-      this.marginMode = MARGIN_MODE_MAP[rawMode] ?? "cross";
-      if (wallet) {
-        this.lastWallet = wallet;
-        this.rawCoins = mergeRawCoins(/* @__PURE__ */ new Map(), wallet.coin ?? []);
-        this.onStateUpdate({
-          balance: buildBalance(wallet, this.rawCoins, this.marginMode)
-        });
-      }
-      this.onStateUpdate({ positions: mapPositions(positions) });
-      this.ws = new BybitWs(
-        {
-          onMessage: (topic, data) => this.handleMessage(topic, data),
-          onClose: () => {
-            if (!this.manualClose) {
-              this.stopAll();
-              this.scheduleReconnect();
-            }
-          }
-        },
-        this.demo
-      );
-      await this.ws.connect(creds);
-      this.reconnectAttempts = 0;
-    } catch (err) {
-      if (gen !== this.startGeneration) return;
-      this.stopAll();
-      this.onError(err instanceof Error ? err : new Error(String(err)));
-      this.scheduleReconnect();
-    }
+    this.creds = credentials;
+    this.assetTracker = new BybitAssetTracker({
+      onStateUpdate: (update) => this.onStateUpdate(update),
+      onError: (err) => this.onError(err),
+      getCreds: () => this.creds,
+      getDemo: () => this.demo
+    });
+    this.stateHandler = new BybitStateHandler({
+      onStateUpdate: (update) => this.onStateUpdate(update),
+      getTrackedAssetInfos: () => this.assetTracker.getInfos()
+    });
+  }
+  async initAsync() {
+    const [wallet, positionsUsd, positionsUsdc, accountInfo] = await Promise.all([
+      fetchWalletBalance(this.creds, this.demo),
+      fetchPositions(this.creds, "USDT", this.demo),
+      fetchPositions(this.creds, "USDC", this.demo),
+      fetchAccountInfo(this.creds, this.demo)
+    ]);
+    this.stateHandler.handleInitialData(
+      wallet ?? null,
+      [positionsUsd, positionsUsdc].flat(),
+      accountInfo?.marginMode ?? null
+    );
+    this.ws = new BybitWs(
+      {
+        onMessage: (msg) => this.stateHandler.handleMessage(msg)
+      },
+      this.demo
+    );
+    await this.ws.connect(this.creds);
   }
-  stop() {
-    this.manualClose = true;
-    this.stopAll();
-    this.rawCoins.clear();
-    this.lastWallet = null;
-    this.trackedAssetInfos.clear();
-    this.marginMode = "cross";
-    this.credentials = null;
+  cleanupConnections() {
+    this.ws?.close();
+  }
+  async stop() {
+    this.stopped = true;
+    this.cleanupConnections();
   }
   get isConnected() {
     return this.ws?.isConnected ?? false;
   }
   onAssetTracked(coin) {
-    const creds = this.credentials;
-    if (!creds) return;
-    fetchPositionLeverage(creds, coin, this.demo).then((pos) => {
-      const leverage = pos?.leverage || "1";
-      const marginType = pos?.tradeMode === "1" ? "isolated" : "cross";
-      const info = {
-        coin,
-        leverage,
-        marginType
-      };
-      this.trackedAssetInfos.set(coin, info);
-      const trackedAssets = /* @__PURE__ */ new Map();
-      trackedAssets.set(coin, info);
-      this.onStateUpdate({ trackedAssets });
-    }).catch((err) => {
-      this.onError(err instanceof Error ? err : new Error(String(err)));
-    });
+    this.assetTracker.onAssetTracked(coin);
   }
   onAssetUntracked(coin) {
-    this.trackedAssetInfos.delete(coin);
-    this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
-  }
-  async setLeverage(symbol, leverage) {
-    const creds = this.credentials;
-    if (!creds) throw new Error("Not connected");
-    await setLeverage(creds, symbol, leverage, this.demo);
-  }
-  stopAll() {
-    this.clearReconnectTimer();
-    this.ws?.close();
-    this.ws = null;
-  }
-  handleMessage(topic, data) {
-    if (topic === "wallet") {
-      const wallet = data[0];
-      if (wallet) this.handleWalletUpdate(wallet);
-    } else if (topic === "position") {
-      const rawPositions = data;
-      const positions = mapPositionUpdates(rawPositions);
-      if (positions.size > 0) {
-        const trackedAssets = /* @__PURE__ */ new Map();
-        for (const pos of rawPositions) {
-          const existing = this.trackedAssetInfos.get(pos.symbol);
-          if (existing) {
-            const leverage = pos.leverage || existing.leverage;
-            const marginType = pos.tradeMode === "1" ? "isolated" : "cross";
-            const updated = { ...existing, leverage, marginType };
-            this.trackedAssetInfos.set(pos.symbol, updated);
-            trackedAssets.set(pos.symbol, updated);
-          }
-        }
-        this.onStateUpdate({
-          positions,
-          ...trackedAssets.size > 0 ? { trackedAssets } : {}
-        });
-      }
-    }
-  }
-  handleWalletUpdate(raw) {
-    this.rawCoins = mergeRawCoins(this.rawCoins, raw.coin ?? []);
-    const merged = this.lastWallet ? {
-      totalEquity: raw.totalEquity || this.lastWallet.totalEquity,
-      totalWalletBalance: raw.totalWalletBalance || this.lastWallet.totalWalletBalance,
-      totalMarginBalance: raw.totalMarginBalance || this.lastWallet.totalMarginBalance,
-      totalAvailableBalance: raw.totalAvailableBalance || this.lastWallet.totalAvailableBalance,
-      totalPerpUPL: raw.totalPerpUPL || this.lastWallet.totalPerpUPL,
-      totalInitialMargin: raw.totalInitialMargin || this.lastWallet.totalInitialMargin,
-      totalMaintenanceMargin: raw.totalMaintenanceMargin || this.lastWallet.totalMaintenanceMargin,
-      accountMMRate: raw.accountMMRate || this.lastWallet.accountMMRate,
-      coin: raw.coin ?? this.lastWallet.coin
-    } : raw;
-    this.lastWallet = merged;
-    this.onStateUpdate({
-      balance: buildBalance(merged, this.rawCoins, this.marginMode)
-    });
+    this.assetTracker.onAssetUntracked(coin);
   }
 }
 

package/dist/account/exchanges/bybit/rest.d.ts

@@ -2,10 +2,9 @@ import { BybitCredentialsDTO } from '@pear-protocol/types';
 import { BybitRawAccountInfo, BybitRawPosition, BybitRawWallet } from './types.js';
 
 declare function fetchWalletBalance(creds: BybitCredentialsDTO, demo: boolean): Promise<BybitRawWallet | undefined>;
-declare function fetchPositions(creds: BybitCredentialsDTO, demo: boolean): Promise<BybitRawPosition[]>;
+declare function fetchPositions(creds: BybitCredentialsDTO, settleCoin: string, demo: boolean): Promise<BybitRawPosition[]>;
 declare function fetchPositionLeverage(creds: BybitCredentialsDTO, symbol: string, demo: boolean): Promise<BybitRawPosition | undefined>;
-declare function setLeverage(creds: BybitCredentialsDTO, symbol: string, leverage: string, demo: boolean): Promise<void>;
 declare function fetchAccountInfo(creds: BybitCredentialsDTO, demo: boolean): Promise<BybitRawAccountInfo>;
 declare function fetchCollateralRatios(creds: BybitCredentialsDTO, demo: boolean): Promise<Map<string, string>>;
 
-export { fetchAccountInfo, fetchCollateralRatios, fetchPositionLeverage, fetchPositions, fetchWalletBalance, setLeverage };
+export { fetchAccountInfo, fetchCollateralRatios, fetchPositionLeverage, fetchPositions, fetchWalletBalance };

package/dist/account/exchanges/bybit/rest.js

@@ -1,33 +1,6 @@
 import { hmacSha256Hex } from '../../../utils/hmac';
 import { BASE_URL_DEMO, BASE_URL } from './const';
 
-async function signedPost(creds, path, body, demo) {
-  const baseUrl = demo ? BASE_URL_DEMO : BASE_URL;
-  const timestamp = Date.now().toString();
-  const recvWindow = "5000";
-  const bodyStr = JSON.stringify(body);
-  const signPayload = `${timestamp}${creds.api_key}${recvWindow}${bodyStr}`;
-  const signature = await hmacSha256Hex(creds.api_secret, signPayload);
-  const response = await fetch(`${baseUrl}${path}`, {
-    method: "POST",
-    headers: {
-      "X-BAPI-API-KEY": creds.api_key,
-      "X-BAPI-SIGN": signature,
-      "X-BAPI-TIMESTAMP": timestamp,
-      "X-BAPI-RECV-WINDOW": recvWindow,
-      "Content-Type": "application/json"
-    },
-    body: bodyStr
-  });
-  if (!response.ok) {
-    throw new Error(`Bybit API error: ${response.status} ${response.statusText}`);
-  }
-  const result = await response.json();
-  if (result.retCode !== 0) {
-    throw new Error(`Bybit API error: ${result.retCode} ${result.retMsg}`);
-  }
-  return result.result;
-}
 async function signedGet(creds, path, params, demo) {
   const baseUrl = demo ? BASE_URL_DEMO : BASE_URL;
   const timestamp = Date.now().toString();
@@ -61,11 +34,11 @@ async function fetchWalletBalance(creds, demo) {
   );
   return result.list[0];
 }
-async function fetchPositions(creds, demo) {
+async function fetchPositions(creds, settleCoin, demo) {
   const result = await signedGet(
     creds,
     "/v5/position/list",
-    { category: "linear", settleCoin: "USDT" },
+    { category: "linear", settleCoin },
     demo
   );
   return result.list;
@@ -79,16 +52,8 @@ async function fetchPositionLeverage(creds, symbol, demo) {
   );
   return result.list[0];
 }
-async function setLeverage(creds, symbol, leverage, demo) {
-  await signedPost(
-    creds,
-    "/v5/position/set-leverage",
-    { category: "linear", symbol, buyLeverage: leverage, sellLeverage: leverage },
-    demo
-  );
-}
 async function fetchAccountInfo(creds, demo) {
-  return signedGet(creds, "/v5/account/account-info", {}, demo);
+  return signedGet(creds, "/v5/account/info", {}, demo);
 }
 async function fetchCollateralRatios(creds, demo) {
   const result = await signedGet(
@@ -107,4 +72,4 @@ async function fetchCollateralRatios(creds, demo) {
   return ratios;
 }
 
-export { fetchAccountInfo, fetchCollateralRatios, fetchPositionLeverage, fetchPositions, fetchWalletBalance, setLeverage };
+export { fetchAccountInfo, fetchCollateralRatios, fetchPositionLeverage, fetchPositions, fetchWalletBalance };

package/dist/account/exchanges/bybit/state-handler.d.ts

@@ -0,0 +1,22 @@
+import { S as StateUpdate, h as TrackedAssetInfo } from '../../../types-D2dbAtin.js';
+import { BybitRawWallet, BybitRawPosition, BybitAccountType, BybitWsMessage } from './types.js';
+import '@pear-protocol/types';
+import '../hyperliquid/types.js';
+
+type OnStateUpdate = (update: StateUpdate) => void;
+declare class BybitStateHandler {
+    private onStateUpdate;
+    private getTrackedAssetInfos;
+    private rawCoins;
+    private lastWallet;
+    private accountType;
+    constructor(deps: {
+        onStateUpdate: OnStateUpdate;
+        getTrackedAssetInfos: () => Map<string, TrackedAssetInfo>;
+    });
+    handleInitialData(wallet: BybitRawWallet | null, positions: BybitRawPosition[], accountType: BybitAccountType | null): void;
+    handleMessage(msg: BybitWsMessage): void;
+    private handleWalletUpdate;
+}
+
+export { BybitStateHandler };