@pear-protocol/exchanges-sdk 0.2.0 → 0.4.0

package/dist/tracker/hyperliquid/mapper.js

@@ -1,35 +1,141 @@
 import BigNumber from 'bignumber.js';
 import { positionKey } from '../utils';
-import { COLLATERAL_TOKEN_MAP } from './types';
+import { COLLATERAL_TOKEN_MAP, HyperliquidAccountType } from './types';
 
-const COLLATERAL_COINS = new Set(Object.values(COLLATERAL_TOKEN_MAP));
-function mapBalance(summary, spotCoinBalances, accountType, availableToTradeByCollateral) {
-  if (!accountType) return null;
+const LEGACY_COLLATERAL_TOKEN_MAP = new Map(
+  Object.entries(COLLATERAL_TOKEN_MAP).map(([token, coin]) => [Number(token), coin])
+);
+const FULL_UTILIZATION_RATIO = "1.0000";
+const ZERO_COLLATERAL_SUMMARY = {
+  accountValue: "0",
+  totalMarginUsed: "0",
+  crossMaintenanceMarginUsed: "0",
+  isolatedMaintenanceMarginUsed: "0",
+  isolatedMarginUsed: "0",
+  withdrawable: "0",
+  totalUnrealizedPnl: "0"
+};
+function aggregateClearinghouseStates(states) {
+  const summary = {
+    accountValue: "0",
+    totalMarginUsed: "0",
+    totalRawUsd: "0",
+    crossMaintenanceMarginUsed: "0",
+    isolatedMaintenanceMarginUsed: "0",
+    maximumStandardMarginRatio: "0.0000",
+    withdrawable: "0",
+    totalUnrealizedPnl: "0",
+    byCollateralToken: /* @__PURE__ */ new Map()
+  };
+  const assetPositions = [];
+  for (const dexState of states) {
+    const state = dexState.state;
+    const positions = state.assetPositions ?? [];
+    const unrealizedPnl = sum(positions.map((position) => position.position.unrealizedPnl));
+    const isolatedRisks = positions.flatMap((position) => {
+      if (position.position.leverage.type !== "isolated") {
+        return [];
+      }
+      return [{ collateral: position.position.marginUsed, maintenance: isolatedMaintenanceMargin(dexState, position) }];
+    });
+    const isolatedMaintenanceMarginUsed = sum(isolatedRisks.map((risk) => risk.maintenance));
+    const isolatedMarginUsed = sum(isolatedRisks.map((risk) => risk.collateral));
+    let dexMaximumMarginRatio = ratio(state.crossMaintenanceMarginUsed, state.crossMarginSummary.accountValue);
+    for (const isolatedRisk of isolatedRisks) {
+      dexMaximumMarginRatio = BigNumber.max(
+        dexMaximumMarginRatio,
+        ratio(isolatedRisk.maintenance, isolatedRisk.collateral)
+      ).toFixed(4);
+    }
+    summary.accountValue = add(summary.accountValue, state.marginSummary.accountValue);
+    summary.totalMarginUsed = add(summary.totalMarginUsed, state.marginSummary.totalMarginUsed);
+    summary.totalRawUsd = add(summary.totalRawUsd, state.marginSummary.totalRawUsd);
+    summary.crossMaintenanceMarginUsed = add(summary.crossMaintenanceMarginUsed, state.crossMaintenanceMarginUsed);
+    summary.isolatedMaintenanceMarginUsed = add(summary.isolatedMaintenanceMarginUsed, isolatedMaintenanceMarginUsed);
+    summary.maximumStandardMarginRatio = BigNumber.max(
+      summary.maximumStandardMarginRatio,
+      dexMaximumMarginRatio
+    ).toFixed(4);
+    summary.withdrawable = add(summary.withdrawable, state.withdrawable);
+    summary.totalUnrealizedPnl = add(summary.totalUnrealizedPnl, unrealizedPnl);
+    assetPositions.push(...positions);
+    if (dexState.collateralToken === null) {
+      continue;
+    }
+    const collateral = summary.byCollateralToken.get(dexState.collateralToken) ?? ZERO_COLLATERAL_SUMMARY;
+    summary.byCollateralToken.set(dexState.collateralToken, {
+      accountValue: add(collateral.accountValue, state.marginSummary.accountValue),
+      totalMarginUsed: add(collateral.totalMarginUsed, state.marginSummary.totalMarginUsed),
+      crossMaintenanceMarginUsed: add(collateral.crossMaintenanceMarginUsed, state.crossMaintenanceMarginUsed),
+      isolatedMaintenanceMarginUsed: add(collateral.isolatedMaintenanceMarginUsed, isolatedMaintenanceMarginUsed),
+      isolatedMarginUsed: add(collateral.isolatedMarginUsed, isolatedMarginUsed),
+      withdrawable: add(collateral.withdrawable, state.withdrawable),
+      totalUnrealizedPnl: add(collateral.totalUnrealizedPnl, unrealizedPnl)
+    });
+  }
+  return { summary, assetPositions };
+}
+function mapBalance(summary, spotCoinBalances, accountType, collateralTokenMap = LEGACY_COLLATERAL_TOKEN_MAP) {
+  if (!accountType) {
+    return null;
+  }
+  switch (accountType) {
+    case HyperliquidAccountType.DEFAULT:
+    case HyperliquidAccountType.DISABLED:
+      return mapStandardBalance(summary, accountType, collateralTokenMap);
+    case HyperliquidAccountType.UNIFIED_ACCOUNT:
+      return mapUnifiedBalance(summary, spotCoinBalances, accountType, collateralTokenMap);
+    case HyperliquidAccountType.DEX_ABSTRACTION:
+    case HyperliquidAccountType.PORTFOLIO_MARGIN:
+      return null;
+  }
+}
+function mapPositions(raw) {
+  const positions = /* @__PURE__ */ new Map();
+  for (const assetPosition of raw) {
+    const position = assetPosition.position;
+    const size = new BigNumber(position.szi || "0");
+    if (size.isZero()) {
+      continue;
+    }
+    const coin = position.coin || "";
+    const side = size.isPositive() ? "long" : "short";
+    positions.set(positionKey(coin, side), {
+      symbol: coin,
+      side,
+      size: size.toFixed(),
+      entryPrice: position.entryPx || "0",
+      unrealizedPnl: position.unrealizedPnl || "0",
+      leverage: position.leverage.value.toString(),
+      marginType: position.leverage.type,
+      liquidationPrice: position.liquidationPx || null
+    });
+  }
+  return positions;
+}
+function mapStandardBalance(summary, accountType, collateralTokenMap) {
   const free = {};
   const used = {};
   const total = {};
   const assets = [];
-  for (const [, coin] of spotCoinBalances) {
-    if (!COLLATERAL_COINS.has(coin.coin)) continue;
-    const availableOverride = availableToTradeByCollateral.get(coin.coin);
-    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;
+  for (const [token, collateral] of summary.byCollateralToken) {
+    const coin = collateralTokenMap.get(token);
+    if (!coin) {
+      continue;
+    }
+    free[coin] = collateral.withdrawable;
+    used[coin] = collateral.totalMarginUsed;
+    total[coin] = collateral.accountValue;
     assets.push({
-      asset: coin.coin,
-      free: coinFree,
-      used: coinUsed,
-      total: coinTotal,
-      walletBalance: coinTotal,
-      usdValue: coinTotal
+      asset: coin,
+      free: collateral.withdrawable,
+      used: collateral.totalMarginUsed,
+      total: collateral.accountValue,
+      walletBalance: subtract(collateral.accountValue, collateral.totalUnrealizedPnl),
+      usdValue: collateral.accountValue
     });
   }
-  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";
+  const maintenanceMargin = add(summary.crossMaintenanceMarginUsed, summary.isolatedMaintenanceMarginUsed);
   return {
     accountType,
     free,
@@ -37,35 +143,129 @@ function mapBalance(summary, spotCoinBalances, accountType, availableToTradeByCo
     total,
     availableToTrade: summary.withdrawable,
     totalEquity: summary.accountValue,
-    walletBalance,
+    walletBalance: subtract(summary.accountValue, summary.totalUnrealizedPnl),
     unrealizedPnl: summary.totalUnrealizedPnl,
     initialMarginUsed: summary.totalMarginUsed,
-    maintenanceMargin: summary.crossMaintenanceMarginUsed,
-    marginRatio,
+    maintenanceMargin,
+    marginRatio: summary.maximumStandardMarginRatio,
     assets,
     timestamp: Date.now()
   };
 }
-function mapPositions(raw) {
-  const positions = /* @__PURE__ */ new Map();
-  for (const ap of raw) {
-    const pos = ap.position;
-    const sziBN = new BigNumber(pos.szi || "0");
-    if (sziBN.isZero()) continue;
-    const coin = pos.coin || "";
-    const side = sziBN.isPositive() ? "long" : "short";
-    positions.set(positionKey(coin, side), {
-      symbol: coin,
-      side,
-      size: sziBN.toFixed(),
-      entryPrice: pos.entryPx || "0",
-      unrealizedPnl: pos.unrealizedPnl || "0",
-      leverage: pos.leverage.value.toString(),
-      marginType: pos.leverage.type,
-      liquidationPrice: pos.liquidationPx || null
+function mapUnifiedBalance(summary, spotCoinBalances, accountType, collateralTokenMap) {
+  const free = {};
+  const used = {};
+  const total = {};
+  const assets = [];
+  let totalEquity = new BigNumber(0);
+  let availableToTrade = new BigNumber(0);
+  for (const balance of spotCoinBalances.values()) {
+    if (!collateralTokenMap.has(balance.token)) {
+      continue;
+    }
+    const collateral = summary.byCollateralToken.get(balance.token) ?? ZERO_COLLATERAL_SUMMARY;
+    const coinUsed = balance.hold;
+    const coinFree = subtract(balance.total, coinUsed);
+    const coinWalletBalance = subtract(balance.total, collateral.totalUnrealizedPnl);
+    free[balance.coin] = coinFree;
+    used[balance.coin] = coinUsed;
+    total[balance.coin] = balance.total;
+    totalEquity = totalEquity.plus(balance.total);
+    availableToTrade = availableToTrade.plus(balance.availableAfterMaintenance ?? "0");
+    assets.push({
+      asset: balance.coin,
+      free: coinFree,
+      used: coinUsed,
+      total: balance.total,
+      walletBalance: coinWalletBalance,
+      usdValue: balance.total
     });
   }
-  return positions;
+  const maintenanceMargin = add(summary.crossMaintenanceMarginUsed, summary.isolatedMaintenanceMarginUsed);
+  const totalEquityValue = totalEquity.toFixed();
+  const walletBalance = subtract(totalEquityValue, summary.totalUnrealizedPnl);
+  return {
+    accountType,
+    free,
+    used,
+    total,
+    availableToTrade: availableToTrade.toFixed(),
+    // Unified spot totals are the authoritative equity balances and already include perp PnL.
+    totalEquity: totalEquityValue,
+    walletBalance,
+    unrealizedPnl: summary.totalUnrealizedPnl,
+    initialMarginUsed: summary.totalMarginUsed,
+    maintenanceMargin,
+    marginRatio: unifiedMarginRatio(summary, spotCoinBalances),
+    assets,
+    timestamp: Date.now()
+  };
+}
+function unifiedMarginRatio(summary, spotCoinBalances) {
+  let maximumRatio = new BigNumber(0);
+  for (const [token, collateral] of summary.byCollateralToken) {
+    const spotBalance = [...spotCoinBalances.values()].find((balance) => balance.token === token);
+    const available = new BigNumber(spotBalance?.total ?? "0").minus(collateral.isolatedMarginUsed);
+    maximumRatio = BigNumber.max(maximumRatio, ratio(collateral.crossMaintenanceMarginUsed, available.toFixed()));
+  }
+  return maximumRatio.toFixed(4);
+}
+function isolatedMaintenanceMargin(dexState, assetPosition) {
+  const position = assetPosition.position;
+  if (position.leverage.type !== "isolated" || position.maxLeverage <= 0) {
+    return "0";
+  }
+  const notional = new BigNumber(position.positionValue).abs();
+  const marginTiers = findMarginTiers(dexState, position.coin);
+  const firstMarginTier = marginTiers?.[0];
+  if (!marginTiers || !firstMarginTier || marginTiers.some((tier) => tier.maxLeverage <= 0)) {
+    return notional.div(position.maxLeverage).div(2).toFixed();
+  }
+  let activeTier = firstMarginTier;
+  let maintenanceDeduction = new BigNumber(0);
+  for (const nextTier of marginTiers.slice(1)) {
+    if (notional.lt(nextTier.lowerBound)) {
+      break;
+    }
+    const previousRate = maintenanceMarginRate(activeTier.maxLeverage);
+    const nextRate = maintenanceMarginRate(nextTier.maxLeverage);
+    maintenanceDeduction = maintenanceDeduction.plus(
+      new BigNumber(nextTier.lowerBound).times(nextRate.minus(previousRate))
+    );
+    activeTier = nextTier;
+  }
+  return notional.times(maintenanceMarginRate(activeTier.maxLeverage)).minus(maintenanceDeduction).toFixed();
+}
+function findMarginTiers(dexState, coin) {
+  if (!dexState.meta) {
+    return null;
+  }
+  const unprefixedCoin = dexState.dex && coin.startsWith(`${dexState.dex}:`) ? coin.slice(dexState.dex.length + 1) : coin;
+  const asset = dexState.meta.universe.find(
+    (candidate) => candidate.name === coin || candidate.name === unprefixedCoin
+  );
+  const marginTable = dexState.meta.marginTables.find(([id]) => id === asset?.marginTableId)?.[1];
+  return marginTable?.marginTiers.length ? marginTable.marginTiers : null;
+}
+function maintenanceMarginRate(maxLeverage) {
+  return new BigNumber(1).div(maxLeverage).div(2);
+}
+function add(left, right) {
+  return new BigNumber(left || "0").plus(right || "0").toFixed();
+}
+function subtract(left, right) {
+  return new BigNumber(left || "0").minus(right || "0").toFixed();
+}
+function sum(values) {
+  return values.reduce((total, value) => total.plus(value || "0"), new BigNumber(0)).toFixed();
+}
+function ratio(numerator, denominator) {
+  const numeratorValue = new BigNumber(numerator || "0");
+  const denominatorValue = new BigNumber(denominator || "0");
+  if (denominatorValue.gt(0)) {
+    return numeratorValue.div(denominatorValue).toFixed(4);
+  }
+  return numeratorValue.gt(0) ? FULL_UTILIZATION_RATIO : "0.0000";
 }
 
-export { mapBalance, mapPositions };
+export { aggregateClearinghouseStates, mapBalance, mapPositions };

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([]);
+  });
+});