@symmio/trading-core 1.1.0 → 3.0.0

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"}

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, in descending precedence: the
+ * `initialOpenedPrice` it first opened at, else the settled `openedPrice`, else
+ * the current `requestedOpenPrice`.
+ *
+ * Leverage describes the position *as it was opened*, so the original open price
+ * wins — `requestedOpenPrice` can drift after edits and is only the last resort.
+ * A `0n` (or absent) price at any tier falls through to the next. 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 none is set.
+ */
+export declare function leveragePriceOf(quote: Pick<UnifiedQuote, "initialOpenedPrice" | "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,CAC7B,KAAK,EAAE,IAAI,CAAC,YAAY,EAAE,oBAAoB,GAAG,aAAa,GAAG,oBAAoB,CAAC,GACrF,MAAM,CAIR"}

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.initialOpenedPrice !== void 0 && e.initialOpenedPrice !== 0n ? e.initialOpenedPrice : e.openedPrice !== void 0 && e.openedPrice !== 0n ? e.openedPrice : 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, in descending precedence: the\n * `initialOpenedPrice` it first opened at, else the settled `openedPrice`, else\n * the current `requestedOpenPrice`.\n *\n * Leverage describes the position *as it was opened*, so the original open price\n * wins — `requestedOpenPrice` can drift after edits and is only the last resort.\n * A `0n` (or absent) price at any tier falls through to the next. Shared by\n * `aggregateGroupMetrics` and `calculateQuoteLeverage`, which agree on this rule\n * while deliberately 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 none is set.\n */\nexport function leveragePriceOf(\n  quote: Pick<UnifiedQuote, \"initialOpenedPrice\" | \"openedPrice\" | \"requestedOpenPrice\">,\n): bigint {\n  if (quote.initialOpenedPrice !== undefined && quote.initialOpenedPrice !== 0n) return quote.initialOpenedPrice;\n  if (quote.openedPrice !== undefined && quote.openedPrice !== 0n) return quote.openedPrice;\n  return quote.requestedOpenPrice;\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,EACd,GACQ;CAGR,OAFI,EAAM,uBAAuB,KAAA,KAAa,EAAM,uBAAuB,KAAW,EAAM,qBACxF,EAAM,gBAAgB,KAAA,KAAa,EAAM,gBAAgB,KAAW,EAAM,cACvE,EAAM;AACf"}

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