@symmio/trading-core 1.1.0 → 2.0.0

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

@@ -6,10 +6,11 @@ import { UnifiedQuote } from '../unified-quote.js';
  * The dimensions a {@link QuoteGroup} is keyed on. Only the fields the active
  * strategy groups by are set:
  *
- * - `MARKET_DIRECTION` → `{ symbolId, positionType }`
- * - `MARKET` → `{ symbolId }`
- * - `POSITION` / `CUSTOM` (per-quote) → `{ symbolId, positionType, vaAddress }`
- *   (the single quote's full identity)
+ * - `MARKET_DIRECTION` (the only isolation-backed strategy) →
+ *   `{ symbolId, positionType }`
+ * - `keyQuoteByMarket` → `{ symbolId }`
+ * - `keyQuotePerQuote` → `{ symbolId, positionType, vaAddress }` (the single
+ *   quote's full identity)
  *
  * A custom `keyOf` may set whichever subset it groups on.
  */
@@ -33,9 +34,10 @@ export interface QuoteGroupKey {
     by: QuoteGroupBy;
 }
 /**
- * Derives the group a quote belongs to. Built-in strategies provide one per
- * {@link SubAccountIsolationType}; a consumer supplies their own to group on any
- * dimension (e.g. by `vaAddress`, or market + direction + VA).
+ * Derives the group a quote belongs to. The built-in strategy keys by market +
+ * side (`MARKET_DIRECTION`); a consumer supplies their own to group on any other
+ * dimension (e.g. by `vaAddress`, or market + direction + VA) — `keyQuoteByMarket`
+ * and `keyQuotePerQuote` ship as ready-made key functions.
  *
  * @param quote - The quote to place into a group.
  * @returns The group's stable key and structured dimensions.
@@ -44,23 +46,30 @@ export type QuoteGroupKeyFn = (quote: UnifiedQuote) => QuoteGroupKey;
 /**
  * How {@link groupQuotes} folds quotes into groups:
  *
- * - a {@link SubAccountIsolationType} selects the matching built-in strategy
- *   (`POSITION` and `CUSTOM` produce one group per quote; `MARKET` groups by
- *   market; `MARKET_DIRECTION` groups by market + side);
+ * - `SubAccountIsolationType.MARKET_DIRECTION` — the only accepted isolation
+ *   type — groups by market + side;
  * - `{ keyOf }` lets the consumer group on any dimension.
  *
- * Reusing the on-chain isolation enum keeps the UI grouping faithful to how the
- * AccountLayer actually allocates Virtual Accounts for the subaccount.
+ * Passing any other {@link SubAccountIsolationType} throws
+ * `UNSUPPORTED_GROUPING_ISOLATION`: grouped positions are defined only where a
+ * market + side cohort is a real on-chain unit, which is exactly the isolation
+ * where the AccountLayer allocates one Virtual Account per market + direction.
+ * See `supportsQuoteGrouping` for the reasoning and `keyQuoteByMarket` /
+ * `keyQuotePerQuote` for the explicit opt-outs.
  */
 export type QuoteGroupingStrategy = SubAccountIsolationType | {
     readonly keyOf: QuoteGroupKeyFn;
 };
 /**
  * Pure, price-independent aggregations over a group's child quotes. Every amount
- * is 18-decimal wei `bigint`, matching {@link UnifiedQuote}. Metrics that need a
- * live mark price or VA balance (unrealized PnL, market value, liquidation price)
- * are intentionally **not** here — they belong to a follow-up slice that injects
- * those inputs.
+ * is 18-decimal wei `bigint`, matching {@link UnifiedQuote}.
+ *
+ * Metrics that need a live mark price or Virtual Account balance are
+ * intentionally **not** here — they take those inputs explicitly instead:
+ * `aggregateGroupUpnl` (unrealized PnL — and its return percentages — at a mark
+ * price), `calculateMarginRisk`
+ * (margin, equity and liquidation buffer from an account's balance), and
+ * `calculateLiquidationPrice` (the price liquidation happens at).
  */
 export interface QuoteGroupMetrics {
     /** Number of child quotes in the group. */
@@ -81,14 +90,19 @@ export interface QuoteGroupMetrics {
      * optimistic open) — render a loading state in that case.
      */
     weightedOpenPrice?: bigint;
-    /** Σ initial notional (`openQuantity × price`) across children, wei. */
-    notional: bigint;
+    /**
+     * Σ frozen at-open notional (`quantity × (initialOpenedPrice ?? requestedOpenPrice)`)
+     * across children, wei. Partial closes do not shrink it.
+     */
+    initialNotional: bigint;
     /** Σ of each {@link LockedValues} leg (`cva`, `lf`, `partyAmm`, `partyBmm`) across children, wei. */
     lockedValues: LockedValues;
     /**
-     * Blended leverage as an 18-decimal fixed-point `bigint` (e.g. `2.5x →
-     * 2_500000000000000000n`): `notional / (Σ cva + lf + partyAmm)`. `undefined`
-     * when the locked partyA margin is `0` (nothing to leverage against).
+     * Blended opening leverage as an 18-decimal fixed-point `bigint` (e.g. `2.5x →
+     * 2_500000000000000000n`): `Σ(quantity × (requestedOpenPrice ?? openedPrice)) /
+     * Σ(cva + lf + partyAmm + partyBmm)`, each child using its frozen
+     * `initialLockedValues` (else `lockedValues`). `undefined` when that locked
+     * margin is `0` (nothing to leverage against).
      */
     leverage?: bigint;
 }

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

@@ -1 +1 @@
-{"version":3,"file":"quote-group.d.ts","sourceRoot":"","sources":["../../../src/quotes/grouping/quote-group.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4CAA4C,CAAC;AAC1F,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACtF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;;;;;GAUG;AACH,MAAM,WAAW,YAAY;IAC3B,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8DAA8D;IAC9D,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,0EAA0E;IAC1E,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,oFAAoF;IACpF,GAAG,EAAE,MAAM,CAAC;IACZ,0DAA0D;IAC1D,EAAE,EAAE,YAAY,CAAC;CAClB;AAED;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,aAAa,CAAC;AAErE;;;;;;;;;;GAUG;AACH,MAAM,MAAM,qBAAqB,GAAG,uBAAuB,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;CAAE,CAAC;AAElG;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB;IAChC,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,YAAY,EAAE,MAAM,CAAC;IACrB,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,mGAAmG;IACnG,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,wEAAwE;IACxE,QAAQ,EAAE,MAAM,CAAC;IACjB,qGAAqG;IACrG,YAAY,EAAE,YAAY,CAAC;IAC3B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU;IACzB,kGAAkG;IAClG,GAAG,EAAE,MAAM,CAAC;IACZ,+CAA+C;IAC/C,EAAE,EAAE,YAAY,CAAC;IACjB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,kCAAkC;IAClC,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,qGAAqG;IACrG,WAAW,EAAE,OAAO,CAAC;IACrB,mDAAmD;IACnD,OAAO,EAAE,iBAAiB,CAAC;CAC5B"}
+{"version":3,"file":"quote-group.d.ts","sourceRoot":"","sources":["../../../src/quotes/grouping/quote-group.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,4CAA4C,CAAC;AAC1F,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,qCAAqC,CAAC;AACtF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,YAAY;IAC3B,uDAAuD;IACvD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,8DAA8D;IAC9D,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,0EAA0E;IAC1E,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,WAAW,aAAa;IAC5B,oFAAoF;IACpF,GAAG,EAAE,MAAM,CAAC;IACZ,0DAA0D;IAC1D,EAAE,EAAE,YAAY,CAAC;CAClB;AAED;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,GAAG,CAAC,KAAK,EAAE,YAAY,KAAK,aAAa,CAAC;AAErE;;;;;;;;;;;;;GAaG;AACH,MAAM,MAAM,qBAAqB,GAAG,uBAAuB,GAAG;IAAE,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAA;CAAE,CAAC;AAElG;;;;;;;;;;GAUG;AACH,MAAM,WAAW,iBAAiB;IAChC,2CAA2C;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,wEAAwE;IACxE,SAAS,EAAE,MAAM,CAAC;IAClB,4EAA4E;IAC5E,YAAY,EAAE,MAAM,CAAC;IACrB,8DAA8D;IAC9D,QAAQ,EAAE,MAAM,CAAC;IACjB,mGAAmG;IACnG,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,eAAe,EAAE,MAAM,CAAC;IACxB,qGAAqG;IACrG,YAAY,EAAE,YAAY,CAAC;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,UAAU;IACzB,kGAAkG;IAClG,GAAG,EAAE,MAAM,CAAC;IACZ,+CAA+C;IAC/C,EAAE,EAAE,YAAY,CAAC;IACjB;;;;OAIG;IACH,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,kCAAkC;IAClC,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,qGAAqG;IACrG,WAAW,EAAE,OAAO,CAAC;IACrB,mDAAmD;IACnD,OAAO,EAAE,iBAAiB,CAAC;CAC5B"}

package/dist/quotes/index.d.ts

@@ -1,13 +1,17 @@
 export * from './apply-notification.js';
+export * from './close-planning/index.js';
 export * from './fees/index.js';
 export * from './fingerprint.js';
 export * from './get-quote-events-by-type/index.js';
 export * from './get-quote-funding/index.js';
 export * from './get-quote-history/index.js';
+export * from './get-quotes-events-by-type/index.js';
 export * from './get-sub-account-quotes/index.js';
 export * from './grouping/index.js';
 export * from './liquidation/index.js';
+export * from './open-price.js';
 export * from './open-quantity.js';
+export * from './quote-id-key-part.js';
 export * from './reconcile-quotes.js';
 export * from './resolve-quote-accounts.js';
 export * from './should-accelerate.js';

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/quotes/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,QAAQ,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/quotes/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,kBAAkB,CAAC;AACjC,cAAc,QAAQ,CAAC;AACvB,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,YAAY,CAAC;AAC3B,cAAc,eAAe,CAAC;AAC9B,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,QAAQ,CAAC"}

package/dist/quotes/liquidation/calculate-liquidation-price.js

@@ -1,17 +1,17 @@
 import { PositionType as e } from "../../symmio-contracts/symmio/types.js";
-import { WEI as t } from "../../shared/utils/wei.js";
+import { WEI as t, mulWei as n } from "../../shared/utils/wei.js";
 //#region src/quotes/liquidation/calculate-liquidation-price.ts
-function n(n) {
-	let r = 0n, i = 0n;
-	for (let e of n.positions) {
-		let n = e.quantity - (e.closedAmount ?? 0n);
-		n <= 0n || (r += n, i += n * e.openedPrice / t);
+function r(r) {
+	let i = 0n, a = 0n;
+	for (let e of r.positions) {
+		let t = e.quantity - (e.closedAmount ?? 0n);
+		t <= 0n || (i += t, a += n(t, e.openedPrice));
 	}
-	if (r === 0n) return 0n;
-	let a = n.allocatedBalance - n.lockedCVA - n.lockedLF, o = (n.positionType === e.LONG ? i - a : i + a) * t / r;
-	return o > 0n ? o : 0n;
+	if (i === 0n) return 0n;
+	let o = r.allocatedBalance - r.lockedCVA - r.lockedLF, s = (r.positionType === e.LONG ? a - o : a + o) * t / i;
+	return s > 0n ? s : 0n;
 }
 //#endregion
-export { n as calculateLiquidationPrice };
+export { r as calculateLiquidationPrice };
 
 //# sourceMappingURL=calculate-liquidation-price.js.map

package/dist/quotes/liquidation/calculate-liquidation-price.js.map

@@ -1 +1 @@
-{"version":3,"file":"calculate-liquidation-price.js","names":[],"sources":["../../../src/quotes/liquidation/calculate-liquidation-price.ts"],"sourcesContent":["import { WEI } from \"../../shared/utils/wei\";\nimport { PositionType } from \"../../symmio-contracts/symmio/types\";\n\n/**\n * One open position attributed to an account (sub-account or virtual account).\n * Used by every aggregate calc that runs over an account's positions (currently\n * {@link calculateLiquidationPrice}; more to follow).\n *\n * Every field is 18-decimal wei `bigint`. `closedAmount` defaults to `0n` when\n * omitted; `openedPrice` is the settled fill price.\n */\nexport interface AccountPosition {\n  /** Total quote quantity (wei). */\n  quantity: bigint;\n  /** Already-closed quantity (wei). Defaults to `0n`. */\n  closedAmount?: bigint;\n  /** Settled `openedPrice` (wei). */\n  openedPrice: bigint;\n}\n\n/**\n * Inputs for {@link calculateLiquidationPrice}. All bigint fields are 18-decimal wei.\n */\nexport interface CalculateLiquidationPriceInputs {\n  /** Active positions in the account (sub-account or virtual account). */\n  positions: readonly AccountPosition[];\n  /** Direction of the account's net position (LONG or SHORT). */\n  positionType: PositionType;\n  /** Account's allocated collateral, from `balanceInfoOfPartyA(account)`. */\n  allocatedBalance: bigint;\n  /** Account's locked CVA, from `balanceInfoOfPartyA(account)`. */\n  lockedCVA: bigint;\n  /** Account's locked LF, from `balanceInfoOfPartyA(account)`. */\n  lockedLF: bigint;\n}\n\n/**\n * Liquidation price for an account (sub-account or virtual account), in\n * 18-decimal-wei collateral units. Aggregates the account's active positions:\n *\n * ```\n * freeBalance   = allocatedBalance − lockedCVA − lockedLF\n * openQty_i     = quantity_i − closedAmount_i\n * totalQty      = Σ openQty_i\n * totalNotional = Σ (openQty_i × openedPrice_i)\n *\n * LONG : liqPrice = (totalNotional − freeBalance) / totalQty\n * SHORT: liqPrice = (totalNotional + freeBalance) / totalQty\n * ```\n *\n * Returns `0n` when `totalQty` is `0n` or the computed price is `≤ 0n`\n * (typically meaning the account has no liquidation risk at any positive price).\n * All math is pure `bigint`, so there is no floating-point drift.\n *\n * @example\n * ```ts\n * const liq = calculateLiquidationPrice({\n *   positions: [{ quantity: 1_000_000_000_000_000_000n, openedPrice: 2_000_000_000_000_000_000n }],\n *   positionType: PositionType.LONG,\n *   allocatedBalance: 200_000_000_000_000_000_000n,\n *   lockedCVA: 10_000_000_000_000_000_000n,\n *   lockedLF: 5_000_000_000_000_000_000n,\n * });\n * ```\n */\nexport function calculateLiquidationPrice(inputs: CalculateLiquidationPriceInputs): bigint {\n  let totalQty = 0n;\n  let totalNotional = 0n;\n  for (const position of inputs.positions) {\n    const openQty = position.quantity - (position.closedAmount ?? 0n);\n    if (openQty <= 0n) continue;\n    totalQty += openQty;\n    totalNotional += (openQty * position.openedPrice) / WEI;\n  }\n  if (totalQty === 0n) return 0n;\n\n  const freeBalance = inputs.allocatedBalance - inputs.lockedCVA - inputs.lockedLF;\n  const numerator =\n    inputs.positionType === PositionType.LONG ? totalNotional - freeBalance : totalNotional + freeBalance;\n\n  const liquidationPrice = (numerator * WEI) / totalQty;\n  return liquidationPrice > 0n ? liquidationPrice : 0n;\n}\n"],"mappings":";;;AAiEA,SAAgB,EAA0B,GAAiD;CACzF,IAAI,IAAW,IACX,IAAgB;CACpB,KAAK,IAAM,KAAY,EAAO,WAAW;EACvC,IAAM,IAAU,EAAS,YAAY,EAAS,gBAAgB;EAC1D,KAAW,OACf,KAAY,GACZ,KAAkB,IAAU,EAAS,cAAe;CACtD;CACA,IAAI,MAAa,IAAI,OAAO;CAE5B,IAAM,IAAc,EAAO,mBAAmB,EAAO,YAAY,EAAO,UAIlE,KAFJ,EAAO,iBAAiB,EAAa,OAAO,IAAgB,IAAc,IAAgB,KAEtD,IAAO;CAC7C,OAAO,IAAmB,KAAK,IAAmB;AACpD"}
+{"version":3,"file":"calculate-liquidation-price.js","names":[],"sources":["../../../src/quotes/liquidation/calculate-liquidation-price.ts"],"sourcesContent":["import { mulWei, WEI } from \"../../shared/utils/wei\";\nimport { PositionType } from \"../../symmio-contracts/symmio/types\";\n\n/**\n * One open position attributed to an account (sub-account or virtual account).\n * Used by every aggregate calc that runs over an account's positions (currently\n * {@link calculateLiquidationPrice}; more to follow).\n *\n * Every field is 18-decimal wei `bigint`. `closedAmount` defaults to `0n` when\n * omitted; `openedPrice` is the settled fill price.\n */\nexport interface AccountPosition {\n  /** Total quote quantity (wei). */\n  quantity: bigint;\n  /** Already-closed quantity (wei). Defaults to `0n`. */\n  closedAmount?: bigint;\n  /** Settled `openedPrice` (wei). */\n  openedPrice: bigint;\n}\n\n/**\n * Inputs for {@link calculateLiquidationPrice}. All bigint fields are 18-decimal wei.\n */\nexport interface CalculateLiquidationPriceInputs {\n  /** Active positions in the account (sub-account or virtual account). */\n  positions: readonly AccountPosition[];\n  /** Direction of the account's net position (LONG or SHORT). */\n  positionType: PositionType;\n  /** Account's allocated collateral, from `balanceInfoOfPartyA(account)`. */\n  allocatedBalance: bigint;\n  /** Account's locked CVA, from `balanceInfoOfPartyA(account)`. */\n  lockedCVA: bigint;\n  /** Account's locked LF, from `balanceInfoOfPartyA(account)`. */\n  lockedLF: bigint;\n}\n\n/**\n * Liquidation price for an account (sub-account or virtual account), in\n * 18-decimal-wei collateral units. Aggregates the account's active positions:\n *\n * ```\n * freeBalance   = allocatedBalance − lockedCVA − lockedLF\n * openQty_i     = quantity_i − closedAmount_i\n * totalQty      = Σ openQty_i\n * totalNotional = Σ (openQty_i × openedPrice_i)\n *\n * LONG : liqPrice = (totalNotional − freeBalance) / totalQty\n * SHORT: liqPrice = (totalNotional + freeBalance) / totalQty\n * ```\n *\n * Returns `0n` when `totalQty` is `0n` or the computed price is `≤ 0n`\n * (typically meaning the account has no liquidation risk at any positive price).\n * All math is pure `bigint`, so there is no floating-point drift.\n *\n * @example\n * ```ts\n * const liq = calculateLiquidationPrice({\n *   positions: [{ quantity: 1_000_000_000_000_000_000n, openedPrice: 2_000_000_000_000_000_000n }],\n *   positionType: PositionType.LONG,\n *   allocatedBalance: 200_000_000_000_000_000_000n,\n *   lockedCVA: 10_000_000_000_000_000_000n,\n *   lockedLF: 5_000_000_000_000_000_000n,\n * });\n * ```\n */\nexport function calculateLiquidationPrice(inputs: CalculateLiquidationPriceInputs): bigint {\n  let totalQty = 0n;\n  let totalNotional = 0n;\n  for (const position of inputs.positions) {\n    const openQty = position.quantity - (position.closedAmount ?? 0n);\n    if (openQty <= 0n) continue;\n    totalQty += openQty;\n    totalNotional += mulWei(openQty, position.openedPrice);\n  }\n  if (totalQty === 0n) return 0n;\n\n  const freeBalance = inputs.allocatedBalance - inputs.lockedCVA - inputs.lockedLF;\n  const numerator =\n    inputs.positionType === PositionType.LONG ? totalNotional - freeBalance : totalNotional + freeBalance;\n\n  const liquidationPrice = (numerator * WEI) / totalQty;\n  return liquidationPrice > 0n ? liquidationPrice : 0n;\n}\n"],"mappings":";;;AAiEA,SAAgB,EAA0B,GAAiD;CACzF,IAAI,IAAW,IACX,IAAgB;CACpB,KAAK,IAAM,KAAY,EAAO,WAAW;EACvC,IAAM,IAAU,EAAS,YAAY,EAAS,gBAAgB;EAC1D,KAAW,OACf,KAAY,GACZ,KAAiB,EAAO,GAAS,EAAS,WAAW;CACvD;CACA,IAAI,MAAa,IAAI,OAAO;CAE5B,IAAM,IAAc,EAAO,mBAAmB,EAAO,YAAY,EAAO,UAIlE,KAFJ,EAAO,iBAAiB,EAAa,OAAO,IAAgB,IAAc,IAAgB,KAEtD,IAAO;CAC7C,OAAO,IAAmB,KAAK,IAAmB;AACpD"}

package/dist/quotes/open-price.d.ts

@@ -0,0 +1,51 @@
+import { UnifiedQuote } from './unified-quote.js';
+/**
+ * A quote's settled open price, or `undefined` while it has none — a pending or
+ * optimistic open.
+ *
+ * A quote carries `openedPrice: 0n` in the same situations it carries
+ * `undefined`, so both collapse to `undefined` here; callers never have to
+ * repeat that pair of checks. Substituting `requestedOpenPrice` would value the
+ * position at a fill that never happened — use {@link openPriceOf} only where
+ * that fallback is intended.
+ *
+ * @param quote - Any object carrying the quote's settled open price.
+ * @returns The settled price in wei, or `undefined` when it is not settled yet.
+ */
+export declare function settledOpenPriceOf(quote: Pick<UnifiedQuote, "openedPrice">): bigint | undefined;
+/**
+ * Whether a quote still lacks a settled open price (a pending or optimistic
+ * open). The exact complement of {@link settledOpenPriceOf}.
+ *
+ * @param quote - Any object carrying the quote's settled open price.
+ * @returns `true` while the open price is unsettled.
+ */
+export declare function hasUnsettledOpenPrice(quote: Pick<UnifiedQuote, "openedPrice">): boolean;
+/**
+ * A quote's open price for valuation: the settled `openedPrice`, else the
+ * `requestedOpenPrice` it was submitted at.
+ *
+ * This is the fallback rule shared by `aggregateGroupMetrics` and
+ * `toGroupTpSlChildren`, so a group's weighted open price and its TP/SL
+ * children are always valued against the same number.
+ *
+ * @param quote - Any object carrying the quote's open prices.
+ * @returns The valuation price in wei.
+ */
+export declare function openPriceOf(quote: Pick<UnifiedQuote, "openedPrice" | "requestedOpenPrice">): bigint;
+/**
+ * A quote's reference price for leverage: the `requestedOpenPrice`, else the
+ * settled `openedPrice`.
+ *
+ * **The precedence is the inverse of {@link openPriceOf}** and that is
+ * deliberate: leverage describes the position as it was *opened*, so the price
+ * the trader committed to wins, and the settled fill steps in only when there is
+ * no requested price on record. Shared by `aggregateGroupMetrics` and
+ * `calculateQuoteLeverage`, which agree on this rule while deliberately
+ * differing in numeric strategy (exact bigint vs. float).
+ *
+ * @param quote - Any object carrying the quote's open prices.
+ * @returns The leverage reference price in wei, or `0n` when neither is set.
+ */
+export declare function leveragePriceOf(quote: Pick<UnifiedQuote, "openedPrice" | "requestedOpenPrice">): bigint;
+//# sourceMappingURL=open-price.d.ts.map

package/dist/quotes/open-price.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-price.d.ts","sourceRoot":"","sources":["../../src/quotes/open-price.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;;;;;;GAYG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,aAAa,CAAC,GAAG,MAAM,GAAG,SAAS,CAE/F;AAED;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,aAAa,CAAC,GAAG,OAAO,CAEvF;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,aAAa,GAAG,oBAAoB,CAAC,GAAG,MAAM,CAEnG;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,aAAa,GAAG,oBAAoB,CAAC,GAAG,MAAM,CAEvG"}

package/dist/quotes/open-price.js

@@ -0,0 +1,17 @@
+//#region src/quotes/open-price.ts
+function e(e) {
+	return e.openedPrice !== void 0 && e.openedPrice !== 0n ? e.openedPrice : void 0;
+}
+function t(t) {
+	return e(t) === void 0;
+}
+function n(t) {
+	return e(t) ?? t.requestedOpenPrice;
+}
+function r(e) {
+	return e.requestedOpenPrice === 0n ? e.openedPrice ?? 0n : e.requestedOpenPrice;
+}
+//#endregion
+export { t as hasUnsettledOpenPrice, r as leveragePriceOf, n as openPriceOf, e as settledOpenPriceOf };
+
+//# sourceMappingURL=open-price.js.map

package/dist/quotes/open-price.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-price.js","names":[],"sources":["../../src/quotes/open-price.ts"],"sourcesContent":["import type { UnifiedQuote } from \"./unified-quote\";\n\n/**\n * A quote's settled open price, or `undefined` while it has none — a pending or\n * optimistic open.\n *\n * A quote carries `openedPrice: 0n` in the same situations it carries\n * `undefined`, so both collapse to `undefined` here; callers never have to\n * repeat that pair of checks. Substituting `requestedOpenPrice` would value the\n * position at a fill that never happened — use {@link openPriceOf} only where\n * that fallback is intended.\n *\n * @param quote - Any object carrying the quote's settled open price.\n * @returns The settled price in wei, or `undefined` when it is not settled yet.\n */\nexport function settledOpenPriceOf(quote: Pick<UnifiedQuote, \"openedPrice\">): bigint | undefined {\n  return quote.openedPrice !== undefined && quote.openedPrice !== 0n ? quote.openedPrice : undefined;\n}\n\n/**\n * Whether a quote still lacks a settled open price (a pending or optimistic\n * open). The exact complement of {@link settledOpenPriceOf}.\n *\n * @param quote - Any object carrying the quote's settled open price.\n * @returns `true` while the open price is unsettled.\n */\nexport function hasUnsettledOpenPrice(quote: Pick<UnifiedQuote, \"openedPrice\">): boolean {\n  return settledOpenPriceOf(quote) === undefined;\n}\n\n/**\n * A quote's open price for valuation: the settled `openedPrice`, else the\n * `requestedOpenPrice` it was submitted at.\n *\n * This is the fallback rule shared by `aggregateGroupMetrics` and\n * `toGroupTpSlChildren`, so a group's weighted open price and its TP/SL\n * children are always valued against the same number.\n *\n * @param quote - Any object carrying the quote's open prices.\n * @returns The valuation price in wei.\n */\nexport function openPriceOf(quote: Pick<UnifiedQuote, \"openedPrice\" | \"requestedOpenPrice\">): bigint {\n  return settledOpenPriceOf(quote) ?? quote.requestedOpenPrice;\n}\n\n/**\n * A quote's reference price for leverage: the `requestedOpenPrice`, else the\n * settled `openedPrice`.\n *\n * **The precedence is the inverse of {@link openPriceOf}** and that is\n * deliberate: leverage describes the position as it was *opened*, so the price\n * the trader committed to wins, and the settled fill steps in only when there is\n * no requested price on record. Shared by `aggregateGroupMetrics` and\n * `calculateQuoteLeverage`, which agree on this rule while deliberately\n * differing in numeric strategy (exact bigint vs. float).\n *\n * @param quote - Any object carrying the quote's open prices.\n * @returns The leverage reference price in wei, or `0n` when neither is set.\n */\nexport function leveragePriceOf(quote: Pick<UnifiedQuote, \"openedPrice\" | \"requestedOpenPrice\">): bigint {\n  return quote.requestedOpenPrice !== 0n ? quote.requestedOpenPrice : (quote.openedPrice ?? 0n);\n}\n"],"mappings":";AAeA,SAAgB,EAAmB,GAA8D;CAC/F,OAAO,EAAM,gBAAgB,KAAA,KAAa,EAAM,gBAAgB,KAAK,EAAM,cAAc,KAAA;AAC3F;AASA,SAAgB,EAAsB,GAAmD;CACvF,OAAO,EAAmB,CAAK,MAAM,KAAA;AACvC;AAaA,SAAgB,EAAY,GAAyE;CACnG,OAAO,EAAmB,CAAK,KAAK,EAAM;AAC5C;AAgBA,SAAgB,EAAgB,GAAyE;CACvG,OAAO,EAAM,uBAAuB,KAAiC,EAAM,eAAe,KAAjD,EAAM;AACjD"}

package/dist/quotes/open-quantity.d.ts

@@ -12,6 +12,12 @@ import { UnifiedQuote } from './unified-quote.js';
  * once fully closed `closedAmount === quantity`, so the open size is `0` — the
  * exact semantics of the on-chain `LibQuote.quoteOpenAmount`.
  *
+ * This is a **size, not a state**. A quote that has not opened at all — `PENDING`,
+ * `LOCKED`, `CANCEL_PENDING` — has closed nothing, so it still reports its full
+ * `quantity` here. Do not use `> 0` as a test for "this is an open position":
+ * classify with `isPendingOrder` / `isActivePosition`, which read the on-chain
+ * `QuoteStatus`.
+ *
  * @param quote - The amount fields needed to derive the open size.
  * @returns The remaining open quantity, in 18-decimal wei.
  *

package/dist/quotes/open-quantity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"open-quantity.d.ts","sourceRoot":"","sources":["../../src/quotes/open-quantity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,UAAU,GAAG,cAAc,CAAC,GAAG,MAAM,CAEhG"}
+{"version":3,"file":"open-quantity.d.ts","sourceRoot":"","sources":["../../src/quotes/open-quantity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,UAAU,GAAG,cAAc,CAAC,GAAG,MAAM,CAEhG"}

package/dist/quotes/open-quantity.js.map

@@ -1 +1 @@
-{"version":3,"file":"open-quantity.js","names":[],"sources":["../../src/quotes/open-quantity.ts"],"sourcesContent":["import type { UnifiedQuote } from \"./unified-quote\";\n\n/**\n * Compute a quote's remaining **open** size — the live quantity still on the\n * position, `quantity − closedAmount`.\n *\n * A position keeps its original {@link UnifiedQuote.quantity} for its entire life;\n * a partial close does **not** shrink `quantity`, it accrues into\n * {@link UnifiedQuote.closedAmount}. The size a trader can still close (and the\n * figure a UI shows as \"position size\") is therefore the difference between the\n * two. When `closedAmount` is absent (an off-chain optimistic open that has not\n * closed anything yet) it is treated as `0`, so the open size equals `quantity`;\n * once fully closed `closedAmount === quantity`, so the open size is `0` — the\n * exact semantics of the on-chain `LibQuote.quoteOpenAmount`.\n *\n * @param quote - The amount fields needed to derive the open size.\n * @returns The remaining open quantity, in 18-decimal wei.\n *\n * @example\n * ```ts\n * // quantity 142.191812e18, closedAmount 100e18\n * quoteOpenQuantity(quote); // → 42.191812e18\n * ```\n */\nexport function quoteOpenQuantity(quote: Pick<UnifiedQuote, \"quantity\" | \"closedAmount\">): bigint {\n  return quote.quantity - (quote.closedAmount ?? 0n);\n}\n"],"mappings":";AAwBA,SAAgB,EAAkB,GAAgE;CAChG,OAAO,EAAM,YAAY,EAAM,gBAAgB;AACjD"}
+{"version":3,"file":"open-quantity.js","names":[],"sources":["../../src/quotes/open-quantity.ts"],"sourcesContent":["import type { UnifiedQuote } from \"./unified-quote\";\n\n/**\n * Compute a quote's remaining **open** size — the live quantity still on the\n * position, `quantity − closedAmount`.\n *\n * A position keeps its original {@link UnifiedQuote.quantity} for its entire life;\n * a partial close does **not** shrink `quantity`, it accrues into\n * {@link UnifiedQuote.closedAmount}. The size a trader can still close (and the\n * figure a UI shows as \"position size\") is therefore the difference between the\n * two. When `closedAmount` is absent (an off-chain optimistic open that has not\n * closed anything yet) it is treated as `0`, so the open size equals `quantity`;\n * once fully closed `closedAmount === quantity`, so the open size is `0` — the\n * exact semantics of the on-chain `LibQuote.quoteOpenAmount`.\n *\n * This is a **size, not a state**. A quote that has not opened at all — `PENDING`,\n * `LOCKED`, `CANCEL_PENDING` — has closed nothing, so it still reports its full\n * `quantity` here. Do not use `> 0` as a test for \"this is an open position\":\n * classify with `isPendingOrder` / `isActivePosition`, which read the on-chain\n * `QuoteStatus`.\n *\n * @param quote - The amount fields needed to derive the open size.\n * @returns The remaining open quantity, in 18-decimal wei.\n *\n * @example\n * ```ts\n * // quantity 142.191812e18, closedAmount 100e18\n * quoteOpenQuantity(quote); // → 42.191812e18\n * ```\n */\nexport function quoteOpenQuantity(quote: Pick<UnifiedQuote, \"quantity\" | \"closedAmount\">): bigint {\n  return quote.quantity - (quote.closedAmount ?? 0n);\n}\n"],"mappings":";AA8BA,SAAgB,EAAkB,GAAgE;CAChG,OAAO,EAAM,YAAY,EAAM,gBAAgB;AACjD"}

package/dist/quotes/quote-id-key-part.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Stringify a list of quote ids for a TanStack query key, sorted ascending so
+ * that two calls that pass the same ids in a different order share one cache
+ * entry instead of fragmenting into two identical round-trips.
+ *
+ * Sorts numerically (not lexicographically) on a copy — the caller's array is
+ * never mutated. `bigint` ids are stringified so the key survives structural
+ * hashing, which cannot serialize a `bigint`.
+ *
+ * @param quoteIds - On-chain quote ids to put in the key.
+ * @returns The ids as decimal strings, ascending.
+ *
+ * @example
+ * ```ts
+ * toQuoteIdKeyPart([10n, 9n, 100n]); // ["9", "10", "100"]
+ * ```
+ */
+export declare function toQuoteIdKeyPart(quoteIds: readonly bigint[]): string[];
+//# sourceMappingURL=quote-id-key-part.d.ts.map

package/dist/quotes/quote-id-key-part.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quote-id-key-part.d.ts","sourceRoot":"","sources":["../../src/quotes/quote-id-key-part.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAEtE"}

package/dist/quotes/quote-id-key-part.js

@@ -0,0 +1,8 @@
+//#region src/quotes/quote-id-key-part.ts
+function e(e) {
+	return [...e].sort((e, t) => e < t ? -1 : +(e > t)).map((e) => e.toString());
+}
+//#endregion
+export { e as toQuoteIdKeyPart };
+
+//# sourceMappingURL=quote-id-key-part.js.map

package/dist/quotes/quote-id-key-part.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"quote-id-key-part.js","names":[],"sources":["../../src/quotes/quote-id-key-part.ts"],"sourcesContent":["/**\n * Stringify a list of quote ids for a TanStack query key, sorted ascending so\n * that two calls that pass the same ids in a different order share one cache\n * entry instead of fragmenting into two identical round-trips.\n *\n * Sorts numerically (not lexicographically) on a copy — the caller's array is\n * never mutated. `bigint` ids are stringified so the key survives structural\n * hashing, which cannot serialize a `bigint`.\n *\n * @param quoteIds - On-chain quote ids to put in the key.\n * @returns The ids as decimal strings, ascending.\n *\n * @example\n * ```ts\n * toQuoteIdKeyPart([10n, 9n, 100n]); // [\"9\", \"10\", \"100\"]\n * ```\n */\nexport function toQuoteIdKeyPart(quoteIds: readonly bigint[]): string[] {\n  return [...quoteIds].sort((a, b) => (a < b ? -1 : a > b ? 1 : 0)).map((id) => id.toString());\n}\n"],"mappings":";AAiBA,SAAgB,EAAiB,GAAuC;CACtE,OAAO,CAAC,GAAG,CAAQ,EAAE,MAAM,GAAG,MAAO,IAAI,IAAI,KAAK,MAAI,EAAU,EAAE,KAAK,MAAO,EAAG,SAAS,CAAC;AAC7F"}

package/dist/quotes/reconcile-quotes.d.ts

@@ -1,6 +1,6 @@
 import { Address } from 'viem';
 import { PendingInstantClose } from '../solvers/instant-close/get-instant-closes/to-pending-instant-close.js';
-import { PendingInstantOpen } from '../solvers/instant-open/get-instant-opens/to-pending-instant-open.js';
+import { PendingInstantOpen } from '../solvers/instant-open/get-instant-opens/types.js';
 import { Quote } from '../symmio-contracts/symmio/types.js';
 import { Notification } from '../websocket/notifications/types.js';
 import { UnifiedQuote } from './unified-quote.js';
@@ -40,6 +40,17 @@ export interface ReconcileQuotesInput {
      * struct, so the retained copy is ignored).
      */
     retainedAnchors?: readonly UnifiedQuote[];
+    /**
+     * On-chain quote ids (decimal strings) whose close is **in flight** — filled
+     * off-chain but not yet reflected by the on-chain read. The close-side mirror
+     * of {@link retainedAnchors}: the poll rebuilds a filled-but-unsettled close as
+     * `ONCHAIN` (`OPENED`) every tick, and a replayed close notification cannot
+     * restore the stage on a poll-confirmed row (apply-notification's `inClosingFlow`
+     * guard), so a row still read `OPENED` whose id is here is held at
+     * {@link QuoteLifecycle.WRITE_ONCHAIN_CLOSE}. The caller bounds the set with its
+     * close-confirm hold, so it clears at `CLOSE_PENDING` / removal / budget.
+     */
+    closingQuoteIds?: readonly string[];
 }
 /** Output of {@link reconcileQuotes}: the merged rows plus the temp ↔ on-chain links. */
 export interface ReconcileQuotesResult {

package/dist/quotes/reconcile-quotes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reconcile-quotes.d.ts","sourceRoot":"","sources":["../../src/quotes/reconcile-quotes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sEAAsE,CAAC;AAChH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mEAAmE,CAAC;AAC5G,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kCAAkC,CAAC;AAC9D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAIrE,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpE;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,oDAAoD;IACpD,MAAM,EAAE,OAAO,CAAC;IAChB,0DAA0D;IAC1D,gBAAgB,EAAE,SAAS,KAAK,EAAE,CAAC;IACnC,uDAAuD;IACvD,oBAAoB,EAAE,SAAS,KAAK,EAAE,CAAC;IACvC,oDAAoD;IACpD,YAAY,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC5C,qDAAqD;IACrD,aAAa,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC9C;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChD,gEAAgE;IAChE,aAAa,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IACxC;;;;;;;;;OASG;IACH,eAAe,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;CAC3C;AAED,yFAAyF;AACzF,MAAM,WAAW,qBAAqB;IACpC,kEAAkE;IAClE,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B;;;;;OAKG;IACH,cAAc,EAAE,YAAY,EAAE,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,GAAG,qBAAqB,CA6ElF"}
+{"version":3,"file":"reconcile-quotes.d.ts","sourceRoot":"","sources":["../../src/quotes/reconcile-quotes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sEAAsE,CAAC;AAChH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AAC1F,OAAO,EAAe,KAAK,KAAK,EAAE,MAAM,kCAAkC,CAAC;AAC3E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAIrE,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAEpE;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,oDAAoD;IACpD,MAAM,EAAE,OAAO,CAAC;IAChB,0DAA0D;IAC1D,gBAAgB,EAAE,SAAS,KAAK,EAAE,CAAC;IACnC,uDAAuD;IACvD,oBAAoB,EAAE,SAAS,KAAK,EAAE,CAAC;IACvC,oDAAoD;IACpD,YAAY,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC5C,qDAAqD;IACrD,aAAa,EAAE,SAAS,mBAAmB,EAAE,CAAC;IAC9C;;;;;OAKG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChD,gEAAgE;IAChE,aAAa,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IACxC;;;;;;;;;OASG;IACH,eAAe,CAAC,EAAE,SAAS,YAAY,EAAE,CAAC;IAC1C;;;;;;;;;OASG;IACH,eAAe,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACrC;AAED,yFAAyF;AACzF,MAAM,WAAW,qBAAqB;IACpC,kEAAkE;IAClE,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB;;;;;OAKG;IACH,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC9B;;;;;OAKG;IACH,cAAc,EAAE,YAAY,EAAE,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,oBAAoB,GAAG,qBAAqB,CAsGlF"}

package/dist/quotes/reconcile-quotes.js

@@ -1,24 +1,25 @@
-import { QuoteLifecycle as e } from "./unified-quote.js";
-import { applyNotificationToQuotes as t } from "./apply-notification.js";
-import { fingerprintQuote as n } from "./fingerprint.js";
-import { toUnifiedQuoteFromInstantOpen as r, toUnifiedQuoteFromOnchain as i } from "./to-unified-quote.js";
+import { QuoteStatus as e } from "../symmio-contracts/symmio/types.js";
+import { QuoteLifecycle as t } from "./unified-quote.js";
+import { applyNotificationToQuotes as n } from "./apply-notification.js";
+import { fingerprintQuote as r } from "./fingerprint.js";
+import { toUnifiedQuoteFromInstantOpen as i, toUnifiedQuoteFromOnchain as a } from "./to-unified-quote.js";
 //#region src/quotes/reconcile-quotes.ts
-function a(a) {
-	let c = /* @__PURE__ */ new Map();
-	for (let e of a.onchainPositions) {
-		let t = l(i(e), a.partyA);
-		c.set(t.key, t);
+function o(o) {
+	let l = /* @__PURE__ */ new Map();
+	for (let e of o.onchainPositions) {
+		let t = u(a(e), o.partyA);
+		l.set(t.key, t);
 	}
-	for (let e of a.onchainPendingQuotes) {
-		let t = l(i(e), a.partyA);
-		c.has(t.key) || c.set(t.key, t);
+	for (let e of o.onchainPendingQuotes) {
+		let t = u(a(e), o.partyA);
+		l.has(t.key) || l.set(t.key, t);
 	}
-	for (let e of a.retainedAnchors ?? []) c.has(e.key) || c.set(e.key, e);
-	for (let e of a.instantCloses) {
-		let t = `onchain:${e.quoteId}`, n = c.get(t);
-		n && c.set(t, {
+	for (let e of o.retainedAnchors ?? []) l.has(e.key) || l.set(e.key, e);
+	for (let e of o.instantCloses) {
+		let t = `onchain:${e.quoteId}`, n = l.get(t);
+		n && l.set(t, {
 			...n,
-			lifecycle: o(n),
+			lifecycle: s(n),
 			quantityToClose: e.quantityToClose,
 			raw: {
 				...n.raw,
@@ -26,43 +27,50 @@ function a(a) {
 			}
 		});
 	}
-	let d = /* @__PURE__ */ new Set();
-	for (let e of c.values()) e.origin === "onchain" && d.add(n(e));
-	for (let e of a.instantOpens) {
-		let t = r(e);
-		if (d.has(n(t))) continue;
-		let i = a.instantOpenVaByTempId?.[e.tempQuoteId];
-		i && (t.vaAddress = i), c.has(t.key) || c.set(t.key, t);
+	let f = /* @__PURE__ */ new Set();
+	for (let e of l.values()) e.origin === "onchain" && f.add(r(e));
+	for (let e of o.instantOpens) {
+		let t = i(e);
+		if (f.has(r(t))) continue;
+		let n = o.instantOpenVaByTempId?.[e.tempQuoteId];
+		n && (t.vaAddress = n), l.has(t.key) || l.set(t.key, t);
 	}
-	let f = [...c.values()];
-	for (let e of a.notifications ?? []) f = t(f, e);
-	f = s(f), f.sort((e, t) => {
+	let p = [...l.values()];
+	for (let e of o.notifications ?? []) p = n(p, e);
+	if (p = c(p), o.closingQuoteIds?.length) {
+		let n = new Set(o.closingQuoteIds);
+		p = p.map((r) => r.quoteId !== void 0 && n.has(`${r.quoteId}`) && r.lifecycle === t.ONCHAIN && r.quoteStatus === e.OPENED ? {
+			...r,
+			lifecycle: t.WRITE_ONCHAIN_CLOSE
+		} : r);
+	}
+	p = p.filter((e) => e.lifecycle !== t.CLOSED), p.sort((e, t) => {
 		let n = e.statusModifyTimestamp ?? 0n, r = t.statusModifyTimestamp ?? 0n;
 		if (n !== r) return n > r ? -1 : 1;
-		let i = u(e), a = u(t);
+		let i = d(e), a = d(t);
 		return i === a ? 0 : i > a ? -1 : 1;
 	});
-	let p = {};
-	for (let e of f) e.tempQuoteId !== void 0 && e.quoteId !== void 0 && (p[e.tempQuoteId] = e.key);
-	let m = f.filter((t) => t.lifecycle === e.WRITE_ONCHAIN);
+	let m = {};
+	for (let e of p) e.tempQuoteId !== void 0 && e.quoteId !== void 0 && (m[e.tempQuoteId] = e.key);
+	let h = p.filter((e) => e.lifecycle === t.WRITE_ONCHAIN);
 	return {
-		quotes: f,
-		links: p,
-		pendingAnchors: m
+		quotes: p,
+		links: m,
+		pendingAnchors: h
 	};
 }
-function o(t) {
-	return t.lifecycle === e.CLOSED ? e.CLOSED : t.lifecycle === e.CLOSING ? e.CLOSING : e.OPTIMISTIC_CLOSE;
+function s(n) {
+	return n.lifecycle === t.CLOSED ? t.CLOSED : n.quoteStatus === e.CLOSE_PENDING || n.quoteStatus === e.CANCEL_CLOSE_PENDING ? n.lifecycle : t.OPTIMISTIC_CLOSE;
 }
-function s(e) {
+function c(e) {
 	let t = /* @__PURE__ */ new Map();
 	for (let n of e) {
 		let e = t.get(n.key);
-		t.set(n.key, e ? c(e, n) : n);
+		t.set(n.key, e ? l(e, n) : n);
 	}
 	return [...t.values()];
 }
-function c(e, t) {
+function l(e, t) {
 	let n = e.raw.onchain ? e : t, r = n === e ? t : e;
 	return {
 		...n,
@@ -77,16 +85,16 @@ function c(e, t) {
 		}
 	};
 }
-function l(e, t) {
+function u(e, t) {
 	return e.partyA.toLowerCase() === t.toLowerCase() ? e : {
 		...e,
 		vaAddress: e.partyA
 	};
 }
-function u(e) {
+function d(e) {
 	return e.quoteId === void 0 ? e.tempQuoteId === void 0 ? 0n : BigInt(e.tempQuoteId) : e.quoteId;
 }
 //#endregion
-export { a as reconcileQuotes };
+export { o as reconcileQuotes };
 
 //# sourceMappingURL=reconcile-quotes.js.map

package/dist/quotes/reconcile-quotes.js.map

@@ -1 +1 @@
-{"version":3,"file":"reconcile-quotes.js","names":[],"sources":["../../src/quotes/reconcile-quotes.ts"],"sourcesContent":["import type { Address } from \"viem\";\nimport type { PendingInstantClose } from \"../solvers/instant-close/get-instant-closes/to-pending-instant-close\";\nimport type { PendingInstantOpen } from \"../solvers/instant-open/get-instant-opens/to-pending-instant-open\";\nimport type { Quote } from \"../symmio-contracts/symmio/types\";\nimport type { Notification } from \"../websocket/notifications/types\";\nimport { applyNotificationToQuotes } from \"./apply-notification\";\nimport { fingerprintQuote } from \"./fingerprint\";\nimport { toUnifiedQuoteFromInstantOpen, toUnifiedQuoteFromOnchain } from \"./to-unified-quote\";\nimport { QuoteLifecycle, type UnifiedQuote } from \"./unified-quote\";\n\n/**\n * Inputs to {@link reconcileQuotes}: one snapshot of every quote source. The\n * result is \"active quotes only\" — a quote appears in the output iff it is\n * present in at least one of these sources this tick.\n */\nexport interface ReconcileQuotesInput {\n  /** Sub-account (partyA) the snapshot belongs to. */\n  partyA: Address;\n  /** On-chain open positions (`getPartyAOpenPositions`). */\n  onchainPositions: readonly Quote[];\n  /** On-chain pending quotes hydrated via `getQuote`. */\n  onchainPendingQuotes: readonly Quote[];\n  /** Pending instant-open records from the hedger. */\n  instantOpens: readonly PendingInstantOpen[];\n  /** Pending instant-close records from the hedger. */\n  instantCloses: readonly PendingInstantClose[];\n  /**\n   * Map from a pending instant-open's `tempQuoteId` to the Virtual Account (VA)\n   * address its position will land in (from `resolveQuoteAccounts`). When a temp\n   * id is present here, the optimistic row is stamped with its eventual VA so the\n   * UI can show the VA before the trade anchors on-chain.\n   */\n  instantOpenVaByTempId?: Record<number, Address>;\n  /** Notifications to apply after the merge, in arrival order. */\n  notifications?: readonly Notification[];\n  /**\n   * Rows that anchored on-chain on a prior tick (a notification set their\n   * `quoteId`) but whose on-chain struct has not been read yet — the\n   * `pendingAnchors` returned by the previous {@link reconcileQuotes} call. The\n   * consumer feeds them back so an anchored row survives the gap between \"the\n   * hedger drops the pending open\" and \"the on-chain read returns the quote\"\n   * instead of vanishing for a tick. Each is dropped automatically once the\n   * matching on-chain read arrives (its `key` is already populated with the real\n   * struct, so the retained copy is ignored).\n   */\n  retainedAnchors?: readonly UnifiedQuote[];\n}\n\n/** Output of {@link reconcileQuotes}: the merged rows plus the temp ↔ on-chain links. */\nexport interface ReconcileQuotesResult {\n  /** Merged, de-duplicated, lifecycle-tagged rows, newest first. */\n  quotes: UnifiedQuote[];\n  /**\n   * Map from `tempQuoteId` to the on-chain row `key` it resolved to, recorded\n   * **only once the row has anchored on-chain** (`quoteId` present). A\n   * still-optimistic temp id is absent until then, so consumers can use this to\n   * clear an optimistic seed exactly when its on-chain twin exists.\n   */\n  links: Record<number, string>;\n  /**\n   * Rows currently in {@link QuoteLifecycle.WRITE_ONCHAIN} — anchored per a\n   * notification but not yet returned by the on-chain read. The consumer retains\n   * these and feeds them back as {@link ReconcileQuotesInput.retainedAnchors} on\n   * the next tick so they do not flicker out while the RPC catches up.\n   */\n  pendingAnchors: UnifiedQuote[];\n}\n\n/**\n * Merge every quote source for a sub-account into one stable, de-duplicated,\n * lifecycle-tagged list — **active quotes only**: a quote appears iff it is in at\n * least one source this tick, so a quote that has left every source is simply\n * absent (no lingering \"removed\" rows). **Pure** and stateless: given the same\n * `input` it always returns the same result, reading no clock and no randomness.\n *\n * Pipeline:\n *\n * 1. On-chain positions + pending quotes become anchored rows; `retainedAnchors`\n *    re-seed any anchored-but-not-yet-read row so it does not flicker out.\n * 2. Pending instant-closes overlay the matching on-chain row — `CLOSING` once the\n *    on-chain status shows the close pending, else `WRITE_ONCHAIN_CLOSE`.\n * 3. Pending instant-opens become `OPTIMISTIC` rows, **dropped** when an on-chain\n *    row already carries the same {@link fingerprintQuote} (the trade landed).\n * 4. Notifications are applied in order to link temp ↔ on-chain ids and advance\n *    lifecycles (an anchored-but-unread row sits at `WRITE_ONCHAIN`); `collapseByKey`\n *    then merges a rekeyed optimistic row into its on-chain twin, so the off-chain\n *    row drops once on-chain.\n * 5. Rows are sorted by `statusModifyTimestamp` descending (newest first), and the\n *    `WRITE_ONCHAIN` rows are returned as `pendingAnchors` for the next tick.\n *\n * @param input - One snapshot of all sources.\n * @returns The merged rows plus the temp ↔ on-chain `links`.\n *\n * @example\n * ```ts\n * const { quotes } = reconcileQuotes({\n *   partyA,\n *   onchainPositions,\n *   onchainPendingQuotes,\n *   instantOpens,\n *   instantCloses,\n *   notifications,\n * });\n * ```\n */\nexport function reconcileQuotes(input: ReconcileQuotesInput): ReconcileQuotesResult {\n  const byKey = new Map<string, UnifiedQuote>();\n\n  for (const quote of input.onchainPositions) {\n    const row = withVaAddress(toUnifiedQuoteFromOnchain(quote), input.partyA);\n    byKey.set(row.key, row);\n  }\n  for (const quote of input.onchainPendingQuotes) {\n    const row = withVaAddress(toUnifiedQuoteFromOnchain(quote), input.partyA);\n    if (!byKey.has(row.key)) byKey.set(row.key, row);\n  }\n  /**\n   * Re-seed rows that anchored on a prior tick but have no on-chain struct yet, so\n   * they survive the hedger-drop → on-chain-read gap. Skipped the moment the real\n   * on-chain read populates the same `key` (inserted above), so retention ends\n   * itself once the RPC confirms.\n   */\n  for (const anchor of input.retainedAnchors ?? []) {\n    if (!byKey.has(anchor.key)) byKey.set(anchor.key, anchor);\n  }\n  for (const close of input.instantCloses) {\n    const key = `onchain:${close.quoteId}`;\n    const existing = byKey.get(key);\n    /**\n     * An instant-close always references a quote that already exists on-chain, so\n     * we only overlay the close onto its matching row. If the on-chain row has not\n     * loaded yet we skip it rather than synthesize a placeholder with no market or\n     * side; the overlay applies on the next tick once the position read catches up.\n     */\n    if (!existing) continue;\n    byKey.set(key, {\n      ...existing,\n      lifecycle: overlayCloseLifecycle(existing),\n      quantityToClose: close.quantityToClose,\n      raw: { ...existing.raw, instantClose: close },\n    });\n  }\n\n  const onchainFingerprints = new Set<string>();\n\n  for (const row of byKey.values()) {\n    if (row.origin === \"onchain\") onchainFingerprints.add(fingerprintQuote(row));\n  }\n  for (const open of input.instantOpens) {\n    const row = toUnifiedQuoteFromInstantOpen(open);\n    if (onchainFingerprints.has(fingerprintQuote(row))) continue;\n    const vaAddress = input.instantOpenVaByTempId?.[open.tempQuoteId];\n    if (vaAddress) row.vaAddress = vaAddress;\n    if (!byKey.has(row.key)) byKey.set(row.key, row);\n  }\n  let merged = [...byKey.values()];\n  for (const notification of input.notifications ?? []) {\n    merged = applyNotificationToQuotes(merged, notification);\n  }\n  merged = collapseByKey(merged);\n  merged.sort((a, b) => {\n    const aTs = a.statusModifyTimestamp ?? 0n;\n    const bTs = b.statusModifyTimestamp ?? 0n;\n    if (aTs !== bTs) return aTs > bTs ? -1 : 1;\n    const aId = stableSortKey(a);\n    const bId = stableSortKey(b);\n    if (aId !== bId) return aId > bId ? -1 : 1;\n    return 0;\n  });\n  const links: Record<number, string> = {};\n  for (const row of merged) {\n    /**\n     * Only record a temp ↔ on-chain link once the row has actually anchored\n     * (`quoteId` set). A still-optimistic row carries only its own `temp:` key —\n     * recording that as a \"link\" would let the consumer clear its optimistic seed\n     * before the on-chain twin exists, dropping the row for a tick (the\n     * appear→disappear→reappear flicker).\n     */\n    if (row.tempQuoteId !== undefined && row.quoteId !== undefined) links[row.tempQuoteId] = row.key;\n  }\n  const pendingAnchors = merged.filter((row) => row.lifecycle === QuoteLifecycle.WRITE_ONCHAIN);\n  return { quotes: merged, links, pendingAnchors };\n}\n\n/**\n * Lifecycle for an on-chain row that a pending instant-close overlays. Keep a\n * terminal `CLOSED` as-is; keep `CLOSING` when the on-chain status already shows\n * the close pending; otherwise the close is in-flight but the read still shows the\n * position open — surface {@link QuoteLifecycle.OPTIMISTIC_CLOSE} as the base close\n * stage. Close notifications (applied after this overlay) then advance it to\n * `CLOSE_PRICE_FILLED` → `WRITE_ONCHAIN_CLOSE`; the poll moves it to `CLOSING` once\n * the on-chain status reflects the pending close.\n */\nfunction overlayCloseLifecycle(existing: UnifiedQuote): QuoteLifecycle {\n  if (existing.lifecycle === QuoteLifecycle.CLOSED) return QuoteLifecycle.CLOSED;\n  if (existing.lifecycle === QuoteLifecycle.CLOSING) return QuoteLifecycle.CLOSING;\n  return QuoteLifecycle.OPTIMISTIC_CLOSE;\n}\n\n/**\n * Collapse rows that ended up sharing a `key` after a notification rekeyed an\n * optimistic row (`temp:<id>` → `onchain:<id>`) onto an on-chain twin the poll\n * already returned. Without this the same quote can appear twice — once from the\n * poll and once from the rekeyed optimistic row — yielding duplicate React keys.\n * The genuine on-chain row (the one carrying `raw.onchain`) wins; the optimistic\n * row's `tempQuoteId` / `raw.instantOpen` are grafted on so the temp ↔ on-chain\n * link survives and the optimistic entry can be cleared.\n */\nfunction collapseByKey(rows: UnifiedQuote[]): UnifiedQuote[] {\n  const byKey = new Map<string, UnifiedQuote>();\n  for (const row of rows) {\n    const existing = byKey.get(row.key);\n    byKey.set(row.key, existing ? mergeDuplicateRows(existing, row) : row);\n  }\n  return [...byKey.values()];\n}\n\n/**\n * Merge two rows that resolved to the same `key`, preferring the one that carries\n * the polled on-chain struct and grafting the off-chain identifiers from the other.\n */\nfunction mergeDuplicateRows(a: UnifiedQuote, b: UnifiedQuote): UnifiedQuote {\n  const primary = a.raw.onchain ? a : b;\n  const secondary = primary === a ? b : a;\n  return {\n    ...primary,\n    tempQuoteId: primary.tempQuoteId ?? secondary.tempQuoteId,\n    vaAddress: primary.vaAddress ?? secondary.vaAddress,\n    openedPrice: primary.openedPrice ?? secondary.openedPrice,\n    avgClosedPrice: primary.avgClosedPrice ?? secondary.avgClosedPrice,\n    quantityToClose: primary.quantityToClose ?? secondary.quantityToClose,\n    raw: { ...secondary.raw, ...primary.raw },\n  };\n}\n\n/**\n * Stamp the row's Virtual Account on `vaAddress` when it was read from a VA — in\n * lowcap a VA-scoped position's `partyA` IS its VA, so when the row's `partyA`\n * differs from the sub-account being reconciled we surface it on the dedicated\n * `vaAddress` field for the consumer.\n */\nfunction withVaAddress(row: UnifiedQuote, subAccount: Address): UnifiedQuote {\n  if (row.partyA.toLowerCase() === subAccount.toLowerCase()) return row;\n  return { ...row, vaAddress: row.partyA };\n}\n\n/**\n * Deterministic tiebreak key for rows that share a `statusModifyTimestamp`: the\n * on-chain quote id when anchored, else the (negative) temp id. Keeps the sort\n * order reproducible regardless of the unstable on-chain read order — the\n * contract stores positions with swap-and-pop, so the raw read order reshuffles\n * on every open/close.\n */\nfunction stableSortKey(quote: UnifiedQuote): bigint {\n  if (quote.quoteId !== undefined) return quote.quoteId;\n  if (quote.tempQuoteId !== undefined) return BigInt(quote.tempQuoteId);\n  return 0n;\n}\n"],"mappings":"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"}
+{"version":3,"file":"reconcile-quotes.js","names":[],"sources":["../../src/quotes/reconcile-quotes.ts"],"sourcesContent":["import type { Address } from \"viem\";\nimport type { PendingInstantClose } from \"../solvers/instant-close/get-instant-closes/to-pending-instant-close\";\nimport type { PendingInstantOpen } from \"../solvers/instant-open/get-instant-opens/types\";\nimport { QuoteStatus, type Quote } from \"../symmio-contracts/symmio/types\";\nimport type { Notification } from \"../websocket/notifications/types\";\nimport { applyNotificationToQuotes } from \"./apply-notification\";\nimport { fingerprintQuote } from \"./fingerprint\";\nimport { toUnifiedQuoteFromInstantOpen, toUnifiedQuoteFromOnchain } from \"./to-unified-quote\";\nimport { QuoteLifecycle, type UnifiedQuote } from \"./unified-quote\";\n\n/**\n * Inputs to {@link reconcileQuotes}: one snapshot of every quote source. The\n * result is \"active quotes only\" — a quote appears in the output iff it is\n * present in at least one of these sources this tick.\n */\nexport interface ReconcileQuotesInput {\n  /** Sub-account (partyA) the snapshot belongs to. */\n  partyA: Address;\n  /** On-chain open positions (`getPartyAOpenPositions`). */\n  onchainPositions: readonly Quote[];\n  /** On-chain pending quotes hydrated via `getQuote`. */\n  onchainPendingQuotes: readonly Quote[];\n  /** Pending instant-open records from the hedger. */\n  instantOpens: readonly PendingInstantOpen[];\n  /** Pending instant-close records from the hedger. */\n  instantCloses: readonly PendingInstantClose[];\n  /**\n   * Map from a pending instant-open's `tempQuoteId` to the Virtual Account (VA)\n   * address its position will land in (from `resolveQuoteAccounts`). When a temp\n   * id is present here, the optimistic row is stamped with its eventual VA so the\n   * UI can show the VA before the trade anchors on-chain.\n   */\n  instantOpenVaByTempId?: Record<number, Address>;\n  /** Notifications to apply after the merge, in arrival order. */\n  notifications?: readonly Notification[];\n  /**\n   * Rows that anchored on-chain on a prior tick (a notification set their\n   * `quoteId`) but whose on-chain struct has not been read yet — the\n   * `pendingAnchors` returned by the previous {@link reconcileQuotes} call. The\n   * consumer feeds them back so an anchored row survives the gap between \"the\n   * hedger drops the pending open\" and \"the on-chain read returns the quote\"\n   * instead of vanishing for a tick. Each is dropped automatically once the\n   * matching on-chain read arrives (its `key` is already populated with the real\n   * struct, so the retained copy is ignored).\n   */\n  retainedAnchors?: readonly UnifiedQuote[];\n  /**\n   * On-chain quote ids (decimal strings) whose close is **in flight** — filled\n   * off-chain but not yet reflected by the on-chain read. The close-side mirror\n   * of {@link retainedAnchors}: the poll rebuilds a filled-but-unsettled close as\n   * `ONCHAIN` (`OPENED`) every tick, and a replayed close notification cannot\n   * restore the stage on a poll-confirmed row (apply-notification's `inClosingFlow`\n   * guard), so a row still read `OPENED` whose id is here is held at\n   * {@link QuoteLifecycle.WRITE_ONCHAIN_CLOSE}. The caller bounds the set with its\n   * close-confirm hold, so it clears at `CLOSE_PENDING` / removal / budget.\n   */\n  closingQuoteIds?: readonly string[];\n}\n\n/** Output of {@link reconcileQuotes}: the merged rows plus the temp ↔ on-chain links. */\nexport interface ReconcileQuotesResult {\n  /** Merged, de-duplicated, lifecycle-tagged rows, newest first. */\n  quotes: UnifiedQuote[];\n  /**\n   * Map from `tempQuoteId` to the on-chain row `key` it resolved to, recorded\n   * **only once the row has anchored on-chain** (`quoteId` present). A\n   * still-optimistic temp id is absent until then, so consumers can use this to\n   * clear an optimistic seed exactly when its on-chain twin exists.\n   */\n  links: Record<number, string>;\n  /**\n   * Rows currently in {@link QuoteLifecycle.WRITE_ONCHAIN} — anchored per a\n   * notification but not yet returned by the on-chain read. The consumer retains\n   * these and feeds them back as {@link ReconcileQuotesInput.retainedAnchors} on\n   * the next tick so they do not flicker out while the RPC catches up.\n   */\n  pendingAnchors: UnifiedQuote[];\n}\n\n/**\n * Merge every quote source for a sub-account into one stable, de-duplicated,\n * lifecycle-tagged list — **active quotes only**: a quote appears iff it is in at\n * least one source this tick, so a quote that has left every source is simply\n * absent (no lingering \"removed\" rows). **Pure** and stateless: given the same\n * `input` it always returns the same result, reading no clock and no randomness.\n *\n * Pipeline:\n *\n * 1. On-chain positions + pending quotes become anchored rows; `retainedAnchors`\n *    re-seed any anchored-but-not-yet-read row so it does not flicker out.\n * 2. Pending instant-closes overlay the matching on-chain row — `CLOSING` once the\n *    on-chain status shows the close pending, else `WRITE_ONCHAIN_CLOSE`.\n * 3. Pending instant-opens become `OPTIMISTIC` rows, **dropped** when an on-chain\n *    row already carries the same {@link fingerprintQuote} (the trade landed).\n * 4. Notifications are applied in order to link temp ↔ on-chain ids and advance\n *    lifecycles (an anchored-but-unread row sits at `WRITE_ONCHAIN`); `collapseByKey`\n *    then merges a rekeyed optimistic row into its on-chain twin, so the off-chain\n *    row drops once on-chain.\n * 5. Rows are sorted by `statusModifyTimestamp` descending (newest first), and the\n *    `WRITE_ONCHAIN` rows are returned as `pendingAnchors` for the next tick.\n *\n * @param input - One snapshot of all sources.\n * @returns The merged rows plus the temp ↔ on-chain `links`.\n *\n * @example\n * ```ts\n * const { quotes } = reconcileQuotes({\n *   partyA,\n *   onchainPositions,\n *   onchainPendingQuotes,\n *   instantOpens,\n *   instantCloses,\n *   notifications,\n * });\n * ```\n */\nexport function reconcileQuotes(input: ReconcileQuotesInput): ReconcileQuotesResult {\n  const byKey = new Map<string, UnifiedQuote>();\n\n  for (const quote of input.onchainPositions) {\n    const row = withVaAddress(toUnifiedQuoteFromOnchain(quote), input.partyA);\n    byKey.set(row.key, row);\n  }\n  for (const quote of input.onchainPendingQuotes) {\n    const row = withVaAddress(toUnifiedQuoteFromOnchain(quote), input.partyA);\n    if (!byKey.has(row.key)) byKey.set(row.key, row);\n  }\n  /**\n   * Re-seed rows that anchored on a prior tick but have no on-chain struct yet, so\n   * they survive the hedger-drop → on-chain-read gap. Skipped the moment the real\n   * on-chain read populates the same `key` (inserted above), so retention ends\n   * itself once the RPC confirms.\n   */\n  for (const anchor of input.retainedAnchors ?? []) {\n    if (!byKey.has(anchor.key)) byKey.set(anchor.key, anchor);\n  }\n  for (const close of input.instantCloses) {\n    const key = `onchain:${close.quoteId}`;\n    const existing = byKey.get(key);\n    /**\n     * An instant-close always references a quote that already exists on-chain, so\n     * we only overlay the close onto its matching row. If the on-chain row has not\n     * loaded yet we skip it rather than synthesize a placeholder with no market or\n     * side; the overlay applies on the next tick once the position read catches up.\n     */\n    if (!existing) continue;\n    byKey.set(key, {\n      ...existing,\n      lifecycle: overlayCloseLifecycle(existing),\n      quantityToClose: close.quantityToClose,\n      raw: { ...existing.raw, instantClose: close },\n    });\n  }\n\n  const onchainFingerprints = new Set<string>();\n\n  for (const row of byKey.values()) {\n    if (row.origin === \"onchain\") onchainFingerprints.add(fingerprintQuote(row));\n  }\n  for (const open of input.instantOpens) {\n    const row = toUnifiedQuoteFromInstantOpen(open);\n    if (onchainFingerprints.has(fingerprintQuote(row))) continue;\n    const vaAddress = input.instantOpenVaByTempId?.[open.tempQuoteId];\n    if (vaAddress) row.vaAddress = vaAddress;\n    if (!byKey.has(row.key)) byKey.set(row.key, row);\n  }\n  let merged = [...byKey.values()];\n  for (const notification of input.notifications ?? []) {\n    merged = applyNotificationToQuotes(merged, notification);\n  }\n  merged = collapseByKey(merged);\n  /**\n   * Close-side retention (mirror of `retainedAnchors`). A close that filled\n   * off-chain sits at `WRITE_ONCHAIN_CLOSE`, but the poll keeps reading the quote\n   * `OPENED` until the settle mines and rebuilds the row as `ONCHAIN` — and the\n   * replayed close notification cannot restore the stage on that poll-confirmed\n   * row (`applyNotificationToQuotes`' `inClosingFlow` guard). So a still-`OPENED`\n   * row whose close the caller is chasing is held at `WRITE_ONCHAIN_CLOSE` until\n   * the chain reflects the close (`CLOSE_PENDING` / removed) or the caller drops it.\n   */\n  if (input.closingQuoteIds?.length) {\n    const closing = new Set(input.closingQuoteIds);\n    merged = merged.map((row) =>\n      row.quoteId !== undefined &&\n      closing.has(`${row.quoteId}`) &&\n      row.lifecycle === QuoteLifecycle.ONCHAIN &&\n      row.quoteStatus === QuoteStatus.OPENED\n        ? { ...row, lifecycle: QuoteLifecycle.WRITE_ONCHAIN_CLOSE }\n        : row,\n    );\n  }\n  // Drop terminal quotes: a `CLOSED` lifecycle only comes from an on-chain\n  // terminal status (`CANCELED` / `CLOSED` / `EXPIRED`) — a done quote a lagging\n  // read still lists (e.g. a just force-cancelled limit order). It is not active,\n  // so it must not linger in the list. (Off-chain rows never reach `CLOSED`.)\n  merged = merged.filter((row) => row.lifecycle !== QuoteLifecycle.CLOSED);\n  merged.sort((a, b) => {\n    const aTs = a.statusModifyTimestamp ?? 0n;\n    const bTs = b.statusModifyTimestamp ?? 0n;\n    if (aTs !== bTs) return aTs > bTs ? -1 : 1;\n    const aId = stableSortKey(a);\n    const bId = stableSortKey(b);\n    if (aId !== bId) return aId > bId ? -1 : 1;\n    return 0;\n  });\n  const links: Record<number, string> = {};\n  for (const row of merged) {\n    /**\n     * Only record a temp ↔ on-chain link once the row has actually anchored\n     * (`quoteId` set). A still-optimistic row carries only its own `temp:` key —\n     * recording that as a \"link\" would let the consumer clear its optimistic seed\n     * before the on-chain twin exists, dropping the row for a tick (the\n     * appear→disappear→reappear flicker).\n     */\n    if (row.tempQuoteId !== undefined && row.quoteId !== undefined) links[row.tempQuoteId] = row.key;\n  }\n  const pendingAnchors = merged.filter((row) => row.lifecycle === QuoteLifecycle.WRITE_ONCHAIN);\n  return { quotes: merged, links, pendingAnchors };\n}\n\n/**\n * Lifecycle for an on-chain row that a pending instant-close overlays. Keep a\n * terminal `CLOSED` as-is; keep the row's on-chain lifecycle (`ONCHAIN`) when the\n * on-chain status **already** reflects the close (`CLOSE_PENDING` /\n * `CANCEL_CLOSE_PENDING`) — the close landed, don't drag it backwards; otherwise\n * the read still shows the position open while the close is in-flight, so surface\n * {@link QuoteLifecycle.OPTIMISTIC_CLOSE} as the base close stage. Close\n * notifications (applied after this overlay) then advance it to\n * `CLOSE_PRICE_FILLED` → `WRITE_ONCHAIN_CLOSE`, and once the on-chain read reflects\n * the pending close it resolves to `ONCHAIN` (with `quoteStatus: CLOSE_PENDING`).\n */\nfunction overlayCloseLifecycle(existing: UnifiedQuote): QuoteLifecycle {\n  if (existing.lifecycle === QuoteLifecycle.CLOSED) return QuoteLifecycle.CLOSED;\n  if (existing.quoteStatus === QuoteStatus.CLOSE_PENDING || existing.quoteStatus === QuoteStatus.CANCEL_CLOSE_PENDING) {\n    return existing.lifecycle;\n  }\n  return QuoteLifecycle.OPTIMISTIC_CLOSE;\n}\n\n/**\n * Collapse rows that ended up sharing a `key` after a notification rekeyed an\n * optimistic row (`temp:<id>` → `onchain:<id>`) onto an on-chain twin the poll\n * already returned. Without this the same quote can appear twice — once from the\n * poll and once from the rekeyed optimistic row — yielding duplicate React keys.\n * The genuine on-chain row (the one carrying `raw.onchain`) wins; the optimistic\n * row's `tempQuoteId` / `raw.instantOpen` are grafted on so the temp ↔ on-chain\n * link survives and the optimistic entry can be cleared.\n */\nfunction collapseByKey(rows: UnifiedQuote[]): UnifiedQuote[] {\n  const byKey = new Map<string, UnifiedQuote>();\n  for (const row of rows) {\n    const existing = byKey.get(row.key);\n    byKey.set(row.key, existing ? mergeDuplicateRows(existing, row) : row);\n  }\n  return [...byKey.values()];\n}\n\n/**\n * Merge two rows that resolved to the same `key`, preferring the one that carries\n * the polled on-chain struct and grafting the off-chain identifiers from the other.\n */\nfunction mergeDuplicateRows(a: UnifiedQuote, b: UnifiedQuote): UnifiedQuote {\n  const primary = a.raw.onchain ? a : b;\n  const secondary = primary === a ? b : a;\n  return {\n    ...primary,\n    tempQuoteId: primary.tempQuoteId ?? secondary.tempQuoteId,\n    vaAddress: primary.vaAddress ?? secondary.vaAddress,\n    openedPrice: primary.openedPrice ?? secondary.openedPrice,\n    avgClosedPrice: primary.avgClosedPrice ?? secondary.avgClosedPrice,\n    quantityToClose: primary.quantityToClose ?? secondary.quantityToClose,\n    raw: { ...secondary.raw, ...primary.raw },\n  };\n}\n\n/**\n * Stamp the row's Virtual Account on `vaAddress` when it was read from a VA — in\n * lowcap a VA-scoped position's `partyA` IS its VA, so when the row's `partyA`\n * differs from the sub-account being reconciled we surface it on the dedicated\n * `vaAddress` field for the consumer.\n */\nfunction withVaAddress(row: UnifiedQuote, subAccount: Address): UnifiedQuote {\n  if (row.partyA.toLowerCase() === subAccount.toLowerCase()) return row;\n  return { ...row, vaAddress: row.partyA };\n}\n\n/**\n * Deterministic tiebreak key for rows that share a `statusModifyTimestamp`: the\n * on-chain quote id when anchored, else the (negative) temp id. Keeps the sort\n * order reproducible regardless of the unstable on-chain read order — the\n * contract stores positions with swap-and-pop, so the raw read order reshuffles\n * on every open/close.\n */\nfunction stableSortKey(quote: UnifiedQuote): bigint {\n  if (quote.quoteId !== undefined) return quote.quoteId;\n  if (quote.tempQuoteId !== undefined) return BigInt(quote.tempQuoteId);\n  return 0n;\n}\n"],"mappings":";;;;;;AAoHA,SAAgB,EAAgB,GAAoD;CAClF,IAAM,oBAAQ,IAAI,IAA0B;CAE5C,KAAK,IAAM,KAAS,EAAM,kBAAkB;EAC1C,IAAM,IAAM,EAAc,EAA0B,CAAK,GAAG,EAAM,MAAM;EACxE,EAAM,IAAI,EAAI,KAAK,CAAG;CACxB;CACA,KAAK,IAAM,KAAS,EAAM,sBAAsB;EAC9C,IAAM,IAAM,EAAc,EAA0B,CAAK,GAAG,EAAM,MAAM;EACxE,AAAK,EAAM,IAAI,EAAI,GAAG,KAAG,EAAM,IAAI,EAAI,KAAK,CAAG;CACjD;CAOA,KAAK,IAAM,KAAU,EAAM,mBAAmB,CAAC,GAC7C,AAAK,EAAM,IAAI,EAAO,GAAG,KAAG,EAAM,IAAI,EAAO,KAAK,CAAM;CAE1D,KAAK,IAAM,KAAS,EAAM,eAAe;EACvC,IAAM,IAAM,WAAW,EAAM,WACvB,IAAW,EAAM,IAAI,CAAG;EAOzB,KACL,EAAM,IAAI,GAAK;GACb,GAAG;GACH,WAAW,EAAsB,CAAQ;GACzC,iBAAiB,EAAM;GACvB,KAAK;IAAE,GAAG,EAAS;IAAK,cAAc;GAAM;EAC9C,CAAC;CACH;CAEA,IAAM,oBAAsB,IAAI,IAAY;CAE5C,KAAK,IAAM,KAAO,EAAM,OAAO,GAC7B,AAAI,EAAI,WAAW,aAAW,EAAoB,IAAI,EAAiB,CAAG,CAAC;CAE7E,KAAK,IAAM,KAAQ,EAAM,cAAc;EACrC,IAAM,IAAM,EAA8B,CAAI;EAC9C,IAAI,EAAoB,IAAI,EAAiB,CAAG,CAAC,GAAG;EACpD,IAAM,IAAY,EAAM,wBAAwB,EAAK;EAErD,AADI,MAAW,EAAI,YAAY,IAC1B,EAAM,IAAI,EAAI,GAAG,KAAG,EAAM,IAAI,EAAI,KAAK,CAAG;CACjD;CACA,IAAI,IAAS,CAAC,GAAG,EAAM,OAAO,CAAC;CAC/B,KAAK,IAAM,KAAgB,EAAM,iBAAiB,CAAC,GACjD,IAAS,EAA0B,GAAQ,CAAY;CAYzD,IAVA,IAAS,EAAc,CAAM,GAUzB,EAAM,iBAAiB,QAAQ;EACjC,IAAM,IAAU,IAAI,IAAI,EAAM,eAAe;EAC7C,IAAS,EAAO,KAAK,MACnB,EAAI,YAAY,KAAA,KAChB,EAAQ,IAAI,GAAG,EAAI,SAAS,KAC5B,EAAI,cAAc,EAAe,WACjC,EAAI,gBAAgB,EAAY,SAC5B;GAAE,GAAG;GAAK,WAAW,EAAe;EAAoB,IACxD,CACN;CACF;CAMA,AADA,IAAS,EAAO,QAAQ,MAAQ,EAAI,cAAc,EAAe,MAAM,GACvE,EAAO,MAAM,GAAG,MAAM;EACpB,IAAM,IAAM,EAAE,yBAAyB,IACjC,IAAM,EAAE,yBAAyB;EACvC,IAAI,MAAQ,GAAK,OAAO,IAAM,IAAM,KAAK;EACzC,IAAM,IAAM,EAAc,CAAC,GACrB,IAAM,EAAc,CAAC;EAE3B,OADI,MAAQ,IACL,IADiB,IAAM,IAAM,KAAK;CAE3C,CAAC;CACD,IAAM,IAAgC,CAAC;CACvC,KAAK,IAAM,KAAO,GAQhB,AAAI,EAAI,gBAAgB,KAAA,KAAa,EAAI,YAAY,KAAA,MAAW,EAAM,EAAI,eAAe,EAAI;CAE/F,IAAM,IAAiB,EAAO,QAAQ,MAAQ,EAAI,cAAc,EAAe,aAAa;CAC5F,OAAO;EAAE,QAAQ;EAAQ;EAAO;CAAe;AACjD;AAaA,SAAS,EAAsB,GAAwC;CAKrE,OAJI,EAAS,cAAc,EAAe,SAAe,EAAe,SACpE,EAAS,gBAAgB,EAAY,iBAAiB,EAAS,gBAAgB,EAAY,uBACtF,EAAS,YAEX,EAAe;AACxB;AAWA,SAAS,EAAc,GAAsC;CAC3D,IAAM,oBAAQ,IAAI,IAA0B;CAC5C,KAAK,IAAM,KAAO,GAAM;EACtB,IAAM,IAAW,EAAM,IAAI,EAAI,GAAG;EAClC,EAAM,IAAI,EAAI,KAAK,IAAW,EAAmB,GAAU,CAAG,IAAI,CAAG;CACvE;CACA,OAAO,CAAC,GAAG,EAAM,OAAO,CAAC;AAC3B;AAMA,SAAS,EAAmB,GAAiB,GAA+B;CAC1E,IAAM,IAAU,EAAE,IAAI,UAAU,IAAI,GAC9B,IAAY,MAAY,IAAI,IAAI;CACtC,OAAO;EACL,GAAG;EACH,aAAa,EAAQ,eAAe,EAAU;EAC9C,WAAW,EAAQ,aAAa,EAAU;EAC1C,aAAa,EAAQ,eAAe,EAAU;EAC9C,gBAAgB,EAAQ,kBAAkB,EAAU;EACpD,iBAAiB,EAAQ,mBAAmB,EAAU;EACtD,KAAK;GAAE,GAAG,EAAU;GAAK,GAAG,EAAQ;EAAI;CAC1C;AACF;AAQA,SAAS,EAAc,GAAmB,GAAmC;CAE3E,OADI,EAAI,OAAO,YAAY,MAAM,EAAW,YAAY,IAAU,IAC3D;EAAE,GAAG;EAAK,WAAW,EAAI;CAAO;AACzC;AASA,SAAS,EAAc,GAA6B;CAGlD,OAFI,EAAM,YAAY,KAAA,IAClB,EAAM,gBAAgB,KAAA,IACnB,KADqC,OAAO,EAAM,WAAW,IAD5B,EAAM;AAGhD"}

package/dist/quotes/resolve-quote-accounts.d.ts

@@ -1,7 +1,7 @@
 import { Address } from 'viem';
 import { Config } from '../core/config/index.js';
 import { ChainIdParameter, Compute } from '../shared/types/properties.js';
-import { PendingInstantOpen } from '../solvers/instant-open/get-instant-opens/to-pending-instant-open.js';
+import { PendingInstantOpen } from '../solvers/instant-open/get-instant-opens/types.js';
 /**
  * Parameters for {@link resolveQuoteAccounts}.
  */

package/dist/quotes/resolve-quote-accounts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"resolve-quote-accounts.d.ts","sourceRoot":"","sources":["../../src/quotes/resolve-quote-accounts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,OAAO,EAAE,MAAM,MAAM,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mEAAmE,CAAC;AAK5G;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,OAAO,CAClD,gBAAgB,GAAG;IACjB,kEAAkE;IAClE,UAAU,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,YAAY,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC7C;;;OAGG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,2EAA2E;IAC3E,aAAa,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CACpC,CACF,CAAC;AAEF,8CAA8C;AAC9C,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB;;;;OAIG;IACH,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,8BAA8B,GACzC,OAAO,CAAC,0BAA0B,CAAC,CAwDrC"}
+{"version":3,"file":"resolve-quote-accounts.d.ts","sourceRoot":"","sources":["../../src/quotes/resolve-quote-accounts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAc,KAAK,OAAO,EAAE,MAAM,MAAM,CAAC;AAChD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAC;AAC5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AAK1F;;GAEG;AACH,MAAM,MAAM,8BAA8B,GAAG,OAAO,CAClD,gBAAgB,GAAG;IACjB,kEAAkE;IAClE,UAAU,EAAE,OAAO,CAAC;IACpB;;;OAGG;IACH,YAAY,CAAC,EAAE,SAAS,kBAAkB,EAAE,CAAC;IAC7C;;;OAGG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,2EAA2E;IAC3E,aAAa,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;CACpC,CACF,CAAC;AAEF,8CAA8C;AAC9C,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB;;;;OAIG;IACH,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAChD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,MAAM,EACd,UAAU,EAAE,8BAA8B,GACzC,OAAO,CAAC,0BAA0B,CAAC,CAwDrC"}