@pear-protocol/exchanges-sdk 0.0.10 → 0.0.11

package/dist/account/exchanges/bybit/state-handler.js

@@ -0,0 +1,70 @@
+import { mergeRawCoins, buildBalance, mapPositions, mapPositionUpdates } from './mapper';
+import './types';
+
+class BybitStateHandler {
+  onStateUpdate;
+  getTrackedAssetInfos;
+  rawCoins = /* @__PURE__ */ new Map();
+  lastWallet = null;
+  accountType = null;
+  constructor(deps) {
+    this.onStateUpdate = deps.onStateUpdate;
+    this.getTrackedAssetInfos = deps.getTrackedAssetInfos;
+  }
+  handleInitialData(wallet, positions, accountType) {
+    this.accountType = accountType;
+    if (wallet) {
+      this.lastWallet = wallet;
+      this.rawCoins = mergeRawCoins(/* @__PURE__ */ new Map(), wallet.coin ?? []);
+      const balance = buildBalance(wallet, this.rawCoins, this.accountType);
+      if (balance) this.onStateUpdate({ balance });
+    }
+    this.onStateUpdate({ positions: mapPositions(positions) });
+  }
+  handleMessage(msg) {
+    if (msg.topic === "wallet") {
+      const wallet = msg.data[0];
+      if (wallet) this.handleWalletUpdate(wallet);
+    } else if (msg.topic === "position") {
+      const rawPositions = msg.data;
+      const positions = mapPositionUpdates(rawPositions);
+      if (positions.size > 0) {
+        const trackedAssetInfos = this.getTrackedAssetInfos();
+        const trackedAssets = /* @__PURE__ */ new Map();
+        for (const pos of rawPositions) {
+          const existing = trackedAssetInfos.get(pos.symbol);
+          if (existing) {
+            const leverage = pos.leverage || existing.leverage;
+            const marginType = pos.tradeMode === "1" ? "isolated" : "cross";
+            const updated = { ...existing, leverage, marginType };
+            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;
+    const balance = buildBalance(merged, this.rawCoins, this.accountType);
+    if (balance) this.onStateUpdate({ balance });
+  }
+}
+
+export { BybitStateHandler };

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

@@ -23,6 +23,11 @@ interface BybitRawWallet {
     accountMMRate: string;
     coin: BybitRawCoin[];
 }
+declare enum BybitAccountType {
+    ISOLATED_MARGIN = "ISOLATED_MARGIN",
+    REGULAR_MARGIN = "REGULAR_MARGIN",
+    PORTFOLIO_MARGIN = "PORTFOLIO_MARGIN"
+}
 interface BybitRawAccountInfo {
     marginMode: string;
     updatedTime: string;
@@ -51,9 +56,15 @@ interface BybitResponse<T> {
     retMsg: string;
     result: T;
 }
+type BybitWsMessage = {
+    topic: 'wallet';
+    data: BybitRawWallet[];
+} | {
+    topic: 'position';
+    data: BybitRawPosition[];
+};
 interface BybitWsHandlers {
-    onMessage: (topic: string, data: unknown[]) => void;
-    onClose: () => void;
+    onMessage: (msg: BybitWsMessage) => void;
 }
 
-export type { BybitRawAccountInfo, BybitRawCoin, BybitRawCollateralRatioEntry, BybitRawCollateralTier, BybitRawPosition, BybitRawWallet, BybitResponse, BybitWsHandlers };
+export { BybitAccountType, type BybitRawAccountInfo, type BybitRawCoin, type BybitRawCollateralRatioEntry, type BybitRawCollateralTier, type BybitRawPosition, type BybitRawWallet, type BybitResponse, type BybitWsHandlers, type BybitWsMessage };

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

@@ -1 +1,8 @@
+var BybitAccountType = /* @__PURE__ */ ((BybitAccountType2) => {
+  BybitAccountType2["ISOLATED_MARGIN"] = "ISOLATED_MARGIN";
+  BybitAccountType2["REGULAR_MARGIN"] = "REGULAR_MARGIN";
+  BybitAccountType2["PORTFOLIO_MARGIN"] = "PORTFOLIO_MARGIN";
+  return BybitAccountType2;
+})(BybitAccountType || {});
 
+export { BybitAccountType };

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

@@ -6,6 +6,7 @@ declare class BybitWs {
     private pingTimer;
     private handlers;
     private demo;
+    private creds;
     private readonly pingIntervalMs;
     constructor(handlers: BybitWsHandlers, demo: boolean, pingIntervalMs?: number);
     connect(creds: BybitCredentialsDTO): Promise<void>;

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

@@ -1,5 +1,5 @@
 import { hmacSha256Hex } from '../../../utils/hmac';
-import { connectWs, sendWs, clearIntervalTimer } from '../../../utils/ws';
+import { createWs, sendWs, waitForOpen, ReconnectingWebSocket, clearIntervalTimer } from '../../../utils/ws';
 import { DEFAULT_PING_INTERVAL_MS, WS_URL_DEMO, WS_URL } from './const';
 
 class BybitWs {
@@ -7,6 +7,7 @@ class BybitWs {
   pingTimer = null;
   handlers;
   demo;
+  creds = null;
   pingIntervalMs;
   constructor(handlers, demo, pingIntervalMs = DEFAULT_PING_INTERVAL_MS) {
     this.handlers = handlers;
@@ -14,36 +15,44 @@ class BybitWs {
     this.pingIntervalMs = pingIntervalMs;
   }
   async connect(creds) {
-    this.ws = await connectWs(this.demo ? WS_URL_DEMO : WS_URL);
-    this.ws.onclose = () => {
-      this.clearPing();
-      this.handlers.onClose();
-    };
-    this.ws.onerror = () => {
-    };
+    this.creds = creds;
+    this.ws = createWs(this.demo ? WS_URL_DEMO : WS_URL);
     this.ws.addEventListener("message", (event) => {
       try {
         const msg = JSON.parse(event.data);
         if (msg.topic && msg.data) {
-          this.handlers.onMessage(msg.topic, msg.data);
+          this.handlers.onMessage({ topic: msg.topic, data: msg.data });
         }
       } catch {
       }
     });
+    let initialOpen = true;
+    this.ws.addEventListener("open", () => {
+      if (initialOpen) {
+        initialOpen = false;
+        return;
+      }
+      if (!this.creds) return;
+      this.authenticate(this.creds).then(() => {
+        sendWs(this.ws, { op: "subscribe", args: ["wallet", "position"] });
+      }).catch(() => {
+      });
+    });
+    await waitForOpen(this.ws);
     await this.authenticate(creds);
-    sendWs(this.ws, { op: "subscribe", args: ["wallet", "position", "execution"] });
+    sendWs(this.ws, { op: "subscribe", args: ["wallet", "position"] });
     this.pingTimer = setInterval(() => sendWs(this.ws, { op: "ping" }), this.pingIntervalMs);
   }
   close() {
     this.clearPing();
+    this.creds = null;
     if (this.ws) {
-      this.ws.onclose = null;
       this.ws.close();
       this.ws = null;
     }
   }
   get isConnected() {
-    return this.ws?.readyState === WebSocket.OPEN;
+    return this.ws?.readyState === ReconnectingWebSocket.OPEN;
   }
   clearPing() {
     this.pingTimer = clearIntervalTimer(this.pingTimer);

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

@@ -0,0 +1,34 @@
+import { S as StateUpdate } from '../../../types-D2dbAtin.js';
+import { WebSocket } from 'partysocket';
+import { ActiveAssetDataEvent } from './types.js';
+import '@pear-protocol/types';
+import '../bybit/types.js';
+
+type OnStateUpdate = (update: StateUpdate) => void;
+type OnActiveAssetData = (data: ActiveAssetDataEvent) => void;
+declare class HyperliquidAssetTracker {
+    private onStateUpdate;
+    private onActiveAssetData;
+    private getWs;
+    private getAddress;
+    private isStopped;
+    private subscribedCoins;
+    private trackedAssetData;
+    constructor(deps: {
+        onStateUpdate: OnStateUpdate;
+        onActiveAssetData: OnActiveAssetData;
+        getWs: () => WebSocket | null;
+        getAddress: () => `0x${string}` | null;
+        isStopped: () => boolean;
+    });
+    onAssetTracked(coin: string): void;
+    onAssetUntracked(coin: string): void;
+    canUntrack(coin: string): boolean;
+    handleActiveAssetDataMessage(data: ActiveAssetDataEvent): void;
+    subscribeAll(coins: ReadonlySet<string>): void;
+    private subscribeActiveAssetData;
+    private unsubscribeActiveAssetData;
+    private buildTrackedAssetsMap;
+}
+
+export { HyperliquidAssetTracker };

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

@@ -0,0 +1,83 @@
+import { sendWs } from '../../../utils/ws';
+import { LOCKED_TRACKED_COINS } from './const';
+import { buildTrackedAssetInfo } from './state-handler';
+
+class HyperliquidAssetTracker {
+  onStateUpdate;
+  onActiveAssetData;
+  getWs;
+  getAddress;
+  isStopped;
+  subscribedCoins = /* @__PURE__ */ new Set();
+  trackedAssetData = /* @__PURE__ */ new Map();
+  constructor(deps) {
+    this.onStateUpdate = deps.onStateUpdate;
+    this.onActiveAssetData = deps.onActiveAssetData;
+    this.getWs = deps.getWs;
+    this.getAddress = deps.getAddress;
+    this.isStopped = deps.isStopped;
+  }
+  onAssetTracked(coin) {
+    this.subscribeActiveAssetData(coin);
+  }
+  onAssetUntracked(coin) {
+    this.unsubscribeActiveAssetData(coin);
+    this.trackedAssetData.delete(coin);
+    this.onStateUpdate({ trackedAssets: this.buildTrackedAssetsMap() });
+  }
+  canUntrack(coin) {
+    return !LOCKED_TRACKED_COINS.includes(coin);
+  }
+  handleActiveAssetDataMessage(data) {
+    if (!data.coin) return;
+    if (!this.subscribedCoins.has(data.coin)) return;
+    this.trackedAssetData.set(data.coin, data);
+    this.onActiveAssetData(data);
+  }
+  subscribeAll(coins) {
+    for (const coin of coins) {
+      if (!LOCKED_TRACKED_COINS.includes(coin)) {
+        this.subscribeActiveAssetData(coin);
+      }
+    }
+  }
+  subscribeActiveAssetData(coin) {
+    const ws = this.getWs();
+    const address = this.getAddress();
+    if (!ws || !address || this.isStopped()) return;
+    if (this.subscribedCoins.has(coin)) return;
+    this.subscribedCoins.add(coin);
+    sendWs(ws, {
+      method: "subscribe",
+      subscription: {
+        type: "activeAssetData",
+        coin,
+        user: address.toLowerCase()
+      }
+    });
+  }
+  unsubscribeActiveAssetData(coin) {
+    if (!this.subscribedCoins.has(coin)) return;
+    this.subscribedCoins.delete(coin);
+    const ws = this.getWs();
+    const address = this.getAddress();
+    if (!ws || !address) return;
+    sendWs(ws, {
+      method: "unsubscribe",
+      subscription: {
+        type: "activeAssetData",
+        coin,
+        user: address.toLowerCase()
+      }
+    });
+  }
+  buildTrackedAssetsMap() {
+    const result = /* @__PURE__ */ new Map();
+    for (const [coin, data] of this.trackedAssetData) {
+      result.set(coin, buildTrackedAssetInfo(data));
+    }
+    return result;
+  }
+}
+
+export { HyperliquidAssetTracker };

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

@@ -1,9 +1,9 @@
-import { AccountBalance, AccountPosition } from '../../types.js';
-import { AggregatedClearinghouseSummary, HyperliquidCoinBalance, AssetPosition } from './types.js';
+import { a as AccountBalance, c as AccountPosition } from '../../../types-D2dbAtin.js';
+import { AggregatedClearinghouseSummary, HyperliquidCoinBalance, HyperliquidAccountType, AssetPosition } from './types.js';
 import '@pear-protocol/types';
-import '@nktkas/hyperliquid/api/subscription';
+import '../bybit/types.js';
 
-declare function mapBalance(summary: AggregatedClearinghouseSummary, spotCoinBalances: Map<string, HyperliquidCoinBalance>, accountType: string, availableToTradeByCollateral: Map<string, number>): AccountBalance;
+declare function mapBalance(summary: AggregatedClearinghouseSummary, spotCoinBalances: Map<string, HyperliquidCoinBalance>, accountType: HyperliquidAccountType | null, availableToTradeByCollateral: Map<string, number>): AccountBalance | null;
 declare function mapPositions(raw: AssetPosition[]): Map<string, AccountPosition>;
 
 export { mapBalance, mapPositions };

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

@@ -3,6 +3,7 @@ import { COLLATERAL_TOKEN_MAP } from './types';
 
 const COLLATERAL_COINS = new Set(Object.values(COLLATERAL_TOKEN_MAP));
 function mapBalance(summary, spotCoinBalances, accountType, availableToTradeByCollateral) {
+  if (!accountType) return null;
   const free = {};
   const used = {};
   const total = {};

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

@@ -1,38 +1,25 @@
-import { InstrumentId } from '@pear-protocol/types';
-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 '../bybit/types.js';
+import './types.js';
 
 declare class HyperliquidOrchestrator extends BaseOrchestrator {
-    private static httpTransport;
-    private static wsTransport;
-    private infoClient;
-    private subsClient;
-    private subscriptions;
+    private ws;
     private address;
-    private activeAssetSubscriptions;
-    private trackedAssetData;
-    private spotCoinBalances;
-    private accountType;
-    private symbolToCollateralToken;
-    private availableToTradeByCollateral;
-    private lastSummary;
-    start(credentials: SupportedCredentials): Promise<void>;
-    stop(): void;
+    private stateHandler;
+    private assetTracker;
+    constructor(config: OrchestratorConfig, credentials: SupportedCredentials);
+    protected initAsync(): Promise<void>;
+    private subscribe;
+    private handleMessage;
+    private fetchInfo;
+    protected cleanupConnections(): void;
+    stop(): Promise<void>;
     get isConnected(): boolean;
     onAssetTracked(coin: string): void;
     onAssetUntracked(coin: string): void;
-    setLeverage(id: InstrumentId, leverage: string): Promise<void>;
     protected canUntrackAsset(coin: string): boolean;
-    private fetchPerpMetas;
-    private subscribeActiveAssetData;
-    private stopAll;
-    private handleClearinghouseState;
-    private handleActiveAssetData;
-    private buildTrackedAssetInfo;
-    private buildTrackedAssetsMap;
-    private buildBalance;
-    private handleWebData3;
-    private handleSpotState;
 }
 
 export { HyperliquidOrchestrator };