@pear-protocol/exchanges-sdk 0.6.7 → 0.8.0

package/dist/tracker/hyperliquid/spot-pricing.js

@@ -0,0 +1,106 @@
+import { toPrice, toDecimal, ZERO, ONE } from './decimal';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const USDC_TOKEN_INDEX = 0;
+class SpotPrices {
+  static {
+    __name(this, "SpotPrices");
+  }
+  midByToken;
+  tokenByCoin;
+  constructor(midByToken, tokenByCoin) {
+    this.midByToken = midByToken;
+    this.tokenByCoin = tokenByCoin;
+  }
+  /** Builds the price book from the USDC-quoted pairs, then from the pairs those pairs unlock. */
+  static from(spotMeta, mids) {
+    const tokenByCoin = /* @__PURE__ */ new Map();
+    for (const token of spotMeta.tokens ?? []) {
+      tokenByCoin.set(token.name, token.index);
+    }
+    const directMids = directUsdcMids(spotMeta, mids);
+    const midByToken = new Map(directMids);
+    for (const pair of spotMeta.universe ?? []) {
+      const [base, quote] = pair.tokens;
+      const quoteMid = directMids.get(quote);
+      if (quoteMid === void 0 || midByToken.has(base)) {
+        continue;
+      }
+      const pairMid = toPrice(mids[pair.name]);
+      if (pairMid !== null) {
+        midByToken.set(base, pairMid.times(quoteMid));
+      }
+    }
+    return new SpotPrices(midByToken, tokenByCoin);
+  }
+  /** The USDC mid for a named coin, or `null` when the venue publishes no usable price for it. */
+  midForCoin(coin) {
+    const token = this.tokenByCoin.get(coin);
+    if (token === void 0) {
+      return null;
+    }
+    return this.midForToken(token);
+  }
+  /**
+  * The USDC mid for a token index, or `null` when the venue publishes no usable price for it.
+  *
+  * A spot balance carries the index rather than a name, so this is the direct reach; `midForCoin`
+  * is the same lookup for a caller that only holds a name (staked HYPE).
+  */
+  midForToken(token) {
+    return this.midByToken.get(token)?.toFixed() ?? null;
+  }
+  /**
+  * Values every balance in USD, summing over ALL tokens rather than the collateral tokens alone.
+  *
+  * A token the book holds no usable price for is reported rather than silently valued at zero, so
+  * a caller can see that the equity it received is incomplete.
+  *
+  * KNOWN LIMITATION — an illiquid book can disagree with the venue's own valuation. On
+  * `0xb1ec7feb…` the venue valued BRIDGE at $59,378 where `allMids["@219"]` gives $48,393, 18.5%
+  * apart; that book quotes `midPx 0.025246`, `markPx 0.018561` and `prevDayPx 0.030264`, and the
+  * venue's figure matches none of the three. It is the single cell above 1% across 86 measured on
+  * 14 accounts, and it costs 0.26% of that account's Total Equity. No LTV-bearing token and no
+  * stablecoin was ever mispriced this way, so no margin figure is affected — only equity, and only
+  * through non-collateral dust. Chasing it would need a second price source the venue does not
+  * publish.
+  */
+  valueBalances(balances) {
+    let equity = ZERO;
+    const unpricedCoins = [];
+    for (const balance of balances) {
+      const total = toDecimal(balance.total);
+      const mid = this.midByToken.get(balance.token);
+      if (mid === void 0) {
+        if (!total.isZero()) {
+          unpricedCoins.push(balance.coin);
+        }
+        continue;
+      }
+      equity = equity.plus(total.times(mid));
+    }
+    return {
+      equity: equity.toFixed(),
+      unpricedCoins
+    };
+  }
+}
+function directUsdcMids(spotMeta, mids) {
+  const midByToken = /* @__PURE__ */ new Map();
+  midByToken.set(USDC_TOKEN_INDEX, ONE);
+  for (const pair of spotMeta.universe ?? []) {
+    const [base, quote] = pair.tokens;
+    if (quote !== USDC_TOKEN_INDEX || base === USDC_TOKEN_INDEX) {
+      continue;
+    }
+    const mid = toPrice(mids[pair.name]);
+    if (mid !== null && !midByToken.has(base)) {
+      midByToken.set(base, mid);
+    }
+  }
+  return midByToken;
+}
+__name(directUsdcMids, "directUsdcMids");
+
+export { SpotPrices };

package/dist/tracker/hyperliquid/tracker.js

@@ -1,13 +1,22 @@
-import BigNumber from 'bignumber.js';
 import { createExchangeWs } from '../../client';
-import { fetchPerpDexs, fetchInfo, fetchUserAbstraction, fetchSpotClearinghouseState, fetchClearinghouseState, fetchActiveAssetData } from '../../client/hyperliquid/rest';
+import { fetchPerpDexs, fetchInfo, fetchAllMids, fetchUserAbstraction, fetchSpotClearinghouseState, fetchDelegatorSummary, fetchUserVaultEquities, fetchClearinghouseState, fetchActiveAssetData } from '../../client/hyperliquid/rest';
 import { BaseAccountTracker } from '../base';
+import { computeMaxBasketSize } from '../basket-size';
+import { resolveHyperliquidAccountType } from './account-mode';
+import { minimumAvailableToTrade, findLegMarket, buildPoolBudgets, buildCappedLegs } from './basket-size';
+import { buildAvailableMarginByToken, buildCollateralTokenNames } from './collateral';
 import { LOCKED_TRACKED_COINS } from './const';
-import { aggregateClearinghouseStates, mapBalance, mapPositions } from './mapper';
-import { HyperliquidAccountType, COLLATERAL_TOKEN_MAP } from './types';
+import { toDecimal, ZERO } from './decimal';
+import { emptyClearinghouseSummary, aggregateClearinghouseStates, mapBalance, mapPositions } from './mapper';
+import { SpotPrices } from './spot-pricing';
+import { HyperliquidAccountType } from './types';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const EMPTY_SPOT_META = {
+  tokens: [],
+  universe: []
+};
 class HyperliquidAccountTracker extends BaseAccountTracker {
   static {
     __name(this, "HyperliquidAccountTracker");
@@ -18,12 +27,20 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
   openListenerId = null;
   lifecycleVersion = 0;
   subscribedCoins = /* @__PURE__ */ new Set();
-  lastSummary = emptySummary();
+  lastSummary = emptyClearinghouseSummary();
   spotCoinBalances = /* @__PURE__ */ new Map();
+  /** Portfolio Margin's own risk scalars, which ride the same `spotState` frame the balances do. */
+  portfolioMarginRatio = null;
+  borrowRatioByToken = /* @__PURE__ */ new Map();
   hasSpotState = false;
   hasClearinghouseState = false;
   accountType = null;
-  collateralTokenMap = legacyCollateralTokenMap();
+  spotMeta = EMPTY_SPOT_META;
+  collateralTokenNames = /* @__PURE__ */ new Map();
+  prices = null;
+  hasWebData3 = false;
+  vaultEquity = "0";
+  stakedHype = "0";
   dexToMeta = /* @__PURE__ */ new Map();
   trackedAssetData = /* @__PURE__ */ new Map();
   constructor(config) {
@@ -31,11 +48,12 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     this.address = config.account.exchangeIdentifier;
   }
   /**
-  * Reads account mode, collateral balances, per-DEX state, and positions without opening a socket.
+  * Reads account mode, spot prices, collateral balances, per-DEX state, staking, vaults and
+  * per-asset headroom without opening a socket.
   */
   async snapshot() {
     const user = this.addrLower();
-    const [perpDexs, allMetas, spotMeta, abstraction, spotState] = await Promise.all([
+    const [perpDexs, allMetas, spotMeta, mids, abstraction, spotState, delegator, vaults] = await Promise.all([
       fetchPerpDexs(this.demo),
       fetchInfo({
         type: "allPerpMetas"
@@ -43,8 +61,11 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
       fetchInfo({
         type: "spotMeta"
       }, this.demo),
+      fetchAllMids(this.demo),
       fetchUserAbstraction(user, this.demo),
-      fetchSpotClearinghouseState(user, this.demo)
+      fetchSpotClearinghouseState(user, this.demo),
+      fetchDelegatorSummary(user, this.demo),
+      fetchUserVaultEquities(user, this.demo)
     ]);
     const descriptors = uniqueDexDescriptors(perpDexs, allMetas);
     const clearinghouseStates = await Promise.all(descriptors.map(async ({ dex, meta }) => ({
@@ -53,17 +74,57 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
       meta,
       state: await fetchClearinghouseState(user, dex, this.demo)
     })));
+    const assetData = await this.fetchActiveAssetEvents(this.coinsForAvailableMargin());
     const { summary, assetPositions } = aggregateClearinghouseStates(clearinghouseStates);
-    const accountType = resolveHyperliquidAccountType(abstraction);
-    const collateralTokenMap = buildCollateralTokenMap(allMetas, spotMeta);
-    const spotCoinBalances = mapSpotBalances(spotState);
-    const balance = mapBalance(summary, spotCoinBalances, accountType, collateralTokenMap);
+    const balance = mapBalance({
+      accountType: resolveHyperliquidAccountType(abstraction),
+      summary,
+      spotBalances: mapSpotBalances(spotState),
+      prices: SpotPrices.from(spotMeta, mids),
+      vaultEquity: sumRestVaultEquity(vaults),
+      stakedHype: stakingAccountHype(delegator),
+      availableMargin: minimumAvailableToTrade(assetData.values()),
+      collateralTokenNames: buildCollateralTokenNames(spotMeta),
+      availableMarginByToken: buildAvailableMarginByToken(summary.perDexState, assetData.values()),
+      portfolioMarginRatio: spotState.portfolioMarginRatio ?? null,
+      borrowRatioByToken: mapBorrowRatios(spotState),
+      timestamp: Date.now()
+    });
     const positions = Array.from(mapPositions(assetPositions).values());
     return {
       balance,
       positions
     };
   }
+  /** Sizes a basket over REST alone, so the call stays usable without a running socket. */
+  async snapshotMaxBasketSize(input) {
+    const [dexToMeta, tokenNames] = await Promise.all([
+      this.loadPerpMetasOnce(),
+      this.loadCollateralTokenNamesOnce()
+    ]);
+    const assetData = await this.fetchActiveAssetEvents(input.legs.map((leg) => leg.asset));
+    return sizeBasket(input, dexToMeta, tokenNames, assetData);
+  }
+  /**
+  * Sizes a basket against live state, fetching per-asset data for any leg the socket has not
+  * subscribed to — which is exactly why the call is asynchronous on both paths.
+  */
+  async maxBasketSize(input) {
+    const [dexToMeta, tokenNames] = await Promise.all([
+      this.loadPerpMetasOnce(),
+      this.loadCollateralTokenNamesOnce()
+    ]);
+    const missingCoins = input.legs.map((leg) => leg.asset).filter((asset) => !this.trackedAssetData.has(asset));
+    const fetched = await this.fetchActiveAssetEvents(missingCoins);
+    const assetData = new Map(fetched);
+    for (const leg of input.legs) {
+      const cached = this.trackedAssetData.get(leg.asset);
+      if (cached) {
+        assetData.set(leg.asset, cached);
+      }
+    }
+    return sizeBasket(input, dexToMeta, tokenNames, assetData);
+  }
   /**
   * Stateless one-shot per-asset settings read via the `activeAssetData` info request (the REST
   * twin of the live WS subscription), one request per coin fired in parallel — the info endpoint
@@ -71,16 +132,15 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
   * throws if every coin fetch fails.
   */
   async fetchAssetSnapshots(coins) {
-    const user = this.addrLower();
-    const settled = await Promise.allSettled(coins.map((coin) => fetchActiveAssetData(user, coin, this.demo)));
-    if (settled.every((r) => r.status === "rejected")) {
+    const events = await this.fetchActiveAssetEvents(coins);
+    if (coins.length > 0 && events.size === 0) {
       throw new Error("Hyperliquid snapshotAssets: every activeAssetData read failed");
     }
     const result = {};
-    coins.forEach((coin, i) => {
-      const r = settled[i];
-      result[coin] = r?.status === "fulfilled" && r.value.coin ? buildTrackedAssetInfo(r.value) : null;
-    });
+    for (const coin of coins) {
+      const event = events.get(coin);
+      result[coin] = event ? buildTrackedAssetInfo(event) : null;
+    }
     return result;
   }
   async start() {
@@ -90,7 +150,7 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     this.subscribedCoins.clear();
     this.resetLiveAccountState();
     this.dexToMeta.clear();
-    const [allMetas, perpDexs, spotMeta, abstraction] = await Promise.all([
+    const [allMetas, perpDexs, spotMeta, abstraction, delegator] = await Promise.all([
       fetchInfo({
         type: "allPerpMetas"
       }, this.demo),
@@ -98,12 +158,15 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
       fetchInfo({
         type: "spotMeta"
       }, this.demo),
-      fetchUserAbstraction(user, this.demo)
+      fetchUserAbstraction(user, this.demo),
+      fetchDelegatorSummary(user, this.demo)
     ]);
     if (lifecycleVersion !== this.lifecycleVersion) return;
     this.loadPerpMetas(allMetas, perpDexs);
-    this.collateralTokenMap = buildCollateralTokenMap(allMetas, spotMeta);
+    this.spotMeta = spotMeta;
+    this.collateralTokenNames = buildCollateralTokenNames(spotMeta);
     this.accountType = resolveHyperliquidAccountType(abstraction);
+    this.stakedHype = stakingAccountHype(delegator);
     const ws = (await createExchangeWs("hyperliquid", {
       demo: this.demo,
       credentials: this.credentials
@@ -197,6 +260,12 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
         user
       }
     });
+    this.ws?.send({
+      method: "subscribe",
+      subscription: {
+        type: "allMids"
+      }
+    });
   }
   /** Subscribes to the spot state variant required by the active account mode. */
   sendSpotStateSubscription(method, accountType) {
@@ -252,6 +321,12 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
             data: msg.data
           });
           break;
+        case "allMids":
+          this.handle({
+            kind: "allMids",
+            data: msg.data
+          });
+          break;
         case "activeAssetData":
           this.handle({
             kind: "activeAssetData",
@@ -274,6 +349,9 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
       case "webData3":
         this.onWebData3(event.data);
         break;
+      case "allMids":
+        this.onAllMids(event.data);
+        break;
       case "activeAssetData":
         this.onActiveAssetData(event.data);
         break;
@@ -285,6 +363,56 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
       this.dexToMeta.set(dex, dexMeta);
     });
   }
+  /** Loads the dex metadata a sizing call needs, reusing whatever `start()` already cached. */
+  async loadPerpMetasOnce() {
+    if (this.dexToMeta.size > 0) {
+      return this.dexToMeta;
+    }
+    const [allMetas, perpDexs] = await Promise.all([
+      fetchInfo({
+        type: "allPerpMetas"
+      }, this.demo),
+      fetchPerpDexs(this.demo)
+    ]);
+    this.loadPerpMetas(allMetas, perpDexs);
+    return this.dexToMeta;
+  }
+  /** Loads the token names a pool id is spelled with, reusing whatever `start()` already cached. */
+  async loadCollateralTokenNamesOnce() {
+    if (this.collateralTokenNames.size > 0) {
+      return this.collateralTokenNames;
+    }
+    const spotMeta = await fetchInfo({
+      type: "spotMeta"
+    }, this.demo);
+    this.collateralTokenNames = buildCollateralTokenNames(spotMeta);
+    return this.collateralTokenNames;
+  }
+  /** Reads `activeAssetData` for each coin in parallel, dropping the coins the venue refuses. */
+  async fetchActiveAssetEvents(coins) {
+    const unique = [
+      ...new Set(coins)
+    ];
+    const user = this.addrLower();
+    const settled = await Promise.allSettled(unique.map((coin) => fetchActiveAssetData(user, coin, this.demo)));
+    const events = /* @__PURE__ */ new Map();
+    unique.forEach((coin, index) => {
+      const result = settled[index];
+      if (result?.status === "fulfilled" && result.value.coin) {
+        events.set(coin, result.value);
+      }
+    });
+    return events;
+  }
+  /** The asset set `availableMargin` is the floor over: the locked coins plus every tracked one. */
+  coinsForAvailableMargin() {
+    return [
+      .../* @__PURE__ */ new Set([
+        ...LOCKED_TRACKED_COINS,
+        ...this.trackedCoins
+      ])
+    ];
+  }
   onClearinghouseState(data) {
     const states = (data.clearinghouseStates || []).flatMap(([dex, state]) => state ? [
       {
@@ -310,12 +438,33 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
   onActiveAssetData(data) {
     if (!data.coin) return;
     if (!this.subscribedCoins.has(data.coin)) return;
+    const previousMargin = this.availableMargin();
     this.trackedAssetData.set(data.coin, data);
     const trackedAssets = /* @__PURE__ */ new Map();
     trackedAssets.set(data.coin, buildTrackedAssetInfo(data));
     this.onStateUpdate({
       trackedAssets
     });
+    if (this.availableMargin() === previousMargin) {
+      return;
+    }
+    const balance = this.buildBalance();
+    if (balance !== void 0) {
+      this.onStateUpdate({
+        balance
+      });
+    }
+  }
+  onAllMids(data) {
+    const mids = data?.mids;
+    if (!mids) return;
+    this.prices = SpotPrices.from(this.spotMeta, mids);
+    const balance = this.buildBalance();
+    if (balance !== void 0) {
+      this.onStateUpdate({
+        balance
+      });
+    }
   }
   onWebData3(data) {
     const previousAccountType = this.accountType;
@@ -329,6 +478,8 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
       this.resetLiveAccountState();
     }
     this.accountType = nextAccountType;
+    this.vaultEquity = sumLiveVaultEquity(data.perpDexStates ?? []);
+    this.hasWebData3 = true;
     if (!nextAccountType) {
       this.onStateUpdate({
         balance: null
@@ -346,6 +497,8 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     const balances = data?.spotState?.balances;
     if (!balances) return;
     this.spotCoinBalances = mapSpotBalances(data.spotState);
+    this.portfolioMarginRatio = data.spotState.portfolioMarginRatio ?? null;
+    this.borrowRatioByToken = mapBorrowRatios(data.spotState);
     this.hasSpotState = true;
     const balance = this.buildBalance();
     if (balance !== void 0) {
@@ -354,21 +507,47 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
       });
     }
   }
+  /**
+  * Builds the live balance once every channel that feeds it has reported, or `undefined` until then.
+  *
+  * All four are required. Every mode now values the spot wallet, so a balance emitted before
+  * `spotState` and `allMids` would report equity missing its whole spot half; and one emitted
+  * before `webData3` would report vault equity as zero on an account that holds millions in a
+  * vault. Partial equity is worse than no equity, so nothing is published early.
+  */
   buildBalance() {
-    if (!this.hasClearinghouseState || !this.accountType) {
-      return void 0;
-    }
-    if ((this.accountType === HyperliquidAccountType.UNIFIED_ACCOUNT || this.accountType === HyperliquidAccountType.PORTFOLIO_MARGIN) && !this.hasSpotState) {
+    if (!this.hasClearinghouseState || !this.hasSpotState || !this.hasWebData3 || !this.prices || !this.accountType) {
       return void 0;
     }
-    return mapBalance(this.lastSummary, this.spotCoinBalances, this.accountType, this.collateralTokenMap);
+    return mapBalance({
+      accountType: this.accountType,
+      summary: this.lastSummary,
+      spotBalances: this.spotCoinBalances,
+      prices: this.prices,
+      vaultEquity: this.vaultEquity,
+      stakedHype: this.stakedHype,
+      availableMargin: this.availableMargin(),
+      collateralTokenNames: this.collateralTokenNames,
+      availableMarginByToken: buildAvailableMarginByToken(this.lastSummary.perDexState, this.trackedAssetData.values()),
+      portfolioMarginRatio: this.portfolioMarginRatio,
+      borrowRatioByToken: this.borrowRatioByToken,
+      timestamp: Date.now()
+    });
+  }
+  /** The floor of `availableToTrade` over the tracked set; `null` when nothing is tracked. */
+  availableMargin() {
+    return minimumAvailableToTrade(this.trackedAssetData.values());
   }
   /** Clears both sides of the live balance join and the public account cache without emitting. */
   resetLiveAccountState() {
     this.hasSpotState = false;
     this.hasClearinghouseState = false;
-    this.lastSummary = emptySummary();
+    this.hasWebData3 = false;
+    this.vaultEquity = "0";
+    this.lastSummary = emptyClearinghouseSummary();
     this.spotCoinBalances.clear();
+    this.portfolioMarginRatio = null;
+    this.borrowRatioByToken.clear();
     this.resetAccountState();
   }
   buildTrackedAssetsMap() {
@@ -379,6 +558,18 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     return result;
   }
 }
+function sizeBasket(input, dexToMeta, tokenNames, assetData) {
+  const markets = new Map(input.legs.map((leg) => [
+    leg.asset,
+    findLegMarket(dexToMeta, tokenNames, leg.asset, assetData.get(leg.asset)?.leverage.value ?? null)
+  ]));
+  const budgets = buildPoolBudgets(input.legs, markets, assetData);
+  return computeMaxBasketSize({
+    budgets,
+    legs: buildCappedLegs(input.legs, markets)
+  });
+}
+__name(sizeBasket, "sizeBasket");
 function buildTrackedAssetInfo(data) {
   return {
     coin: data.coin,
@@ -387,18 +578,6 @@ function buildTrackedAssetInfo(data) {
   };
 }
 __name(buildTrackedAssetInfo, "buildTrackedAssetInfo");
-const HYPERLIQUID_ACCOUNT_TYPES = Object.values(HyperliquidAccountType);
-function toHyperliquidAccountType(abstraction) {
-  if (!abstraction) {
-    return null;
-  }
-  return HYPERLIQUID_ACCOUNT_TYPES.includes(abstraction) ? abstraction : null;
-}
-__name(toHyperliquidAccountType, "toHyperliquidAccountType");
-function resolveHyperliquidAccountType(abstraction) {
-  return toHyperliquidAccountType(abstraction);
-}
-__name(resolveHyperliquidAccountType, "resolveHyperliquidAccountType");
 function uniqueDexDescriptors(perpDexs, allMetas) {
   const seen = /* @__PURE__ */ new Set();
   return perpDexs.flatMap((descriptor, index) => {
@@ -418,9 +597,8 @@ function uniqueDexDescriptors(perpDexs, allMetas) {
 __name(uniqueDexDescriptors, "uniqueDexDescriptors");
 function mapSpotBalances(spotState) {
   const balances = /* @__PURE__ */ new Map();
-  const availableAfterMaintenance = new Map(spotState.tokenToAvailableAfterMaintenance ?? []);
   for (const balance of spotState.balances) {
-    if (new BigNumber(balance.total || "0").isZero() && new BigNumber(balance.hold || "0").isZero()) {
+    if (toDecimal(balance.total).isZero() && toDecimal(balance.hold).isZero()) {
       continue;
     }
     balances.set(balance.coin, {
@@ -428,48 +606,29 @@ function mapSpotBalances(spotState) {
       token: balance.token,
       total: balance.total,
       hold: balance.hold,
-      availableAfterMaintenance: availableAfterMaintenance.get(balance.token)
+      // An absent `ltv` means "not collateral", which weighs zero — never a zero weight, which is
+      // a stablecoin at full value. The two states stay apart from the wire onward.
+      ltv: balance.ltv ?? null
     });
   }
   return balances;
 }
 __name(mapSpotBalances, "mapSpotBalances");
-function emptySummary() {
-  return {
-    accountValue: "0",
-    totalMarginUsed: "0",
-    totalRawUsd: "0",
-    crossMaintenanceMarginUsed: "0",
-    isolatedMaintenanceMarginUsed: "0",
-    maximumStandardMarginRatio: "0.0000",
-    withdrawable: "0",
-    totalUnrealizedPnl: "0",
-    byCollateralToken: /* @__PURE__ */ new Map()
-  };
+function mapBorrowRatios(spotState) {
+  return new Map(spotState.tokenToPortfolioBorrowRatio ?? []);
 }
-__name(emptySummary, "emptySummary");
-function buildCollateralTokenMap(allMetas, spotMeta) {
-  const spotTokenNames = new Map(spotMeta.tokens.map((token) => [
-    token.index,
-    token.name
-  ]));
-  const result = /* @__PURE__ */ new Map();
-  for (const meta of allMetas) {
-    const token = meta.collateralToken;
-    const coin = spotTokenNames.get(token) ?? COLLATERAL_TOKEN_MAP[token];
-    if (coin) {
-      result.set(token, coin);
-    }
-  }
-  return result;
+__name(mapBorrowRatios, "mapBorrowRatios");
+function stakingAccountHype(delegator) {
+  return toDecimal(delegator.delegated).plus(toDecimal(delegator.undelegated)).toFixed();
 }
-__name(buildCollateralTokenMap, "buildCollateralTokenMap");
-function legacyCollateralTokenMap() {
-  return new Map(Object.entries(COLLATERAL_TOKEN_MAP).map(([token, coin]) => [
-    Number(token),
-    coin
-  ]));
+__name(stakingAccountHype, "stakingAccountHype");
+function sumRestVaultEquity(vaults) {
+  return vaults.reduce((total, vault) => total.plus(toDecimal(vault.equity)), ZERO).toFixed();
+}
+__name(sumRestVaultEquity, "sumRestVaultEquity");
+function sumLiveVaultEquity(perpDexStates) {
+  return perpDexStates.reduce((total, state) => total.plus(toDecimal(state?.totalVaultEquity)), ZERO).toFixed();
 }
-__name(legacyCollateralTokenMap, "legacyCollateralTokenMap");
+__name(sumLiveVaultEquity, "sumLiveVaultEquity");
 
 export { HyperliquidAccountTracker };

package/dist/tracker/hyperliquid/types.js

@@ -5,11 +5,5 @@ var HyperliquidAccountType = /* @__PURE__ */ (function(HyperliquidAccountType2)
   HyperliquidAccountType2["UNIFIED_ACCOUNT"] = "unifiedAccount";
   return HyperliquidAccountType2;
 })({});
-const COLLATERAL_TOKEN_MAP = {
-  0: "USDC",
-  235: "USDE",
-  268: "USDT0",
-  360: "USDH"
-};
 
-export { COLLATERAL_TOKEN_MAP, HyperliquidAccountType };
+export { HyperliquidAccountType };

package/dist/tracker/index.js

@@ -8,12 +8,15 @@ import { LighterAccountTracker } from './lighter/tracker';
 export { LighterAccountTracker } from './lighter/tracker';
 import { OkxAccountTracker } from './okx/tracker';
 export { OkxAccountTracker } from './okx/tracker';
+export { AccountBalance } from './balance';
+export { ACCOUNT_MODE_LABELS, AccountBalanceCore, AccountMode, CollateralBalance, DecimalString, MarginMode, Side, SignedDecimalString } from './balance-core';
 export { BaseAccountTracker } from './base';
-export { BinanceAccountType } from './binance/types';
-export { BybitAccountType } from './bybit/types';
-export { HyperliquidAccountType } from './hyperliquid/types';
-export { LighterAccountType } from './lighter/types';
-export { OkxAccountType } from './okx/types';
+export { BasketLeg, MaxBasketSizeInput, MaxBasketSizeResult, computeMaxBasketSize } from './basket-size';
+export { BinanceMultiAssetBalance, BinanceSingleAssetBalance } from './binance/balance';
+export { BybitIsolatedMarginBalance, BybitPortfolioMarginBalance, BybitRegularMarginBalance } from './bybit/balance';
+export { HyperliquidDexState, HyperliquidPortfolioMarginBalance, HyperliquidPortfolioMarginCollateral, HyperliquidStandardBalance, HyperliquidUnifiedBalance } from './hyperliquid/balance';
+export { LighterClassicBalance, LighterUnifiedBalance } from './lighter/balance';
+export { OkxFuturesBalance, OkxMultiCurrencyMarginBalance, OkxPortfolioMarginBalance, OkxSpotBalance } from './okx/balance';
 export * from './types';
 
 var __defProp = Object.defineProperty;
@@ -50,8 +53,7 @@ function createAccountTracker(exchange, config) {
         demo: config.demo,
         onError: config.onError,
         account: config.account,
-        credentials: config.credentials,
-        sdk: config.sdk
+        credentials: config.credentials
       });
     default: {
       const _exhaustive = exchange;