@reyaxyz/account-figures 0.0.0-stage → 0.3.0

package/dist/liquidation.js

@@ -0,0 +1,117 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roundTowardMark = exports.roundTowardMarkD = exports.distanceToLiquidation = exports.distanceToLiquidationD = exports.liquidationPrice = exports.liquidationPriceD = exports.marginUsage = exports.marginUsageD = void 0;
+/**
+ * Margin usage and the cross-margin liquidation price, ported from the Agent
+ * Kit's `_margin.py` (kit 0.12.20).
+ *
+ * The liquidation price of one position is the price in its market at which
+ * equity equals the liquidation margin, every other mark, collateral price and
+ * funding unchanged, with the position's own liquidation margin recomputed at
+ * that price. Per position, with q its signed base, P its mark, E the account's
+ * equity, s the market's liquidation-margin rate and LM_other the liquidation
+ * margin of the account's other positions:
+ *
+ *   liq = (q·P − E + LM_other) / (q·(1 − sign(q)·s))
+ *
+ * which is the kit's `mark − (E − LM) / (q·(1 − sign(q)·s))`.
+ */
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const decimal_1 = require("./decimal");
+const engine_1 = require("./engine");
+const errors_1 = require("./errors");
+function marginUsageD(marginBalance, lm) {
+    if (marginBalance.lte(0)) {
+        return null;
+    }
+    return lm.div(marginBalance);
+}
+exports.marginUsageD = marginUsageD;
+/**
+ * Liquidation margin / equity: 1 is the liquidation line. `null` when equity
+ * is not positive.
+ */
+function marginUsage(marginBalance, lm) {
+    const usage = marginUsageD((0, decimal_1.parseDecimal)(marginBalance, 'margin balance'), (0, decimal_1.parseDecimal)(lm, 'liquidation margin'));
+    return usage === null ? null : (0, decimal_1.toText)(usage);
+}
+exports.marginUsage = marginUsage;
+function liquidationPriceD(margin, market, lm) {
+    const risk = margin.markets.get(market);
+    if (risk === undefined) {
+        throw new errors_1.AccountFiguresInputError(`No mark or margin rate for ${market}`);
+    }
+    if (risk.base.isZero()) {
+        return null;
+    }
+    const buffer = margin.marginBalance.minus(lm);
+    let price;
+    if (risk.base.gt(0)) {
+        if (risk.marginRate.gte(1)) {
+            return null;
+        }
+        price = risk.mark.minus(buffer.div(risk.base.times(new decimal_1.Dec(1).minus(risk.marginRate))));
+    }
+    else {
+        price = risk.mark.plus(buffer.div(risk.base.negated().times(new decimal_1.Dec(1).plus(risk.marginRate))));
+    }
+    // A long that no positive price liquidates has none. A short whose price
+    // would be at or below zero is past the line at every price (equity is
+    // already below the liquidation margin, so the account reads liquidatable);
+    // it has none either, rather than the negative price the kit returns
+    // (RET-256).
+    return price.gt(0) ? price : null;
+}
+exports.liquidationPriceD = liquidationPriceD;
+/**
+ * Cross margin: the price in `market` at which equity equals the liquidation
+ * margin `lm` (the settled projection's), every other mark, collateral price
+ * and funding unchanged. `null` for a flat market and when no positive price
+ * is the liquidation line. Exact; see `roundTowardMark` for display.
+ */
+function liquidationPrice(margin, market, lm) {
+    const price = liquidationPriceD((0, engine_1.parseMargin)(margin), market, (0, decimal_1.parseDecimal)(lm, 'liquidation margin'));
+    return price === null ? null : (0, decimal_1.toText)(price);
+}
+exports.liquidationPrice = liquidationPrice;
+function distanceToLiquidationD(risk, price) {
+    if (price === null || risk.base.isZero()) {
+        return null;
+    }
+    return risk.base.gt(0)
+        ? risk.mark.minus(price).div(risk.mark)
+        : price.minus(risk.mark).div(risk.mark);
+}
+exports.distanceToLiquidationD = distanceToLiquidationD;
+/**
+ * How far the mark must move against the position to reach `price`, as a
+ * fraction of the mark. Negative when the account is already past the
+ * liquidation line.
+ */
+function distanceToLiquidation(risk, price) {
+    const distance = distanceToLiquidationD((0, engine_1.parseRisk)('position', risk), price === null ? null : (0, decimal_1.parseDecimal)(price, 'liquidation price'));
+    return distance === null ? null : (0, decimal_1.toText)(distance);
+}
+exports.distanceToLiquidation = distanceToLiquidation;
+function roundTowardMarkD(price, risk, tick) {
+    if (price === null) {
+        return null;
+    }
+    if (!tick.gt(0)) {
+        throw new errors_1.AccountFiguresInputError('tick size must be positive');
+    }
+    return (0, decimal_1.roundTo)(price, tick, risk.base.gt(0) ? bignumber_js_1.default.ROUND_CEIL : bignumber_js_1.default.ROUND_FLOOR);
+}
+exports.roundTowardMarkD = roundTowardMarkD;
+/**
+ * A liquidation price rounded onto the tick toward the mark, so it never reads
+ * farther away than it is: up for a long, down for a short.
+ */
+function roundTowardMark(price, risk, tick) {
+    const rounded = roundTowardMarkD(price === null ? null : (0, decimal_1.parseDecimal)(price, 'liquidation price'), (0, engine_1.parseRisk)('position', risk), (0, decimal_1.parseDecimal)(tick, 'tick size'));
+    return rounded === null ? null : (0, decimal_1.toText)(rounded);
+}
+exports.roundTowardMark = roundTowardMark;

package/dist/response.d.ts

@@ -0,0 +1,47 @@
+import { MarginInputs } from './snapshot';
+/** Added to a position only when the complete account can be valued. */
+export interface PositionValuation {
+    markPrice: string;
+    notional: string;
+    unrealizedPnl: string;
+    liquidationMarginRequirement: string;
+    liquidationPrice: string | null;
+    hasCorrelatedCollateral: boolean;
+    updatedAt: number;
+    pricesUpdatedAt: number | null;
+}
+export interface AccountRiskInputs extends MarginInputs {
+    marketSummaries: readonly (MarginInputs['marketSummaries'][number] & {
+        pricesUpdatedAt?: number;
+    })[];
+    assetOraclePrices?: readonly (NonNullable<MarginInputs['assetOraclePrices']>[number] & {
+        updatedAt: number;
+    })[];
+}
+/** Keep source freshness separate from the time at which this response is calculated. */
+export declare function accountRiskResponse(inputs: AccountRiskInputs, updatedAt: number): {
+    summary: {
+        updatedAt: number;
+        pricesUpdatedAt: number | null;
+        accountId: number;
+        collateralValue: string;
+        unrealizedPnl: string;
+        marginBalance: string;
+        initialMarginRequirement: string;
+        liquidationMarginRequirement: string;
+        freeCollateral: string;
+        initialMarginRatio: string | null;
+        liquidationMarginRatio: string | null;
+    };
+    positions: {
+        updatedAt: number;
+        pricesUpdatedAt: number | null;
+        symbol: string;
+        markPrice: string;
+        notional: string;
+        unrealizedPnl: string;
+        liquidationMarginRequirement: string;
+        liquidationPrice: string | null;
+        hasCorrelatedCollateral: boolean;
+    }[];
+};

package/dist/response.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accountRiskResponse = void 0;
+const figures_1 = require("./figures");
+const snapshot_1 = require("./snapshot");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+/** Keep source freshness separate from the time at which this response is calculated. */
+function accountRiskResponse(inputs, updatedAt) {
+    const figures = (0, figures_1.computeAccountFigures)(inputs);
+    const timestamps = [];
+    for (const position of figures.positions) {
+        const timestamp = inputs.marketSummaries.find((row) => row.symbol === position.symbol)?.pricesUpdatedAt;
+        if (!Number.isSafeInteger(timestamp) || timestamp <= 0) {
+            throw new Error(`Missing mark timestamp for ${position.symbol}`);
+        }
+        timestamps.push(timestamp);
+    }
+    for (const collateral of figures.collateral) {
+        if (collateral.asset === snapshot_1.RUSD || new bignumber_js_1.default(collateral.balance).isZero())
+            continue;
+        const timestamp = inputs.assetOraclePrices?.find((row) => row.asset === collateral.asset)?.updatedAt;
+        if (!Number.isSafeInteger(timestamp) || timestamp <= 0) {
+            throw new Error(`Missing collateral timestamp for ${collateral.asset}`);
+        }
+        timestamps.push(timestamp);
+    }
+    const freshness = {
+        updatedAt,
+        pricesUpdatedAt: timestamps.length ? Math.min(...timestamps) : null,
+    };
+    return {
+        summary: {
+            accountId: Number(inputs.accountId),
+            collateralValue: figures.realBalance,
+            unrealizedPnl: figures.unrealizedPnl,
+            marginBalance: figures.equity,
+            initialMarginRequirement: figures.imr,
+            liquidationMarginRequirement: figures.lmr,
+            freeCollateral: figures.availableMargin,
+            initialMarginRatio: ratio(figures.initialMarginUsage),
+            liquidationMarginRatio: ratio(figures.liquidationMarginUsage),
+            ...freshness,
+        },
+        positions: figures.positions
+            .map((position) => ({
+            symbol: position.symbol,
+            markPrice: position.markPrice,
+            notional: position.notional,
+            unrealizedPnl: position.unrealizedPnl,
+            liquidationMarginRequirement: position.lmr,
+            liquidationPrice: position.liquidationPrice,
+            hasCorrelatedCollateral: position.assumesFixedCollateral,
+            ...freshness,
+        }))
+            .sort((a, b) => a.symbol.localeCompare(b.symbol)),
+    };
+}
+exports.accountRiskResponse = accountRiskResponse;
+const ratio = (value) => value === null
+    ? null
+    : new bignumber_js_1.default(value).decimalPlaces(18, bignumber_js_1.default.ROUND_UP).toFixed();

package/dist/snapshot.d.ts

@@ -0,0 +1,123 @@
+import { Dec } from './decimal';
+import { AccountMargin, MarginD } from './engine';
+/** One row of `GET /wallet/{address}/accountBalances`. */
+export interface V2AccountBalance {
+    accountId: number | string;
+    asset: string;
+    /**
+     * Net deposits; for rUSD also realised PnL and the funding and ADL
+     * cashflows up to the latest market trackers, so no funding is added here.
+     */
+    realBalance: string;
+}
+/** One row of `GET /wallet/{address}/positions`. */
+export interface V2Position {
+    accountId: number | string;
+    symbol: string;
+    /** Unsigned, ADL-adjusted. */
+    qty: string;
+    /** `B` long, `A` short. */
+    side: 'B' | 'A';
+    avgEntryPrice: string;
+}
+/** One row of `GET /perpMarketDefinitions`. */
+export interface V2MarketDefinition {
+    symbol: string;
+    tickSize: string;
+    liquidationMarginParameter: string;
+    initialMarginParameter: string;
+}
+/** One row of `GET /perpMarkets/summary`. */
+export interface V2MarketSummary {
+    symbol: string;
+    markPrice?: string;
+}
+/** One row of `GET /assetDefinitions`. */
+export interface V2AssetDefinition {
+    asset: string;
+    priceHaircut: string;
+    /**
+     * `ENABLED` or `WITHDRAWAL_ONLY`: V2's deposit policy only. It does not
+     * change margin credit, which Core gives every supporting collateral.
+     */
+    status: string;
+}
+/** One row of `GET /assetOraclePrices`. */
+export interface V2AssetOraclePrice {
+    asset: string;
+    oraclePrice: string;
+}
+export interface MarginInputs {
+    accountId: number | string;
+    /** The wallet's balances; rows of other accounts are ignored. */
+    balances: readonly V2AccountBalance[];
+    /** The wallet's positions; rows of other accounts are ignored. */
+    positions: readonly V2Position[];
+    marketDefinitions: readonly V2MarketDefinition[];
+    marketSummaries: readonly V2MarketSummary[];
+    /** Needed only when the account holds collateral other than rUSD. */
+    assetDefinitions?: readonly V2AssetDefinition[];
+    /** Needed only when the account holds collateral other than rUSD. */
+    assetOraclePrices?: readonly V2AssetOraclePrice[];
+    /** Markets to include without a position, such as the one an order is for. */
+    symbols?: readonly string[];
+}
+export interface CollateralRow {
+    asset: string;
+    /** V2's balance string. */
+    balance: string;
+    priceUsd: string;
+    haircut: string;
+    /** Balance × price, before the haircut. */
+    valueUsd: string;
+    /**
+     * What counts toward equity, as Core values it: balance × price × (1 −
+     * haircut), or for a debt balance × price / (1 − haircut). Withdrawal-only
+     * collateral counts like any other.
+     */
+    marginCreditUsd: string;
+    /** The asset definition's deposit status; `null` when none was given (rUSD needs none). */
+    status: string | null;
+}
+export interface PositionDetail {
+    symbol: string;
+    side: 'LONG' | 'SHORT';
+    /** V2's qty string (unsigned). */
+    qty: string;
+    signedQty: string;
+    /** V2's average entry price string. */
+    avgEntryPrice: string;
+    /** V2's mark price string. */
+    markPrice: string;
+    unrealizedPnl: string;
+}
+/** One account's margin as read from V2. */
+export interface MarginSnapshot {
+    accountId: number | string;
+    margin: AccountMargin;
+    imMultiplier: string;
+    definitions: Readonly<Record<string, V2MarketDefinition>>;
+    collateral: CollateralRow[];
+    positions: PositionDetail[];
+    unrealizedPnl: string;
+}
+export declare const RUSD = "RUSD";
+/** The asset a collateral's price follows: `WSTETH` → `ETH`, `BTC` → `BTC`. */
+export declare function collateralUnderlying(asset: string): string;
+/** The asset a perp market trades: `ETHRUSDPERP` → `ETH`. */
+export declare function marketUnderlying(symbol: string): string;
+/**
+ * The collateral pool's IM multiplier, as V2 publishes it per market
+ * (IM = LM rate × multiplier). V2 computes both parameters in floating point,
+ * so the ratio is rounded to 12 places; markets that disagree resolve to the
+ * largest. A market without positive parameters is skipped here; one an
+ * account holds fails on its own rate instead.
+ */
+export declare function imMultiplierFrom(definitions: readonly Pick<V2MarketDefinition, 'symbol' | 'liquidationMarginParameter' | 'initialMarginParameter'>[]): string | null;
+export declare function buildMarginSnapshotD(inputs: MarginInputs): {
+    snapshot: MarginSnapshot;
+    margin: MarginD;
+    imMultiplier: Dec;
+};
+/** One account's margin inputs from V2 reads, valued as Core values them. */
+export declare function buildMarginSnapshot(inputs: MarginInputs): MarginSnapshot;

package/dist/snapshot.js

@@ -0,0 +1,259 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildMarginSnapshot = exports.buildMarginSnapshotD = exports.imMultiplierFrom = exports.marketUnderlying = exports.collateralUnderlying = exports.RUSD = void 0;
+/**
+ * Assembles an account's margin inputs from V2 reads, the way Core values them
+ * (reya-network `AccountExposure.sol`, `PriceHelpers.sol`): every supporting
+ * collateral at price × (1 − haircut), a debt at price / (1 − haircut), plus
+ * unrealised PnL at mark. The structure follows the Agent Kit's
+ * `build_snapshot` (kit 0.12.20); where the kit differs from Core (it credits
+ * withdrawal-only collateral at 0, counts a debt at price and subtracts a
+ * funding estimate already in the balance), this follows Core. Missing data
+ * throws instead of counting as zero.
+ *
+ * The input types name only the fields the figures read, with V2's names and
+ * types, so V2 responses (and the `@reyaxyz/api-v2-sdk` models) pass as they
+ * are.
+ */
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const decimal_1 = require("./decimal");
+const engine_1 = require("./engine");
+const errors_1 = require("./errors");
+exports.RUSD = 'RUSD';
+/**
+ * Collateral that tracks another asset's price: wrapped and staked forms of
+ * ETH, BTC and REYA.
+ */
+const UNDERLYING = {
+    WETH: 'ETH',
+    STETH: 'ETH',
+    WSTETH: 'ETH',
+    WBTC: 'BTC',
+    SREYA: 'REYA',
+};
+/** The asset a collateral's price follows: `WSTETH` → `ETH`, `BTC` → `BTC`. */
+function collateralUnderlying(asset) {
+    const upper = asset.toUpperCase();
+    return UNDERLYING[upper] ?? upper;
+}
+exports.collateralUnderlying = collateralUnderlying;
+/** The asset a perp market trades: `ETHRUSDPERP` → `ETH`. */
+function marketUnderlying(symbol) {
+    return symbol.replace(/RUSDPERP$/i, '').toUpperCase();
+}
+exports.marketUnderlying = marketUnderlying;
+function sameAccount(a, b) {
+    return String(a) === String(b);
+}
+function marginRate(definition) {
+    const rate = (0, decimal_1.parseDecimal)(definition.liquidationMarginParameter, `${definition.symbol} liquidation margin parameter`);
+    if (!(rate.gt(0) && rate.lt(1))) {
+        throw new errors_1.AccountFiguresInputError(`${definition.symbol} liquidation margin parameter must be between 0 and 1`);
+    }
+    return rate;
+}
+function imMultiplierD(definitions) {
+    let best = null;
+    for (const md of definitions) {
+        let lm;
+        let im;
+        try {
+            lm = (0, decimal_1.parseDecimal)(md.liquidationMarginParameter, `${md.symbol} liquidation margin parameter`);
+            im = (0, decimal_1.parseDecimal)(md.initialMarginParameter, `${md.symbol} initial margin parameter`);
+        }
+        catch (error) {
+            if (error instanceof errors_1.AccountFiguresInputError) {
+                continue;
+            }
+            throw error;
+        }
+        if (lm.gt(0) && im.gt(0)) {
+            const ratio = im.div(lm).decimalPlaces(12, bignumber_js_1.default.ROUND_HALF_EVEN);
+            if (best === null || ratio.gt(best)) {
+                best = ratio;
+            }
+        }
+    }
+    return best;
+}
+/**
+ * The collateral pool's IM multiplier, as V2 publishes it per market
+ * (IM = LM rate × multiplier). V2 computes both parameters in floating point,
+ * so the ratio is rounded to 12 places; markets that disagree resolve to the
+ * largest. A market without positive parameters is skipped here; one an
+ * account holds fails on its own rate instead.
+ */
+function imMultiplierFrom(definitions) {
+    const multiplier = imMultiplierD(definitions);
+    return multiplier === null ? null : (0, decimal_1.toText)(multiplier);
+}
+exports.imMultiplierFrom = imMultiplierFrom;
+function buildMarginSnapshotD(inputs) {
+    const bySymbol = new Map();
+    for (const md of inputs.marketDefinitions) {
+        bySymbol.set(md.symbol, md);
+    }
+    const summaries = new Map();
+    for (const summary of inputs.marketSummaries) {
+        summaries.set(summary.symbol, summary);
+    }
+    const assets = new Map();
+    for (const asset of inputs.assetDefinitions ?? []) {
+        assets.set(asset.asset, asset);
+    }
+    const assetPrices = new Map();
+    for (const price of inputs.assetOraclePrices ?? []) {
+        assetPrices.set(price.asset, price.oraclePrice);
+    }
+    const unit = (0, decimal_1.nativeUnit)(decimal_1.RUSD_DECIMALS);
+    const collateral = [];
+    let creditTotal = decimal_1.ZERO;
+    for (const balance of inputs.balances) {
+        if (!sameAccount(balance.accountId, inputs.accountId)) {
+            continue;
+        }
+        const amount = (0, decimal_1.parseDecimal)(balance.realBalance, `${balance.asset} balance`);
+        if (amount.isZero()) {
+            continue;
+        }
+        const status = assets.get(balance.asset)?.status ?? null;
+        let row;
+        let credit;
+        if (balance.asset === exports.RUSD) {
+            // rUSD is the quote collateral: price 1, no haircut.
+            credit = (0, decimal_1.floorTo)(amount, unit);
+            row = {
+                asset: balance.asset,
+                balance: balance.realBalance,
+                priceUsd: '1',
+                haircut: '0',
+                valueUsd: (0, decimal_1.toText)(amount),
+                marginCreditUsd: (0, decimal_1.toText)(credit),
+                status,
+            };
+        }
+        else {
+            const definition = assets.get(balance.asset);
+            if (definition === undefined) {
+                throw new errors_1.AccountFiguresInputError(`Asset '${balance.asset}' has a balance but is missing from the asset definitions. ` +
+                    'This is usually a transient API issue: retry.');
+            }
+            const price = (0, decimal_1.requirePrice)(assetPrices.get(balance.asset), `${balance.asset} collateral oracle price`);
+            const haircut = (0, decimal_1.parseDecimal)(definition.priceHaircut, `${balance.asset} haircut`);
+            if (haircut.lt(0) || haircut.gte(1)) {
+                throw new errors_1.AccountFiguresInputError(`${balance.asset} haircut must be at least 0 and below 1`);
+            }
+            const value = amount.times(price);
+            // Core's exchangeWithHaircut: a holding is worth less than its price, a
+            // debt costs more (PriceHelpers.sol). Both round down, against the account.
+            credit = (0, decimal_1.floorTo)(amount.gt(0)
+                ? value.times(decimal_1.ONE.minus(haircut))
+                : value.div(decimal_1.ONE.minus(haircut)), unit);
+            row = {
+                asset: balance.asset,
+                balance: balance.realBalance,
+                priceUsd: (0, decimal_1.toText)(price),
+                haircut: (0, decimal_1.toText)(haircut),
+                valueUsd: (0, decimal_1.toText)(value),
+                marginCreditUsd: (0, decimal_1.toText)(credit),
+                status,
+            };
+        }
+        creditTotal = creditTotal.plus(credit);
+        collateral.push(row);
+    }
+    const markets = new Map();
+    const details = [];
+    let upnlTotal = decimal_1.ZERO;
+    for (const position of inputs.positions) {
+        if (!sameAccount(position.accountId, inputs.accountId)) {
+            continue;
+        }
+        const unsigned = (0, decimal_1.parseDecimal)(position.qty, `${position.symbol} position qty`);
+        const qty = position.side === 'B' ? unsigned : unsigned.negated();
+        if (qty.isZero()) {
+            continue;
+        }
+        const definition = bySymbol.get(position.symbol);
+        if (definition === undefined) {
+            throw new errors_1.AccountFiguresInputError(`Position symbol '${position.symbol}' is missing from the perp market definitions.`);
+        }
+        const summary = summaries.get(position.symbol);
+        if (summary === undefined) {
+            throw new errors_1.AccountFiguresInputError(`Position symbol '${position.symbol}' is missing from the perp market summaries.`);
+        }
+        const mark = (0, decimal_1.requirePrice)(summary.markPrice, `${position.symbol} mark price`);
+        const entry = (0, decimal_1.parseDecimal)(position.avgEntryPrice, `${position.symbol} entry price`);
+        const rate = marginRate(definition);
+        const upnl = (0, decimal_1.floorTo)((0, decimal_1.floorTo)(qty.times(mark.minus(entry))), unit);
+        upnlTotal = upnlTotal.plus(upnl);
+        markets.set(position.symbol, { base: qty, mark, marginRate: rate, entry });
+        details.push({
+            symbol: position.symbol,
+            side: qty.gt(0) ? 'LONG' : 'SHORT',
+            qty: position.qty,
+            signedQty: (0, decimal_1.toText)(qty),
+            avgEntryPrice: position.avgEntryPrice,
+            markPrice: summary.markPrice,
+            unrealizedPnl: (0, decimal_1.toText)(upnl),
+        });
+    }
+    for (const symbol of inputs.symbols ?? []) {
+        if (markets.has(symbol)) {
+            continue;
+        }
+        const definition = bySymbol.get(symbol);
+        if (definition === undefined) {
+            throw new errors_1.AccountFiguresInputError(`Unknown symbol '${symbol}'.`);
+        }
+        const summary = summaries.get(symbol);
+        if (summary === undefined) {
+            throw new errors_1.AccountFiguresInputError(`'${symbol}' is missing from the market summaries.`);
+        }
+        const mark = (0, decimal_1.requirePrice)(summary.markPrice, `${symbol} mark price`);
+        markets.set(symbol, {
+            base: decimal_1.ZERO,
+            mark,
+            marginRate: marginRate(definition),
+            entry: mark,
+        });
+    }
+    const multiplier = imMultiplierD(inputs.marketDefinitions);
+    if (multiplier === null && markets.size > 0) {
+        throw new errors_1.AccountFiguresInputError('No perp market definition publishes margin parameters; cannot compute initial margin');
+    }
+    // Without markets there is no margin requirement for a multiplier to scale.
+    const imMultiplier = multiplier ?? decimal_1.ONE;
+    const realBalance = creditTotal;
+    const margin = {
+        realBalance,
+        marginBalance: realBalance.plus(upnlTotal),
+        markets,
+    };
+    const definitions = {};
+    for (const [symbol, md] of bySymbol) {
+        definitions[symbol] = md;
+    }
+    return {
+        margin,
+        imMultiplier,
+        snapshot: {
+            accountId: inputs.accountId,
+            margin: (0, engine_1.marginText)(margin),
+            imMultiplier: (0, decimal_1.toText)(imMultiplier),
+            definitions,
+            collateral,
+            positions: details,
+            unrealizedPnl: (0, decimal_1.toText)(upnlTotal),
+        },
+    };
+}
+exports.buildMarginSnapshotD = buildMarginSnapshotD;
+/** One account's margin inputs from V2 reads, valued as Core values them. */
+function buildMarginSnapshot(inputs) {
+    return buildMarginSnapshotD(inputs).snapshot;
+}
+exports.buildMarginSnapshot = buildMarginSnapshot;

package/package.json

@@ -1,6 +1,45 @@
 {
   "name": "@reyaxyz/account-figures",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0",
+  "description": "Reya account figures from public V2 data: equity, margin requirements, margin usage and liquidation prices",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Reya-Labs/reya-off-chain-monorepo.git"
+  },
+  "license": "MIT",
+  "author": "Reya Network",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.18.0"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.build.json",
+    "ts:check-types": "tsc --noEmit",
+    "ts:circular-check": "dpdm --no-output --no-tree --no-warning --exit-code circular:1 -T src/index.ts",
+    "ts:check": "pnpm ts:check-types && pnpm ts:circular-check",
+    "prettier:check": "prettier --log-level silent --check './src/**/*.ts' './tests/**/*.ts'",
+    "prettier:fix": "prettier --log-level silent --write './src/**/*.ts' './tests/**/*.ts'",
+    "lint:check": "eslint src tests --ext .ts",
+    "lint:fix": "eslint src tests --ext .ts --fix",
+    "code-quality:check": "concurrently 'pnpm ts:check' 'pnpm prettier:check' 'pnpm lint:check --quiet'",
+    "test": "jest --runInBand"
+  },
+  "dependencies": {
+    "bignumber.js": "9.1.2"
+  },
+  "devDependencies": {
+    "@reyaxyz/api-v2-sdk": "0.316.0",
+    "typescript": "5.3.3"
+  },
+  "gitHead": "c79e1c00f842259ddcb7c435ed799ea0b49e9939"
+}