@pear-protocol/exchanges-sdk 0.6.7 → 0.8.0

package/dist/tracker/lighter/mapper.js

@@ -1,110 +1,79 @@
 import BigNumber from 'bignumber.js';
 import { positionKey } from '../utils';
 import { QUOTE_ASSET } from './const';
-import { LighterAccountType, LighterAccountTier } from './types';
+import { LighterAccountType } from './types';
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-function buildAssetBalances(rawAssets) {
-  const free = {};
-  const used = {};
-  const total = {};
-  const assets = [];
-  for (const rawAsset of rawAssets) {
-    const balance = new BigNumber(rawAsset.balance || "0");
-    const lockedBalance = new BigNumber(rawAsset.locked_balance || "0");
-    const marginBalance = new BigNumber(rawAsset.margin_balance || "0");
-    const totalAmount = balance.plus(marginBalance).toFixed();
-    const freeAmount = BigNumber.max(balance.plus(marginBalance).minus(lockedBalance), 0).toFixed();
-    free[rawAsset.symbol] = freeAmount;
-    used[rawAsset.symbol] = rawAsset.locked_balance;
-    total[rawAsset.symbol] = totalAmount;
-    assets.push({
-      asset: rawAsset.symbol,
-      free: freeAmount,
-      used: rawAsset.locked_balance,
-      total: totalAmount,
-      walletBalance: totalAmount,
-      usdValue: rawAsset.symbol === QUOTE_ASSET ? totalAmount : "0"
-    });
-  }
-  return {
-    free,
-    used,
-    total,
-    assets
-  };
+const USD_DECIMALS = 6;
+const RATE_DECIMALS = 2;
+const FRACTION_DECIMALS = 4;
+const PERCENT_SCALE = 100;
+const MARGIN_FRACTION_SCALE = 1e4;
+const ACCOUNT_MODE_BY_TYPE = {
+  [LighterAccountType.CLASSIC]: "lighter:classic",
+  [LighterAccountType.UNIFIED]: "lighter:unified"
+};
+function mapLiveBalance(stats, assets, positions, markets, timestamp) {
+  const openPositions = Array.from(positions);
+  const heldAssets = Array.from(assets);
+  const risks = toPositionRisks(openPositions, markets.perpByMarketId);
+  const crossEquity = toDecimal(stats.cross.portfolio_value);
+  const equity = toEquitySplit(heldAssets, markets.spotPriceBySymbol);
+  const perCollateral = toCollateralRows(heldAssets, stats.total.available_balance);
+  const crossMaintenance = asMarginRequirement(sumMaintenance(risks, "cross"));
+  const isolatedMaintenance = asMarginRequirement(sumMaintenance(risks, "isolated"));
+  return toLighterBalance({
+    accountMode: ACCOUNT_MODE_BY_TYPE[stats.accountType],
+    equity,
+    perCollateral,
+    unrealizedPnl: signed(sumUnrealizedPnl(openPositions)),
+    // The venue states leverage and usage outright here and REST derives them, so each pair meets
+    // at one formatter — otherwise the paths would agree only while the venue kept its precision.
+    // Usage arrives in percent points and leaves as a fraction, which is the venue's scale changed.
+    crossLeverage: rate(toDecimal(stats.cross.leverage)),
+    crossMarginUsage: fractionOfPercent(toDecimal(stats.cross.margin_usage)),
+    crossMarginRatio: fractionOf(crossMaintenance, crossEquity),
+    maintenanceMargin: usdOrNull(sumOf([
+      crossMaintenance,
+      isolatedMaintenance
+    ])),
+    availableBalance: stats.total.available_balance,
+    timestamp
+  });
 }
-__name(buildAssetBalances, "buildAssetBalances");
-function mapBalance(summary, assetsByAssetId, rawPositions, marketsByMarketId) {
-  const { free, used, total, assets } = buildAssetBalances(assetsByAssetId.values());
-  const portfolioValueBN = new BigNumber(summary.portfolioValue);
-  const marginUsageFrac = new BigNumber(summary.marginUsagePct).div(100);
-  const unrealizedPnl = portfolioValueBN.minus(summary.collateral).toFixed(6);
-  const initialMarginUsed = marginUsageFrac.multipliedBy(portfolioValueBN).toFixed(6);
-  const positionRisks = calculatePositionRisks(rawPositions, marketsByMarketId);
-  const maintenanceMargin = positionRisks.reduce((totalMaintenance, positionRisk) => totalMaintenance.plus(positionRisk.maintenance), new BigNumber(0));
-  const isolatedEquity = positionRisks.reduce((totalEquity, positionRisk) => positionRisk.marginMode === "isolated" ? totalEquity.plus(positionRisk.equity) : totalEquity, new BigNumber(0));
-  const crossEquity = new BigNumber(summary.crossPortfolioValue ?? portfolioValueBN.minus(isolatedEquity));
-  const marginRatio = maximumMarginRatio(positionRisks, crossEquity);
-  return {
-    accountType: summary.accountType,
-    accountTier: summary.accountTier,
-    free,
-    used,
-    total,
-    availableToTrade: summary.availableToTrade,
-    totalEquity: summary.portfolioValue,
-    walletBalance: summary.collateral,
-    unrealizedPnl,
-    initialMarginUsed,
-    maintenanceMargin: maintenanceMargin.toFixed(6),
-    marginRatio,
-    assets,
-    timestamp: Date.now()
-  };
-}
-__name(mapBalance, "mapBalance");
-function buildAccountBalance(account, marketsByMarketId, accountTier) {
-  const { free, used, total, assets } = buildAssetBalances(account.assets ?? []);
+__name(mapLiveBalance, "mapLiveBalance");
+function mapRestBalance(account, markets, timestamp) {
   const positions = account.positions ?? [];
-  const allocatedMargin = sumPositionField(positions, "allocated_margin", (position) => position.margin_mode === 1);
-  const totalCollateral = new BigNumber(account.collateral).plus(allocatedMargin);
-  const isolatedInitialMargin = positions.reduce((totalInitialMargin, position) => {
-    if (position.margin_mode !== 1 || new BigNumber(position.position).isZero()) {
-      return totalInitialMargin;
-    }
-    return totalInitialMargin.plus(new BigNumber(position.position_value).abs().times(position.initial_margin_fraction).div(100));
-  }, new BigNumber(0));
-  const initialMargin = new BigNumber(account.cross_initial_margin_requirement).plus(isolatedInitialMargin);
-  const positionRisks = calculatePositionRisks(positions, marketsByMarketId);
-  const isolatedMaintenanceMargin = positionRisks.reduce((totalMaintenance, positionRisk) => positionRisk.marginMode === "isolated" ? totalMaintenance.plus(positionRisk.maintenance) : totalMaintenance, new BigNumber(0));
-  const maintenanceMarginBN = new BigNumber(account.cross_maintenance_margin_requirement).plus(isolatedMaintenanceMargin);
-  const marginRatio = maximumMarginRatio(positionRisks.filter((positionRisk) => positionRisk.marginMode === "isolated"), new BigNumber(account.cross_asset_value), new BigNumber(account.cross_maintenance_margin_requirement));
-  const unrealizedPnl = sumPositionField(positions, "unrealized_pnl").toFixed(6);
-  return {
-    accountType: toLighterAccountType(account.account_trading_mode),
-    accountTier,
-    free,
-    used,
-    total,
-    availableToTrade: account.available_balance,
-    totalEquity: account.total_asset_value,
-    walletBalance: totalCollateral.toFixed(6),
-    unrealizedPnl,
-    initialMarginUsed: initialMargin.toFixed(6),
-    maintenanceMargin: maintenanceMarginBN.toFixed(6),
-    marginRatio,
-    assets,
-    timestamp: Date.now()
-  };
+  const assets = account.assets ?? [];
+  const risks = toPositionRisks(positions, markets.perpByMarketId);
+  const crossEquity = toDecimal(account.cross_asset_value);
+  const crossMaintenance = toDecimal(account.cross_maintenance_margin_requirement);
+  const isolatedMaintenance = asMarginRequirement(sumMaintenance(risks, "isolated"));
+  const equity = toEquitySplit(assets, markets.spotPriceBySymbol);
+  const perCollateral = toCollateralRows(assets, account.available_balance);
+  return toLighterBalance({
+    accountMode: ACCOUNT_MODE_BY_TYPE[toLighterAccountType(account.account_trading_mode)],
+    equity,
+    perCollateral,
+    unrealizedPnl: signed(sumUnrealizedPnl(positions)),
+    crossLeverage: multipleOf(sumNotional(risks, "cross"), crossEquity),
+    crossMarginUsage: fractionOf(toDecimal(account.cross_initial_margin_requirement), crossEquity),
+    crossMarginRatio: fractionOf(crossMaintenance, crossEquity),
+    maintenanceMargin: usdOrNull(sumOf([
+      crossMaintenance,
+      isolatedMaintenance
+    ])),
+    availableBalance: account.available_balance,
+    timestamp
+  });
 }
-__name(buildAccountBalance, "buildAccountBalance");
+__name(mapRestBalance, "mapRestBalance");
 function mapPositions(raw, includeZeroPositions = false) {
   const positions = /* @__PURE__ */ new Map();
   const trackedAssets = /* @__PURE__ */ new Map();
   for (const rawPosition of Object.values(raw)) {
-    const unsignedSize = new BigNumber(rawPosition.position || "0");
+    const unsignedSize = toDecimalOrZero(rawPosition.position);
     const side = rawPosition.sign === -1 ? "short" : "long";
     const size = rawPosition.sign === -1 ? unsignedSize.negated() : unsignedSize;
     const leverage = leverageFromImf(rawPosition.initial_margin_fraction);
@@ -134,7 +103,7 @@ function mapPositions(raw, includeZeroPositions = false) {
 }
 __name(mapPositions, "mapPositions");
 function leverageFromImf(imfPct) {
-  const pct = new BigNumber(imfPct);
+  const pct = toDecimalOrZero(imfPct);
   if (!pct.isFinite() || pct.lte(0)) return "1";
   return new BigNumber(100).div(pct).integerValue(BigNumber.ROUND_FLOOR).toFixed();
 }
@@ -142,76 +111,286 @@ __name(leverageFromImf, "leverageFromImf");
 function mapMarketDefaultAssetInfo(market) {
   return {
     coin: market.symbol,
-    leverage: leverageFromImf(new BigNumber(market.default_initial_margin_fraction).div(100).toFixed()),
+    leverage: leverageFromImf(toDecimalOrZero(market.default_initial_margin_fraction).div(100).toFixed()),
     marginType: "cross"
   };
 }
 __name(mapMarketDefaultAssetInfo, "mapMarketDefaultAssetInfo");
+function buildSpotPriceIndex(spotMarkets) {
+  const priceBySymbol = /* @__PURE__ */ new Map([
+    [
+      QUOTE_ASSET,
+      "1"
+    ]
+  ]);
+  for (const market of spotMarkets) {
+    const [baseSymbol] = market.symbol.split("/");
+    const price = toDecimal(market.last_trade_price);
+    if (baseSymbol === void 0 || market.status !== "active" || price === null || !price.isGreaterThan(0)) {
+      continue;
+    }
+    priceBySymbol.set(baseSymbol, price.toFixed());
+  }
+  return priceBySymbol;
+}
+__name(buildSpotPriceIndex, "buildSpotPriceIndex");
 function toLighterAccountType(accountTradingMode) {
   return accountTradingMode === 1 ? LighterAccountType.UNIFIED : LighterAccountType.CLASSIC;
 }
 __name(toLighterAccountType, "toLighterAccountType");
-function toLighterAccountTier(userTier) {
-  switch (userTier?.trim().toLowerCase()) {
-    case "std":
-    case "standard":
-      return LighterAccountTier.STANDARD;
-    case "premium":
-      return LighterAccountTier.PREMIUM;
-    case "plus":
-      return LighterAccountTier.PLUS;
-    default:
-      return void 0;
-  }
-}
-__name(toLighterAccountTier, "toLighterAccountTier");
-function calculatePositionRisks(rawPositions, marketsByMarketId) {
-  const positionRisks = [];
-  for (const rawPosition of rawPositions) {
-    const market = marketsByMarketId.get(rawPosition.market_id);
-    if (!market || new BigNumber(rawPosition.position).isZero()) {
+function toLighterBalance(figures) {
+  const spotEquity = figures.equity.spot;
+  const perpetualsEquity = figures.equity.perpetuals;
+  const tradingEquity = sumOf([
+    perpetualsEquity,
+    spotEquity
+  ]);
+  const shared = {
+    // Public pools, staking and credited LIT are the terms still missing from this sum.
+    totalEquity: usdOrNull(tradingEquity),
+    withdrawableBalance: usdOrNull(toDecimal(figures.availableBalance)),
+    availableMargin: usdOrNull(toDecimal(figures.availableBalance)),
+    // Lighter margins every position out of ONE cross pool, so the rows below are holdings inside
+    // that pool rather than budgets that could fund each other — only the scalars are spendable.
+    poolsShared: true,
+    // The rows outlive the scalars: an unpriceable holding nulls `spotEquity`, `tradingEquity` and
+    // `totalEquity` above, and still lists here in its own units, because a row needs no price.
+    perCollateral: figures.perCollateral,
+    timestamp: figures.timestamp,
+    tradingEquity: usdOrNull(tradingEquity),
+    perpetualsEquity: usdOrNull(perpetualsEquity),
+    spotEquity: usdOrNull(spotEquity),
+    // Public pool shares have no published net asset value, and staking has no field at all.
+    publicPoolsEquity: null,
+    stakingEquity: null,
+    creditedInLit: null,
+    unrealizedPnl: figures.unrealizedPnl,
+    crossLeverage: figures.crossLeverage,
+    maintenanceMargin: figures.maintenanceMargin,
+    crossMarginUsage: figures.crossMarginUsage,
+    crossMarginRatio: figures.crossMarginRatio
+  };
+  switch (figures.accountMode) {
+    case "lighter:classic":
+      return {
+        accountMode: "lighter:classic",
+        ...shared
+      };
+    case "lighter:unified":
+      return {
+        accountMode: "lighter:unified",
+        ...shared,
+        // Unified mode's portfolio margin figure appears in neither `/account` nor `user_stats`.
+        portfolioMargin: null
+      };
+  }
+}
+__name(toLighterBalance, "toLighterBalance");
+function toEquitySplit(assets, priceBySymbol) {
+  let perpetuals = new BigNumber(0);
+  let spot = new BigNumber(0);
+  for (const asset of assets) {
+    if (asset.symbol === QUOTE_ASSET) {
+      perpetuals = sumOf([
+        perpetuals,
+        toDecimal(asset.margin_balance)
+      ]);
+    }
+    const balance = toDecimal(asset.balance);
+    if (balance === null) {
+      spot = null;
       continue;
     }
-    const marginMode = rawPosition.margin_mode === 1 ? "isolated" : "cross";
-    const maintenance = new BigNumber(rawPosition.position_value).abs().times(market.maintenance_margin_fraction).div(1e4);
-    const equity = marginMode === "isolated" ? new BigNumber(rawPosition.allocated_margin).plus(rawPosition.unrealized_pnl) : new BigNumber(0);
-    positionRisks.push({
-      marginMode,
-      maintenance,
-      equity
-    });
+    if (balance.isZero()) {
+      continue;
+    }
+    const price = priceBySymbol.get(asset.symbol);
+    if (price === void 0) {
+      spot = null;
+      continue;
+    }
+    spot = sumOf([
+      spot,
+      balance.times(price)
+    ]);
   }
-  return positionRisks;
+  return {
+    perpetuals,
+    spot
+  };
 }
-__name(calculatePositionRisks, "calculatePositionRisks");
-function maximumMarginRatio(positionRisks, crossEquity, authoritativeCrossMaintenance) {
-  const calculatedCrossMaintenance = positionRisks.reduce((totalMaintenance, positionRisk) => positionRisk.marginMode === "cross" ? totalMaintenance.plus(positionRisk.maintenance) : totalMaintenance, new BigNumber(0));
-  const crossMaintenance = authoritativeCrossMaintenance ?? calculatedCrossMaintenance;
-  let maximumRatio = maintenanceRatio(crossMaintenance, crossEquity);
-  for (const positionRisk of positionRisks) {
-    if (positionRisk.marginMode === "isolated") {
-      maximumRatio = BigNumber.max(maximumRatio, maintenanceRatio(positionRisk.maintenance, positionRisk.equity));
+__name(toEquitySplit, "toEquitySplit");
+function toCollateralRows(assets, availableBalance) {
+  const rows = [];
+  for (const asset of assets) {
+    const held = heldAmount(asset);
+    if (held === null || held.isZero()) {
+      continue;
     }
+    rows.push(toCollateralRow(asset.symbol, held, availableBalance));
+  }
+  rows.sort(byAssetName);
+  return rows;
+}
+__name(toCollateralRows, "toCollateralRows");
+function heldAmount(asset) {
+  return sumOf([
+    toDecimal(asset.balance),
+    toDecimal(asset.margin_balance)
+  ]);
+}
+__name(heldAmount, "heldAmount");
+function toCollateralRow(asset, held, availableBalance) {
+  if (asset !== QUOTE_ASSET) {
+    return {
+      asset,
+      equity: held.toFixed(),
+      availableMargin: null,
+      withdrawable: null
+    };
   }
-  return maximumRatio.toFixed(4);
+  const usable = usdOrNull(toDecimal(availableBalance));
+  return {
+    asset,
+    equity: held.toFixed(),
+    availableMargin: usable,
+    withdrawable: usable
+  };
 }
-__name(maximumMarginRatio, "maximumMarginRatio");
-function maintenanceRatio(maintenance, equity) {
-  if (equity.gt(0)) {
-    return maintenance.div(equity);
+__name(toCollateralRow, "toCollateralRow");
+function byAssetName(left, right) {
+  if (left.asset < right.asset) {
+    return -1;
   }
-  return maintenance.gt(0) ? new BigNumber(1) : new BigNumber(0);
+  if (left.asset > right.asset) {
+    return 1;
+  }
+  return 0;
 }
-__name(maintenanceRatio, "maintenanceRatio");
-function sumPositionField(positions, field, include = () => true) {
-  let total = new BigNumber(0);
+__name(byAssetName, "byAssetName");
+function sumUnrealizedPnl(positions) {
+  return sumOf(Array.from(positions, (position) => toDecimal(position.unrealized_pnl)));
+}
+__name(sumUnrealizedPnl, "sumUnrealizedPnl");
+function toPositionRisks(positions, perpByMarketId) {
+  const risks = [];
   for (const position of positions) {
-    if (include(position)) {
-      total = total.plus(position[field] || "0");
+    if (toDecimalOrZero(position.position).isZero()) {
+      continue;
+    }
+    const positionValue = toDecimal(position.position_value);
+    const notional = positionValue === null ? null : positionValue.abs();
+    const market = perpByMarketId.get(position.market_id);
+    const maintenanceFraction = market === void 0 ? null : toDecimal(market.maintenance_margin_fraction);
+    risks.push({
+      marginMode: position.margin_mode === 1 ? "isolated" : "cross",
+      notional,
+      maintenance: notional === null || maintenanceFraction === null ? null : notional.times(maintenanceFraction).div(MARGIN_FRACTION_SCALE)
+    });
+  }
+  return risks;
+}
+__name(toPositionRisks, "toPositionRisks");
+function sumMaintenance(risks, marginMode) {
+  return sumOf(risks.filter((risk) => risk.marginMode === marginMode).map((risk) => risk.maintenance));
+}
+__name(sumMaintenance, "sumMaintenance");
+function sumNotional(risks, marginMode) {
+  return sumOf(risks.filter((risk) => risk.marginMode === marginMode).map((risk) => risk.notional));
+}
+__name(sumNotional, "sumNotional");
+function sumOf(values) {
+  let total = new BigNumber(0);
+  for (const value of values) {
+    if (value === null) {
+      return null;
     }
+    total = total.plus(value);
   }
   return total;
 }
-__name(sumPositionField, "sumPositionField");
+__name(sumOf, "sumOf");
+function fractionOf(part, base) {
+  if (part === null || base === null) {
+    return null;
+  }
+  if (base.isGreaterThan(0)) {
+    return fraction(part.div(base));
+  }
+  return part.isZero() ? fraction(part) : null;
+}
+__name(fractionOf, "fractionOf");
+function fractionOfPercent(percent) {
+  if (percent === null) {
+    return null;
+  }
+  return fraction(percent.div(PERCENT_SCALE));
+}
+__name(fractionOfPercent, "fractionOfPercent");
+function multipleOf(part, base) {
+  if (part === null || base === null) {
+    return null;
+  }
+  if (base.isGreaterThan(0)) {
+    return rate(part.div(base));
+  }
+  return part.isZero() ? rate(part) : null;
+}
+__name(multipleOf, "multipleOf");
+function rate(value) {
+  if (value === null) {
+    return null;
+  }
+  return value.toFixed(RATE_DECIMALS, BigNumber.ROUND_HALF_UP);
+}
+__name(rate, "rate");
+function fraction(value) {
+  return value.toFixed(FRACTION_DECIMALS, BigNumber.ROUND_HALF_UP);
+}
+__name(fraction, "fraction");
+function usd(value) {
+  return value.toFixed(USD_DECIMALS, BigNumber.ROUND_DOWN);
+}
+__name(usd, "usd");
+function usdOrNull(value) {
+  if (value === null) {
+    return null;
+  }
+  return usd(value);
+}
+__name(usdOrNull, "usdOrNull");
+function asMarginRequirement(value) {
+  if (value === null) {
+    return null;
+  }
+  return new BigNumber(value.toFixed(USD_DECIMALS, BigNumber.ROUND_HALF_UP));
+}
+__name(asMarginRequirement, "asMarginRequirement");
+const DECIMAL_PATTERN = /^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/;
+function toDecimal(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? new BigNumber(value) : null;
+  }
+  if (typeof value !== "string" || !DECIMAL_PATTERN.test(value)) {
+    return null;
+  }
+  return new BigNumber(value);
+}
+__name(toDecimal, "toDecimal");
+function toDecimalOrZero(value) {
+  return toDecimal(value) ?? new BigNumber(0);
+}
+__name(toDecimalOrZero, "toDecimalOrZero");
+function signed(value) {
+  if (value === null) {
+    return null;
+  }
+  const fixed = usd(value);
+  if (new BigNumber(fixed).isZero()) {
+    return "+0";
+  }
+  return value.isNegative() ? fixed : `+${fixed}`;
+}
+__name(signed, "signed");
 
-export { buildAccountBalance, leverageFromImf, mapBalance, mapMarketDefaultAssetInfo, mapPositions, toLighterAccountTier, toLighterAccountType };
+export { buildSpotPriceIndex, leverageFromImf, mapLiveBalance, mapMarketDefaultAssetInfo, mapPositions, mapRestBalance, toLighterAccountType };