@pear-protocol/exchanges-sdk 0.6.4 → 0.6.6

package/dist/tracker/base.test.js

@@ -1,132 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { BaseAccountTracker } from './base';
-import { HyperliquidAccountType } from './hyperliquid/types';
-
-class FakeAccountTracker extends BaseAccountTracker {
-  connected = false;
-  startCalls = 0;
-  cleanupCalls = 0;
-  assetSnapshotCalls = [];
-  async start() {
-    this.startCalls++;
-    this.connected = true;
-  }
-  async snapshot() {
-    return { balance: null, positions: [] };
-  }
-  async fetchAssetSnapshots(coins) {
-    this.assetSnapshotCalls.push(coins);
-    return Object.fromEntries(coins.map((coin) => [coin, { coin, leverage: "1", marginType: "cross" }]));
-  }
-  get isConnected() {
-    return this.connected;
-  }
-  updatePositions(positions, mode = "merge") {
-    this.onStateUpdate({ positions, positionsMode: mode });
-  }
-  updateBalance(balance) {
-    this.onStateUpdate({ balance });
-  }
-  updateTrackedAsset(asset, info) {
-    this.onStateUpdate({ trackedAssets: /* @__PURE__ */ new Map([[asset, info]]) });
-  }
-  ensureAssetTracked() {
-  }
-  releaseAsset() {
-  }
-  async cleanupConnections() {
-    this.cleanupCalls++;
-    this.connected = false;
-  }
-}
-function buildConfig() {
-  return { demo: true, credentials: { api_key: "key", api_secret: "secret", api_pass: "pass" } };
-}
-describe("BaseAccountTracker", () => {
-  it("constructs from credentials + demo with no socket side-effect", () => {
-    const tracker = new FakeAccountTracker(buildConfig());
-    expect(tracker.isConnected).toBe(false);
-    expect(tracker.isInitialized).toBe(false);
-    expect(tracker.startCalls).toBe(0);
-  });
-  it("exposes snapshot() on the AccountTracker interface", () => {
-    const tracker = new FakeAccountTracker(buildConfig());
-    expect(typeof tracker.snapshot).toBe("function");
-  });
-  it("snapshotAssets() dedupes requested coins and skips the read entirely for an empty list", async () => {
-    const tracker = new FakeAccountTracker(buildConfig());
-    await expect(tracker.snapshotAssets([])).resolves.toEqual({});
-    expect(tracker.assetSnapshotCalls).toEqual([]);
-    const result = await tracker.snapshotAssets(["BTC", "ETH", "BTC"]);
-    expect(tracker.assetSnapshotCalls).toEqual([["BTC", "ETH"]]);
-    expect(Object.keys(result)).toEqual(["BTC", "ETH"]);
-  });
-  it("start() opens a connection and disconnect() tears down whatever start() created", async () => {
-    const tracker = new FakeAccountTracker(buildConfig());
-    await tracker.start();
-    expect(tracker.isConnected).toBe(true);
-    expect(tracker.cleanupCalls).toBe(0);
-    await tracker.disconnect();
-    expect(tracker.isConnected).toBe(false);
-    expect(tracker.cleanupCalls).toBe(1);
-  });
-  it("distinguishes incremental position deltas from authoritative snapshots", () => {
-    const tracker = new FakeAccountTracker(buildConfig());
-    const btc = {
-      symbol: "BTC",
-      side: "long",
-      size: "1",
-      entryPrice: "100",
-      unrealizedPnl: "0",
-      leverage: "2",
-      marginType: "cross",
-      liquidationPrice: null
-    };
-    const eth = { ...btc, symbol: "ETH" };
-    tracker.updatePositions(/* @__PURE__ */ new Map([["BTC:long", btc]]));
-    tracker.updatePositions(/* @__PURE__ */ new Map([["ETH:long", eth]]));
-    expect(tracker.getPositions()).toEqual([btc, eth]);
-    tracker.updatePositions(/* @__PURE__ */ new Map([["ETH:long", eth]]), "replace");
-    expect(tracker.getPositions()).toEqual([eth]);
-    tracker.updatePositions(/* @__PURE__ */ new Map(), "replace");
-    expect(tracker.getPositions()).toEqual([]);
-  });
-  it("clears and broadcasts a balance that is no longer safe to represent", () => {
-    const tracker = new FakeAccountTracker(buildConfig());
-    const balance = {
-      accountType: HyperliquidAccountType.DEFAULT,
-      free: { USDC: "100" },
-      used: { USDC: "0" },
-      total: { USDC: "100" },
-      availableToTrade: "100",
-      totalEquity: "100",
-      walletBalance: "100",
-      unrealizedPnl: "0",
-      initialMarginUsed: "0",
-      maintenanceMargin: "0",
-      marginRatio: "0.0000",
-      assets: [],
-      timestamp: 1
-    };
-    const updates = [];
-    tracker.trackBalance((update) => updates.push(update));
-    tracker.updateBalance(balance);
-    tracker.updateBalance(null);
-    expect(tracker.getBalance()).toBeNull();
-    expect(updates).toEqual([balance, null]);
-  });
-  it("replays an explicitly cleared balance to listeners registered later", () => {
-    const tracker = new FakeAccountTracker(buildConfig());
-    const updates = [];
-    tracker.updateBalance(null);
-    tracker.trackBalance((update) => updates.push(update));
-    expect(tracker.isInitialized).toBe(true);
-    expect(updates).toEqual([null]);
-  });
-  it("does not mark account state initialized from asset metadata alone", () => {
-    const tracker = new FakeAccountTracker(buildConfig());
-    tracker.updateTrackedAsset("BTC", { coin: "BTC", leverage: "2", marginType: "cross" });
-    expect(tracker.getTrackedAsset("BTC")).toEqual({ coin: "BTC", leverage: "2", marginType: "cross" });
-    expect(tracker.isInitialized).toBe(false);
-  });
-});

package/dist/tracker/binance/tracker.test.js

@@ -1,138 +0,0 @@
-import { vi, describe, beforeEach, it, expect } from 'vitest';
-import { BinanceAccountTracker } from './tracker';
-
-const {
-  fetchAccountStatusMock,
-  fetchAllPositionRiskMock,
-  fetchMultiAssetsMarginMock,
-  fetchPositionRiskMock,
-  keepAliveListenKeyMock
-} = vi.hoisted(() => ({
-  fetchAccountStatusMock: vi.fn(),
-  fetchAllPositionRiskMock: vi.fn(),
-  fetchMultiAssetsMarginMock: vi.fn(),
-  fetchPositionRiskMock: vi.fn(),
-  keepAliveListenKeyMock: vi.fn()
-}));
-vi.mock("../../client/binance/rest", () => ({
-  fetchAccountStatus: fetchAccountStatusMock,
-  fetchAllPositionRisk: fetchAllPositionRiskMock,
-  fetchMultiAssetsMargin: fetchMultiAssetsMarginMock,
-  fetchPositionRisk: fetchPositionRiskMock,
-  keepAliveListenKey: keepAliveListenKeyMock
-}));
-const creds = {
-  read: { api_key: "rk", api_secret: "rs" },
-  write: { api_key: "wk", api_secret: "ws" }
-};
-function buildTracker() {
-  return new BinanceAccountTracker({ demo: true, credentials: creds });
-}
-describe("BinanceAccountTracker.snapshot", () => {
-  beforeEach(() => {
-    fetchAccountStatusMock.mockReset();
-    fetchAllPositionRiskMock.mockReset();
-    fetchMultiAssetsMarginMock.mockReset();
-  });
-  it("splices accountType onto the omit-shaped mapBalance() result", async () => {
-    fetchAccountStatusMock.mockResolvedValue({
-      totalWalletBalance: "5000",
-      totalMarginBalance: "5000",
-      availableBalance: "4500",
-      totalUnrealizedProfit: "25",
-      totalInitialMargin: "200",
-      totalMaintMargin: "50",
-      assets: [
-        {
-          asset: "USDT",
-          walletBalance: "5000",
-          availableBalance: "4500",
-          unrealizedProfit: "25",
-          marginBalance: "5000",
-          initialMargin: "200",
-          maintMargin: "50",
-          marginAvailable: true
-        }
-      ]
-    });
-    fetchAllPositionRiskMock.mockResolvedValue([
-      {
-        symbol: "BTCUSDT",
-        leverage: "10",
-        marginType: "cross",
-        isAutoAddMargin: "false",
-        isolatedMargin: "0",
-        positionAmt: "0.5",
-        entryPrice: "50000",
-        breakEvenPrice: "50000",
-        unRealizedProfit: "25",
-        liquidationPrice: "40000",
-        markPrice: "51000",
-        maxNotionalValue: "1000000",
-        positionSide: "BOTH",
-        notional: "25500",
-        isolatedWallet: "0",
-        updateTime: 0
-      }
-    ]);
-    fetchMultiAssetsMarginMock.mockResolvedValue(true);
-    const snapshot = await buildTracker().snapshot();
-    expect(snapshot.balance).toMatchObject({
-      accountType: "MULTI_ASSET",
-      totalEquity: "5000",
-      availableToTrade: "4500",
-      maintenanceMargin: "50",
-      marginRatio: "0.0100"
-    });
-    expect(snapshot.positions).toHaveLength(1);
-    expect(snapshot.positions[0]).toMatchObject({
-      symbol: "BTCUSDT",
-      side: "long",
-      leverage: "10",
-      marginType: "cross",
-      liquidationPrice: "40000"
-    });
-  });
-  it("reports SINGLE_ASSET accountType when multi-assets margin is off", async () => {
-    fetchAccountStatusMock.mockResolvedValue({
-      totalWalletBalance: "0",
-      totalMarginBalance: "0",
-      availableBalance: "0",
-      totalUnrealizedProfit: "0",
-      totalInitialMargin: "0",
-      totalMaintMargin: "0",
-      assets: []
-    });
-    fetchAllPositionRiskMock.mockResolvedValue([]);
-    fetchMultiAssetsMarginMock.mockResolvedValue(false);
-    const snapshot = await buildTracker().snapshot();
-    expect(snapshot.balance?.accountType).toBe("SINGLE_ASSET");
-    expect(snapshot.positions).toEqual([]);
-  });
-});
-describe("BinanceAccountTracker.snapshotAssets", () => {
-  beforeEach(() => {
-    fetchAllPositionRiskMock.mockReset();
-  });
-  it("answers any number of symbols from one all-symbols positionRisk call", async () => {
-    fetchAllPositionRiskMock.mockResolvedValue([
-      { symbol: "BTCUSDT", leverage: "10", marginType: "cross" },
-      { symbol: "ETHUSDT", leverage: "5", marginType: "isolated" }
-    ]);
-    const result = await buildTracker().snapshotAssets(["BTCUSDT", "ETHUSDT", "DOGEUSDT"]);
-    expect(fetchAllPositionRiskMock).toHaveBeenCalledTimes(1);
-    expect(result).toEqual({
-      BTCUSDT: { coin: "BTCUSDT", leverage: "10", marginType: "cross" },
-      ETHUSDT: { coin: "ETHUSDT", leverage: "5", marginType: "isolated" },
-      DOGEUSDT: null
-    });
-  });
-  it("collapses hedge-mode LONG/SHORT rows into one entry per symbol", async () => {
-    fetchAllPositionRiskMock.mockResolvedValue([
-      { symbol: "BTCUSDT", leverage: "10", marginType: "cross", positionSide: "LONG" },
-      { symbol: "BTCUSDT", leverage: "10", marginType: "cross", positionSide: "SHORT" }
-    ]);
-    const result = await buildTracker().snapshotAssets(["BTCUSDT"]);
-    expect(result.BTCUSDT).toEqual({ coin: "BTCUSDT", leverage: "10", marginType: "cross" });
-  });
-});

package/dist/tracker/bybit/tracker.test.js

@@ -1,145 +0,0 @@
-import { vi, describe, beforeEach, it, expect } from 'vitest';
-import { BybitAccountTracker } from './tracker';
-
-const { fetchWalletBalanceMock, fetchPositionsMock, fetchAccountInfoMock, fetchPositionLeverageMock } = vi.hoisted(
-  () => ({
-    fetchWalletBalanceMock: vi.fn(),
-    fetchPositionsMock: vi.fn(),
-    fetchAccountInfoMock: vi.fn(),
-    fetchPositionLeverageMock: vi.fn()
-  })
-);
-vi.mock("../../client/bybit/rest", () => ({
-  fetchWalletBalance: fetchWalletBalanceMock,
-  fetchPositions: fetchPositionsMock,
-  fetchAccountInfo: fetchAccountInfoMock,
-  fetchPositionLeverage: fetchPositionLeverageMock
-}));
-const creds = { api_key: "k", api_secret: "s" };
-function buildTracker() {
-  return new BybitAccountTracker({ demo: true, credentials: creds });
-}
-describe("BybitAccountTracker.snapshot", () => {
-  beforeEach(() => {
-    fetchWalletBalanceMock.mockReset();
-    fetchPositionsMock.mockReset();
-    fetchAccountInfoMock.mockReset();
-  });
-  it("returns mapped balance + positions across USDT and USDC settle coins with no socket opened", async () => {
-    fetchWalletBalanceMock.mockResolvedValue({
-      totalEquity: "2000",
-      totalWalletBalance: "2000",
-      totalMarginBalance: "2000",
-      totalAvailableBalance: "1800",
-      totalPerpUPL: "50",
-      totalInitialMargin: "100",
-      totalMaintenanceMargin: "20",
-      accountMMRate: "0.0100",
-      coin: [
-        {
-          coin: "USDT",
-          equity: "2000",
-          usdValue: "2000",
-          walletBalance: "2000",
-          unrealisedPnl: "50",
-          totalPositionIM: "100",
-          totalPositionMM: "20",
-          totalOrderIM: "0",
-          locked: "0",
-          borrowAmount: "0",
-          marginCollateral: true,
-          collateralSwitch: true
-        }
-      ]
-    });
-    fetchPositionsMock.mockImplementation(async (_creds, settleCoin) => {
-      if (settleCoin === "USDT") {
-        return [
-          {
-            symbol: "BTCUSDT",
-            side: "Buy",
-            size: "1",
-            avgPrice: "50000",
-            unrealisedPnl: "10",
-            leverage: "5",
-            tradeMode: "0",
-            liqPrice: "40000"
-          }
-        ];
-      }
-      return [];
-    });
-    fetchAccountInfoMock.mockResolvedValue({ marginMode: "REGULAR_MARGIN", updatedTime: "0" });
-    const snapshot = await buildTracker().snapshot();
-    expect(snapshot.balance).toMatchObject({
-      accountType: "REGULAR_MARGIN",
-      totalEquity: "2000",
-      availableToTrade: "1800",
-      maintenanceMargin: "20",
-      marginRatio: "0.0100"
-    });
-    expect(snapshot.positions).toHaveLength(1);
-    expect(snapshot.positions[0]).toMatchObject({
-      symbol: "BTCUSDT",
-      side: "long",
-      leverage: "5",
-      marginType: "cross",
-      liquidationPrice: "40000"
-    });
-    expect(fetchPositionsMock).toHaveBeenCalledWith(creds, "USDT", true);
-    expect(fetchPositionsMock).toHaveBeenCalledWith(creds, "USDC", true);
-    expect(fetchPositionLeverageMock).not.toHaveBeenCalled();
-  });
-  it("returns a null balance when the wallet fetch is empty", async () => {
-    fetchWalletBalanceMock.mockResolvedValue(void 0);
-    fetchPositionsMock.mockResolvedValue([]);
-    fetchAccountInfoMock.mockResolvedValue({ marginMode: "REGULAR_MARGIN", updatedTime: "0" });
-    const snapshot = await buildTracker().snapshot();
-    expect(snapshot.balance).toBeNull();
-    expect(snapshot.positions).toEqual([]);
-  });
-});
-describe("BybitAccountTracker.snapshotAssets", () => {
-  beforeEach(() => {
-    fetchPositionsMock.mockReset();
-    fetchPositionLeverageMock.mockReset();
-  });
-  it(">2 symbols: resolves positioned symbols from the two settleCoin reads and fills in the rest per symbol", async () => {
-    fetchPositionsMock.mockImplementation(
-      async (_creds, settleCoin) => settleCoin === "USDT" ? [
-        { symbol: "BTCUSDT", size: "1", leverage: "10", tradeMode: "0" },
-        { symbol: "ETHUSDT", size: "2", leverage: "5", tradeMode: "1" }
-      ] : []
-    );
-    fetchPositionLeverageMock.mockResolvedValue({ symbol: "DOGEUSDT", size: "0", leverage: "3", tradeMode: "0" });
-    const result = await buildTracker().snapshotAssets(["BTCUSDT", "ETHUSDT", "DOGEUSDT"]);
-    expect(fetchPositionsMock).toHaveBeenCalledTimes(2);
-    expect(fetchPositionLeverageMock).toHaveBeenCalledTimes(1);
-    expect(fetchPositionLeverageMock).toHaveBeenCalledWith(creds, "DOGEUSDT", true);
-    expect(result).toEqual({
-      BTCUSDT: { coin: "BTCUSDT", leverage: "10", marginType: "cross" },
-      ETHUSDT: { coin: "ETHUSDT", leverage: "5", marginType: "isolated" },
-      DOGEUSDT: { coin: "DOGEUSDT", leverage: "3", marginType: "cross" }
-    });
-  });
-  it("\u22642 symbols: skips the settleCoin batch and reads per symbol directly", async () => {
-    fetchPositionLeverageMock.mockResolvedValue({ symbol: "BTCUSDT", size: "0", leverage: "10", tradeMode: "0" });
-    const result = await buildTracker().snapshotAssets(["BTCUSDT"]);
-    expect(fetchPositionsMock).not.toHaveBeenCalled();
-    expect(fetchPositionLeverageMock).toHaveBeenCalledTimes(1);
-    expect(result.BTCUSDT).toEqual({ coin: "BTCUSDT", leverage: "10", marginType: "cross" });
-  });
-  it("maps a failed fill-in to null while the others succeed", async () => {
-    fetchPositionLeverageMock.mockImplementation(async (_creds, symbol) => {
-      if (symbol === "NOPEUSDT") throw new Error("10001");
-      return { symbol, size: "0", leverage: "10", tradeMode: "0" };
-    });
-    const result = await buildTracker().snapshotAssets(["BTCUSDT", "NOPEUSDT"]);
-    expect(result.BTCUSDT).toMatchObject({ leverage: "10", marginType: "cross" });
-    expect(result.NOPEUSDT).toBeNull();
-  });
-  it("throws when every per-symbol read fails", async () => {
-    fetchPositionLeverageMock.mockRejectedValue(new Error("down"));
-    await expect(buildTracker().snapshotAssets(["BTCUSDT", "ETHUSDT"])).rejects.toThrow("every position read failed");
-  });
-});

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

@@ -1,260 +0,0 @@
-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("maps Portfolio Margin balances with the same calculation as Unified Account", () => {
-    const state = buildState({
-      accountValue: "999",
-      totalMarginUsed: "30",
-      crossMaintenanceMarginUsed: "10",
-      withdrawable: "999",
-      coin: "BTC",
-      unrealizedPnl: "5"
-    });
-    const { summary } = aggregateClearinghouseStates([dexState(state, 0)]);
-    const spotBalances = /* @__PURE__ */ new Map([
-      ["USDC", { coin: "USDC", token: 0, total: "100", hold: "5", availableAfterMaintenance: "70" }]
-    ]);
-    const portfolio = mapBalance(summary, spotBalances, HyperliquidAccountType.PORTFOLIO_MARGIN);
-    const unified = mapBalance(summary, spotBalances, HyperliquidAccountType.UNIFIED_ACCOUNT);
-    expect(portfolio).toMatchObject({
-      accountType: "portfolioMargin",
-      totalEquity: "100",
-      availableToTrade: "70"
-    });
-    expect({ ...portfolio, accountType: "unifiedAccount", timestamp: 0 }).toEqual({ ...unified, timestamp: 0 });
-  });
-  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([]);
-  });
-});