@pear-protocol/exchanges-sdk 0.0.17 → 0.1.1

package/dist/{account/exchanges → tracker}/bybit/mapper.d.ts

@@ -1,7 +1,9 @@
-import { a as AccountBalance, c as AccountPosition } from '../../../types-Caz2X4h0.js';
-import { BybitRawWallet, BybitRawCoin, BybitAccountType, BybitRawPosition } from './types.js';
-import '@pear-protocol/types';
+import { BybitRawWallet, BybitRawCoin, BybitRawPosition } from '../../client/bybit/types.js';
+import { AccountBalance, AccountPosition } from '../types.js';
+import { BybitAccountType } from './types.js';
+import '../binance/types.js';
 import '../hyperliquid/types.js';
+import '../lighter/types.js';
 import '../okx/types.js';
 
 declare function buildBalance(raw: BybitRawWallet, coins: Map<string, BybitRawCoin>, accountType: BybitAccountType | null): AccountBalance | null;

package/dist/{account/exchanges → tracker}/bybit/mapper.js

@@ -1,5 +1,6 @@
-import '../../types';
-import { positionKey } from '../../utils';
+import BigNumber from 'bignumber.js';
+import '../types';
+import { positionKey } from '../utils';
 import { BybitAccountType } from './types';
 
 function buildBalance(raw, coins, accountType) {
@@ -14,19 +15,19 @@ function buildBalance(raw, coins, accountType) {
     const positionInitialMargin = c.totalPositionIM === "" ? "0" : c.totalPositionIM ?? "0";
     const orderInitialMargin = c.totalOrderIM === "" ? "0" : c.totalOrderIM ?? "0";
     const locked = c.locked ?? "0";
-    const equityNum = parseFloat(equity);
-    const positionInitialMarginNum = parseFloat(positionInitialMargin);
-    const orderInitialMarginNum = parseFloat(orderInitialMargin);
-    const lockedNum = parseFloat(locked);
-    if (equityNum === 0 && parseFloat(c.walletBalance ?? "0") === 0) continue;
+    const equityBN = new BigNumber(equity);
+    const positionInitialMarginBN = new BigNumber(positionInitialMargin);
+    const orderInitialMarginBN = new BigNumber(orderInitialMargin);
+    const lockedBN = new BigNumber(locked);
+    if (equityBN.isZero() && new BigNumber(c.walletBalance ?? "0").isZero()) continue;
     let coinFree;
     let coinUsed;
     if (isPortfolio) {
-      coinFree = (equityNum - lockedNum).toString();
+      coinFree = equityBN.minus(lockedBN).toFixed();
       coinUsed = "0";
     } else {
-      coinFree = (equityNum - positionInitialMarginNum - orderInitialMarginNum - lockedNum).toString();
-      coinUsed = (positionInitialMarginNum + orderInitialMarginNum).toString();
+      coinFree = equityBN.minus(positionInitialMarginBN).minus(orderInitialMarginBN).minus(lockedBN).toFixed();
+      coinUsed = positionInitialMarginBN.plus(orderInitialMarginBN).toFixed();
     }
     free[c.coin] = coinFree;
     used[c.coin] = coinUsed;

package/dist/tracker/bybit/tracker.d.ts

@@ -0,0 +1,51 @@
+import { BybitExchangeWs } from '../../client/bybit/exchange-ws.js';
+import { SupportedCredentials } from '../../types.js';
+import { BaseAccountTracker, AccountTrackerConfig } from '../base.js';
+import '@pear-protocol/types';
+import '../../client/base-ws.js';
+import 'partysocket';
+import '../../client/exchange-ws.js';
+import '../../client/bybit/ws.js';
+import '@pear-protocol/core-sdk';
+import '../../client/binance/exchange-ws.js';
+import '../../client/binance/ws.js';
+import '../../client/hyperliquid/exchange-ws.js';
+import '../../client/hyperliquid/ws.js';
+import '../../client/lighter/exchange-ws.js';
+import '../../client/lighter/ws.js';
+import '../../client/okx/exchange-ws.js';
+import '../../client/okx/ws.js';
+import '../types.js';
+import '../binance/types.js';
+import './types.js';
+import '../hyperliquid/types.js';
+import '../lighter/types.js';
+import '../okx/types.js';
+
+type BybitAccountTrackerConfig = AccountTrackerConfig & {
+    credentials: SupportedCredentials;
+    ws: BybitExchangeWs;
+};
+declare class BybitAccountTracker extends BaseAccountTracker {
+    private readonly creds;
+    private readonly ws;
+    private messageListenerId;
+    private openListenerId;
+    private rawCoins;
+    private lastWallet;
+    private accountType;
+    private trackedAssetInfos;
+    constructor(config: BybitAccountTrackerConfig);
+    start(): Promise<void>;
+    protected cleanupConnections(): Promise<void>;
+    get isConnected(): boolean;
+    protected ensureAssetTracked(coin: string): void;
+    protected releaseAsset(coin: string): void;
+    private subscribe;
+    private handleInitialData;
+    private routeRaw;
+    private handleMessage;
+    private handleWalletUpdate;
+}
+
+export { BybitAccountTracker, type BybitAccountTrackerConfig };

package/dist/tracker/bybit/tracker.js

@@ -0,0 +1,138 @@
+import { fetchWalletBalance, fetchPositions, fetchAccountInfo, fetchPositionLeverage } from '../../client/bybit/rest';
+import { BaseAccountTracker } from '../base';
+import { mergeRawCoins, buildBalance, mapPositions, mapPositionUpdates } from './mapper';
+import './types';
+
+class BybitAccountTracker extends BaseAccountTracker {
+  creds;
+  ws;
+  messageListenerId = null;
+  openListenerId = null;
+  rawCoins = /* @__PURE__ */ new Map();
+  lastWallet = null;
+  accountType = null;
+  trackedAssetInfos = /* @__PURE__ */ new Map();
+  constructor(config) {
+    super(config);
+    this.credentials = config.credentials;
+    this.creds = config.credentials;
+    this.ws = config.ws;
+  }
+  async start() {
+    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.handleInitialData(
+      wallet ?? null,
+      [positionsUsd, positionsUsdc].flat(),
+      accountInfo?.marginMode ?? null
+    );
+    this.messageListenerId = this.ws.main.addMessageListener((raw) => this.routeRaw(raw));
+    this.openListenerId = this.ws.main.addOpenListener(() => {
+      this.ws.authenticate().then(() => this.subscribe()).catch((err) => this.onError(err));
+    });
+    this.subscribe();
+  }
+  async cleanupConnections() {
+    if (this.messageListenerId) {
+      this.ws.main.removeMessageListener(this.messageListenerId);
+      this.messageListenerId = null;
+    }
+    if (this.openListenerId) {
+      this.ws.main.removeOpenListener(this.openListenerId);
+      this.openListenerId = null;
+    }
+  }
+  get isConnected() {
+    return this.ws.isConnected;
+  }
+  ensureAssetTracked(coin) {
+    if (this.trackedAssetInfos.has(coin)) return;
+    fetchPositionLeverage(this.creds, coin, this.demo).then((pos) => {
+      const leverage = pos?.leverage || "1";
+      const marginType = pos?.tradeMode === "1" ? "cross" : "isolated";
+      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)));
+    });
+  }
+  releaseAsset(coin) {
+    this.trackedAssetInfos.delete(coin);
+    this.onStateUpdate({ trackedAssets: new Map(this.trackedAssetInfos) });
+  }
+  subscribe() {
+    this.ws.main.send({ op: "subscribe", args: ["wallet", "position"] });
+  }
+  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) });
+  }
+  routeRaw(raw) {
+    try {
+      const msg = JSON.parse(raw);
+      if (msg.topic && msg.data) {
+        this.handleMessage({ topic: msg.topic, data: msg.data });
+      }
+    } catch (err) {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  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 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;
+    const balance = buildBalance(merged, this.rawCoins, this.accountType);
+    if (balance) this.onStateUpdate({ balance });
+  }
+}
+
+export { BybitAccountTracker };

package/dist/tracker/bybit/types.d.ts

@@ -0,0 +1,7 @@
+declare enum BybitAccountType {
+    ISOLATED_MARGIN = "ISOLATED_MARGIN",
+    REGULAR_MARGIN = "REGULAR_MARGIN",
+    PORTFOLIO_MARGIN = "PORTFOLIO_MARGIN"
+}
+
+export { BybitAccountType };

package/dist/{account/exchanges → tracker}/hyperliquid/mapper.d.ts

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

package/dist/{account/exchanges → tracker}/hyperliquid/mapper.js

@@ -1,4 +1,5 @@
-import { positionKey } from '../../utils';
+import BigNumber from 'bignumber.js';
+import { positionKey } from '../utils';
 import { COLLATERAL_TOKEN_MAP } from './types';
 
 const COLLATERAL_COINS = new Set(Object.values(COLLATERAL_TOKEN_MAP));
@@ -11,9 +12,9 @@ function mapBalance(summary, spotCoinBalances, accountType, availableToTradeByCo
   for (const [, coin] of spotCoinBalances) {
     if (!COLLATERAL_COINS.has(coin.coin)) continue;
     const availableOverride = availableToTradeByCollateral.get(coin.coin);
-    const coinFree = availableOverride !== void 0 ? availableOverride.toString() : (coin.total - coin.hold).toString();
-    const coinUsed = coin.hold.toString();
-    const coinTotal = coin.total.toString();
+    const coinFree = availableOverride !== void 0 ? availableOverride : new BigNumber(coin.total).minus(coin.hold).toFixed();
+    const coinUsed = coin.hold;
+    const coinTotal = coin.total;
     free[coin.coin] = coinFree;
     used[coin.coin] = coinUsed;
     total[coin.coin] = coinTotal;
@@ -26,19 +27,20 @@ function mapBalance(summary, spotCoinBalances, accountType, availableToTradeByCo
       usdValue: coinTotal
     });
   }
-  const walletBalance = summary.accountValue - summary.totalUnrealizedPnl;
-  const marginRatio = summary.accountValue > 0 ? (summary.crossMaintenanceMarginUsed / summary.accountValue).toFixed(4) : "0.0000";
+  const accountValueBN = new BigNumber(summary.accountValue);
+  const walletBalance = accountValueBN.minus(summary.totalUnrealizedPnl).toFixed();
+  const marginRatio = accountValueBN.gt(0) ? new BigNumber(summary.crossMaintenanceMarginUsed).div(accountValueBN).toFixed(4) : "0.0000";
   return {
     accountType,
     free,
     used,
     total,
-    availableToTrade: summary.withdrawable.toString(),
-    totalEquity: summary.accountValue.toString(),
-    walletBalance: walletBalance.toString(),
-    unrealizedPnl: summary.totalUnrealizedPnl.toString(),
-    initialMarginUsed: summary.totalMarginUsed.toString(),
-    maintenanceMargin: summary.crossMaintenanceMarginUsed.toString(),
+    availableToTrade: summary.withdrawable,
+    totalEquity: summary.accountValue,
+    walletBalance,
+    unrealizedPnl: summary.totalUnrealizedPnl,
+    initialMarginUsed: summary.totalMarginUsed,
+    maintenanceMargin: summary.crossMaintenanceMarginUsed,
     marginRatio,
     assets,
     timestamp: Date.now()
@@ -48,14 +50,14 @@ function mapPositions(raw) {
   const positions = /* @__PURE__ */ new Map();
   for (const ap of raw) {
     const pos = ap.position;
-    const szi = Number.parseFloat(pos.szi || "0");
-    if (szi === 0) continue;
+    const sziBN = new BigNumber(pos.szi || "0");
+    if (sziBN.isZero()) continue;
     const coin = pos.coin || "";
-    const side = szi > 0 ? "long" : "short";
+    const side = sziBN.isPositive() ? "long" : "short";
     positions.set(positionKey(coin, side), {
       symbol: coin,
       side,
-      size: szi.toString(),
+      size: sziBN.toFixed(),
       entryPrice: pos.entryPx || "0",
       unrealizedPnl: pos.unrealizedPnl || "0",
       leverage: pos.leverage.value.toString(),

package/dist/tracker/hyperliquid/tracker.d.ts

@@ -0,0 +1,62 @@
+import { HyperliquidWs } from '../../client/hyperliquid/ws.js';
+import { SupportedCredentials } from '../../types.js';
+import { BaseAccountTracker, AccountTrackerConfig } from '../base.js';
+import '../../client/base-ws.js';
+import 'partysocket';
+import '@pear-protocol/core-sdk';
+import '@pear-protocol/types';
+import '../../client/binance/exchange-ws.js';
+import '../../client/exchange-ws.js';
+import '../../client/binance/ws.js';
+import '../../client/bybit/exchange-ws.js';
+import '../../client/bybit/ws.js';
+import '../../client/hyperliquid/exchange-ws.js';
+import '../../client/lighter/exchange-ws.js';
+import '../../client/lighter/ws.js';
+import '../../client/okx/exchange-ws.js';
+import '../../client/okx/ws.js';
+import '../types.js';
+import '../binance/types.js';
+import '../bybit/types.js';
+import './types.js';
+import '../lighter/types.js';
+import '../okx/types.js';
+
+type HyperliquidAccountTrackerConfig = AccountTrackerConfig & {
+    credentials: SupportedCredentials;
+    ws: HyperliquidWs;
+};
+declare class HyperliquidAccountTracker extends BaseAccountTracker {
+    private readonly address;
+    private readonly ws;
+    private messageListenerId;
+    private openListenerId;
+    private subscribedCoins;
+    private lastSummary;
+    private spotCoinBalances;
+    private accountType;
+    private symbolToCollateralToken;
+    private availableToTradeByCollateral;
+    private trackedAssetData;
+    constructor(config: HyperliquidAccountTrackerConfig);
+    start(): Promise<void>;
+    protected cleanupConnections(): Promise<void>;
+    get isConnected(): boolean;
+    protected ensureAssetTracked(coin: string): void;
+    protected releaseAsset(coin: string): void;
+    private isLocked;
+    private addrLower;
+    private sendStaticSubs;
+    private resubscribeAll;
+    private routeRaw;
+    private handle;
+    private loadPerpMetas;
+    private onClearinghouseState;
+    private onActiveAssetData;
+    private onWebData3;
+    private onSpotState;
+    private buildBalance;
+    private buildTrackedAssetsMap;
+}
+
+export { HyperliquidAccountTracker, type HyperliquidAccountTrackerConfig };

package/dist/tracker/hyperliquid/tracker.js

@@ -0,0 +1,219 @@
+import BigNumber from 'bignumber.js';
+import { fetchInfo } from '../../client/hyperliquid/rest';
+import { BaseAccountTracker } from '../base';
+import { LOCKED_TRACKED_COINS } from './const';
+import { mapPositions, mapBalance } from './mapper';
+import { COLLATERAL_TOKEN_MAP } from './types';
+
+class HyperliquidAccountTracker extends BaseAccountTracker {
+  address;
+  ws;
+  messageListenerId = null;
+  openListenerId = null;
+  subscribedCoins = /* @__PURE__ */ new Set();
+  lastSummary = {
+    accountValue: "0",
+    totalMarginUsed: "0",
+    totalRawUsd: "0",
+    crossMaintenanceMarginUsed: "0",
+    withdrawable: "0",
+    totalUnrealizedPnl: "0"
+  };
+  spotCoinBalances = /* @__PURE__ */ new Map();
+  accountType = null;
+  symbolToCollateralToken = /* @__PURE__ */ new Map();
+  availableToTradeByCollateral = /* @__PURE__ */ new Map();
+  trackedAssetData = /* @__PURE__ */ new Map();
+  constructor(config) {
+    super(config);
+    const creds = config.credentials;
+    this.credentials = config.credentials;
+    this.address = creds.accountIdentifier;
+    this.ws = config.ws;
+  }
+  async start() {
+    const allMetas = await fetchInfo({ type: "allPerpMetas" });
+    this.loadPerpMetas(allMetas);
+    this.messageListenerId = this.ws.addMessageListener((raw) => this.routeRaw(raw));
+    this.openListenerId = this.ws.addOpenListener(() => this.resubscribeAll());
+    this.sendStaticSubs();
+    for (const coin of LOCKED_TRACKED_COINS) {
+      this.ensureAssetTracked(coin);
+    }
+  }
+  async cleanupConnections() {
+    if (this.messageListenerId) {
+      this.ws.removeMessageListener(this.messageListenerId);
+      this.messageListenerId = null;
+    }
+    if (this.openListenerId) {
+      this.ws.removeOpenListener(this.openListenerId);
+      this.openListenerId = null;
+    }
+    this.subscribedCoins.clear();
+  }
+  get isConnected() {
+    return this.ws.connected;
+  }
+  ensureAssetTracked(coin) {
+    if (this.subscribedCoins.has(coin)) return;
+    this.subscribedCoins.add(coin);
+    this.ws.send({
+      method: "subscribe",
+      subscription: { type: "activeAssetData", coin, user: this.addrLower() }
+    });
+  }
+  releaseAsset(coin) {
+    if (this.isLocked(coin)) return;
+    if (!this.subscribedCoins.has(coin)) return;
+    this.subscribedCoins.delete(coin);
+    this.ws.send({
+      method: "unsubscribe",
+      subscription: { type: "activeAssetData", coin, user: this.addrLower() }
+    });
+    this.trackedAssetData.delete(coin);
+    this.onStateUpdate({ trackedAssets: this.buildTrackedAssetsMap() });
+  }
+  isLocked(coin) {
+    return LOCKED_TRACKED_COINS.includes(coin);
+  }
+  addrLower() {
+    return this.address.toLowerCase();
+  }
+  sendStaticSubs() {
+    const user = this.addrLower();
+    this.ws.send({ method: "subscribe", subscription: { type: "allDexsClearinghouseState", user } });
+    this.ws.send({ method: "subscribe", subscription: { type: "spotState", user } });
+    this.ws.send({ method: "subscribe", subscription: { type: "webData3", user } });
+  }
+  resubscribeAll() {
+    this.sendStaticSubs();
+    const user = this.addrLower();
+    for (const coin of this.subscribedCoins) {
+      this.ws.send({
+        method: "subscribe",
+        subscription: { type: "activeAssetData", coin, user }
+      });
+    }
+  }
+  routeRaw(raw) {
+    try {
+      const msg = JSON.parse(raw);
+      if (!msg.channel || !msg.data) return;
+      switch (msg.channel) {
+        case "allDexsClearinghouseState":
+          this.handle({ kind: "clearinghouseState", data: msg.data });
+          break;
+        case "spotState":
+          this.handle({ kind: "spotState", data: msg.data });
+          break;
+        case "webData3":
+          this.handle({ kind: "webData3", data: msg.data });
+          break;
+        case "activeAssetData":
+          this.handle({ kind: "activeAssetData", data: msg.data });
+          break;
+      }
+    } catch (err) {
+      this.onError(err instanceof Error ? err : new Error(String(err)));
+    }
+  }
+  handle(event) {
+    switch (event.kind) {
+      case "clearinghouseState":
+        this.onClearinghouseState(event.data);
+        break;
+      case "spotState":
+        this.onSpotState(event.data);
+        break;
+      case "webData3":
+        this.onWebData3(event.data);
+        break;
+      case "activeAssetData":
+        this.onActiveAssetData(event.data);
+        break;
+    }
+  }
+  loadPerpMetas(allMetas) {
+    allMetas.forEach((dexMeta) => {
+      const collateralToken = COLLATERAL_TOKEN_MAP[dexMeta.collateralToken];
+      dexMeta.universe.forEach((asset) => {
+        if (!asset.name) return;
+        if (collateralToken && !this.symbolToCollateralToken.has(asset.name)) {
+          this.symbolToCollateralToken.set(asset.name, collateralToken);
+        }
+      });
+    });
+  }
+  onClearinghouseState(data) {
+    const states = (data.clearinghouseStates || []).map(([, s]) => s).filter(Boolean);
+    const sumStr = (values) => values.reduce((acc, v) => acc.plus(new BigNumber(v || "0")), new BigNumber(0)).toFixed();
+    const allAssetPositions = states.flatMap((s) => s.assetPositions || []);
+    const totalUnrealizedPnl = allAssetPositions.reduce((acc, ap) => acc.plus(new BigNumber(ap.position.unrealizedPnl || "0")), new BigNumber(0)).toFixed();
+    this.lastSummary = {
+      accountValue: sumStr(states.map((s) => s.crossMarginSummary.accountValue)),
+      totalMarginUsed: sumStr(states.map((s) => s.crossMarginSummary.totalMarginUsed)),
+      totalRawUsd: sumStr(states.map((s) => s.crossMarginSummary.totalRawUsd)),
+      crossMaintenanceMarginUsed: sumStr(states.map((s) => s.crossMaintenanceMarginUsed)),
+      withdrawable: sumStr(states.map((s) => s.withdrawable)),
+      totalUnrealizedPnl
+    };
+    const balance = this.buildBalance();
+    const positions = mapPositions(allAssetPositions);
+    this.onStateUpdate({ balance: balance ?? void 0, positions });
+  }
+  onActiveAssetData(data) {
+    if (!data.coin) return;
+    if (!this.trackedCoins.has(data.coin)) return;
+    this.trackedAssetData.set(data.coin, data);
+    const collateral = this.symbolToCollateralToken.get(data.coin);
+    if (collateral && data.availableToTrade) {
+      const long = new BigNumber(data.availableToTrade[0] || "0");
+      const short = new BigNumber(data.availableToTrade[1] || "0");
+      const minAvailable = BigNumber.min(long, short).toFixed();
+      this.availableToTradeByCollateral.set(collateral, minAvailable);
+      const balance = this.buildBalance();
+      if (balance) this.onStateUpdate({ balance });
+    }
+    const trackedAssets = /* @__PURE__ */ new Map();
+    trackedAssets.set(data.coin, buildTrackedAssetInfo(data));
+    this.onStateUpdate({ trackedAssets });
+  }
+  onWebData3(data) {
+    this.accountType = data.userState.abstraction ?? null;
+  }
+  onSpotState(data) {
+    const balances = data?.spotState?.balances;
+    if (!balances) return;
+    for (const b of balances) {
+      const totalBN = new BigNumber(b.total || "0");
+      const holdBN = new BigNumber(b.hold || "0");
+      if (!totalBN.isZero() || !holdBN.isZero()) {
+        this.spotCoinBalances.set(b.coin, { coin: b.coin, total: totalBN.toFixed(), hold: holdBN.toFixed() });
+      } else {
+        this.spotCoinBalances.delete(b.coin);
+      }
+    }
+    const balance = this.buildBalance();
+    if (balance) this.onStateUpdate({ balance });
+  }
+  buildBalance() {
+    return mapBalance(this.lastSummary, this.spotCoinBalances, this.accountType, this.availableToTradeByCollateral);
+  }
+  buildTrackedAssetsMap() {
+    const result = /* @__PURE__ */ new Map();
+    for (const [coin, data] of this.trackedAssetData) {
+      result.set(coin, buildTrackedAssetInfo(data));
+    }
+    return result;
+  }
+}
+function buildTrackedAssetInfo(data) {
+  return {
+    coin: data.coin,
+    leverage: (data.leverage?.value ?? 1).toString(),
+    marginType: data.leverage?.type
+  };
+}
+
+export { HyperliquidAccountTracker };

package/dist/tracker/hyperliquid/types.d.ts

@@ -0,0 +1,23 @@
+declare enum HyperliquidAccountType {
+    DEFAULT = "default",
+    DEX_ABSTRACTION = "dexAbstraction",
+    DISABLED = "disabled",
+    PORTFOLIO_MARGIN = "portfolioMargin",
+    UNIFIED_ACCOUNT = "unifiedAccount"
+}
+interface HyperliquidCoinBalance {
+    coin: string;
+    total: string;
+    hold: string;
+}
+interface AggregatedClearinghouseSummary {
+    accountValue: string;
+    totalMarginUsed: string;
+    totalRawUsd: string;
+    crossMaintenanceMarginUsed: string;
+    withdrawable: string;
+    totalUnrealizedPnl: string;
+}
+declare const COLLATERAL_TOKEN_MAP: Record<number, string>;
+
+export { type AggregatedClearinghouseSummary, COLLATERAL_TOKEN_MAP, HyperliquidAccountType, type HyperliquidCoinBalance };