@pear-protocol/exchanges-sdk 0.6.6 → 0.7.0

package/dist/tracker/hyperliquid/mapper.js

@@ -1,105 +1,109 @@
 import BigNumber from 'bignumber.js';
 import { positionKey } from '../utils';
-import { COLLATERAL_TOKEN_MAP, HyperliquidAccountType } from './types';
+import { toDecimal, ZERO } from './decimal';
+import { HyperliquidAccountType } from './types';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-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 RATIO_DECIMALS = 4;
+const USDC_TOKEN_INDEX = 0;
 const ZERO_COLLATERAL_SUMMARY = {
-  accountValue: "0",
-  totalMarginUsed: "0",
   crossMaintenanceMarginUsed: "0",
-  isolatedMaintenanceMarginUsed: "0",
   isolatedMarginUsed: "0",
-  withdrawable: "0",
-  totalUnrealizedPnl: "0"
+  accountValue: "0",
+  withdrawable: "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 summary = emptyClearinghouseSummary();
   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) => {
+    const unrealizedPnl = sum(positions.map((position) => position.position.unrealizedPnl)).toFixed();
+    const isolatedMarginUsed = sum(positions.flatMap((position) => {
       if (position.position.leverage.type !== "isolated") {
         return [];
       }
       return [
-        {
-          collateral: position.position.marginUsed,
-          maintenance: isolatedMaintenanceMargin(dexState, position)
-        }
+        position.position.marginUsed
       ];
-    });
-    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);
-    }
+    })).toFixed();
     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.crossAccountValue = add(summary.crossAccountValue, state.crossMarginSummary.accountValue);
+    summary.crossNotional = add(summary.crossNotional, state.crossMarginSummary.totalNtlPos);
     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);
+    summary.perDexState.push({
+      dex: dexState.dex,
+      collateralToken: dexState.collateralToken,
+      accountValue: state.marginSummary.accountValue,
+      crossNotional: state.crossMarginSummary.totalNtlPos,
+      crossMaintenanceMargin: state.crossMaintenanceMarginUsed,
+      withdrawable: state.withdrawable
+    });
     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)
+      accountValue: add(collateral.accountValue, state.marginSummary.accountValue),
+      withdrawable: add(collateral.withdrawable, state.withdrawable)
     });
   }
+  summary.perDexState.sort(byDexName);
   return {
     summary,
     assetPositions
   };
 }
 __name(aggregateClearinghouseStates, "aggregateClearinghouseStates");
-function mapBalance(summary, spotCoinBalances, accountType, collateralTokenMap = LEGACY_COLLATERAL_TOKEN_MAP) {
-  if (!accountType) {
+function byDexName(left, right) {
+  if (left.dex === right.dex) {
+    return 0;
+  }
+  return left.dex < right.dex ? -1 : 1;
+}
+__name(byDexName, "byDexName");
+function emptyClearinghouseSummary() {
+  return {
+    accountValue: "0",
+    crossAccountValue: "0",
+    crossNotional: "0",
+    crossMaintenanceMarginUsed: "0",
+    withdrawable: "0",
+    totalUnrealizedPnl: "0",
+    byCollateralToken: /* @__PURE__ */ new Map(),
+    perDexState: []
+  };
+}
+__name(emptyClearinghouseSummary, "emptyClearinghouseSummary");
+function mapBalance(context) {
+  if (!context.accountType) {
     return null;
   }
-  switch (accountType) {
+  switch (context.accountType) {
     case HyperliquidAccountType.DEFAULT:
     case HyperliquidAccountType.DISABLED:
-      return mapStandardBalance(summary, accountType, collateralTokenMap);
+      return mapStandardBalance(context);
     case HyperliquidAccountType.UNIFIED_ACCOUNT:
+      return mapUnifiedBalance(context);
     case HyperliquidAccountType.PORTFOLIO_MARGIN:
-      return mapUnifiedBalance(summary, spotCoinBalances, accountType, collateralTokenMap);
+      return mapPortfolioMarginBalance(context);
   }
 }
 __name(mapBalance, "mapBalance");
 function mapPositions(raw) {
   const positions = /* @__PURE__ */ new Map();
-  for (const assetPosition of raw) {
+  for (const assetPosition of [
+    ...raw
+  ].sort(byPositionKey)) {
     const position = assetPosition.position;
-    const size = new BigNumber(position.szi || "0");
+    const size = toDecimal(position.szi);
     if (size.isZero()) {
       continue;
     }
@@ -119,167 +123,386 @@ function mapPositions(raw) {
   return positions;
 }
 __name(mapPositions, "mapPositions");
-function mapStandardBalance(summary, accountType, collateralTokenMap) {
-  const free = {};
-  const used = {};
-  const total = {};
-  const assets = [];
-  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,
-      free: collateral.withdrawable,
-      used: collateral.totalMarginUsed,
-      total: collateral.accountValue,
-      walletBalance: subtract(collateral.accountValue, collateral.totalUnrealizedPnl),
-      usdValue: collateral.accountValue
-    });
+function byPositionKey(left, right) {
+  const leftCoin = left.position.coin || "";
+  const rightCoin = right.position.coin || "";
+  if (leftCoin === rightCoin) {
+    return 0;
   }
-  const maintenanceMargin = add(summary.crossMaintenanceMarginUsed, summary.isolatedMaintenanceMarginUsed);
+  return leftCoin < rightCoin ? -1 : 1;
+}
+__name(byPositionKey, "byPositionKey");
+function mapStandardBalance(context) {
+  const spotEquity = spotEquityOf(context);
+  const perpsEquity = subtract(context.summary.accountValue, context.summary.totalUnrealizedPnl);
+  const stakedEquity = stakedEquityOf(context);
   return {
-    accountType,
-    free,
-    used,
-    total,
-    availableToTrade: summary.withdrawable,
-    totalEquity: summary.accountValue,
-    walletBalance: subtract(summary.accountValue, summary.totalUnrealizedPnl),
-    unrealizedPnl: summary.totalUnrealizedPnl,
-    initialMarginUsed: summary.totalMarginUsed,
-    maintenanceMargin,
-    marginRatio: summary.maximumStandardMarginRatio,
-    assets,
-    timestamp: Date.now()
+    accountMode: "hyperliquid:standard",
+    totalEquity: addAllKnown([
+      spotEquity,
+      perpsEquity,
+      context.vaultEquity,
+      stakedEquity
+    ]),
+    // Standard withdrawable is the perps wallet's free margin, summed across dexes.
+    withdrawableBalance: context.summary.withdrawable,
+    availableMargin: context.availableMargin,
+    // Separate budgets, not holdings in one pool: a USDH dex cannot spend the USDC beside it.
+    poolsShared: false,
+    perCollateral: perpsCollateralRows(context),
+    spotEquity,
+    perpsEquity: signed(perpsEquity),
+    vaultEquity: context.vaultEquity,
+    stakedEquity,
+    unrealizedPnl: signed(context.summary.totalUnrealizedPnl),
+    // Cross-only: isolated legs carry their own margin and liquidate independently.
+    maintenanceMargin: context.summary.crossMaintenanceMarginUsed,
+    // Risk levers against ACCOUNT VALUE, not the cash above: one pool, one quotient, one division.
+    crossMarginRatio: ratio(context.summary.crossMaintenanceMarginUsed, context.summary.crossAccountValue),
+    crossAccountLeverage: accountLeverage(context.summary.crossNotional, context.summary.crossAccountValue),
+    perDexState: context.summary.perDexState,
+    timestamp: context.timestamp
   };
 }
 __name(mapStandardBalance, "mapStandardBalance");
-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)) {
+function mapUnifiedBalance(context) {
+  const tradingEquity = spotEquityOf(context);
+  const stakedEquity = stakedEquityOf(context);
+  const portfolioValue = addAllKnown([
+    tradingEquity,
+    context.vaultEquity,
+    stakedEquity
+  ]);
+  return {
+    accountMode: "hyperliquid:unified",
+    totalEquity: portfolioValue,
+    // What may leave is the spot balance net of the margin the perps side has locked.
+    withdrawableBalance: freeCollateral(context),
+    availableMargin: context.availableMargin,
+    // Separate budgets, not holdings in one pool: a USDH dex cannot spend the USDC beside it.
+    poolsShared: false,
+    perCollateral: spotCollateralRows(context),
+    tradingEquity,
+    vaultEquity: context.vaultEquity,
+    stakedEquity,
+    portfolioValue,
+    unrealizedPnl: signed(context.summary.totalUnrealizedPnl),
+    // Cross-only: adding isolated maintenance overstated the figure by 2x against the venue's UI.
+    perpsMaintenanceMargin: context.summary.crossMaintenanceMarginUsed,
+    unifiedAccountRatio: crossRatioAgainstFreeSpot(context),
+    unifiedAccountLeverage: unifiedAccountLeverage(context),
+    perDexState: context.summary.perDexState,
+    timestamp: context.timestamp
+  };
+}
+__name(mapUnifiedBalance, "mapUnifiedBalance");
+function mapPortfolioMarginBalance(context) {
+  const tradingEquity = spotEquityOf(context);
+  const stakedEquity = stakedEquityOf(context);
+  return {
+    accountMode: "hyperliquid:portfolioMargin",
+    // Total Equity is the only figure that adds what sits outside trading back on.
+    totalEquity: addAllKnown([
+      tradingEquity,
+      context.vaultEquity,
+      stakedEquity
+    ]),
+    withdrawableBalance: settlementAvailableBalance(context),
+    availableMargin: context.availableMargin,
+    // Holdings in one pool, not separate budgets: PM lends against every coin at its LTV weight.
+    poolsShared: true,
+    perCollateral: portfolioMarginCollateralRows(context),
+    tradingEquity,
+    vaultEquity: context.vaultEquity,
+    stakedEquity,
+    portfolioValue: tradingEquity,
+    unrealizedPnl: signed(context.summary.totalUnrealizedPnl),
+    perpsMaintenanceMargin: context.summary.crossMaintenanceMarginUsed,
+    portfolioMarginRatio: wireMarginRatio(context),
+    portfolioAccountLeverage: portfolioAccountLeverage(context),
+    borrowCapUsed: worstBorrowCapUsed(context),
+    perDexState: context.summary.perDexState,
+    timestamp: context.timestamp
+  };
+}
+__name(mapPortfolioMarginBalance, "mapPortfolioMarginBalance");
+function settlementAvailableBalance(context) {
+  const settlement = spotBalanceForToken(context, USDC_TOKEN_INDEX);
+  if (!settlement) {
+    return null;
+  }
+  const available = toDecimal(settlement.total).minus(toDecimal(settlement.hold));
+  return available.isNegative() ? null : available.toFixed();
+}
+__name(settlementAvailableBalance, "settlementAvailableBalance");
+function portfolioMarginCollateralRows(context) {
+  const rows = [];
+  for (const balance of context.spotBalances.values()) {
+    const total = toDecimal(balance.total);
+    rows.push({
+      asset: balance.coin,
+      equity: signed(total.toFixed()),
+      availableMargin: context.availableMarginByToken.get(balance.token) ?? null,
+      withdrawable: signed(total.minus(toDecimal(balance.hold)).toFixed()),
+      ltv: balance.ltv === null ? null : toDecimal(balance.ltv).toFixed(),
+      borrowCapUsed: borrowCapUsedFor(context, balance.token)
+    });
+  }
+  rows.sort(byRowAsset);
+  return rows;
+}
+__name(portfolioMarginCollateralRows, "portfolioMarginCollateralRows");
+function byRowAsset(left, right) {
+  if (left.asset === right.asset) {
+    return 0;
+  }
+  return left.asset < right.asset ? -1 : 1;
+}
+__name(byRowAsset, "byRowAsset");
+function borrowCapUsedFor(context, token) {
+  const used = toDecimal(context.borrowRatioByToken.get(token));
+  return used.isZero() ? null : used.toFixed(RATIO_DECIMALS);
+}
+__name(borrowCapUsedFor, "borrowCapUsedFor");
+function worstBorrowCapUsed(context) {
+  let worst = ZERO;
+  for (const ratio2 of context.borrowRatioByToken.values()) {
+    worst = BigNumber.max(worst, toDecimal(ratio2));
+  }
+  return worst.isZero() ? null : worst.toFixed(RATIO_DECIMALS);
+}
+__name(worstBorrowCapUsed, "worstBorrowCapUsed");
+function wireMarginRatio(context) {
+  if (context.portfolioMarginRatio === null) {
+    return null;
+  }
+  return toDecimal(context.portfolioMarginRatio).toFixed(RATIO_DECIMALS);
+}
+__name(wireMarginRatio, "wireMarginRatio");
+function portfolioAccountLeverage(context) {
+  const collateral = haircutCollateral(context);
+  if (collateral === null) {
+    return null;
+  }
+  return accountLeverage(context.summary.crossNotional, collateral);
+}
+__name(portfolioAccountLeverage, "portfolioAccountLeverage");
+function haircutCollateral(context) {
+  let collateral = ZERO;
+  for (const balance of context.spotBalances.values()) {
+    const total = toDecimal(balance.total);
+    if (total.isZero()) {
       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
+    if (balance.ltv === null && total.isPositive()) {
+      continue;
+    }
+    const mid = context.prices.midForToken(balance.token);
+    if (mid === null) {
+      return null;
+    }
+    collateral = collateral.plus(weightedCollateral(total.times(toDecimal(mid)), balance.ltv));
+  }
+  return collateral.toFixed();
+}
+__name(haircutCollateral, "haircutCollateral");
+function weightedCollateral(usd, ltv) {
+  if (usd.isNegative()) {
+    return usd;
+  }
+  if (ltv === null) {
+    return ZERO;
+  }
+  const weight = toDecimal(ltv);
+  return weight.isZero() ? usd : usd.times(weight);
+}
+__name(weightedCollateral, "weightedCollateral");
+function perpsCollateralRows(context) {
+  const rows = collateralPools(context).map((pool) => ({
+    asset: pool.asset,
+    equity: pool.collateral.accountValue,
+    availableMargin: context.availableMarginByToken.get(pool.token) ?? null,
+    withdrawable: pool.collateral.withdrawable
+  }));
+  return fundedRows(rows);
+}
+__name(perpsCollateralRows, "perpsCollateralRows");
+function spotCollateralRows(context) {
+  const rows = collateralPools(context).map((pool) => {
+    const balance = spotBalanceForToken(context, pool.token);
+    const total = toDecimal(balance?.total);
+    const locked = BigNumber.max(toDecimal(balance?.hold), ZERO);
+    return {
+      asset: pool.asset,
+      equity: total.toFixed(),
+      availableMargin: context.availableMarginByToken.get(pool.token) ?? null,
+      withdrawable: total.minus(locked).toFixed()
+    };
+  });
+  return fundedRows(rows);
+}
+__name(spotCollateralRows, "spotCollateralRows");
+function fundedRows(rows) {
+  return rows.filter(isFundedRow);
+}
+__name(fundedRows, "fundedRows");
+function isFundedRow(row) {
+  const figures = [
+    row.equity,
+    row.withdrawable,
+    row.availableMargin ?? "0"
+  ];
+  return figures.some((figure) => !toDecimal(figure).isZero());
+}
+__name(isFundedRow, "isFundedRow");
+function collateralPools(context) {
+  const pools = [];
+  for (const [token, collateral] of context.summary.byCollateralToken) {
+    const asset = context.collateralTokenNames.get(token);
+    if (asset === void 0) {
+      continue;
+    }
+    pools.push({
+      token,
+      asset,
+      collateral
     });
   }
-  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()
-  };
+  pools.sort(byAssetName);
+  return pools;
 }
-__name(mapUnifiedBalance, "mapUnifiedBalance");
-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()));
+__name(collateralPools, "collateralPools");
+function byAssetName(left, right) {
+  if (left.asset === right.asset) {
+    return 0;
   }
-  return maximumRatio.toFixed(4);
+  return left.asset < right.asset ? -1 : 1;
 }
-__name(unifiedMarginRatio, "unifiedMarginRatio");
-function isolatedMaintenanceMargin(dexState, assetPosition) {
-  const position = assetPosition.position;
-  if (position.leverage.type !== "isolated" || position.maxLeverage <= 0) {
+__name(byAssetName, "byAssetName");
+function spotEquityOf(context) {
+  const valuation = context.prices.valueBalances(context.spotBalances.values());
+  if (valuation.unpricedCoins.length > 0) {
+    return null;
+  }
+  return valuation.equity;
+}
+__name(spotEquityOf, "spotEquityOf");
+function stakedEquityOf(context) {
+  const staked = toDecimal(context.stakedHype);
+  if (staked.isZero()) {
     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();
+  const mid = context.prices.midForCoin("HYPE");
+  if (mid === null) {
+    return null;
   }
-  let activeTier = firstMarginTier;
-  let maintenanceDeduction = new BigNumber(0);
-  for (const nextTier of marginTiers.slice(1)) {
-    if (notional.lt(nextTier.lowerBound)) {
-      break;
+  return staked.times(toDecimal(mid)).toFixed();
+}
+__name(stakedEquityOf, "stakedEquityOf");
+function freeCollateral(context) {
+  let free = ZERO;
+  for (const token of context.summary.byCollateralToken.keys()) {
+    const balance = spotBalanceForToken(context, token);
+    if (!balance) {
+      continue;
     }
-    const previousRate = maintenanceMarginRate(activeTier.maxLeverage);
-    const nextRate = maintenanceMarginRate(nextTier.maxLeverage);
-    maintenanceDeduction = maintenanceDeduction.plus(new BigNumber(nextTier.lowerBound).times(nextRate.minus(previousRate)));
-    activeTier = nextTier;
+    const locked = BigNumber.max(toDecimal(balance.hold), ZERO);
+    free = free.plus(toDecimal(balance.total).minus(locked));
   }
-  return notional.times(maintenanceMarginRate(activeTier.maxLeverage)).minus(maintenanceDeduction).toFixed();
+  return free.toFixed();
 }
-__name(isolatedMaintenanceMargin, "isolatedMaintenanceMargin");
-function findMarginTiers(dexState, coin) {
-  if (!dexState.meta) {
+__name(freeCollateral, "freeCollateral");
+function crossRatioAgainstFreeSpot(context) {
+  let maximumRatio = ZERO;
+  for (const [token, collateral] of context.summary.byCollateralToken) {
+    const spotTotal = spotBalanceForToken(context, token)?.total ?? "0";
+    const available = toDecimal(spotTotal).minus(toDecimal(collateral.isolatedMarginUsed));
+    maximumRatio = BigNumber.max(maximumRatio, ratio(collateral.crossMaintenanceMarginUsed, available.toFixed()));
+  }
+  return maximumRatio.toFixed(RATIO_DECIMALS);
+}
+__name(crossRatioAgainstFreeSpot, "crossRatioAgainstFreeSpot");
+function unifiedAccountLeverage(context) {
+  const collateral = collateralValue(context);
+  if (collateral === null) {
     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;
+  return accountLeverage(context.summary.crossNotional, collateral);
 }
-__name(findMarginTiers, "findMarginTiers");
-function maintenanceMarginRate(maxLeverage) {
-  return new BigNumber(1).div(maxLeverage).div(2);
+__name(unifiedAccountLeverage, "unifiedAccountLeverage");
+function collateralValue(context) {
+  let collateral = ZERO;
+  for (const token of context.summary.byCollateralToken.keys()) {
+    const balance = spotBalanceForToken(context, token);
+    const total = toDecimal(balance?.total);
+    if (total.isZero()) {
+      continue;
+    }
+    const mid = context.prices.midForToken(token);
+    if (mid === null) {
+      return null;
+    }
+    collateral = collateral.plus(total.times(toDecimal(mid)));
+  }
+  return collateral.toFixed();
+}
+__name(collateralValue, "collateralValue");
+function spotBalanceForToken(context, token) {
+  for (const balance of context.spotBalances.values()) {
+    if (balance.token === token) {
+      return balance;
+    }
+  }
+  return null;
+}
+__name(spotBalanceForToken, "spotBalanceForToken");
+function accountLeverage(crossNotional, equity) {
+  const equityValue = toDecimal(equity);
+  if (!equityValue.isGreaterThan(0)) {
+    return "0.0000";
+  }
+  return toDecimal(crossNotional).div(equityValue).toFixed(RATIO_DECIMALS);
 }
-__name(maintenanceMarginRate, "maintenanceMarginRate");
+__name(accountLeverage, "accountLeverage");
 function add(left, right) {
-  return new BigNumber(left || "0").plus(right || "0").toFixed();
+  return toDecimal(left).plus(toDecimal(right)).toFixed();
 }
 __name(add, "add");
+function addAllKnown(values) {
+  let total = ZERO;
+  for (const value of values) {
+    if (value === null) {
+      return null;
+    }
+    total = total.plus(toDecimal(value));
+  }
+  return total.toFixed();
+}
+__name(addAllKnown, "addAllKnown");
 function subtract(left, right) {
-  return new BigNumber(left || "0").minus(right || "0").toFixed();
+  return toDecimal(left).minus(toDecimal(right)).toFixed();
 }
 __name(subtract, "subtract");
 function sum(values) {
-  return values.reduce((total, value) => total.plus(value || "0"), new BigNumber(0)).toFixed();
+  return values.reduce((total, value) => total.plus(toDecimal(value)), ZERO);
 }
 __name(sum, "sum");
+function signed(value) {
+  const amount = toDecimal(value);
+  if (amount.isZero()) {
+    return "+0";
+  }
+  return amount.isNegative() ? amount.toFixed() : `+${amount.toFixed()}`;
+}
+__name(signed, "signed");
 function ratio(numerator, denominator) {
-  const numeratorValue = new BigNumber(numerator || "0");
-  const denominatorValue = new BigNumber(denominator || "0");
+  const numeratorValue = toDecimal(numerator);
+  const denominatorValue = toDecimal(denominator);
   if (denominatorValue.gt(0)) {
-    return numeratorValue.div(denominatorValue).toFixed(4);
+    return numeratorValue.div(denominatorValue).toFixed(RATIO_DECIMALS);
   }
   return numeratorValue.gt(0) ? FULL_UTILIZATION_RATIO : "0.0000";
 }
 __name(ratio, "ratio");
 
-export { aggregateClearinghouseStates, mapBalance, mapPositions };
+export { aggregateClearinghouseStates, emptyClearinghouseSummary, mapBalance, mapPositions };