@symmio/trading-core 1.1.0 → 2.0.0

package/dist/quotes/grouping/aggregate-group-upnl.js

@@ -0,0 +1,38 @@
+import { PositionType as e } from "../../symmio-contracts/symmio/types.js";
+import { mulWei as t } from "../../shared/utils/wei.js";
+import { sharePercent as n } from "../../shared/utils/percent.js";
+import { settledOpenPriceOf as r } from "../open-price.js";
+import { isActivePosition as i } from "./partition-quotes.js";
+//#region src/quotes/grouping/aggregate-group-upnl.ts
+function a(e) {
+	if (e.quantity <= 0n) return 0n;
+	let t = e.initialLockedValues ?? e.lockedValues;
+	return (t.cva + t.lf + t.partyAmm + t.partyBmm) * e.openQuantity / e.quantity;
+}
+function o(o, s) {
+	let c = 0n, l = 0n, u = 0n, d = 0, f = 0;
+	for (let n of o) {
+		if (!i(n) || n.openQuantity <= 0n) continue;
+		let o = r(n);
+		if (o === void 0 || s === void 0) {
+			f += 1;
+			continue;
+		}
+		let p = s - o, m = n.positionType === e.SHORT ? -p : p;
+		c += t(n.openQuantity, m), l += t(n.openQuantity, o), u += a(n), d += 1;
+	}
+	return {
+		upnl: c,
+		openNotional: l,
+		openMargin: u,
+		returnPercent: n(c, l),
+		upnlPercent: n(c, u),
+		valuedCount: d,
+		unvaluedCount: f,
+		isComplete: d > 0 && f === 0
+	};
+}
+//#endregion
+export { o as aggregateGroupUpnl };
+
+//# sourceMappingURL=aggregate-group-upnl.js.map

package/dist/quotes/grouping/aggregate-group-upnl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregate-group-upnl.js","names":[],"sources":["../../../src/quotes/grouping/aggregate-group-upnl.ts"],"sourcesContent":["import { sharePercent } from \"../../shared/utils/percent\";\nimport { mulWei } from \"../../shared/utils/wei\";\nimport { PositionType } from \"../../symmio-contracts/symmio/types\";\nimport { settledOpenPriceOf } from \"../open-price\";\nimport type { UnifiedQuote } from \"../unified-quote\";\nimport { isActivePosition } from \"./partition-quotes\";\n\n/**\n * The locked margin backing a child's **still-open** size (wei).\n *\n * Every leg of the frozen `initialLockedValues` when known (else the current\n * `lockedValues`) prorated by `openQuantity / quantity` — mirroring\n * `leverageMarginOf` in `aggregate-metrics.ts`, which pairs the same frozen legs\n * with the full `quantity`. The contract releases margin as a position closes,\n * so the current legs alone would overstate leverage on a partially closed\n * child. Prorating is what keeps this basis aligned with `openNotional`: a\n * half-closed child has half its capital still at risk.\n */\nfunction openMarginOf(quote: UnifiedQuote): bigint {\n  if (quote.quantity <= 0n) return 0n;\n  const margin = quote.initialLockedValues ?? quote.lockedValues;\n  const legs = margin.cva + margin.lf + margin.partyAmm + margin.partyBmm;\n  return (legs * quote.openQuantity) / quote.quantity;\n}\n\n/**\n * Aggregated unrealized PnL for one group of quotes, valued at a single mark\n * price. Every amount is 18-decimal wei `bigint`.\n *\n * **Sign convention** — plain trader convention: a **positive** `upnl` means the\n * group is in profit. This is the same polarity as\n * {@link QuoteGroupFunding.netReceived}, so the two folds — which sit beside each\n * other — can be read, coloured, and added together without either being negated.\n *\n * **Completeness** — `upnl` is always the sum over the children that *could* be\n * valued, i.e. a lower bound in magnitude while some could not; it is never\n * suppressed to `0n`. Read {@link isComplete} to decide whether to trust it, and\n * treat `isComplete: false` as \"PnL unknown\", not as \"no PnL\". The same holds\n * for both percentages: they describe the valued subset only.\n *\n * **One market, one mark price.** Every built-in `QuoteGroupingStrategy` keys on\n * `symbolId`, so a group is single-market by construction. A custom `keyOf` that\n * mixes markets makes this fold meaningless — that is the caller's to avoid.\n */\nexport interface QuoteGroupUpnl {\n  /**\n   * Σ signed unrealized PnL across the group's valued children (wei).\n   * **Positive = the group is in profit.** A lower bound while\n   * {@link isComplete} is `false`.\n   */\n  upnl: bigint;\n  /**\n   * Σ `openQuantity × openedPrice` across the valued children (wei) — the\n   * at-entry position value {@link returnPercent} divides by. `0n` when nothing\n   * was valued.\n   */\n  openNotional: bigint;\n  /**\n   * Σ locked margin backing the still-open size of the valued children (wei) —\n   * the capital at risk {@link upnlPercent} divides by. Each child contributes\n   * every leg of its frozen `initialLockedValues` (else `lockedValues`) prorated\n   * by `openQuantity / quantity`. `0n` when nothing was valued, or when no valued\n   * child has locked collateral on record.\n   */\n  openMargin: bigint;\n  /**\n   * Unleveraged return — `upnl / openNotional × 100` as an 18-decimal\n   * fixed-point percent (`12.5% → 12_500000000000000000n`), signed with `upnl`.\n   * The return on the *position's* value, i.e. how far the market moved in the\n   * group's favour. Same convention as `GroupTpSlReturnEstimate.returnPercent`.\n   *\n   * `undefined` — never `0n` — when nothing was valued: `0n` is a real 0% return.\n   */\n  returnPercent?: bigint;\n  /**\n   * Leveraged return on capital — `upnl / openMargin × 100`, same fixed-point\n   * convention and sign. The group counterpart of `calculateQuoteUpnl`'s\n   * `upnlPercent`, and the figure to show beside the uPnL amount.\n   *\n   * Equals `returnPercent × leverage` whenever the group's children share one\n   * leverage; where they differ it stays the group's true return on deployed\n   * margin rather than a mean of per-child ratios.\n   *\n   * `undefined` when {@link openMargin} is `0n` — a group whose valued children\n   * carry no locked collateral has no capital base to return *on*.\n   */\n  upnlPercent?: bigint;\n  /** Number of children with open size that were valued against the mark price. */\n  valuedCount: number;\n  /**\n   * Number of children with open size whose open price is not settled yet, so\n   * their PnL is unknown. Resting orders and fully-closed children are not\n   * counted here — they have no unrealized PnL to be missing.\n   */\n  unvaluedCount: number;\n  /**\n   * `true` only when a mark price was given, at least one child was valued, and\n   * none was left unvalued — i.e. `upnl` is the group's complete unrealized PnL.\n   *\n   * A group with nothing to value (all-pending, all-closed, or empty) reports\n   * `false` with `upnl: 0n`, so a consumer can tell \"PnL unknown\" apart from\n   * \"no PnL\".\n   */\n  isComplete: boolean;\n}\n\n/**\n * Fold a group's child quotes into a single unrealized-PnL total at the current\n * mark price.\n *\n * Per child that is an active position with open size, using its **settled**\n * `openedPrice`:\n *\n * ```\n * delta  = markPrice − openedPrice\n * signed = positionType === SHORT ? −delta : delta\n * upnl  += openQuantity × signed / 1e18\n * ```\n *\n * and, over the same valued children, the two denominators a percentage needs:\n *\n * ```\n * openNotional += openQuantity × openedPrice / 1e18\n * openMargin   += lockedLegs × openQuantity / quantity\n * returnPercent = upnl / openNotional × 100     // unleveraged\n * upnlPercent   = upnl / openMargin   × 100     // return on capital\n * ```\n *\n * Behaviour:\n *\n * - **Resting orders contribute nothing and are not counted as unvalued.** A\n *   pending order has no unrealized PnL by definition; counting it would pin\n *   `isComplete` to `false` for any group holding one. Same for terminal rows.\n * - **Fully-closed children** (`openQuantity ≤ 0`) are skipped and not counted —\n *   their PnL is realized, not unrealized.\n * - **A position with no settled `openedPrice`** (an optimistic or just-anchored\n *   open) lands in `unvaluedCount` and contributes nothing.\n * - **No mark price** (`undefined`) yields zero amounts with `isComplete: false`.\n *   `markPrice: 0n` is a *real* price (a total loss on a long) — that is why the\n *   parameter is `bigint | undefined` and never a string parsed in here. Use\n *   {@link decimalPriceToWei}, which returns `undefined` rather than a fabricated\n *   `0n`, to convert a price feed's decimal string.\n * - **Both percentages are folded, not averaged.** `upnlPercent` divides the\n *   group's total uPnL by its total open margin, which is the group's actual\n *   return on deployed capital — deliberately not a notional-weighted mean of the\n *   children's individual percentages. The two coincide at a shared leverage; where\n *   leverages differ, a mean of ratios is not a return anyone earned. This also\n *   keeps the fold consistent with `aggregateGroupMetrics`, whose `leverage` is\n *   likewise `Σ notional / Σ margin`, so `upnlPercent ≈ returnPercent × leverage`.\n * - Exact `bigint`, order-independent, no IO. This deliberately differs from the\n *   per-quote `calculateQuoteUpnl`, which is decimal-string/float based. Each\n *   child's term is floored independently (max 1 wei of error per child), matching\n *   `estimateGroupTpSlReturn` and `calculateLiquidationPrice`.\n *\n * @param quotes - The group's child quotes (pass `group.quotes`).\n * @param markPrice - Current mark price in 18-decimal wei, or `undefined` before the first tick.\n * @returns The aggregated unrealized PnL for the group.\n *\n * @example\n * ```ts\n * const upnl = aggregateGroupUpnl(group.quotes, decimalPriceToWei(markPrice));\n * if (!upnl.isComplete) showSkeleton();\n * // positive = in profit; the percent is 18-decimal fixed point, so format it as wei\n * else render(upnl.upnl, upnl.upnlPercent);\n * ```\n */\nexport function aggregateGroupUpnl(quotes: readonly UnifiedQuote[], markPrice?: bigint): QuoteGroupUpnl {\n  let upnl = 0n;\n  let openNotional = 0n;\n  let openMargin = 0n;\n  let valuedCount = 0;\n  let unvaluedCount = 0;\n\n  for (const quote of quotes) {\n    /** Resting orders and terminal rows carry no unrealized PnL at all. */\n    if (!isActivePosition(quote)) continue;\n    /** Nothing open left: whatever this quote earned is realized, not unrealized. */\n    if (quote.openQuantity <= 0n) continue;\n\n    const openedPrice = settledOpenPriceOf(quote);\n    if (openedPrice === undefined || markPrice === undefined) {\n      unvaluedCount += 1;\n      continue;\n    }\n\n    const delta = markPrice - openedPrice;\n    const signed = quote.positionType === PositionType.SHORT ? -delta : delta;\n    upnl += mulWei(quote.openQuantity, signed);\n    openNotional += mulWei(quote.openQuantity, openedPrice);\n    openMargin += openMarginOf(quote);\n    valuedCount += 1;\n  }\n\n  return {\n    upnl,\n    openNotional,\n    openMargin,\n    returnPercent: sharePercent(upnl, openNotional),\n    upnlPercent: sharePercent(upnl, openMargin),\n    valuedCount,\n    unvaluedCount,\n    isComplete: valuedCount > 0 && unvaluedCount === 0,\n  };\n}\n"],"mappings":";;;;;;AAkBA,SAAS,EAAa,GAA6B;CACjD,IAAI,EAAM,YAAY,IAAI,OAAO;CACjC,IAAM,IAAS,EAAM,uBAAuB,EAAM;CAElD,QADa,EAAO,MAAM,EAAO,KAAK,EAAO,WAAW,EAAO,YAChD,EAAM,eAAgB,EAAM;AAC7C;AA+IA,SAAgB,EAAmB,GAAiC,GAAoC;CACtG,IAAI,IAAO,IACP,IAAe,IACf,IAAa,IACb,IAAc,GACd,IAAgB;CAEpB,KAAK,IAAM,KAAS,GAAQ;EAI1B,IAFI,CAAC,EAAiB,CAAK,KAEvB,EAAM,gBAAgB,IAAI;EAE9B,IAAM,IAAc,EAAmB,CAAK;EAC5C,IAAI,MAAgB,KAAA,KAAa,MAAc,KAAA,GAAW;GACxD,KAAiB;GACjB;EACF;EAEA,IAAM,IAAQ,IAAY,GACpB,IAAS,EAAM,iBAAiB,EAAa,QAAQ,CAAC,IAAQ;EAIpE,AAHA,KAAQ,EAAO,EAAM,cAAc,CAAM,GACzC,KAAgB,EAAO,EAAM,cAAc,CAAW,GACtD,KAAc,EAAa,CAAK,GAChC,KAAe;CACjB;CAEA,OAAO;EACL;EACA;EACA;EACA,eAAe,EAAa,GAAM,CAAY;EAC9C,aAAa,EAAa,GAAM,CAAU;EAC1C;EACA;EACA,YAAY,IAAc,KAAK,MAAkB;CACnD;AACF"}

package/dist/quotes/grouping/aggregate-metrics.d.ts

@@ -5,12 +5,15 @@ import { QuoteGroupMetrics } from './quote-group.js';
  * child quotes.
  *
  * - `openQuantity` / `quantity` are plain sums (wei).
- * - `notional = Σ(openQuantity × openPrice)`, rescaled to wei.
- * - `weightedOpenPrice = notionalₙᵤₘ / Σ openQuantity`, suppressed (`undefined`)
- *   when there is no open size or any child has an unsettled open price.
+ * - `initialNotional = Σ(quantity × (initialOpenedPrice ?? requestedOpenPrice))`,
+ *   rescaled to wei — the frozen at-open notional; partial closes do not shrink it.
+ * - `weightedOpenPrice = Σ(openQuantity × openPrice) / Σ openQuantity`, suppressed
+ *   (`undefined`) when there is no open size or any child has an unsettled open price.
  * - `lockedValues` sums each margin leg.
- * - `leverage = notional / (Σ cva + lf + partyAmm)`, as an 18-decimal fixed-point
- *   `bigint`, `undefined` when that margin is `0`.
+ * - `leverage = Σ(quantity × (requestedOpenPrice ?? openedPrice)) / Σ(cva + lf +
+ *   partyAmm + partyBmm)`, each child using its frozen `initialLockedValues` (else
+ *   `lockedValues`), as an 18-decimal fixed-point `bigint`; `undefined` when that
+ *   margin is `0`.
  *
  * Pure and order-independent. Empty input yields all-zero amounts with the
  * optional fields `undefined`.

package/dist/quotes/grouping/aggregate-metrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"aggregate-metrics.d.ts","sourceRoot":"","sources":["../../../src/quotes/grouping/aggregate-metrics.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAYvD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,iBAAiB,CA4CxF"}
+{"version":3,"file":"aggregate-metrics.d.ts","sourceRoot":"","sources":["../../../src/quotes/grouping/aggregate-metrics.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AAiBvD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,iBAAiB,CA6DxF"}

package/dist/quotes/grouping/aggregate-metrics.js

@@ -1,34 +1,36 @@
 import { WEI as e } from "../../shared/utils/wei.js";
-import { isActivePosition as t, isPendingOrder as n } from "./partition-quotes.js";
+import { hasUnsettledOpenPrice as t, leveragePriceOf as n, openPriceOf as r } from "../open-price.js";
+import { isActivePosition as i, isPendingOrder as a } from "./partition-quotes.js";
 //#region src/quotes/grouping/aggregate-metrics.ts
-function r(e) {
-	return e.openedPrice !== void 0 && e.openedPrice !== 0n ? e.openedPrice : e.requestedOpenPrice;
+function o(e) {
+	return e.initialOpenedPrice ?? e.requestedOpenPrice;
 }
-function i(e) {
-	return e.openedPrice === void 0 || e.openedPrice === 0n;
+function s(e) {
+	let t = e.initialLockedValues ?? e.lockedValues;
+	return t.cva + t.lf + t.partyAmm + t.partyBmm;
 }
-function a(a) {
-	let o = 0n, s = 0n, c = 0n, l = 0n, u = 0n, d = 0n, f = 0n, p = 0, m = 0, h = !1;
-	for (let e of a) o += e.quantity, s += e.openQuantity, c += e.openQuantity * r(e), l += e.lockedValues.cva, u += e.lockedValues.lf, d += e.lockedValues.partyAmm, f += e.lockedValues.partyBmm, i(e) && (h = !0), n(e) ? m += 1 : t(e) && (p += 1);
-	let g = {
-		cva: l,
-		lf: u,
-		partyAmm: d,
-		partyBmm: f
-	}, _ = c / e, v = l + u + d, y = s > 0n && !h ? c / s : void 0, b = v > 0n ? _ * e / v : void 0;
+function c(c) {
+	let l = 0n, u = 0n, d = 0n, f = 0n, p = 0n, m = 0n, h = 0n, g = 0n, _ = 0n, v = 0n, y = 0, b = 0, x = !1;
+	for (let e of c) l += e.quantity, u += e.openQuantity, d += e.openQuantity * r(e), f += e.quantity * o(e), p += e.quantity * n(e), m += s(e), h += e.lockedValues.cva, g += e.lockedValues.lf, _ += e.lockedValues.partyAmm, v += e.lockedValues.partyBmm, t(e) && (x = !0), a(e) ? b += 1 : i(e) && (y += 1);
+	let S = {
+		cva: h,
+		lf: g,
+		partyAmm: _,
+		partyBmm: v
+	}, C = f / e, w = u > 0n && !x ? d / u : void 0, T = m > 0n ? p / m : void 0;
 	return {
-		quoteCount: a.length,
-		openCount: p,
-		pendingCount: m,
-		quantity: o,
-		openQuantity: s,
-		weightedOpenPrice: y,
-		notional: _,
-		lockedValues: g,
-		leverage: b
+		quoteCount: c.length,
+		openCount: y,
+		pendingCount: b,
+		quantity: l,
+		openQuantity: u,
+		weightedOpenPrice: w,
+		initialNotional: C,
+		lockedValues: S,
+		leverage: T
 	};
 }
 //#endregion
-export { a as aggregateGroupMetrics };
+export { c as aggregateGroupMetrics };
 
 //# sourceMappingURL=aggregate-metrics.js.map

package/dist/quotes/grouping/aggregate-metrics.js.map

@@ -1 +1 @@
-{"version":3,"file":"aggregate-metrics.js","names":[],"sources":["../../../src/quotes/grouping/aggregate-metrics.ts"],"sourcesContent":["import { WEI } from \"../../shared/utils/wei\";\nimport type { LockedValues } from \"../../symmio-contracts/symmio/types\";\nimport type { UnifiedQuote } from \"../unified-quote\";\nimport { isActivePosition, isPendingOrder } from \"./partition-quotes\";\nimport type { QuoteGroupMetrics } from \"./quote-group\";\n\n/** A quote's open price for valuation: the settled `openedPrice`, else the requested one. */\nfunction openPriceOf(quote: UnifiedQuote): bigint {\n  return quote.openedPrice !== undefined && quote.openedPrice !== 0n ? quote.openedPrice : quote.requestedOpenPrice;\n}\n\n/** Whether a quote still lacks a settled open price (a pending or optimistic open). */\nfunction hasUnsettledOpenPrice(quote: UnifiedQuote): boolean {\n  return quote.openedPrice === undefined || quote.openedPrice === 0n;\n}\n\n/**\n * Compute the pure, price-independent {@link QuoteGroupMetrics} for a set of\n * child quotes.\n *\n * - `openQuantity` / `quantity` are plain sums (wei).\n * - `notional = Σ(openQuantity × openPrice)`, rescaled to wei.\n * - `weightedOpenPrice = notionalₙᵤₘ / Σ openQuantity`, suppressed (`undefined`)\n *   when there is no open size or any child has an unsettled open price.\n * - `lockedValues` sums each margin leg.\n * - `leverage = notional / (Σ cva + lf + partyAmm)`, as an 18-decimal fixed-point\n *   `bigint`, `undefined` when that margin is `0`.\n *\n * Pure and order-independent. Empty input yields all-zero amounts with the\n * optional fields `undefined`.\n *\n * @param quotes - The group's child quotes.\n * @returns The aggregated metrics.\n */\nexport function aggregateGroupMetrics(quotes: readonly UnifiedQuote[]): QuoteGroupMetrics {\n  let quantity = 0n;\n  let openQuantity = 0n;\n  /** Σ(openQuantity × openPrice), scaled by `WEI²` until the final rescale. */\n  let notionalNumerator = 0n;\n  let cva = 0n;\n  let lf = 0n;\n  let partyAmm = 0n;\n  let partyBmm = 0n;\n  let openCount = 0;\n  let pendingCount = 0;\n  let anyUnsettledOpenPrice = false;\n\n  for (const quote of quotes) {\n    quantity += quote.quantity;\n    openQuantity += quote.openQuantity;\n    notionalNumerator += quote.openQuantity * openPriceOf(quote);\n    cva += quote.lockedValues.cva;\n    lf += quote.lockedValues.lf;\n    partyAmm += quote.lockedValues.partyAmm;\n    partyBmm += quote.lockedValues.partyBmm;\n    if (hasUnsettledOpenPrice(quote)) anyUnsettledOpenPrice = true;\n    if (isPendingOrder(quote)) pendingCount += 1;\n    else if (isActivePosition(quote)) openCount += 1;\n  }\n\n  const lockedValues: LockedValues = { cva, lf, partyAmm, partyBmm };\n  const notional = notionalNumerator / WEI;\n  const partyAMargin = cva + lf + partyAmm;\n\n  const weightedOpenPrice = openQuantity > 0n && !anyUnsettledOpenPrice ? notionalNumerator / openQuantity : undefined;\n  const leverage = partyAMargin > 0n ? (notional * WEI) / partyAMargin : undefined;\n\n  return {\n    quoteCount: quotes.length,\n    openCount,\n    pendingCount,\n    quantity,\n    openQuantity,\n    weightedOpenPrice,\n    notional,\n    lockedValues,\n    leverage,\n  };\n}\n"],"mappings":";;;AAOA,SAAS,EAAY,GAA6B;CAChD,OAAO,EAAM,gBAAgB,KAAA,KAAa,EAAM,gBAAgB,KAAK,EAAM,cAAc,EAAM;AACjG;AAGA,SAAS,EAAsB,GAA8B;CAC3D,OAAO,EAAM,gBAAgB,KAAA,KAAa,EAAM,gBAAgB;AAClE;AAoBA,SAAgB,EAAsB,GAAoD;CACxF,IAAI,IAAW,IACX,IAAe,IAEf,IAAoB,IACpB,IAAM,IACN,IAAK,IACL,IAAW,IACX,IAAW,IACX,IAAY,GACZ,IAAe,GACf,IAAwB;CAE5B,KAAK,IAAM,KAAS,GASlB,AARA,KAAY,EAAM,UAClB,KAAgB,EAAM,cACtB,KAAqB,EAAM,eAAe,EAAY,CAAK,GAC3D,KAAO,EAAM,aAAa,KAC1B,KAAM,EAAM,aAAa,IACzB,KAAY,EAAM,aAAa,UAC/B,KAAY,EAAM,aAAa,UAC3B,EAAsB,CAAK,MAAG,IAAwB,KACtD,EAAe,CAAK,IAAG,KAAgB,IAClC,EAAiB,CAAK,MAAG,KAAa;CAGjD,IAAM,IAA6B;EAAE;EAAK;EAAI;EAAU;CAAS,GAC3D,IAAW,IAAoB,GAC/B,IAAe,IAAM,IAAK,GAE1B,IAAoB,IAAe,MAAM,CAAC,IAAwB,IAAoB,IAAe,KAAA,GACrG,IAAW,IAAe,KAAM,IAAW,IAAO,IAAe,KAAA;CAEvE,OAAO;EACL,YAAY,EAAO;EACnB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF;AACF"}
+{"version":3,"file":"aggregate-metrics.js","names":[],"sources":["../../../src/quotes/grouping/aggregate-metrics.ts"],"sourcesContent":["import { WEI } from \"../../shared/utils/wei\";\nimport type { LockedValues } from \"../../symmio-contracts/symmio/types\";\nimport { hasUnsettledOpenPrice, leveragePriceOf, openPriceOf } from \"../open-price\";\nimport type { UnifiedQuote } from \"../unified-quote\";\nimport { isActivePosition, isPendingOrder } from \"./partition-quotes\";\nimport type { QuoteGroupMetrics } from \"./quote-group\";\n\n/** A quote's price for the frozen at-open notional: `initialOpenedPrice`, else the requested one. */\nfunction initialNotionalPriceOf(quote: UnifiedQuote): bigint {\n  return quote.initialOpenedPrice ?? quote.requestedOpenPrice;\n}\n\n/**\n * A quote's locked-margin basis for leverage: every leg (`cva + lf + partyAmm +\n * partyBmm`) of the frozen `initialLockedValues` when known, else of the current\n * `lockedValues`.\n */\nfunction leverageMarginOf(quote: UnifiedQuote): bigint {\n  const margin = quote.initialLockedValues ?? quote.lockedValues;\n  return margin.cva + margin.lf + margin.partyAmm + margin.partyBmm;\n}\n\n/**\n * Compute the pure, price-independent {@link QuoteGroupMetrics} for a set of\n * child quotes.\n *\n * - `openQuantity` / `quantity` are plain sums (wei).\n * - `initialNotional = Σ(quantity × (initialOpenedPrice ?? requestedOpenPrice))`,\n *   rescaled to wei — the frozen at-open notional; partial closes do not shrink it.\n * - `weightedOpenPrice = Σ(openQuantity × openPrice) / Σ openQuantity`, suppressed\n *   (`undefined`) when there is no open size or any child has an unsettled open price.\n * - `lockedValues` sums each margin leg.\n * - `leverage = Σ(quantity × (requestedOpenPrice ?? openedPrice)) / Σ(cva + lf +\n *   partyAmm + partyBmm)`, each child using its frozen `initialLockedValues` (else\n *   `lockedValues`), as an 18-decimal fixed-point `bigint`; `undefined` when that\n *   margin is `0`.\n *\n * Pure and order-independent. Empty input yields all-zero amounts with the\n * optional fields `undefined`.\n *\n * @param quotes - The group's child quotes.\n * @returns The aggregated metrics.\n */\nexport function aggregateGroupMetrics(quotes: readonly UnifiedQuote[]): QuoteGroupMetrics {\n  let quantity = 0n;\n  let openQuantity = 0n;\n  /**\n   * Σ(openQuantity × openPrice), scaled by `WEI²`; feeds `weightedOpenPrice` only.\n   *\n   * **Deliberately not `mulWei`.** Every other `quantity × price` fold in the SDK\n   * rescales to wei per item, but this one must stay at `WEI²`: the divide at the\n   * bottom is by `openQuantity` (wei), not by `WEI`, and it is that surviving\n   * factor which lands `weightedOpenPrice` back on wei scale. Truncating here\n   * would return a price 1e18 too small.\n   */\n  let notionalNumerator = 0n;\n  /** Σ(quantity × (initialOpenedPrice ?? requestedOpenPrice)), scaled by `WEI²` until the final rescale. */\n  let initialNotionalNumerator = 0n;\n  /** Σ(quantity × (requestedOpenPrice ?? openedPrice)), scaled by `WEI²` until the final divide. */\n  let leverageNumerator = 0n;\n  /** Σ of each child's frozen (initial-preferred) locked-margin legs, wei. */\n  let leverageMargin = 0n;\n  let cva = 0n;\n  let lf = 0n;\n  let partyAmm = 0n;\n  let partyBmm = 0n;\n  let openCount = 0;\n  let pendingCount = 0;\n  let anyUnsettledOpenPrice = false;\n\n  for (const quote of quotes) {\n    quantity += quote.quantity;\n    openQuantity += quote.openQuantity;\n    notionalNumerator += quote.openQuantity * openPriceOf(quote);\n    initialNotionalNumerator += quote.quantity * initialNotionalPriceOf(quote);\n    leverageNumerator += quote.quantity * leveragePriceOf(quote);\n    leverageMargin += leverageMarginOf(quote);\n    cva += quote.lockedValues.cva;\n    lf += quote.lockedValues.lf;\n    partyAmm += quote.lockedValues.partyAmm;\n    partyBmm += quote.lockedValues.partyBmm;\n    if (hasUnsettledOpenPrice(quote)) anyUnsettledOpenPrice = true;\n    if (isPendingOrder(quote)) pendingCount += 1;\n    else if (isActivePosition(quote)) openCount += 1;\n  }\n\n  const lockedValues: LockedValues = { cva, lf, partyAmm, partyBmm };\n  const initialNotional = initialNotionalNumerator / WEI;\n\n  const weightedOpenPrice = openQuantity > 0n && !anyUnsettledOpenPrice ? notionalNumerator / openQuantity : undefined;\n  /** `leverageNumerator` is scaled by WEI²; dividing by the WEI-scaled margin yields an 18-decimal ratio. */\n  const leverage = leverageMargin > 0n ? leverageNumerator / leverageMargin : undefined;\n\n  return {\n    quoteCount: quotes.length,\n    openCount,\n    pendingCount,\n    quantity,\n    openQuantity,\n    weightedOpenPrice,\n    initialNotional,\n    lockedValues,\n    leverage,\n  };\n}\n"],"mappings":";;;;AAQA,SAAS,EAAuB,GAA6B;CAC3D,OAAO,EAAM,sBAAsB,EAAM;AAC3C;AAOA,SAAS,EAAiB,GAA6B;CACrD,IAAM,IAAS,EAAM,uBAAuB,EAAM;CAClD,OAAO,EAAO,MAAM,EAAO,KAAK,EAAO,WAAW,EAAO;AAC3D;AAuBA,SAAgB,EAAsB,GAAoD;CACxF,IAAI,IAAW,IACX,IAAe,IAUf,IAAoB,IAEpB,IAA2B,IAE3B,IAAoB,IAEpB,IAAiB,IACjB,IAAM,IACN,IAAK,IACL,IAAW,IACX,IAAW,IACX,IAAY,GACZ,IAAe,GACf,IAAwB;CAE5B,KAAK,IAAM,KAAS,GAYlB,AAXA,KAAY,EAAM,UAClB,KAAgB,EAAM,cACtB,KAAqB,EAAM,eAAe,EAAY,CAAK,GAC3D,KAA4B,EAAM,WAAW,EAAuB,CAAK,GACzE,KAAqB,EAAM,WAAW,EAAgB,CAAK,GAC3D,KAAkB,EAAiB,CAAK,GACxC,KAAO,EAAM,aAAa,KAC1B,KAAM,EAAM,aAAa,IACzB,KAAY,EAAM,aAAa,UAC/B,KAAY,EAAM,aAAa,UAC3B,EAAsB,CAAK,MAAG,IAAwB,KACtD,EAAe,CAAK,IAAG,KAAgB,IAClC,EAAiB,CAAK,MAAG,KAAa;CAGjD,IAAM,IAA6B;EAAE;EAAK;EAAI;EAAU;CAAS,GAC3D,IAAkB,IAA2B,GAE7C,IAAoB,IAAe,MAAM,CAAC,IAAwB,IAAoB,IAAe,KAAA,GAErG,IAAW,IAAiB,KAAK,IAAoB,IAAiB,KAAA;CAE5E,OAAO;EACL,YAAY,EAAO;EACnB;EACA;EACA;EACA;EACA;EACA;EACA;EACA;CACF;AACF"}

package/dist/quotes/grouping/group-quotes.d.ts

@@ -18,10 +18,19 @@ export interface GroupQuotesOptions {
  * resolved Virtual Account, an `isAggregate` flag, and pure
  * {@link QuoteGroupMetrics}. Groups are returned newest-first by default.
  *
+ * Grouped positions are a `MARKET_DIRECTION`-only feature: it is the one
+ * isolation where a market + side cohort is a real on-chain unit (one Virtual
+ * Account per market + direction), so it is the only
+ * {@link SubAccountIsolationType} this accepts. To fold on another dimension,
+ * pass an explicit `{ keyOf }` — `keyQuoteByMarket` and `keyQuotePerQuote` cover
+ * the common cases.
+ *
  * @param quotes - The quotes to group.
- * @param strategy - A {@link SubAccountIsolationType} or a custom `{ keyOf }`.
+ * @param strategy - `SubAccountIsolationType.MARKET_DIRECTION` or a custom `{ keyOf }`.
  * @param options - Optional group ordering override.
  * @returns The groups.
+ * @throws {SymmError} `UNSUPPORTED_GROUPING_ISOLATION` when `strategy` is an
+ *   isolation type other than `MARKET_DIRECTION`.
  *
  * @example
  * ```ts

package/dist/quotes/grouping/group-quotes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"group-quotes.d.ts","sourceRoot":"","sources":["../../../src/quotes/grouping/group-quotes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGrD,OAAO,KAAK,EAAE,UAAU,EAAgB,qBAAqB,EAAE,MAAM,eAAe,CAAC;AA+BrF,uCAAuC;AACvC,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,KAAK,MAAM,CAAC;CACjD;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,SAAS,YAAY,EAAE,EAC/B,QAAQ,EAAE,qBAAqB,EAC/B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,UAAU,EAAE,CA0Bd"}
+{"version":3,"file":"group-quotes.d.ts","sourceRoot":"","sources":["../../../src/quotes/grouping/group-quotes.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAGrD,OAAO,KAAK,EAAE,UAAU,EAAgB,qBAAqB,EAAE,MAAM,eAAe,CAAC;AA+BrF,uCAAuC;AACvC,MAAM,WAAW,kBAAkB;IACjC;;;;OAIG;IACH,IAAI,CAAC,EAAE,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,KAAK,MAAM,CAAC;CACjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,SAAS,YAAY,EAAE,EAC/B,QAAQ,EAAE,qBAAqB,EAC/B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,UAAU,EAAE,CA0Bd"}

package/dist/quotes/grouping/group-quotes.js.map

@@ -1 +1 @@
-{"version":3,"file":"group-quotes.js","names":[],"sources":["../../../src/quotes/grouping/group-quotes.ts"],"sourcesContent":["import type { Address } from \"viem\";\nimport type { UnifiedQuote } from \"../unified-quote\";\nimport { aggregateGroupMetrics } from \"./aggregate-metrics\";\nimport { resolveQuoteGroupingStrategy } from \"./group-strategy\";\nimport type { QuoteGroup, QuoteGroupBy, QuoteGroupingStrategy } from \"./quote-group\";\n\n/** Best-known ordering timestamp for a quote — last status change, else creation. */\nfunction orderingTimestamp(quote: UnifiedQuote): bigint {\n  return quote.statusModifyTimestamp ?? quote.createTimestamp ?? 0n;\n}\n\n/** Newest-first by ordering timestamp, breaking ties by `key` for a stable sort. */\nfunction byNewestQuote(a: UnifiedQuote, b: UnifiedQuote): number {\n  const ta = orderingTimestamp(a);\n  const tb = orderingTimestamp(b);\n  if (ta !== tb) return tb > ta ? 1 : -1;\n  return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;\n}\n\n/** Default group order: newest group first (by its newest child), ties broken by `key`. */\nfunction byNewestGroup(a: QuoteGroup, b: QuoteGroup): number {\n  const ta = a.quotes[0] ? orderingTimestamp(a.quotes[0]) : 0n;\n  const tb = b.quotes[0] ? orderingTimestamp(b.quotes[0]) : 0n;\n  if (ta !== tb) return tb > ta ? 1 : -1;\n  return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;\n}\n\n/** The VA a group resolves to: from its first on-chain child, else any child that carries one. */\nfunction resolveGroupVaAddress(quotes: readonly UnifiedQuote[]): Address | undefined {\n  return (\n    quotes.find((quote) => quote.origin === \"onchain\" && quote.vaAddress)?.vaAddress ??\n    quotes.find((quote) => quote.vaAddress)?.vaAddress\n  );\n}\n\n/** Options for {@link groupQuotes}. */\nexport interface GroupQuotesOptions {\n  /**\n   * Comparator for the returned groups. Defaults to newest-group-first (by each\n   * group's newest child). Child quotes within a group are always sorted\n   * newest-first regardless.\n   */\n  sort?: (a: QuoteGroup, b: QuoteGroup) => number;\n}\n\n/**\n * Fold quotes into {@link QuoteGroup}s under a {@link QuoteGroupingStrategy}.\n *\n * Pure and deterministic: it groups exactly the array it is given (partition into\n * positions vs pending orders first with `partitionQuotes` if you only want to\n * group open positions). Each group carries its child quotes (newest first), its\n * resolved Virtual Account, an `isAggregate` flag, and pure\n * {@link QuoteGroupMetrics}. Groups are returned newest-first by default.\n *\n * @param quotes - The quotes to group.\n * @param strategy - A {@link SubAccountIsolationType} or a custom `{ keyOf }`.\n * @param options - Optional group ordering override.\n * @returns The groups.\n *\n * @example\n * ```ts\n * const { positions } = partitionQuotes(quotes);\n * const groups = groupQuotes(positions, SubAccountIsolationType.MARKET_DIRECTION);\n * // groups[0].metrics.openQuantity, groups[0].metrics.weightedOpenPrice, …\n * ```\n */\nexport function groupQuotes(\n  quotes: readonly UnifiedQuote[],\n  strategy: QuoteGroupingStrategy,\n  options?: GroupQuotesOptions,\n): QuoteGroup[] {\n  const keyOf = resolveQuoteGroupingStrategy(strategy);\n\n  /** Insertion-ordered buckets so groups are built deterministically before sorting. */\n  const buckets = new Map<string, { by: QuoteGroupBy; quotes: UnifiedQuote[] }>();\n  for (const quote of quotes) {\n    const { key, by } = keyOf(quote);\n    const bucket = buckets.get(key);\n    if (bucket) bucket.quotes.push(quote);\n    else buckets.set(key, { by, quotes: [quote] });\n  }\n\n  const groups: QuoteGroup[] = [];\n  for (const [key, bucket] of buckets) {\n    const children = bucket.quotes.sort(byNewestQuote);\n    groups.push({\n      key,\n      by: bucket.by,\n      vaAddress: resolveGroupVaAddress(children),\n      quotes: children,\n      isAggregate: children.length > 1,\n      metrics: aggregateGroupMetrics(children),\n    });\n  }\n\n  return groups.sort(options?.sort ?? byNewestGroup);\n}\n"],"mappings":";;;AAOA,SAAS,EAAkB,GAA6B;CACtD,OAAO,EAAM,yBAAyB,EAAM,mBAAmB;AACjE;AAGA,SAAS,EAAc,GAAiB,GAAyB;CAC/D,IAAM,IAAK,EAAkB,CAAC,GACxB,IAAK,EAAkB,CAAC;CAE9B,OADI,MAAO,IACJ,EAAE,MAAM,EAAE,MAAM,KAAK,IAAE,MAAM,EAAE,OADhB,IAAK,IAAK,IAAI;AAEtC;AAGA,SAAS,EAAc,GAAe,GAAuB;CAC3D,IAAM,IAAK,EAAE,OAAO,KAAK,EAAkB,EAAE,OAAO,EAAE,IAAI,IACpD,IAAK,EAAE,OAAO,KAAK,EAAkB,EAAE,OAAO,EAAE,IAAI;CAE1D,OADI,MAAO,IACJ,EAAE,MAAM,EAAE,MAAM,KAAK,IAAE,MAAM,EAAE,OADhB,IAAK,IAAK,IAAI;AAEtC;AAGA,SAAS,EAAsB,GAAsD;CACnF,OACE,EAAO,MAAM,MAAU,EAAM,WAAW,aAAa,EAAM,SAAS,GAAG,aACvE,EAAO,MAAM,MAAU,EAAM,SAAS,GAAG;AAE7C;AAiCA,SAAgB,EACd,GACA,GACA,GACc;CACd,IAAM,IAAQ,EAA6B,CAAQ,GAG7C,oBAAU,IAAI,IAA0D;CAC9E,KAAK,IAAM,KAAS,GAAQ;EAC1B,IAAM,EAAE,QAAK,UAAO,EAAM,CAAK,GACzB,IAAS,EAAQ,IAAI,CAAG;EAC9B,AAAI,IAAQ,EAAO,OAAO,KAAK,CAAK,IAC/B,EAAQ,IAAI,GAAK;GAAE;GAAI,QAAQ,CAAC,CAAK;EAAE,CAAC;CAC/C;CAEA,IAAM,IAAuB,CAAC;CAC9B,KAAK,IAAM,CAAC,GAAK,MAAW,GAAS;EACnC,IAAM,IAAW,EAAO,OAAO,KAAK,CAAa;EACjD,EAAO,KAAK;GACV;GACA,IAAI,EAAO;GACX,WAAW,EAAsB,CAAQ;GACzC,QAAQ;GACR,aAAa,EAAS,SAAS;GAC/B,SAAS,EAAsB,CAAQ;EACzC,CAAC;CACH;CAEA,OAAO,EAAO,KAAK,GAAS,QAAQ,CAAa;AACnD"}
+{"version":3,"file":"group-quotes.js","names":[],"sources":["../../../src/quotes/grouping/group-quotes.ts"],"sourcesContent":["import type { Address } from \"viem\";\nimport type { UnifiedQuote } from \"../unified-quote\";\nimport { aggregateGroupMetrics } from \"./aggregate-metrics\";\nimport { resolveQuoteGroupingStrategy } from \"./group-strategy\";\nimport type { QuoteGroup, QuoteGroupBy, QuoteGroupingStrategy } from \"./quote-group\";\n\n/** Best-known ordering timestamp for a quote — last status change, else creation. */\nfunction orderingTimestamp(quote: UnifiedQuote): bigint {\n  return quote.statusModifyTimestamp ?? quote.createTimestamp ?? 0n;\n}\n\n/** Newest-first by ordering timestamp, breaking ties by `key` for a stable sort. */\nfunction byNewestQuote(a: UnifiedQuote, b: UnifiedQuote): number {\n  const ta = orderingTimestamp(a);\n  const tb = orderingTimestamp(b);\n  if (ta !== tb) return tb > ta ? 1 : -1;\n  return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;\n}\n\n/** Default group order: newest group first (by its newest child), ties broken by `key`. */\nfunction byNewestGroup(a: QuoteGroup, b: QuoteGroup): number {\n  const ta = a.quotes[0] ? orderingTimestamp(a.quotes[0]) : 0n;\n  const tb = b.quotes[0] ? orderingTimestamp(b.quotes[0]) : 0n;\n  if (ta !== tb) return tb > ta ? 1 : -1;\n  return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;\n}\n\n/** The VA a group resolves to: from its first on-chain child, else any child that carries one. */\nfunction resolveGroupVaAddress(quotes: readonly UnifiedQuote[]): Address | undefined {\n  return (\n    quotes.find((quote) => quote.origin === \"onchain\" && quote.vaAddress)?.vaAddress ??\n    quotes.find((quote) => quote.vaAddress)?.vaAddress\n  );\n}\n\n/** Options for {@link groupQuotes}. */\nexport interface GroupQuotesOptions {\n  /**\n   * Comparator for the returned groups. Defaults to newest-group-first (by each\n   * group's newest child). Child quotes within a group are always sorted\n   * newest-first regardless.\n   */\n  sort?: (a: QuoteGroup, b: QuoteGroup) => number;\n}\n\n/**\n * Fold quotes into {@link QuoteGroup}s under a {@link QuoteGroupingStrategy}.\n *\n * Pure and deterministic: it groups exactly the array it is given (partition into\n * positions vs pending orders first with `partitionQuotes` if you only want to\n * group open positions). Each group carries its child quotes (newest first), its\n * resolved Virtual Account, an `isAggregate` flag, and pure\n * {@link QuoteGroupMetrics}. Groups are returned newest-first by default.\n *\n * Grouped positions are a `MARKET_DIRECTION`-only feature: it is the one\n * isolation where a market + side cohort is a real on-chain unit (one Virtual\n * Account per market + direction), so it is the only\n * {@link SubAccountIsolationType} this accepts. To fold on another dimension,\n * pass an explicit `{ keyOf }` — `keyQuoteByMarket` and `keyQuotePerQuote` cover\n * the common cases.\n *\n * @param quotes - The quotes to group.\n * @param strategy - `SubAccountIsolationType.MARKET_DIRECTION` or a custom `{ keyOf }`.\n * @param options - Optional group ordering override.\n * @returns The groups.\n * @throws {SymmError} `UNSUPPORTED_GROUPING_ISOLATION` when `strategy` is an\n *   isolation type other than `MARKET_DIRECTION`.\n *\n * @example\n * ```ts\n * const { positions } = partitionQuotes(quotes);\n * const groups = groupQuotes(positions, SubAccountIsolationType.MARKET_DIRECTION);\n * // groups[0].metrics.openQuantity, groups[0].metrics.weightedOpenPrice, …\n * ```\n */\nexport function groupQuotes(\n  quotes: readonly UnifiedQuote[],\n  strategy: QuoteGroupingStrategy,\n  options?: GroupQuotesOptions,\n): QuoteGroup[] {\n  const keyOf = resolveQuoteGroupingStrategy(strategy);\n\n  /** Insertion-ordered buckets so groups are built deterministically before sorting. */\n  const buckets = new Map<string, { by: QuoteGroupBy; quotes: UnifiedQuote[] }>();\n  for (const quote of quotes) {\n    const { key, by } = keyOf(quote);\n    const bucket = buckets.get(key);\n    if (bucket) bucket.quotes.push(quote);\n    else buckets.set(key, { by, quotes: [quote] });\n  }\n\n  const groups: QuoteGroup[] = [];\n  for (const [key, bucket] of buckets) {\n    const children = bucket.quotes.sort(byNewestQuote);\n    groups.push({\n      key,\n      by: bucket.by,\n      vaAddress: resolveGroupVaAddress(children),\n      quotes: children,\n      isAggregate: children.length > 1,\n      metrics: aggregateGroupMetrics(children),\n    });\n  }\n\n  return groups.sort(options?.sort ?? byNewestGroup);\n}\n"],"mappings":";;;AAOA,SAAS,EAAkB,GAA6B;CACtD,OAAO,EAAM,yBAAyB,EAAM,mBAAmB;AACjE;AAGA,SAAS,EAAc,GAAiB,GAAyB;CAC/D,IAAM,IAAK,EAAkB,CAAC,GACxB,IAAK,EAAkB,CAAC;CAE9B,OADI,MAAO,IACJ,EAAE,MAAM,EAAE,MAAM,KAAK,IAAE,MAAM,EAAE,OADhB,IAAK,IAAK,IAAI;AAEtC;AAGA,SAAS,EAAc,GAAe,GAAuB;CAC3D,IAAM,IAAK,EAAE,OAAO,KAAK,EAAkB,EAAE,OAAO,EAAE,IAAI,IACpD,IAAK,EAAE,OAAO,KAAK,EAAkB,EAAE,OAAO,EAAE,IAAI;CAE1D,OADI,MAAO,IACJ,EAAE,MAAM,EAAE,MAAM,KAAK,IAAE,MAAM,EAAE,OADhB,IAAK,IAAK,IAAI;AAEtC;AAGA,SAAS,EAAsB,GAAsD;CACnF,OACE,EAAO,MAAM,MAAU,EAAM,WAAW,aAAa,EAAM,SAAS,GAAG,aACvE,EAAO,MAAM,MAAU,EAAM,SAAS,GAAG;AAE7C;AA0CA,SAAgB,EACd,GACA,GACA,GACc;CACd,IAAM,IAAQ,EAA6B,CAAQ,GAG7C,oBAAU,IAAI,IAA0D;CAC9E,KAAK,IAAM,KAAS,GAAQ;EAC1B,IAAM,EAAE,QAAK,UAAO,EAAM,CAAK,GACzB,IAAS,EAAQ,IAAI,CAAG;EAC9B,AAAI,IAAQ,EAAO,OAAO,KAAK,CAAK,IAC/B,EAAQ,IAAI,GAAK;GAAE;GAAI,QAAQ,CAAC,CAAK;EAAE,CAAC;CAC/C;CAEA,IAAM,IAAuB,CAAC;CAC9B,KAAK,IAAM,CAAC,GAAK,MAAW,GAAS;EACnC,IAAM,IAAW,EAAO,OAAO,KAAK,CAAa;EACjD,EAAO,KAAK;GACV;GACA,IAAI,EAAO;GACX,WAAW,EAAsB,CAAQ;GACzC,QAAQ;GACR,aAAa,EAAS,SAAS;GAC/B,SAAS,EAAsB,CAAQ;EACzC,CAAC;CACH;CAEA,OAAO,EAAO,KAAK,GAAS,QAAQ,CAAa;AACnD"}

package/dist/quotes/grouping/group-strategy.d.ts

@@ -1,17 +1,96 @@
-import { QuoteGroupingStrategy, QuoteGroupKeyFn } from './quote-group.js';
+import { SubAccountIsolationType } from '../../symmio-contracts/account-layer/types.js';
+import { UnifiedQuote } from '../unified-quote.js';
+import { QuoteGroupingStrategy, QuoteGroupKey, QuoteGroupKeyFn } from './quote-group.js';
+/**
+ * Key a quote by market only, collapsing both sides of a market into one group.
+ *
+ * Not reachable through a {@link SubAccountIsolationType} — grouped positions are
+ * defined for `MARKET_DIRECTION` only (see {@link supportsQuoteGrouping}). Pass it
+ * as an explicit `{ keyOf }` when you deliberately want market-wide folding and
+ * accept that the aggregated metrics mix longs and shorts.
+ *
+ * @param quote - The quote to place into a group.
+ * @returns The group key `m:<symbolId>` and its `{ symbolId }` dimension.
+ *
+ * @example
+ * ```ts
+ * const groups = groupQuotes(positions, { keyOf: keyQuoteByMarket });
+ * ```
+ */
+export declare function keyQuoteByMarket(quote: UnifiedQuote): QuoteGroupKey;
+/**
+ * Key a quote by its own identity, producing one single-child group per quote —
+ * grouping with no aggregation.
+ *
+ * Not reachable through a {@link SubAccountIsolationType} (see
+ * {@link supportsQuoteGrouping}). Pass it as an explicit `{ keyOf }` to render
+ * ungrouped positions through the same `QuoteGroup` shape the grouped UI uses.
+ *
+ * @param quote - The quote to place into a group.
+ * @returns The quote's own `key` and its full `{ symbolId, positionType, vaAddress }` identity.
+ *
+ * @example
+ * ```ts
+ * const groups = groupQuotes(positions, { keyOf: keyQuotePerQuote });
+ * // every group has isAggregate === false
+ * ```
+ */
+export declare function keyQuotePerQuote(quote: UnifiedQuote): QuoteGroupKey;
+/**
+ * Whether grouped positions are defined for an isolation type.
+ *
+ * Only `MARKET_DIRECTION` groups. It is the one isolation where a market + side
+ * cohort is a real on-chain unit — the AccountLayer allocates one Virtual Account
+ * per market + direction — so folding that cohort's quotes into a single row
+ * aggregates values that genuinely belong to the same position. Under `MARKET`,
+ * `POSITION`, or `CUSTOM` isolation the same fold would merge quotes the protocol
+ * keeps apart (or that never shared a VA at all), producing totals, leverage, and
+ * group-level actions that do not correspond to anything on-chain.
+ *
+ * @param isolationType - The subaccount's on-chain isolation type.
+ * @returns `true` only for `MARKET_DIRECTION`.
+ *
+ * @example
+ * ```ts
+ * if (supportsQuoteGrouping(subAccount.isolationType)) {
+ *   const groups = groupQuotes(positions, subAccount.isolationType);
+ * }
+ * ```
+ */
+export declare function supportsQuoteGrouping(isolationType: SubAccountIsolationType): boolean;
+/**
+ * Throw unless grouped positions are defined for `isolationType`.
+ *
+ * The throwing counterpart of {@link supportsQuoteGrouping}, for call sites that
+ * want to fail loudly rather than branch.
+ *
+ * @param isolationType - The subaccount's on-chain isolation type.
+ * @throws {SymmError} `validation` / `UNSUPPORTED_GROUPING_ISOLATION` for any type
+ *   other than `MARKET_DIRECTION`.
+ *
+ * @example
+ * ```ts
+ * assertQuoteGroupingSupported(subAccount.isolationType);
+ * const groups = groupQuotes(positions, subAccount.isolationType);
+ * ```
+ */
+export declare function assertQuoteGroupingSupported(isolationType: SubAccountIsolationType): void;
 /**
  * Resolve a {@link QuoteGroupingStrategy} to the {@link QuoteGroupKeyFn} that
  * places each quote into its group.
  *
- * A `{ keyOf }` object is returned as-is. A {@link SubAccountIsolationType} maps
- * to its built-in strategy: `MARKET` groups by market, `MARKET_DIRECTION` by
- * market + side, and `POSITION` / `CUSTOM` produce one group per quote (custom
- * isolation places trades in manually-managed VAs, so consumers that want
- * VA-based grouping pass their own `keyOf`).
+ * A `{ keyOf }` object is returned as-is. The only {@link SubAccountIsolationType}
+ * accepted is `MARKET_DIRECTION` (keys by market + side) — every other isolation
+ * type is rejected, because grouped positions are not defined for it (see
+ * {@link supportsQuoteGrouping}). To fold on another dimension, pass an explicit
+ * `{ keyOf }`; {@link keyQuoteByMarket} and {@link keyQuotePerQuote} ship as
+ * ready-made key functions.
  *
  * @param strategy - The grouping strategy.
  * @returns The key function for {@link groupQuotes}.
- * @throws {SymmError} when given an unknown isolation type.
+ * @throws {SymmError} `UNSUPPORTED_GROUPING_ISOLATION` for `MARKET` / `POSITION` /
+ *   `CUSTOM`, or `UNKNOWN_GROUPING_STRATEGY` for a value that is not an isolation
+ *   type at all.
  */
 export declare function resolveQuoteGroupingStrategy(strategy: QuoteGroupingStrategy): QuoteGroupKeyFn;
 //# sourceMappingURL=group-strategy.d.ts.map

package/dist/quotes/grouping/group-strategy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"group-strategy.d.ts","sourceRoot":"","sources":["../../../src/quotes/grouping/group-strategy.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAiB,eAAe,EAAE,MAAM,eAAe,CAAC;AA0B3F;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,qBAAqB,GAAG,eAAe,CAiB7F"}
+{"version":3,"file":"group-strategy.d.ts","sourceRoot":"","sources":["../../../src/quotes/grouping/group-strategy.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,4CAA4C,CAAC;AACrF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,qBAAqB,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAU3F;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,aAAa,CAEnE;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,aAAa,CAKnE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,aAAa,EAAE,uBAAuB,GAAG,OAAO,CAErF;AAYD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,4BAA4B,CAAC,aAAa,EAAE,uBAAuB,GAAG,IAAI,CAGzF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,qBAAqB,GAAG,eAAe,CAW7F"}

package/dist/quotes/grouping/group-strategy.js

@@ -2,12 +2,6 @@ import { SymmError as e } from "../../shared/errors/symm-error.js";
 import { SubAccountIsolationType as t } from "../../symmio-contracts/account-layer/types.js";
 //#region src/quotes/grouping/group-strategy.ts
 function n(e) {
-	return {
-		key: `m:${e.symbolId}`,
-		by: { symbolId: e.symbolId }
-	};
-}
-function r(e) {
 	return {
 		key: `md:${e.symbolId}:${e.positionType}`,
 		by: {
@@ -16,6 +10,12 @@ function r(e) {
 		}
 	};
 }
+function r(e) {
+	return {
+		key: `m:${e.symbolId}`,
+		by: { symbolId: e.symbolId }
+	};
+}
 function i(e) {
 	return {
 		key: e.key,
@@ -26,17 +26,22 @@ function i(e) {
 		}
 	};
 }
-function a(a) {
-	if (typeof a == "object") return a.keyOf;
-	switch (a) {
-		case t.MARKET: return n;
-		case t.MARKET_DIRECTION: return r;
-		case t.POSITION:
-		case t.CUSTOM: return i;
-		default: throw new e("validation", "UNKNOWN_GROUPING_STRATEGY", `groupQuotes: unknown grouping strategy \`${a}\`.`);
-	}
+function a(e) {
+	return e === t.MARKET_DIRECTION;
+}
+function o(n) {
+	let r = t[n] ?? n;
+	return new e("validation", "UNSUPPORTED_GROUPING_ISOLATION", `Grouped positions are only defined for ${t[t.MARKET_DIRECTION]} isolation (got ${r}). Pass a custom \`{ keyOf }\` — e.g. \`keyQuoteByMarket\` or \`keyQuotePerQuote\` — to group on another dimension.`);
+}
+function s(e) {
+	if (!a(e)) throw o(e);
+}
+function c(r) {
+	if (typeof r == "object") return r.keyOf;
+	if (r === t.MARKET_DIRECTION) return n;
+	throw t[r] === void 0 ? new e("validation", "UNKNOWN_GROUPING_STRATEGY", `groupQuotes: unknown grouping strategy \`${r}\`.`) : o(r);
 }
 //#endregion
-export { a as resolveQuoteGroupingStrategy };
+export { s as assertQuoteGroupingSupported, r as keyQuoteByMarket, i as keyQuotePerQuote, c as resolveQuoteGroupingStrategy, a as supportsQuoteGrouping };
 
 //# sourceMappingURL=group-strategy.js.map

package/dist/quotes/grouping/group-strategy.js.map

@@ -1 +1 @@
-{"version":3,"file":"group-strategy.js","names":[],"sources":["../../../src/quotes/grouping/group-strategy.ts"],"sourcesContent":["import { SymmError } from \"../../shared/errors/symm-error\";\nimport { SubAccountIsolationType } from \"../../symmio-contracts/account-layer/types\";\nimport type { UnifiedQuote } from \"../unified-quote\";\nimport type { QuoteGroupingStrategy, QuoteGroupKey, QuoteGroupKeyFn } from \"./quote-group\";\n\n/** Group by market only — both sides of a market collapse together (`MARKET` isolation). */\nfunction keyByMarket(quote: UnifiedQuote): QuoteGroupKey {\n  return { key: `m:${quote.symbolId}`, by: { symbolId: quote.symbolId } };\n}\n\n/** Group by market + side (`MARKET_DIRECTION` isolation — what the lowcap UI used). */\nfunction keyByMarketDirection(quote: UnifiedQuote): QuoteGroupKey {\n  return {\n    key: `md:${quote.symbolId}:${quote.positionType}`,\n    by: { symbolId: quote.symbolId, positionType: quote.positionType },\n  };\n}\n\n/**\n * Group per single quote — no aggregation (`POSITION` and `CUSTOM` isolation).\n * The group carries the quote's full identity so consumers can label it.\n */\nfunction keyPerQuote(quote: UnifiedQuote): QuoteGroupKey {\n  return {\n    key: quote.key,\n    by: { symbolId: quote.symbolId, positionType: quote.positionType, vaAddress: quote.vaAddress },\n  };\n}\n\n/**\n * Resolve a {@link QuoteGroupingStrategy} to the {@link QuoteGroupKeyFn} that\n * places each quote into its group.\n *\n * A `{ keyOf }` object is returned as-is. A {@link SubAccountIsolationType} maps\n * to its built-in strategy: `MARKET` groups by market, `MARKET_DIRECTION` by\n * market + side, and `POSITION` / `CUSTOM` produce one group per quote (custom\n * isolation places trades in manually-managed VAs, so consumers that want\n * VA-based grouping pass their own `keyOf`).\n *\n * @param strategy - The grouping strategy.\n * @returns The key function for {@link groupQuotes}.\n * @throws {SymmError} when given an unknown isolation type.\n */\nexport function resolveQuoteGroupingStrategy(strategy: QuoteGroupingStrategy): QuoteGroupKeyFn {\n  if (typeof strategy === \"object\") return strategy.keyOf;\n  switch (strategy) {\n    case SubAccountIsolationType.MARKET:\n      return keyByMarket;\n    case SubAccountIsolationType.MARKET_DIRECTION:\n      return keyByMarketDirection;\n    case SubAccountIsolationType.POSITION:\n    case SubAccountIsolationType.CUSTOM:\n      return keyPerQuote;\n    default:\n      throw new SymmError(\n        \"validation\",\n        \"UNKNOWN_GROUPING_STRATEGY\",\n        `groupQuotes: unknown grouping strategy \\`${strategy}\\`.`,\n      );\n  }\n}\n"],"mappings":";;;AAMA,SAAS,EAAY,GAAoC;CACvD,OAAO;EAAE,KAAK,KAAK,EAAM;EAAY,IAAI,EAAE,UAAU,EAAM,SAAS;CAAE;AACxE;AAGA,SAAS,EAAqB,GAAoC;CAChE,OAAO;EACL,KAAK,MAAM,EAAM,SAAS,GAAG,EAAM;EACnC,IAAI;GAAE,UAAU,EAAM;GAAU,cAAc,EAAM;EAAa;CACnE;AACF;AAMA,SAAS,EAAY,GAAoC;CACvD,OAAO;EACL,KAAK,EAAM;EACX,IAAI;GAAE,UAAU,EAAM;GAAU,cAAc,EAAM;GAAc,WAAW,EAAM;EAAU;CAC/F;AACF;AAgBA,SAAgB,EAA6B,GAAkD;CAC7F,IAAI,OAAO,KAAa,UAAU,OAAO,EAAS;CAClD,QAAQ,GAAR;EACE,KAAK,EAAwB,QAC3B,OAAO;EACT,KAAK,EAAwB,kBAC3B,OAAO;EACT,KAAK,EAAwB;EAC7B,KAAK,EAAwB,QAC3B,OAAO;EACT,SACE,MAAM,IAAI,EACR,cACA,6BACA,4CAA4C,EAAS,IACvD;CACJ;AACF"}
+{"version":3,"file":"group-strategy.js","names":[],"sources":["../../../src/quotes/grouping/group-strategy.ts"],"sourcesContent":["import { SymmError } from \"../../shared/errors/symm-error\";\nimport { SubAccountIsolationType } from \"../../symmio-contracts/account-layer/types\";\nimport type { UnifiedQuote } from \"../unified-quote\";\nimport type { QuoteGroupingStrategy, QuoteGroupKey, QuoteGroupKeyFn } from \"./quote-group\";\n\n/** Group by market + side — the `MARKET_DIRECTION` strategy, the only isolation-backed one. */\nfunction keyByMarketDirection(quote: UnifiedQuote): QuoteGroupKey {\n  return {\n    key: `md:${quote.symbolId}:${quote.positionType}`,\n    by: { symbolId: quote.symbolId, positionType: quote.positionType },\n  };\n}\n\n/**\n * Key a quote by market only, collapsing both sides of a market into one group.\n *\n * Not reachable through a {@link SubAccountIsolationType} — grouped positions are\n * defined for `MARKET_DIRECTION` only (see {@link supportsQuoteGrouping}). Pass it\n * as an explicit `{ keyOf }` when you deliberately want market-wide folding and\n * accept that the aggregated metrics mix longs and shorts.\n *\n * @param quote - The quote to place into a group.\n * @returns The group key `m:<symbolId>` and its `{ symbolId }` dimension.\n *\n * @example\n * ```ts\n * const groups = groupQuotes(positions, { keyOf: keyQuoteByMarket });\n * ```\n */\nexport function keyQuoteByMarket(quote: UnifiedQuote): QuoteGroupKey {\n  return { key: `m:${quote.symbolId}`, by: { symbolId: quote.symbolId } };\n}\n\n/**\n * Key a quote by its own identity, producing one single-child group per quote —\n * grouping with no aggregation.\n *\n * Not reachable through a {@link SubAccountIsolationType} (see\n * {@link supportsQuoteGrouping}). Pass it as an explicit `{ keyOf }` to render\n * ungrouped positions through the same `QuoteGroup` shape the grouped UI uses.\n *\n * @param quote - The quote to place into a group.\n * @returns The quote's own `key` and its full `{ symbolId, positionType, vaAddress }` identity.\n *\n * @example\n * ```ts\n * const groups = groupQuotes(positions, { keyOf: keyQuotePerQuote });\n * // every group has isAggregate === false\n * ```\n */\nexport function keyQuotePerQuote(quote: UnifiedQuote): QuoteGroupKey {\n  return {\n    key: quote.key,\n    by: { symbolId: quote.symbolId, positionType: quote.positionType, vaAddress: quote.vaAddress },\n  };\n}\n\n/**\n * Whether grouped positions are defined for an isolation type.\n *\n * Only `MARKET_DIRECTION` groups. It is the one isolation where a market + side\n * cohort is a real on-chain unit — the AccountLayer allocates one Virtual Account\n * per market + direction — so folding that cohort's quotes into a single row\n * aggregates values that genuinely belong to the same position. Under `MARKET`,\n * `POSITION`, or `CUSTOM` isolation the same fold would merge quotes the protocol\n * keeps apart (or that never shared a VA at all), producing totals, leverage, and\n * group-level actions that do not correspond to anything on-chain.\n *\n * @param isolationType - The subaccount's on-chain isolation type.\n * @returns `true` only for `MARKET_DIRECTION`.\n *\n * @example\n * ```ts\n * if (supportsQuoteGrouping(subAccount.isolationType)) {\n *   const groups = groupQuotes(positions, subAccount.isolationType);\n * }\n * ```\n */\nexport function supportsQuoteGrouping(isolationType: SubAccountIsolationType): boolean {\n  return isolationType === SubAccountIsolationType.MARKET_DIRECTION;\n}\n\n/** The rejection every unsupported-isolation path throws, built in one place. */\nfunction unsupportedIsolationError(isolationType: SubAccountIsolationType): SymmError {\n  const name = SubAccountIsolationType[isolationType] ?? isolationType;\n  return new SymmError(\n    \"validation\",\n    \"UNSUPPORTED_GROUPING_ISOLATION\",\n    `Grouped positions are only defined for ${SubAccountIsolationType[SubAccountIsolationType.MARKET_DIRECTION]} isolation (got ${name}). Pass a custom \\`{ keyOf }\\` — e.g. \\`keyQuoteByMarket\\` or \\`keyQuotePerQuote\\` — to group on another dimension.`,\n  );\n}\n\n/**\n * Throw unless grouped positions are defined for `isolationType`.\n *\n * The throwing counterpart of {@link supportsQuoteGrouping}, for call sites that\n * want to fail loudly rather than branch.\n *\n * @param isolationType - The subaccount's on-chain isolation type.\n * @throws {SymmError} `validation` / `UNSUPPORTED_GROUPING_ISOLATION` for any type\n *   other than `MARKET_DIRECTION`.\n *\n * @example\n * ```ts\n * assertQuoteGroupingSupported(subAccount.isolationType);\n * const groups = groupQuotes(positions, subAccount.isolationType);\n * ```\n */\nexport function assertQuoteGroupingSupported(isolationType: SubAccountIsolationType): void {\n  if (supportsQuoteGrouping(isolationType)) return;\n  throw unsupportedIsolationError(isolationType);\n}\n\n/**\n * Resolve a {@link QuoteGroupingStrategy} to the {@link QuoteGroupKeyFn} that\n * places each quote into its group.\n *\n * A `{ keyOf }` object is returned as-is. The only {@link SubAccountIsolationType}\n * accepted is `MARKET_DIRECTION` (keys by market + side) — every other isolation\n * type is rejected, because grouped positions are not defined for it (see\n * {@link supportsQuoteGrouping}). To fold on another dimension, pass an explicit\n * `{ keyOf }`; {@link keyQuoteByMarket} and {@link keyQuotePerQuote} ship as\n * ready-made key functions.\n *\n * @param strategy - The grouping strategy.\n * @returns The key function for {@link groupQuotes}.\n * @throws {SymmError} `UNSUPPORTED_GROUPING_ISOLATION` for `MARKET` / `POSITION` /\n *   `CUSTOM`, or `UNKNOWN_GROUPING_STRATEGY` for a value that is not an isolation\n *   type at all.\n */\nexport function resolveQuoteGroupingStrategy(strategy: QuoteGroupingStrategy): QuoteGroupKeyFn {\n  if (typeof strategy === \"object\") return strategy.keyOf;\n  if (strategy === SubAccountIsolationType.MARKET_DIRECTION) return keyByMarketDirection;\n  if (SubAccountIsolationType[strategy] === undefined) {\n    throw new SymmError(\n      \"validation\",\n      \"UNKNOWN_GROUPING_STRATEGY\",\n      `groupQuotes: unknown grouping strategy \\`${strategy}\\`.`,\n    );\n  }\n  throw unsupportedIsolationError(strategy);\n}\n"],"mappings":";;;AAMA,SAAS,EAAqB,GAAoC;CAChE,OAAO;EACL,KAAK,MAAM,EAAM,SAAS,GAAG,EAAM;EACnC,IAAI;GAAE,UAAU,EAAM;GAAU,cAAc,EAAM;EAAa;CACnE;AACF;AAkBA,SAAgB,EAAiB,GAAoC;CACnE,OAAO;EAAE,KAAK,KAAK,EAAM;EAAY,IAAI,EAAE,UAAU,EAAM,SAAS;CAAE;AACxE;AAmBA,SAAgB,EAAiB,GAAoC;CACnE,OAAO;EACL,KAAK,EAAM;EACX,IAAI;GAAE,UAAU,EAAM;GAAU,cAAc,EAAM;GAAc,WAAW,EAAM;EAAU;CAC/F;AACF;AAuBA,SAAgB,EAAsB,GAAiD;CACrF,OAAO,MAAkB,EAAwB;AACnD;AAGA,SAAS,EAA0B,GAAmD;CACpF,IAAM,IAAO,EAAwB,MAAkB;CACvD,OAAO,IAAI,EACT,cACA,kCACA,0CAA0C,EAAwB,EAAwB,kBAAkB,kBAAkB,EAAK,oHACrI;AACF;AAkBA,SAAgB,EAA6B,GAA8C;CACrF,OAAsB,CAAa,GACvC,MAAM,EAA0B,CAAa;AAC/C;AAmBA,SAAgB,EAA6B,GAAkD;CAC7F,IAAI,OAAO,KAAa,UAAU,OAAO,EAAS;CAClD,IAAI,MAAa,EAAwB,kBAAkB,OAAO;CAQlE,MAPI,EAAwB,OAAc,KAAA,IAClC,IAAI,EACR,cACA,6BACA,4CAA4C,EAAS,IACvD,IAEI,EAA0B,CAAQ;AAC1C"}

package/dist/quotes/grouping/index.d.ts

@@ -1,3 +1,5 @@
+export * from './aggregate-group-funding.js';
+export * from './aggregate-group-upnl.js';
 export * from './aggregate-metrics.js';
 export * from './group-quotes.js';
 export * from './group-strategy.js';

package/dist/quotes/grouping/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/quotes/grouping/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/quotes/grouping/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC"}

package/dist/quotes/grouping/partition-quotes.d.ts

@@ -27,9 +27,9 @@ export declare function isPendingOrder(quote: UnifiedQuote): boolean;
  * after a `SendQuoteTransaction` notification anchors the row but before the
  * on-chain poll has returned its full struct — without it the row would drop out of
  * the grouped view for a tick. Any closing-stage row (`OPTIMISTIC_CLOSE` /
- * `CLOSE_PRICE_FILLED` / `WRITE_ONCHAIN_CLOSE` / `CLOSING`) is always active;
- * terminal rows (`CLOSED` / `CANCELED` / `EXPIRED` / `LIQUIDATED`, or an off-chain
- * `FAILED`) are neither.
+ * `CLOSE_PRICE_FILLED` / `WRITE_ONCHAIN_CLOSE`) is always active; terminal rows
+ * (`CLOSED` / `CANCELED` / `EXPIRED` / `LIQUIDATED`, or an off-chain `FAILED`) are
+ * neither.
  *
  * Mutually exclusive with {@link isPendingOrder}.
  *

package/dist/quotes/grouping/partition-quotes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"partition-quotes.d.ts","sourceRoot":"","sources":["../../../src/quotes/grouping/partition-quotes.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAmBrE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAW3D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAgB7D;AAED,yCAAyC;AACzC,MAAM,WAAW,iBAAiB;IAChC,mDAAmD;IACnD,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,8CAA8C;IAC9C,OAAO,EAAE,YAAY,EAAE,CAAC;CACzB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,iBAAiB,CAQlF"}
+{"version":3,"file":"partition-quotes.d.ts","sourceRoot":"","sources":["../../../src/quotes/grouping/partition-quotes.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAmBrE;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAW3D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,YAAY,GAAG,OAAO,CAe7D;AAED,yCAAyC;AACzC,MAAM,WAAW,iBAAiB;IAChC,mDAAmD;IACnD,SAAS,EAAE,YAAY,EAAE,CAAC;IAC1B,8CAA8C;IAC9C,OAAO,EAAE,YAAY,EAAE,CAAC;CACzB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,iBAAiB,CAQlF"}

package/dist/quotes/grouping/partition-quotes.js

@@ -23,8 +23,7 @@ function o(t) {
 		case n.ONCHAIN: return t.orderType !== e.LIMIT;
 		case n.OPTIMISTIC_CLOSE:
 		case n.CLOSE_PRICE_FILLED:
-		case n.WRITE_ONCHAIN_CLOSE:
-		case n.CLOSING: return !0;
+		case n.WRITE_ONCHAIN_CLOSE: return !0;
 		default: return !1;
 	}
 }

package/dist/quotes/grouping/partition-quotes.js.map

@@ -1 +1 @@
-{"version":3,"file":"partition-quotes.js","names":[],"sources":["../../../src/quotes/grouping/partition-quotes.ts"],"sourcesContent":["import { OrderType, QuoteStatus } from \"../../symmio-contracts/symmio/types\";\nimport { QuoteLifecycle, type UnifiedQuote } from \"../unified-quote\";\n\n/**\n * On-chain statuses of a resting order that has **not** become a position yet.\n * These are the statuses `getPartyAPendingQuotes` returns.\n */\nconst PENDING_STATUSES = new Set<QuoteStatus>([QuoteStatus.PENDING, QuoteStatus.LOCKED, QuoteStatus.CANCEL_PENDING]);\n\n/**\n * On-chain statuses of an open position (including one with a close in flight).\n * These are the statuses `getPartyAOpenPositions` returns.\n */\nconst ACTIVE_STATUSES = new Set<QuoteStatus>([\n  QuoteStatus.OPENED,\n  QuoteStatus.CLOSE_PENDING,\n  QuoteStatus.CANCEL_CLOSE_PENDING,\n  QuoteStatus.LIQUIDATED_PENDING,\n]);\n\n/**\n * Whether a quote is a **resting/pending order** — submitted but not yet an open\n * position.\n *\n * An anchored row is classified by its on-chain {@link QuoteStatus}\n * (`PENDING` / `LOCKED` / `CANCEL_PENDING`). An off-chain optimistic row (no\n * status yet) is pending only when it is a not-yet-filled `LIMIT` order; an\n * optimistic `MARKET` open is treated as an opening position instead.\n *\n * Mutually exclusive with {@link isActivePosition}.\n *\n * @param quote - The unified quote to classify.\n * @returns `true` for a resting/pending order.\n */\nexport function isPendingOrder(quote: UnifiedQuote): boolean {\n  if (quote.quoteStatus !== undefined) return PENDING_STATUSES.has(quote.quoteStatus);\n  if (\n    quote.lifecycle === QuoteLifecycle.OPTIMISTIC ||\n    quote.lifecycle === QuoteLifecycle.PRICE_FILLED ||\n    quote.lifecycle === QuoteLifecycle.WRITE_ONCHAIN ||\n    quote.lifecycle === QuoteLifecycle.ONCHAIN\n  ) {\n    return quote.orderType === OrderType.LIMIT;\n  }\n  return false;\n}\n\n/**\n * Whether a quote is an **active position** — opened (or opening), possibly with\n * a close in flight.\n *\n * An anchored row is classified by its on-chain {@link QuoteStatus}\n * (`OPENED` / `CLOSE_PENDING` / `CANCEL_CLOSE_PENDING` / `LIQUIDATED_PENDING`).\n * A row with no `quoteStatus` yet is classified by lifecycle + order type: an\n * optimistic/price-filled or just-anchored (`WRITE_ONCHAIN` / `ONCHAIN`) `MARKET`\n * open is an active position, while the matching `LIMIT` order is still resting\n * (pending). The `WRITE_ONCHAIN`-without-`quoteStatus` case is the brief window\n * after a `SendQuoteTransaction` notification anchors the row but before the\n * on-chain poll has returned its full struct — without it the row would drop out of\n * the grouped view for a tick. Any closing-stage row (`OPTIMISTIC_CLOSE` /\n * `CLOSE_PRICE_FILLED` / `WRITE_ONCHAIN_CLOSE` / `CLOSING`) is always active;\n * terminal rows (`CLOSED` / `CANCELED` / `EXPIRED` / `LIQUIDATED`, or an off-chain\n * `FAILED`) are neither.\n *\n * Mutually exclusive with {@link isPendingOrder}.\n *\n * @param quote - The unified quote to classify.\n * @returns `true` for an active position.\n */\nexport function isActivePosition(quote: UnifiedQuote): boolean {\n  if (quote.quoteStatus !== undefined) return ACTIVE_STATUSES.has(quote.quoteStatus);\n  switch (quote.lifecycle) {\n    case QuoteLifecycle.OPTIMISTIC:\n    case QuoteLifecycle.PRICE_FILLED:\n    case QuoteLifecycle.WRITE_ONCHAIN:\n    case QuoteLifecycle.ONCHAIN:\n      return quote.orderType !== OrderType.LIMIT;\n    case QuoteLifecycle.OPTIMISTIC_CLOSE:\n    case QuoteLifecycle.CLOSE_PRICE_FILLED:\n    case QuoteLifecycle.WRITE_ONCHAIN_CLOSE:\n    case QuoteLifecycle.CLOSING:\n      return true;\n    default:\n      return false;\n  }\n}\n\n/** Result of {@link partitionQuotes}. */\nexport interface PartitionedQuotes {\n  /** Quotes that are open (or opening) positions. */\n  positions: UnifiedQuote[];\n  /** Quotes that are resting/pending orders. */\n  pending: UnifiedQuote[];\n}\n\n/**\n * Split unified quotes into active positions and resting/pending orders — the\n * grouped-view-vs-orders-tab split. Terminal rows (closed / cancelled / expired /\n * liquidated / failed) fall into neither bucket and are dropped, so\n * `positions ∪ pending` is the set of still-live quotes.\n *\n * @param quotes - The unified quotes to split.\n * @returns The `positions` and `pending` buckets, each preserving input order.\n *\n * @example\n * ```ts\n * const { positions, pending } = partitionQuotes(quotes);\n * const groups = groupQuotes(positions, SubAccountIsolationType.MARKET_DIRECTION);\n * ```\n */\nexport function partitionQuotes(quotes: readonly UnifiedQuote[]): PartitionedQuotes {\n  const positions: UnifiedQuote[] = [];\n  const pending: UnifiedQuote[] = [];\n  for (const quote of quotes) {\n    if (isPendingOrder(quote)) pending.push(quote);\n    else if (isActivePosition(quote)) positions.push(quote);\n  }\n  return { positions, pending };\n}\n"],"mappings":";;;AAOA,IAAM,IAAmB,IAAI,IAAiB;CAAC,EAAY;CAAS,EAAY;CAAQ,EAAY;AAAc,CAAC,GAM7G,IAAkB,IAAI,IAAiB;CAC3C,EAAY;CACZ,EAAY;CACZ,EAAY;CACZ,EAAY;AACd,CAAC;AAgBD,SAAgB,EAAe,GAA8B;CAU3D,OATI,EAAM,gBAAgB,KAAA,IAExB,EAAM,cAAc,EAAe,cACnC,EAAM,cAAc,EAAe,gBACnC,EAAM,cAAc,EAAe,iBACnC,EAAM,cAAc,EAAe,UAE5B,EAAM,cAAc,EAAU,QAEhC,KATqC,EAAiB,IAAI,EAAM,WAAW;AAUpF;AAwBA,SAAgB,EAAiB,GAA8B;CAC7D,IAAI,EAAM,gBAAgB,KAAA,GAAW,OAAO,EAAgB,IAAI,EAAM,WAAW;CACjF,QAAQ,EAAM,WAAd;EACE,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe,SAClB,OAAO,EAAM,cAAc,EAAU;EACvC,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe,SAClB,OAAO;EACT,SACE,OAAO;CACX;AACF;AAyBA,SAAgB,EAAgB,GAAoD;CAClF,IAAM,IAA4B,CAAC,GAC7B,IAA0B,CAAC;CACjC,KAAK,IAAM,KAAS,GAClB,AAAI,EAAe,CAAK,IAAG,EAAQ,KAAK,CAAK,IACpC,EAAiB,CAAK,KAAG,EAAU,KAAK,CAAK;CAExD,OAAO;EAAE;EAAW;CAAQ;AAC9B"}
+{"version":3,"file":"partition-quotes.js","names":[],"sources":["../../../src/quotes/grouping/partition-quotes.ts"],"sourcesContent":["import { OrderType, QuoteStatus } from \"../../symmio-contracts/symmio/types\";\nimport { QuoteLifecycle, type UnifiedQuote } from \"../unified-quote\";\n\n/**\n * On-chain statuses of a resting order that has **not** become a position yet.\n * These are the statuses `getPartyAPendingQuotes` returns.\n */\nconst PENDING_STATUSES = new Set<QuoteStatus>([QuoteStatus.PENDING, QuoteStatus.LOCKED, QuoteStatus.CANCEL_PENDING]);\n\n/**\n * On-chain statuses of an open position (including one with a close in flight).\n * These are the statuses `getPartyAOpenPositions` returns.\n */\nconst ACTIVE_STATUSES = new Set<QuoteStatus>([\n  QuoteStatus.OPENED,\n  QuoteStatus.CLOSE_PENDING,\n  QuoteStatus.CANCEL_CLOSE_PENDING,\n  QuoteStatus.LIQUIDATED_PENDING,\n]);\n\n/**\n * Whether a quote is a **resting/pending order** — submitted but not yet an open\n * position.\n *\n * An anchored row is classified by its on-chain {@link QuoteStatus}\n * (`PENDING` / `LOCKED` / `CANCEL_PENDING`). An off-chain optimistic row (no\n * status yet) is pending only when it is a not-yet-filled `LIMIT` order; an\n * optimistic `MARKET` open is treated as an opening position instead.\n *\n * Mutually exclusive with {@link isActivePosition}.\n *\n * @param quote - The unified quote to classify.\n * @returns `true` for a resting/pending order.\n */\nexport function isPendingOrder(quote: UnifiedQuote): boolean {\n  if (quote.quoteStatus !== undefined) return PENDING_STATUSES.has(quote.quoteStatus);\n  if (\n    quote.lifecycle === QuoteLifecycle.OPTIMISTIC ||\n    quote.lifecycle === QuoteLifecycle.PRICE_FILLED ||\n    quote.lifecycle === QuoteLifecycle.WRITE_ONCHAIN ||\n    quote.lifecycle === QuoteLifecycle.ONCHAIN\n  ) {\n    return quote.orderType === OrderType.LIMIT;\n  }\n  return false;\n}\n\n/**\n * Whether a quote is an **active position** — opened (or opening), possibly with\n * a close in flight.\n *\n * An anchored row is classified by its on-chain {@link QuoteStatus}\n * (`OPENED` / `CLOSE_PENDING` / `CANCEL_CLOSE_PENDING` / `LIQUIDATED_PENDING`).\n * A row with no `quoteStatus` yet is classified by lifecycle + order type: an\n * optimistic/price-filled or just-anchored (`WRITE_ONCHAIN` / `ONCHAIN`) `MARKET`\n * open is an active position, while the matching `LIMIT` order is still resting\n * (pending). The `WRITE_ONCHAIN`-without-`quoteStatus` case is the brief window\n * after a `SendQuoteTransaction` notification anchors the row but before the\n * on-chain poll has returned its full struct — without it the row would drop out of\n * the grouped view for a tick. Any closing-stage row (`OPTIMISTIC_CLOSE` /\n * `CLOSE_PRICE_FILLED` / `WRITE_ONCHAIN_CLOSE`) is always active; terminal rows\n * (`CLOSED` / `CANCELED` / `EXPIRED` / `LIQUIDATED`, or an off-chain `FAILED`) are\n * neither.\n *\n * Mutually exclusive with {@link isPendingOrder}.\n *\n * @param quote - The unified quote to classify.\n * @returns `true` for an active position.\n */\nexport function isActivePosition(quote: UnifiedQuote): boolean {\n  if (quote.quoteStatus !== undefined) return ACTIVE_STATUSES.has(quote.quoteStatus);\n  switch (quote.lifecycle) {\n    case QuoteLifecycle.OPTIMISTIC:\n    case QuoteLifecycle.PRICE_FILLED:\n    case QuoteLifecycle.WRITE_ONCHAIN:\n    case QuoteLifecycle.ONCHAIN:\n      return quote.orderType !== OrderType.LIMIT;\n    case QuoteLifecycle.OPTIMISTIC_CLOSE:\n    case QuoteLifecycle.CLOSE_PRICE_FILLED:\n    case QuoteLifecycle.WRITE_ONCHAIN_CLOSE:\n      return true;\n    default:\n      return false;\n  }\n}\n\n/** Result of {@link partitionQuotes}. */\nexport interface PartitionedQuotes {\n  /** Quotes that are open (or opening) positions. */\n  positions: UnifiedQuote[];\n  /** Quotes that are resting/pending orders. */\n  pending: UnifiedQuote[];\n}\n\n/**\n * Split unified quotes into active positions and resting/pending orders — the\n * grouped-view-vs-orders-tab split. Terminal rows (closed / cancelled / expired /\n * liquidated / failed) fall into neither bucket and are dropped, so\n * `positions ∪ pending` is the set of still-live quotes.\n *\n * @param quotes - The unified quotes to split.\n * @returns The `positions` and `pending` buckets, each preserving input order.\n *\n * @example\n * ```ts\n * const { positions, pending } = partitionQuotes(quotes);\n * const groups = groupQuotes(positions, SubAccountIsolationType.MARKET_DIRECTION);\n * ```\n */\nexport function partitionQuotes(quotes: readonly UnifiedQuote[]): PartitionedQuotes {\n  const positions: UnifiedQuote[] = [];\n  const pending: UnifiedQuote[] = [];\n  for (const quote of quotes) {\n    if (isPendingOrder(quote)) pending.push(quote);\n    else if (isActivePosition(quote)) positions.push(quote);\n  }\n  return { positions, pending };\n}\n"],"mappings":";;;AAOA,IAAM,IAAmB,IAAI,IAAiB;CAAC,EAAY;CAAS,EAAY;CAAQ,EAAY;AAAc,CAAC,GAM7G,IAAkB,IAAI,IAAiB;CAC3C,EAAY;CACZ,EAAY;CACZ,EAAY;CACZ,EAAY;AACd,CAAC;AAgBD,SAAgB,EAAe,GAA8B;CAU3D,OATI,EAAM,gBAAgB,KAAA,IAExB,EAAM,cAAc,EAAe,cACnC,EAAM,cAAc,EAAe,gBACnC,EAAM,cAAc,EAAe,iBACnC,EAAM,cAAc,EAAe,UAE5B,EAAM,cAAc,EAAU,QAEhC,KATqC,EAAiB,IAAI,EAAM,WAAW;AAUpF;AAwBA,SAAgB,EAAiB,GAA8B;CAC7D,IAAI,EAAM,gBAAgB,KAAA,GAAW,OAAO,EAAgB,IAAI,EAAM,WAAW;CACjF,QAAQ,EAAM,WAAd;EACE,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe,SAClB,OAAO,EAAM,cAAc,EAAU;EACvC,KAAK,EAAe;EACpB,KAAK,EAAe;EACpB,KAAK,EAAe,qBAClB,OAAO;EACT,SACE,OAAO;CACX;AACF;AAyBA,SAAgB,EAAgB,GAAoD;CAClF,IAAM,IAA4B,CAAC,GAC7B,IAA0B,CAAC;CACjC,KAAK,IAAM,KAAS,GAClB,AAAI,EAAe,CAAK,IAAG,EAAQ,KAAK,CAAK,IACpC,EAAiB,CAAK,KAAG,EAAU,KAAK,CAAK;CAExD,OAAO;EAAE;EAAW;CAAQ;AAC9B"}