@pear-protocol/exchanges-sdk 0.3.0 → 0.4.0

package/dist/tracker/hyperliquid/mapper.test.js

@@ -0,0 +1,255 @@
+import { describe, it, expect } from 'vitest';
+import { aggregateClearinghouseStates, mapBalance } from './mapper';
+import { HyperliquidAccountType } from './types';
+
+function buildState(overrides) {
+  const leverage = overrides.leverage === "isolated" ? { type: "isolated", value: 10, rawUsd: overrides.marginUsed ?? "0" } : { type: "cross", value: 10 };
+  return {
+    marginSummary: {
+      accountValue: overrides.accountValue,
+      totalNtlPos: "0",
+      totalRawUsd: overrides.accountValue,
+      totalMarginUsed: overrides.totalMarginUsed
+    },
+    crossMarginSummary: {
+      accountValue: overrides.crossAccountValue ?? overrides.accountValue,
+      totalNtlPos: "0",
+      totalRawUsd: overrides.crossAccountValue ?? overrides.accountValue,
+      totalMarginUsed: overrides.totalMarginUsed
+    },
+    crossMaintenanceMarginUsed: overrides.crossMaintenanceMarginUsed,
+    withdrawable: overrides.withdrawable,
+    assetPositions: [
+      {
+        type: "oneWay",
+        position: {
+          coin: overrides.coin,
+          szi: "1",
+          leverage,
+          entryPx: "1000",
+          positionValue: overrides.positionValue ?? "1000",
+          unrealizedPnl: overrides.unrealizedPnl,
+          returnOnEquity: "0.1",
+          liquidationPx: "800",
+          marginUsed: overrides.marginUsed ?? "100",
+          maxLeverage: overrides.maxLeverage ?? 10,
+          cumFunding: { allTime: "0", sinceOpen: "0", sinceChange: "0" }
+        }
+      }
+    ],
+    time: 0
+  };
+}
+function dexState(state, collateralToken, dex = "", meta = null) {
+  return {
+    dex,
+    collateralToken,
+    meta,
+    state
+  };
+}
+describe("Hyperliquid balance mapping", () => {
+  it("uses the maximum independent cross and isolated risk ratios for Standard accounts", () => {
+    const state = buildState({
+      accountValue: "120",
+      crossAccountValue: "80",
+      totalMarginUsed: "40",
+      crossMaintenanceMarginUsed: "5",
+      withdrawable: "70",
+      coin: "BTC",
+      unrealizedPnl: "20",
+      leverage: "isolated",
+      positionValue: "1000",
+      maxLeverage: 10
+    });
+    const { summary, assetPositions } = aggregateClearinghouseStates([dexState(state, 0)]);
+    const balance = mapBalance(summary, /* @__PURE__ */ new Map(), HyperliquidAccountType.DEFAULT);
+    expect(summary.accountValue).toBe("120");
+    expect(summary.isolatedMaintenanceMarginUsed).toBe("50");
+    expect(assetPositions).toHaveLength(1);
+    expect(balance).toMatchObject({
+      accountType: "default",
+      totalEquity: "120",
+      walletBalance: "100",
+      initialMarginUsed: "40",
+      maintenanceMargin: "55",
+      marginRatio: "0.5000",
+      availableToTrade: "70"
+    });
+  });
+  it("applies tiered maintenance rates and continuity deductions to isolated positions", () => {
+    const state = buildState({
+      accountValue: "5000",
+      totalMarginUsed: "100",
+      crossMaintenanceMarginUsed: "0",
+      withdrawable: "4900",
+      coin: "BTC",
+      unrealizedPnl: "0",
+      leverage: "isolated",
+      positionValue: "2000",
+      maxLeverage: 50
+    });
+    const meta = {
+      collateralToken: 0,
+      universe: [{ name: "BTC", szDecimals: 5, maxLeverage: 50, marginTableId: 1 }],
+      marginTables: [
+        [
+          1,
+          {
+            description: "tiered",
+            marginTiers: [
+              { lowerBound: "0", maxLeverage: 50 },
+              { lowerBound: "1000", maxLeverage: 25 }
+            ]
+          }
+        ]
+      ]
+    };
+    const { summary } = aggregateClearinghouseStates([dexState(state, 0, "", meta)]);
+    expect(summary.isolatedMaintenanceMarginUsed).toBe("30");
+  });
+  it("uses the maximum per-DEX Standard margin ratio instead of a blended aggregate ratio", () => {
+    const higherRiskState = buildState({
+      accountValue: "100",
+      totalMarginUsed: "20",
+      crossMaintenanceMarginUsed: "10",
+      withdrawable: "80",
+      coin: "BTC",
+      unrealizedPnl: "0"
+    });
+    const lowerRiskState = buildState({
+      accountValue: "900",
+      totalMarginUsed: "90",
+      crossMaintenanceMarginUsed: "45",
+      withdrawable: "810",
+      coin: "xyz:ETH",
+      unrealizedPnl: "0"
+    });
+    const { summary } = aggregateClearinghouseStates([
+      dexState(higherRiskState, 0),
+      dexState(lowerRiskState, 360, "xyz")
+    ]);
+    const balance = mapBalance(summary, /* @__PURE__ */ new Map(), HyperliquidAccountType.DEFAULT);
+    expect(balance).toMatchObject({
+      totalEquity: "1000",
+      maintenanceMargin: "55",
+      marginRatio: "0.1000"
+    });
+  });
+  it("maps network-specific collateral token indexes through spot metadata", () => {
+    const state = buildState({
+      accountValue: "100",
+      totalMarginUsed: "10",
+      crossMaintenanceMarginUsed: "5",
+      withdrawable: "90",
+      coin: "test:ETH",
+      unrealizedPnl: "0"
+    });
+    const { summary } = aggregateClearinghouseStates([dexState(state, 1452, "test")]);
+    const balance = mapBalance(summary, /* @__PURE__ */ new Map(), HyperliquidAccountType.DEFAULT, /* @__PURE__ */ new Map([[1452, "USDH"]]));
+    expect(balance).toMatchObject({
+      free: { USDH: "90" },
+      used: { USDH: "10" },
+      total: { USDH: "100" },
+      assets: [{ asset: "USDH" }]
+    });
+  });
+  it("reports at least full utilization when Standard maintenance is positive without collateral", () => {
+    const state = buildState({
+      accountValue: "0",
+      crossAccountValue: "0",
+      totalMarginUsed: "10",
+      crossMaintenanceMarginUsed: "5",
+      withdrawable: "0",
+      coin: "BTC",
+      unrealizedPnl: "-100"
+    });
+    const { summary } = aggregateClearinghouseStates([dexState(state, 0)]);
+    expect(mapBalance(summary, /* @__PURE__ */ new Map(), HyperliquidAccountType.DEFAULT)?.marginRatio).toBe("1.0000");
+  });
+  it("uses authoritative spot holds and post-maintenance availability for Unified accounts", () => {
+    const usdcState = buildState({
+      accountValue: "999",
+      totalMarginUsed: "30",
+      crossMaintenanceMarginUsed: "10",
+      withdrawable: "999",
+      coin: "BTC",
+      unrealizedPnl: "5",
+      leverage: "isolated",
+      marginUsed: "20",
+      positionValue: "0"
+    });
+    const usdhState = buildState({
+      accountValue: "999",
+      totalMarginUsed: "40",
+      crossMaintenanceMarginUsed: "20",
+      withdrawable: "999",
+      coin: "xyz:ETH",
+      unrealizedPnl: "0"
+    });
+    const { summary } = aggregateClearinghouseStates([dexState(usdcState, 0), dexState(usdhState, 360, "xyz")]);
+    const spotBalances = /* @__PURE__ */ new Map([
+      ["USDC", { coin: "USDC", token: 0, total: "100", hold: "5", availableAfterMaintenance: "70" }],
+      ["USDH", { coin: "USDH", token: 360, total: "400", hold: "10", availableAfterMaintenance: "380" }]
+    ]);
+    const balance = mapBalance(summary, spotBalances, HyperliquidAccountType.UNIFIED_ACCOUNT);
+    expect(balance).toMatchObject({
+      accountType: "unifiedAccount",
+      walletBalance: "495",
+      totalEquity: "500",
+      availableToTrade: "450",
+      marginRatio: "0.1250"
+    });
+    expect(balance?.free).toEqual({ USDC: "95", USDH: "390" });
+    expect(balance?.used).toEqual({ USDC: "5", USDH: "10" });
+    expect(balance?.assets).toEqual([
+      expect.objectContaining({ asset: "USDC", walletBalance: "95", total: "100" }),
+      expect.objectContaining({ asset: "USDH", walletBalance: "400", total: "400" })
+    ]);
+  });
+  it("reports at least full utilization when Unified cross maintenance has no available collateral", () => {
+    const state = buildState({
+      accountValue: "0",
+      totalMarginUsed: "10",
+      crossMaintenanceMarginUsed: "5",
+      withdrawable: "0",
+      coin: "BTC",
+      unrealizedPnl: "-100"
+    });
+    const { summary } = aggregateClearinghouseStates([dexState(state, 0)]);
+    const spotBalances = /* @__PURE__ */ new Map([["USDC", { coin: "USDC", token: 0, total: "0", hold: "0" }]]);
+    expect(mapBalance(summary, spotBalances, HyperliquidAccountType.UNIFIED_ACCOUNT)?.marginRatio).toBe("1.0000");
+  });
+  it("does not fabricate Portfolio Margin or deprecated DEX-abstraction account totals", () => {
+    const sharedState = buildState({
+      accountValue: "100",
+      totalMarginUsed: "10",
+      crossMaintenanceMarginUsed: "5",
+      withdrawable: "90",
+      coin: "BTC",
+      unrealizedPnl: "0"
+    });
+    const { summary } = aggregateClearinghouseStates([
+      dexState(sharedState, 0),
+      dexState(sharedState, 0, "builder-dex")
+    ]);
+    expect(summary.accountValue).toBe("200");
+    expect(mapBalance(summary, /* @__PURE__ */ new Map(), HyperliquidAccountType.DEX_ABSTRACTION)).toBeNull();
+    expect(mapBalance(summary, /* @__PURE__ */ new Map(), HyperliquidAccountType.PORTFOLIO_MARGIN)).toBeNull();
+  });
+  it("returns a zeroed aggregate for an empty DEX list", () => {
+    const { summary, assetPositions } = aggregateClearinghouseStates([]);
+    expect(summary).toMatchObject({
+      accountValue: "0",
+      totalMarginUsed: "0",
+      totalRawUsd: "0",
+      crossMaintenanceMarginUsed: "0",
+      isolatedMaintenanceMarginUsed: "0",
+      maximumStandardMarginRatio: "0.0000",
+      withdrawable: "0",
+      totalUnrealizedPnl: "0"
+    });
+    expect(summary.byCollateralToken.size).toBe(0);
+    expect(assetPositions).toEqual([]);
+  });
+});

package/dist/tracker/hyperliquid/tracker.js

@@ -1,63 +1,136 @@
 import BigNumber from 'bignumber.js';
-import { fetchInfo } from '../../client/hyperliquid/rest';
+import { createExchangeWs } from '../../client';
+import { fetchPerpDexs, fetchInfo, fetchUserAbstraction, fetchSpotClearinghouseState, fetchClearinghouseState, fetchActiveAssetData } 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';
+import { aggregateClearinghouseStates, mapBalance, mapPositions } from './mapper';
+import { HyperliquidAccountType, COLLATERAL_TOKEN_MAP } from './types';
 
 class HyperliquidAccountTracker extends BaseAccountTracker {
   address;
-  ws;
+  ws = null;
   messageListenerId = null;
   openListenerId = null;
+  lifecycleVersion = 0;
   subscribedCoins = /* @__PURE__ */ new Set();
-  lastSummary = {
-    accountValue: "0",
-    totalMarginUsed: "0",
-    totalRawUsd: "0",
-    crossMaintenanceMarginUsed: "0",
-    withdrawable: "0",
-    totalUnrealizedPnl: "0"
-  };
+  lastSummary = emptySummary();
   spotCoinBalances = /* @__PURE__ */ new Map();
+  hasSpotState = false;
+  hasClearinghouseState = false;
   accountType = null;
-  symbolToCollateralToken = /* @__PURE__ */ new Map();
-  availableToTradeByCollateral = /* @__PURE__ */ new Map();
+  collateralTokenMap = legacyCollateralTokenMap();
+  dexToMeta = /* @__PURE__ */ new Map();
   trackedAssetData = /* @__PURE__ */ new Map();
   constructor(config) {
     super(config);
-    this.credentials = config.credentials;
     this.address = config.account.exchangeIdentifier;
-    this.ws = config.ws;
+  }
+  /**
+   * Reads account mode, collateral balances, per-DEX state, and positions without opening a socket.
+   */
+  async snapshot() {
+    const user = this.addrLower();
+    const [perpDexs, allMetas, spotMeta, abstraction, spotState] = await Promise.all([
+      fetchPerpDexs(this.demo),
+      fetchInfo({ type: "allPerpMetas" }, this.demo),
+      fetchInfo({ type: "spotMeta" }, this.demo),
+      fetchUserAbstraction(user, this.demo),
+      fetchSpotClearinghouseState(user, this.demo)
+    ]);
+    const descriptors = uniqueDexDescriptors(perpDexs, allMetas);
+    const clearinghouseStates = await Promise.all(
+      descriptors.map(
+        async ({ dex, meta }) => ({
+          dex,
+          collateralToken: meta?.collateralToken ?? null,
+          meta,
+          state: await fetchClearinghouseState(user, dex, this.demo)
+        })
+      )
+    );
+    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 positions = Array.from(mapPositions(assetPositions).values());
+    return { balance, positions };
+  }
+  /**
+   * 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
+   * has no batch form. Per-coin reads are tolerant (a failed coin maps to `null`); the read only
+   * 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")) {
+      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;
+    });
+    return result;
   }
   async start() {
-    const allMetas = await fetchInfo({ type: "allPerpMetas" });
-    this.loadPerpMetas(allMetas);
+    const lifecycleVersion = ++this.lifecycleVersion;
+    const user = this.addrLower();
+    this.destroyCurrentSocket();
+    this.subscribedCoins.clear();
+    this.resetLiveAccountState();
+    this.dexToMeta.clear();
+    const [allMetas, perpDexs, spotMeta, abstraction] = await Promise.all([
+      fetchInfo({ type: "allPerpMetas" }, this.demo),
+      fetchPerpDexs(this.demo),
+      fetchInfo({ type: "spotMeta" }, this.demo),
+      fetchUserAbstraction(user, this.demo)
+    ]);
+    if (lifecycleVersion !== this.lifecycleVersion) return;
+    this.loadPerpMetas(allMetas, perpDexs);
+    this.collateralTokenMap = buildCollateralTokenMap(allMetas, spotMeta);
+    this.accountType = resolveHyperliquidAccountType(abstraction);
+    const ws = (await createExchangeWs("hyperliquid", { demo: this.demo, credentials: this.credentials })).main;
+    if (lifecycleVersion !== this.lifecycleVersion) {
+      ws.destroy();
+      return;
+    }
+    this.ws = ws;
     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) {
+    const coinsToTrack = /* @__PURE__ */ new Set([...LOCKED_TRACKED_COINS, ...this.trackedCoins]);
+    for (const coin of coinsToTrack) {
       this.ensureAssetTracked(coin);
     }
   }
   async cleanupConnections() {
+    this.lifecycleVersion += 1;
+    this.destroyCurrentSocket();
+    this.subscribedCoins.clear();
+  }
+  /** Detaches and destroys the active socket without changing the current lifecycle generation. */
+  destroyCurrentSocket() {
     if (this.messageListenerId) {
-      this.ws.removeMessageListener(this.messageListenerId);
+      this.ws?.removeMessageListener(this.messageListenerId);
       this.messageListenerId = null;
     }
     if (this.openListenerId) {
-      this.ws.removeOpenListener(this.openListenerId);
+      this.ws?.removeOpenListener(this.openListenerId);
       this.openListenerId = null;
     }
-    this.subscribedCoins.clear();
+    this.ws?.destroy();
+    this.ws = null;
   }
   get isConnected() {
-    return this.ws.connected;
+    return this.ws?.connected ?? false;
   }
   ensureAssetTracked(coin) {
     if (this.subscribedCoins.has(coin)) return;
     this.subscribedCoins.add(coin);
-    this.ws.send({
+    this.ws?.send({
       method: "subscribe",
       subscription: { type: "activeAssetData", coin, user: this.addrLower() }
     });
@@ -66,7 +139,7 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
     if (this.isLocked(coin)) return;
     if (!this.subscribedCoins.has(coin)) return;
     this.subscribedCoins.delete(coin);
-    this.ws.send({
+    this.ws?.send({
       method: "unsubscribe",
       subscription: { type: "activeAssetData", coin, user: this.addrLower() }
     });
@@ -81,15 +154,22 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
   }
   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 } });
+    this.ws?.send({ method: "subscribe", subscription: { type: "allDexsClearinghouseState", user } });
+    this.sendSpotStateSubscription("subscribe", this.accountType);
+    this.ws?.send({ method: "subscribe", subscription: { type: "webData3", user } });
+  }
+  /** Subscribes to the spot state variant required by the active account mode. */
+  sendSpotStateSubscription(method, accountType) {
+    const user = this.addrLower();
+    const subscription = accountType === HyperliquidAccountType.PORTFOLIO_MARGIN ? { type: "spotState", user, isPortfolioMargin: true } : { type: "spotState", user };
+    this.ws?.send({ method, subscription });
   }
   resubscribeAll() {
+    this.resetLiveAccountState();
     this.sendStaticSubs();
     const user = this.addrLower();
     for (const coin of this.subscribedCoins) {
-      this.ws.send({
+      this.ws?.send({
         method: "subscribe",
         subscription: { type: "activeAssetData", coin, user }
       });
@@ -133,71 +213,92 @@ class HyperliquidAccountTracker extends BaseAccountTracker {
         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);
-        }
-      });
+  loadPerpMetas(allMetas, perpDexs) {
+    allMetas.forEach((dexMeta, index) => {
+      const dex = perpDexs[index]?.name ?? "";
+      this.dexToMeta.set(dex, dexMeta);
     });
   }
   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 states = (data.clearinghouseStates || []).flatMap(
+      ([dex, state]) => state ? [
+        {
+          dex,
+          collateralToken: this.dexToMeta.get(dex)?.collateralToken ?? null,
+          meta: this.dexToMeta.get(dex) ?? null,
+          state
+        }
+      ] : []
+    );
+    const { summary, assetPositions } = aggregateClearinghouseStates(states);
+    this.lastSummary = summary;
+    this.hasClearinghouseState = true;
     const balance = this.buildBalance();
-    const positions = mapPositions(allAssetPositions);
-    this.onStateUpdate({ balance: balance ?? void 0, positions });
+    const positions = mapPositions(assetPositions);
+    this.onStateUpdate({
+      ...balance === void 0 ? {} : { balance },
+      positions,
+      positionsMode: "replace"
+    });
   }
   onActiveAssetData(data) {
     if (!data.coin) return;
-    if (!this.trackedCoins.has(data.coin)) return;
+    if (!this.subscribedCoins.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;
+    const previousAccountType = this.accountType;
+    const nextAccountType = resolveHyperliquidAccountType(data.userState.abstraction ?? HyperliquidAccountType.DEFAULT);
+    const portfolioSubscriptionChanged = previousAccountType === HyperliquidAccountType.PORTFOLIO_MARGIN !== (nextAccountType === HyperliquidAccountType.PORTFOLIO_MARGIN);
+    if (portfolioSubscriptionChanged) {
+      this.sendSpotStateSubscription("unsubscribe", previousAccountType);
+      this.sendSpotStateSubscription("subscribe", nextAccountType);
+    }
+    if (previousAccountType !== nextAccountType) {
+      this.resetLiveAccountState();
+    }
+    this.accountType = nextAccountType;
+    if (!nextAccountType) {
+      this.onStateUpdate({ balance: null });
+      return;
+    }
+    const balance = this.buildBalance();
+    if (balance !== void 0) {
+      this.onStateUpdate({ balance });
+    }
   }
   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);
-      }
-    }
+    this.spotCoinBalances = mapSpotBalances(data.spotState);
+    this.hasSpotState = true;
     const balance = this.buildBalance();
-    if (balance) this.onStateUpdate({ balance });
+    if (balance !== void 0) {
+      this.onStateUpdate({ balance });
+    }
   }
   buildBalance() {
-    return mapBalance(this.lastSummary, this.spotCoinBalances, this.accountType, this.availableToTradeByCollateral);
+    if (this.accountType === HyperliquidAccountType.DEX_ABSTRACTION || this.accountType === HyperliquidAccountType.PORTFOLIO_MARGIN) {
+      return null;
+    }
+    if (!this.hasClearinghouseState || !this.accountType) {
+      return void 0;
+    }
+    if (this.accountType === HyperliquidAccountType.UNIFIED_ACCOUNT && !this.hasSpotState) {
+      return void 0;
+    }
+    return mapBalance(this.lastSummary, this.spotCoinBalances, this.accountType, this.collateralTokenMap);
+  }
+  /** 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.spotCoinBalances.clear();
+    this.resetAccountState();
   }
   buildTrackedAssetsMap() {
     const result = /* @__PURE__ */ new Map();
@@ -214,5 +315,71 @@ function buildTrackedAssetInfo(data) {
     marginType: data.leverage?.type
   };
 }
+const HYPERLIQUID_ACCOUNT_TYPES = Object.values(HyperliquidAccountType);
+function toHyperliquidAccountType(abstraction) {
+  if (!abstraction) {
+    return null;
+  }
+  return HYPERLIQUID_ACCOUNT_TYPES.includes(abstraction) ? abstraction : null;
+}
+function resolveHyperliquidAccountType(abstraction) {
+  return toHyperliquidAccountType(abstraction);
+}
+function uniqueDexDescriptors(perpDexs, allMetas) {
+  const seen = /* @__PURE__ */ new Set();
+  return perpDexs.flatMap((descriptor, index) => {
+    const dex = descriptor?.name ?? "";
+    if (seen.has(dex)) {
+      return [];
+    }
+    seen.add(dex);
+    return [{ dex, meta: allMetas[index] ?? null }];
+  });
+}
+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()) {
+      continue;
+    }
+    balances.set(balance.coin, {
+      coin: balance.coin,
+      token: balance.token,
+      total: balance.total,
+      hold: balance.hold,
+      availableAfterMaintenance: availableAfterMaintenance.get(balance.token)
+    });
+  }
+  return balances;
+}
+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 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;
+}
+function legacyCollateralTokenMap() {
+  return new Map(Object.entries(COLLATERAL_TOKEN_MAP).map(([token, coin]) => [Number(token), coin]));
+}
 
 export { HyperliquidAccountTracker };