@pear-protocol/exchanges-sdk 0.6.6 → 0.7.0

package/dist/tracker/lighter/balance.js

@@ -0,0 +1,87 @@
+import { z } from 'zod';
+import { DecimalString, SignedDecimalString, AccountBalanceCore } from '../balance-core';
+
+const lighterShared = {
+  /** Perpetuals + Spot. Null whenever either half is — one unknown term makes the sum unknown. */
+  tradingEquity: DecimalString.nullable(),
+  /**
+  * Collateral posted against perps, which is the quote asset's `margin_balance` alone.
+  *
+  * Null when the venue sends that one field unreadably or omits it: it is not a term of this
+  * figure, it IS the figure, so there is nothing left to report and a zero would say the account
+  * has posted no collateral at all.
+  */
+  perpetualsEquity: DecimalString.nullable(),
+  /**
+  * Spot holdings valued in USD.
+  *
+  * Null when a NON-ZERO holding cannot be priced — no spot book, an inactive book, or a book that
+  * has never traded. Lighter's spot books publish neither a mark nor an index price, so the only
+  * price available is the last trade, and counting an unpriceable holding as zero would report a
+  * number the venue never stated.
+  */
+  spotEquity: DecimalString.nullable(),
+  /** Null until a source is found for each — all three are UI rows with no API field. */
+  publicPoolsEquity: DecimalString.nullable(),
+  stakingEquity: DecimalString.nullable(),
+  creditedInLit: DecimalString.nullable(),
+  /**
+  * Open profit and loss across every position.
+  *
+  * Null when ANY position's own PnL is unreadable: the missing term could be a profit or a loss
+  * of any size, so the rest of the sum is not a smaller version of the answer — `+0` in
+  * particular would read as a flat book.
+  */
+  unrealizedPnl: SignedDecimalString.nullable(),
+  /**
+  * Cross exposure over cross equity.
+  *
+  * A MULTIPLE, not a ratio: `0.72` reads 0.72x, and the venue publishes it that way in both
+  * scopes. The fraction scale the two fields below carry does not reach it — a multiple is
+  * already the same figure on every venue.
+  *
+  * Null when either side is unreadable, and null when equity is zero against real exposure —
+  * that is a division by zero, and calling it `0.00` would report the safest possible account at
+  * the exact moment the venue can no longer measure the riskiest.
+  */
+  crossLeverage: DecimalString.nullable(),
+  /**
+  * Maintenance margin across both margin modes.
+  *
+  * Null when the venue's own cross requirement is unreadable, or when any position feeding the
+  * isolated half is: a requirement understated by a missing term reads as headroom that is not
+  * there. Null on the same terms when a position sits on a market the tracker's market read never
+  * listed — the market carries the maintenance fraction that prices it, so without one there is no
+  * term to add rather than a term worth zero.
+  */
+  maintenanceMargin: DecimalString.nullable(),
+  /**
+  * A FRACTION, not a percentage: `0.0221` is what the venue's own page badges as 2.21%.
+  *
+  * The venue publishes `margin_usage` in percent points and the mapper divides them down, because
+  * every venue in this SDK states a ratio at one scale — a field whose scale depended on the
+  * venue behind it could not be compared across two of them, which is the whole defect the model
+  * exists to remove. Four decimals carry the venue's two decimals of percent exactly.
+  *
+  * Verified to exceed 1 on a live account, which reads 115.22% on the venue — never clamp.
+  *
+  * Null on the same terms as `crossLeverage`: unreadable in, unknown out, and a requirement
+  * standing against zero equity is unmeasurable rather than full or empty. The ratio is null on
+  * one term more: the live path computes it from the positions, so an unlisted market leaves it
+  * unknown wherever it leaves `maintenanceMargin` unknown.
+  */
+  crossMarginUsage: DecimalString.nullable(),
+  crossMarginRatio: DecimalString.nullable()
+};
+const LighterClassicBalance = AccountBalanceCore.extend({
+  accountMode: z.literal("lighter:classic"),
+  ...lighterShared
+});
+const LighterUnifiedBalance = AccountBalanceCore.extend({
+  accountMode: z.literal("lighter:unified"),
+  ...lighterShared,
+  /** Null — no source in `/account` or `user_stats`. */
+  portfolioMargin: DecimalString.nullable()
+});
+
+export { LighterClassicBalance, LighterUnifiedBalance };

package/dist/tracker/lighter/basket-size.js

@@ -0,0 +1,74 @@
+import BigNumber from 'bignumber.js';
+import { QUOTE_ASSET } from './const';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const MARGIN_FRACTION_SCALE = 1e4;
+const CROSS_POOL = QUOTE_ASSET;
+const DECIMAL_PATTERN = /^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/;
+function toLighterBasketCalculation(legs, context) {
+  const capped = [];
+  for (const leg of legs) {
+    const market = context.perpBySymbol.get(leg.asset);
+    if (!market) {
+      return {
+        budgets: {},
+        legs: []
+      };
+    }
+    capped.push(toCappedLeg(leg, market, context.settingsByMarketId.get(String(market.market_id))));
+  }
+  return {
+    // Every leg draws on the same pool, so one entry carries the whole basket's budget.
+    budgets: {
+      [CROSS_POOL]: context.availableBalance
+    },
+    legs: capped
+  };
+}
+__name(toLighterBasketCalculation, "toLighterBasketCalculation");
+function toCappedLeg(leg, market, currentSetting) {
+  return {
+    asset: leg.asset,
+    pool: CROSS_POOL,
+    weight: leg.weight,
+    effectiveLeverage: effectiveLeverage(leg.leverage, market, currentSetting),
+    marginMode: leg.marginMode,
+    maxNotional: null
+  };
+}
+__name(toCappedLeg, "toCappedLeg");
+function effectiveLeverage(requested, market, currentSetting) {
+  const accountLeverage = currentSetting === void 0 ? defaultAccountLeverage(market) : toDecimal(currentSetting.leverage);
+  const granted = BigNumber.min(toDecimal(requested), venueMaxLeverage(market), accountLeverage);
+  return granted.isFinite() && granted.isGreaterThan(0) ? granted.toFixed() : "1";
+}
+__name(effectiveLeverage, "effectiveLeverage");
+function venueMaxLeverage(market) {
+  return leverageFromMarginFraction(market.min_initial_margin_fraction);
+}
+__name(venueMaxLeverage, "venueMaxLeverage");
+function defaultAccountLeverage(market) {
+  return leverageFromMarginFraction(market.default_initial_margin_fraction).integerValue(BigNumber.ROUND_FLOOR);
+}
+__name(defaultAccountLeverage, "defaultAccountLeverage");
+function leverageFromMarginFraction(marginFraction) {
+  const fraction = toDecimal(marginFraction);
+  if (!fraction.isGreaterThan(0)) {
+    return new BigNumber(1);
+  }
+  return new BigNumber(MARGIN_FRACTION_SCALE).div(fraction);
+}
+__name(leverageFromMarginFraction, "leverageFromMarginFraction");
+function toDecimal(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? new BigNumber(value) : new BigNumber(0);
+  }
+  if (typeof value !== "string" || !DECIMAL_PATTERN.test(value)) {
+    return new BigNumber(0);
+  }
+  return new BigNumber(value);
+}
+__name(toDecimal, "toDecimal");
+
+export { toLighterBasketCalculation, venueMaxLeverage };