@symmio/trading-core 1.0.1 → 2.0.0

package/dist/quotes/apply-notification.d.ts

@@ -23,6 +23,63 @@ export type QuoteNotificationActionKind = "open" | "close" | "other";
  * ```
  */
 export declare function classifyQuoteNotificationAction(action: string | null | undefined): QuoteNotificationActionKind;
+/**
+ * Whether a notification's `lastSeenAction` is an open **anchor** — the quote
+ * landed on-chain (`SendQuoteTransaction` / `SendQuote` / `FillLimitOrderOpen`),
+ * as opposed to the earlier off-chain `InstantRFQ` price fill. This is the
+ * "second" notification of a send flow: the temp id now has a real on-chain quote
+ * id. Use it to refetch reads that only change once the quote exists on-chain —
+ * e.g. the pending-quotes (resting limit orders) list.
+ *
+ * @param action - The notification's `lastSeenAction` (may be `null`/absent).
+ * @returns `true` for an open-anchor action, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * if (n.type === NotificationType.SUCCESS && isOpenAnchorAction(n.lastSeenAction)) refetchPending();
+ * ```
+ */
+export declare function isOpenAnchorAction(action: string | null | undefined): boolean;
+/**
+ * Whether a notification's `lastSeenAction` is a close **fill** — the close actually
+ * executed (`FillMarketOrderInstantClose` / `FillLimitOrderClose`), as opposed to a
+ * close *request*. Narrower than {@link classifyQuoteNotificationAction} `=== "close"`,
+ * which also matches the request. Use this to react only once the close has filled —
+ * e.g. to start chasing the on-chain settle, which only begins after the fill.
+ *
+ * @param action - The notification's `lastSeenAction` (may be `null`/absent).
+ * @returns `true` for a close-fill action, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * if (isCloseFillAction(n.lastSeenAction)) startCloseConfirmChase(n.quoteId);
+ * ```
+ */
+export declare function isCloseFillAction(action: string | null | undefined): boolean;
+/**
+ * Whether a notification's `lastSeenAction` belongs to the **cancel** flow —
+ * cancelling a resting order (`RequestToCancelQuote` and the other cancel paths).
+ *
+ * Broader than {@link classifyQuoteNotificationAction}, which reports every cancel
+ * action as `"other"` — deliberately, since a cancel frame must not mutate a row
+ * (the chain is the authority on whether the cancel landed).
+ *
+ * Cancel is the one flow whose **confirming** transaction is sent by someone else:
+ * `requestToCancelQuote` on a `LOCKED` quote only moves it to `CANCEL_PENDING` and
+ * leaves it in `partyAPendingQuotes`; the solver's later `acceptCancelRequest` is
+ * what sets `CANCELED` and removes it — and that transaction is not announced on
+ * the notifications stream. A consumer that reacts to frames alone therefore shows
+ * a cancelled order forever. Use this to start chasing the on-chain read.
+ *
+ * @param action - The notification's `lastSeenAction` (may be `null`/absent).
+ * @returns `true` for a cancel-flow action, otherwise `false`.
+ *
+ * @example
+ * ```ts
+ * if (isCancelAction(n.lastSeenAction)) startCancelConfirmChase(n.quoteId);
+ * ```
+ */
+export declare function isCancelAction(action: string | null | undefined): boolean;
 /**
  * Apply a single notification to a list of {@link UnifiedQuote}s, returning a new
  * list (pure — inputs are never mutated).

package/dist/quotes/apply-notification.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"apply-notification.d.ts","sourceRoot":"","sources":["../../src/quotes/apply-notification.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACvF,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAkDpE;;;;;GAKG;AACH,MAAM,MAAM,2BAA2B,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAErE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,2BAA2B,CAK9G;AAiHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,CAAC,EAAE,YAAY,GAAG,YAAY,EAAE,CAEjG"}
+{"version":3,"file":"apply-notification.d.ts","sourceRoot":"","sources":["../../src/quotes/apply-notification.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,KAAK,YAAY,EAAE,MAAM,kCAAkC,CAAC;AACvF,OAAO,EAAkB,KAAK,YAAY,EAAE,MAAM,iBAAiB,CAAC;AAiFpE;;;;;GAKG;AACH,MAAM,MAAM,2BAA2B,GAAG,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC;AAErE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,+BAA+B,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,2BAA2B,CAK9G;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAE7E;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAE5E;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAEzE;AAmHD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,CAAC,EAAE,YAAY,GAAG,YAAY,EAAE,CAEjG"}

package/dist/quotes/apply-notification.js

@@ -6,38 +6,55 @@ var r = new Set([
 	"SendQuoteTransaction",
 	"SendQuote",
 	"FillLimitOrderOpen"
-]), i = new Set(["InstantRFQ"]), a = new Set(["InstantRequestToClosePosition", "RequestToClosePosition"]), o = new Set(["FillMarketOrderInstantClose", "FillLimitOrderClose"]), s = new Set([...a, ...o]), c = {
+]), i = new Set(["InstantRFQ"]), a = new Set(["InstantRequestToClosePosition", "RequestToClosePosition"]), o = new Set(["FillMarketOrderInstantClose", "FillLimitOrderClose"]), s = new Set(["InstantRequestToLimitClose"]), c = new Set([
+	...a,
+	...s,
+	...o
+]), l = new Set([
+	"RequestToCancelQuote",
+	"AcceptCancelRequest",
+	"ForceCancelQuote",
+	"ExpireQuote"
+]), u = {
 	[n.OPTIMISTIC_CLOSE]: 1,
 	[n.CLOSE_PRICE_FILLED]: 2,
-	[n.WRITE_ONCHAIN_CLOSE]: 3,
-	[n.CLOSING]: 4
+	[n.WRITE_ONCHAIN_CLOSE]: 3
 };
-function l(e) {
-	return c[e] ?? 0;
+function d(e) {
+	return u[e] ?? 0;
 }
-function u(e) {
-	return e ? r.has(e) || i.has(e) ? "open" : s.has(e) ? "close" : "other" : "other";
+function f(e) {
+	return e ? r.has(e) || i.has(e) ? "open" : c.has(e) ? "close" : "other" : "other";
 }
-function d(e, t) {
+function p(e) {
+	return e != null && r.has(e);
+}
+function m(e) {
+	return e != null && o.has(e);
+}
+function h(e) {
+	return e != null && l.has(e);
+}
+function g(e, t) {
 	return e.quoteId !== void 0 && t.quoteId === `${e.quoteId}` || e.tempQuoteId !== void 0 && e.tempQuoteId === t.tempQuoteId;
 }
-function f(a, c) {
-	let u = { ...a }, d = c.quoteId && c.quoteId !== `${c.tempQuoteId}` ? BigInt(c.quoteId) : void 0;
-	d !== void 0 && u.quoteId === void 0 && (u.quoteId = d, u.key = `onchain:${d}`, u.origin = "onchain"), u.tempQuoteId === void 0 && c.tempQuoteId !== 0 && (u.tempQuoteId = c.tempQuoteId), c.vaAddress && (u.vaAddress = c.vaAddress);
-	let f = c.lastSeenAction ?? "";
-	if (c.type === e.FAILED) return u.origin === "onchain" && u.raw.onchain === void 0 && (u.lifecycle = n.FAILED), u;
-	if (c.type !== e.SUCCESS) return u;
-	if (s.has(f)) {
-		c.avgPriceClose && (u.avgClosedPrice = u.avgClosedPrice ?? t(c.avgPriceClose));
-		let e = o.has(f) ? n.WRITE_ONCHAIN_CLOSE : n.CLOSE_PRICE_FILLED;
-		return (l(u.lifecycle) > 0 || u.origin !== "onchain") && l(e) > l(u.lifecycle) && (u.lifecycle = e), u;
+function _(a, l) {
+	let u = { ...a }, f = l.quoteId && l.quoteId !== `${l.tempQuoteId}` ? BigInt(l.quoteId) : void 0;
+	f !== void 0 && u.quoteId === void 0 && (u.quoteId = f, u.key = `onchain:${f}`, u.origin = "onchain"), u.tempQuoteId === void 0 && l.tempQuoteId !== 0 && (u.tempQuoteId = l.tempQuoteId), l.vaAddress && (u.vaAddress = l.vaAddress);
+	let p = l.lastSeenAction ?? "";
+	if (l.type === e.FAILED) return u.origin === "onchain" && u.raw.onchain === void 0 && (u.lifecycle = n.FAILED), u;
+	if (l.type !== e.SUCCESS) return u;
+	if (c.has(p)) {
+		l.avgPriceClose && (u.avgClosedPrice = u.avgClosedPrice ?? t(l.avgPriceClose));
+		let e = o.has(p) || s.has(p) ? n.WRITE_ONCHAIN_CLOSE : n.CLOSE_PRICE_FILLED;
+		return (d(u.lifecycle) > 0 || u.origin !== "onchain") && d(e) > d(u.lifecycle) && (u.lifecycle = e), u;
 	}
-	return r.has(f) ? (c.avgPriceOpen && (u.openedPrice = t(c.avgPriceOpen)), u.raw.onchain === void 0 && (u.lifecycle = n.WRITE_ONCHAIN), u) : i.has(f) ? (c.avgPriceOpen && (u.openedPrice = t(c.avgPriceOpen)), u.lifecycle = u.origin === "onchain" ? u.lifecycle : n.PRICE_FILLED, u) : u;
+	return r.has(p) ? (l.avgPriceOpen && (u.openedPrice = t(l.avgPriceOpen)), u.raw.onchain === void 0 && (u.lifecycle = n.WRITE_ONCHAIN), u) : i.has(p) ? (l.avgPriceOpen && (u.openedPrice = t(l.avgPriceOpen)), u.lifecycle = u.origin === "onchain" ? u.lifecycle : n.PRICE_FILLED, u) : u;
 }
-function p(e, t) {
-	return e.map((e) => d(e, t) ? f(e, t) : e);
+function v(e, t) {
+	return e.map((e) => g(e, t) ? _(e, t) : e);
 }
 //#endregion
-export { p as applyNotificationToQuotes, u as classifyQuoteNotificationAction };
+export { v as applyNotificationToQuotes, f as classifyQuoteNotificationAction, h as isCancelAction, m as isCloseFillAction, p as isOpenAnchorAction };
 
 //# sourceMappingURL=apply-notification.js.map

package/dist/quotes/apply-notification.js.map

@@ -1 +1 @@
-{"version":3,"file":"apply-notification.js","names":[],"sources":["../../src/quotes/apply-notification.ts"],"sourcesContent":["import { toWeiBigInt } from \"../solvers/instant-open/shared/trade-math\";\nimport { NotificationType, type Notification } from \"../websocket/notifications/types\";\nimport { QuoteLifecycle, type UnifiedQuote } from \"./unified-quote\";\n\n/**\n * Solver `lastSeenAction` values that, on success, anchor a quote on-chain.\n */\nconst OPEN_ANCHOR_ACTIONS = new Set([\"SendQuoteTransaction\", \"SendQuote\", \"FillLimitOrderOpen\"]);\n\n/**\n * Solver `lastSeenAction` values that report a fill price while the trade is\n * still off-chain (the optimistic row gets a price before its on-chain id lands).\n */\nconst PRICE_FILL_ACTIONS = new Set([\"InstantRFQ\"]);\n\n/**\n * Close `lastSeenAction` values that report the close price / fill request — the\n * first close notification, analogous to `InstantRFQ` on the open side. Advances a\n * closing row to {@link QuoteLifecycle.CLOSE_PRICE_FILLED}.\n */\nconst CLOSE_REQUEST_ACTIONS = new Set([\"InstantRequestToClosePosition\", \"RequestToClosePosition\"]);\n\n/**\n * Close `lastSeenAction` values that report the on-chain fill — the second close\n * notification, analogous to the open-anchor actions. Advances a closing row to\n * {@link QuoteLifecycle.WRITE_ONCHAIN_CLOSE}.\n */\nconst CLOSE_FILL_ACTIONS = new Set([\"FillMarketOrderInstantClose\", \"FillLimitOrderClose\"]);\n\n/**\n * All `lastSeenAction` values that belong to the closing flow (request + fill).\n */\nconst CLOSE_ACTIONS = new Set([...CLOSE_REQUEST_ACTIONS, ...CLOSE_FILL_ACTIONS]);\n\n/**\n * Rank of each closing-stage lifecycle, used to advance a close monotonically and\n * to detect that a row is currently \"in a close\" (rank &gt; 0). Higher = further\n * along: the poll-confirmed `CLOSING` (`CLOSE_PENDING`) outranks the\n * notification-driven stages, so a replayed close notification never regresses it.\n */\nconst CLOSE_STAGE_RANK: Partial<Record<QuoteLifecycle, number>> = {\n  [QuoteLifecycle.OPTIMISTIC_CLOSE]: 1,\n  [QuoteLifecycle.CLOSE_PRICE_FILLED]: 2,\n  [QuoteLifecycle.WRITE_ONCHAIN_CLOSE]: 3,\n  [QuoteLifecycle.CLOSING]: 4,\n};\n\n/** The closing-stage rank of a lifecycle (0 when it is not a closing stage). */\nfunction closeStageRank(lifecycle: QuoteLifecycle): number {\n  return CLOSE_STAGE_RANK[lifecycle] ?? 0;\n}\n\n/**\n * The kind of quote action a notification reports, derived from its\n * `lastSeenAction`. Consumers use this to scope cache invalidation to the reads a\n * notification can actually affect — an open-anchor event never changes the\n * pending-instant-close feed, and vice versa.\n */\nexport type QuoteNotificationActionKind = \"open\" | \"close\" | \"other\";\n\n/**\n * Classify a notification's `lastSeenAction` into the quote flow it belongs to.\n *\n * Open-side actions (anchoring an open, or the `InstantRFQ` price fill) classify\n * as `\"open\"`; close-request/fill actions classify as `\"close\"`; anything else\n * (including failures and unknown actions) is `\"other\"`.\n *\n * @param action - The notification's `lastSeenAction` (may be `null`/absent).\n * @returns The quote flow the action belongs to.\n *\n * @example\n * ```ts\n * if (classifyQuoteNotificationAction(n.lastSeenAction) === \"close\") invalidateCloses();\n * ```\n */\nexport function classifyQuoteNotificationAction(action: string | null | undefined): QuoteNotificationActionKind {\n  if (!action) return \"other\";\n  if (OPEN_ANCHOR_ACTIONS.has(action) || PRICE_FILL_ACTIONS.has(action)) return \"open\";\n  if (CLOSE_ACTIONS.has(action)) return \"close\";\n  return \"other\";\n}\n\n/**\n * Decide whether a notification refers to a given unified row, matching first by\n * on-chain quote id and then by the pre-chain temp id.\n */\nfunction notificationMatchesQuote(quote: UnifiedQuote, n: Notification): boolean {\n  if (quote.quoteId !== undefined && n.quoteId === `${quote.quoteId}`) return true;\n  if (quote.tempQuoteId !== undefined && quote.tempQuoteId === n.tempQuoteId) return true;\n  return false;\n}\n\n/**\n * Apply one notification to a single matched {@link UnifiedQuote}, returning a\n * new row with the linked ids, filled prices, and advanced lifecycle.\n */\nfunction applyToMatched(quote: UnifiedQuote, n: Notification): UnifiedQuote {\n  const next: UnifiedQuote = { ...quote };\n  const onchainId = n.quoteId && n.quoteId !== `${n.tempQuoteId}` ? BigInt(n.quoteId) : undefined;\n\n  if (onchainId !== undefined && next.quoteId === undefined) {\n    next.quoteId = onchainId;\n    next.key = `onchain:${onchainId}`;\n    next.origin = \"onchain\";\n  }\n  if (next.tempQuoteId === undefined && n.tempQuoteId !== 0) {\n    next.tempQuoteId = n.tempQuoteId;\n  }\n  if (n.vaAddress) {\n    next.vaAddress = n.vaAddress as UnifiedQuote[\"vaAddress\"];\n  }\n\n  const action = n.lastSeenAction ?? \"\";\n\n  if (n.type === NotificationType.FAILED) {\n    /**\n     * A failure is an *event*, not a durable state of a quote that exists, so we do\n     * not flash `FAILED` in the common cases:\n     * - a failed *action* on a confirmed on-chain row (e.g. a rejected partial\n     *   close) leaves the position `OPENED` — it stays put and defers to the polled\n     *   status (notifications are replayed every tick, so stamping `FAILED` here\n     *   would pin a live position and block any retry);\n     * - a failed *open* that never anchored simply has no quote — its optimistic row\n     *   vanishes on its own once the hedger drops the pending open (active-quotes\n     *   only), with no `FAILED` flicker.\n     *\n     * The only row we mark `FAILED` is one the chain was told anchored\n     * (`origin === \"onchain\"`, `quoteId` set) but the read never returned\n     * (`raw.onchain` absent) — a reverted anchor — so it drops out of the retained\n     * anchor set instead of hanging at `WRITE_ONCHAIN` forever.\n     */\n    if (next.origin === \"onchain\" && next.raw.onchain === undefined) {\n      next.lifecycle = QuoteLifecycle.FAILED;\n    }\n    return next;\n  }\n  if (n.type !== NotificationType.SUCCESS) {\n    return next;\n  }\n  if (CLOSE_ACTIONS.has(action)) {\n    if (n.avgPriceClose) {\n      next.avgClosedPrice = next.avgClosedPrice ?? toWeiBigInt(n.avgPriceClose);\n    }\n    /**\n     * Advance the close stage from the notification: the request\n     * (`InstantRequestToClosePosition`) → `CLOSE_PRICE_FILLED`, the fill\n     * (`FillMarketOrderInstantClose`) → `WRITE_ONCHAIN_CLOSE`.\n     *\n     * This only applies to a row that is **already in a closing stage** — the\n     * pending-instant-close overlay (the self-clearing in-flight signal from the\n     * hedger feed) puts an anchored row at `OPTIMISTIC_CLOSE` before notifications\n     * run — or to a not-yet-anchored off-chain row. Once the close settles, the\n     * feed drops, the overlay no longer runs, and the polled row is back at\n     * `ONCHAIN` (rank 0): these **replayed** close notifications then match nothing\n     * to advance, so a settled close never sticks (the bug the old `origin` guard\n     * prevented). The advance is monotonic on {@link closeStageRank}, so neither a\n     * replay nor the earlier request notification can regress the poll-confirmed\n     * `CLOSING`.\n     */\n    const stage = CLOSE_FILL_ACTIONS.has(action)\n      ? QuoteLifecycle.WRITE_ONCHAIN_CLOSE\n      : QuoteLifecycle.CLOSE_PRICE_FILLED;\n    const inClosingFlow = closeStageRank(next.lifecycle) > 0 || next.origin !== \"onchain\";\n    if (inClosingFlow && closeStageRank(stage) > closeStageRank(next.lifecycle)) {\n      next.lifecycle = stage;\n    }\n    return next;\n  }\n  if (OPEN_ANCHOR_ACTIONS.has(action)) {\n    if (n.avgPriceOpen) {\n      next.openedPrice = toWeiBigInt(n.avgPriceOpen);\n    }\n    /**\n     * The notification reports the quote anchored on-chain, but the on-chain read\n     * may not have returned its struct yet. Surface `WRITE_ONCHAIN` — \"anchored,\n     * awaiting the RPC\" — until the polled struct arrives (`raw.onchain` present),\n     * at which point reconciliation collapses this onto the real on-chain row and\n     * its polled status wins. An already-anchored row (struct present) keeps its\n     * polled lifecycle.\n     */\n    if (next.raw.onchain === undefined) next.lifecycle = QuoteLifecycle.WRITE_ONCHAIN;\n    return next;\n  }\n  if (PRICE_FILL_ACTIONS.has(action)) {\n    if (n.avgPriceOpen) {\n      next.openedPrice = toWeiBigInt(n.avgPriceOpen);\n    }\n    next.lifecycle = next.origin === \"onchain\" ? next.lifecycle : QuoteLifecycle.PRICE_FILLED;\n    return next;\n  }\n  return next;\n}\n\n/**\n * Apply a single notification to a list of {@link UnifiedQuote}s, returning a new\n * list (pure — inputs are never mutated).\n *\n * The notification is matched to a row by on-chain quote id, falling back to the\n * pre-chain temp id, which is how an optimistic row gets linked to its on-chain\n * quote (`temp:<id>` → `onchain:<id>`). On the matched row it:\n *\n * - links `tempQuoteId` ↔ `quoteId` and rekeys it once the on-chain id appears;\n * - fills `openedPrice` and advances to `PRICE_FILLED` on `InstantRFQ` success;\n * - advances to `ONCHAIN` on `SendQuoteTransaction` (open-anchor) success;\n * - advances the close stage on a row already in the closing flow (or an\n *   off-chain row): the request → `CLOSE_PRICE_FILLED`, the fill →\n *   `WRITE_ONCHAIN_CLOSE`, monotonically. A settled close (polled back to\n *   `ONCHAIN`) is no longer in a closing stage, so the replayed close\n *   notifications match nothing to advance and never re-stick it;\n * - advances to `FAILED` **only for an anchored-but-unread row whose anchor reverted**\n *   (`origin === \"onchain\"`, `raw.onchain` absent). A failed close on a confirmed\n *   position stays put (defers to the poll), and a failed open's optimistic row just\n *   vanishes when the hedger drops it — failure is an event, not a durable state.\n *\n * @param quotes - The current unified rows.\n * @param n - The normalized notification to apply.\n * @returns A new list with the matched row updated; the same list (by content) when nothing matched.\n *\n * @example\n * ```ts\n * const next = applyNotificationToQuotes(quotes, notification);\n * ```\n */\nexport function applyNotificationToQuotes(quotes: UnifiedQuote[], n: Notification): UnifiedQuote[] {\n  return quotes.map((quote) => (notificationMatchesQuote(quote, n) ? applyToMatched(quote, n) : quote));\n}\n"],"mappings":";;;;AAOA,IAAM,IAAsB,IAAI,IAAI;CAAC;CAAwB;CAAa;AAAoB,CAAC,GAMzF,IAAqB,IAAI,IAAI,CAAC,YAAY,CAAC,GAO3C,IAAwB,IAAI,IAAI,CAAC,iCAAiC,wBAAwB,CAAC,GAO3F,IAAqB,IAAI,IAAI,CAAC,+BAA+B,qBAAqB,CAAC,GAKnF,IAAgB,IAAI,IAAI,CAAC,GAAG,GAAuB,GAAG,CAAkB,CAAC,GAQzE,IAA4D;EAC/D,EAAe,mBAAmB;EAClC,EAAe,qBAAqB;EACpC,EAAe,sBAAsB;EACrC,EAAe,UAAU;AAC5B;AAGA,SAAS,EAAe,GAAmC;CACzD,OAAO,EAAiB,MAAc;AACxC;AAyBA,SAAgB,EAAgC,GAAgE;CAI9G,OAHK,IACD,EAAoB,IAAI,CAAM,KAAK,EAAmB,IAAI,CAAM,IAAU,SAC1E,EAAc,IAAI,CAAM,IAAU,UAC/B,UAHa;AAItB;AAMA,SAAS,EAAyB,GAAqB,GAA0B;CAG/E,OAFI,EAAM,YAAY,KAAA,KAAa,EAAE,YAAY,GAAG,EAAM,aACtD,EAAM,gBAAgB,KAAA,KAAa,EAAM,gBAAgB,EAAE;AAEjE;AAMA,SAAS,EAAe,GAAqB,GAA+B;CAC1E,IAAM,IAAqB,EAAE,GAAG,EAAM,GAChC,IAAY,EAAE,WAAW,EAAE,YAAY,GAAG,EAAE,gBAAgB,OAAO,EAAE,OAAO,IAAI,KAAA;CAUtF,AARI,MAAc,KAAA,KAAa,EAAK,YAAY,KAAA,MAC9C,EAAK,UAAU,GACf,EAAK,MAAM,WAAW,KACtB,EAAK,SAAS,YAEZ,EAAK,gBAAgB,KAAA,KAAa,EAAE,gBAAgB,MACtD,EAAK,cAAc,EAAE,cAEnB,EAAE,cACJ,EAAK,YAAY,EAAE;CAGrB,IAAM,IAAS,EAAE,kBAAkB;CAEnC,IAAI,EAAE,SAAS,EAAiB,QAoB9B,OAHI,EAAK,WAAW,aAAa,EAAK,IAAI,YAAY,KAAA,MACpD,EAAK,YAAY,EAAe,SAE3B;CAET,IAAI,EAAE,SAAS,EAAiB,SAC9B,OAAO;CAET,IAAI,EAAc,IAAI,CAAM,GAAG;EAC7B,AAAI,EAAE,kBACJ,EAAK,iBAAiB,EAAK,kBAAkB,EAAY,EAAE,aAAa;EAkB1E,IAAM,IAAQ,EAAmB,IAAI,CAAM,IACvC,EAAe,sBACf,EAAe;EAKnB,QAJsB,EAAe,EAAK,SAAS,IAAI,KAAK,EAAK,WAAW,cACvD,EAAe,CAAK,IAAI,EAAe,EAAK,SAAS,MACxE,EAAK,YAAY,IAEZ;CACT;CAuBA,OAtBI,EAAoB,IAAI,CAAM,KAC5B,EAAE,iBACJ,EAAK,cAAc,EAAY,EAAE,YAAY,IAU3C,EAAK,IAAI,YAAY,KAAA,MAAW,EAAK,YAAY,EAAe,gBAC7D,KAEL,EAAmB,IAAI,CAAM,KAC3B,EAAE,iBACJ,EAAK,cAAc,EAAY,EAAE,YAAY,IAE/C,EAAK,YAAY,EAAK,WAAW,YAAY,EAAK,YAAY,EAAe,cACtE,KAEF;AACT;AAgCA,SAAgB,EAA0B,GAAwB,GAAiC;CACjG,OAAO,EAAO,KAAK,MAAW,EAAyB,GAAO,CAAC,IAAI,EAAe,GAAO,CAAC,IAAI,CAAM;AACtG"}
+{"version":3,"file":"apply-notification.js","names":[],"sources":["../../src/quotes/apply-notification.ts"],"sourcesContent":["import { toWeiBigInt } from \"../solvers/instant-open/shared/trade-math\";\nimport { NotificationType, type Notification } from \"../websocket/notifications/types\";\nimport { QuoteLifecycle, type UnifiedQuote } from \"./unified-quote\";\n\n/**\n * Solver `lastSeenAction` values that, on success, anchor a quote on-chain.\n */\nconst OPEN_ANCHOR_ACTIONS = new Set([\"SendQuoteTransaction\", \"SendQuote\", \"FillLimitOrderOpen\"]);\n\n/**\n * Solver `lastSeenAction` values that report a fill price while the trade is\n * still off-chain (the optimistic row gets a price before its on-chain id lands).\n */\nconst PRICE_FILL_ACTIONS = new Set([\"InstantRFQ\"]);\n\n/**\n * Close `lastSeenAction` values that report the close price / fill request — the\n * solver **accepted** the close (analogous to `InstantRFQ` on the open side).\n * Advances a closing row to {@link QuoteLifecycle.CLOSE_PRICE_FILLED}.\n */\nconst CLOSE_REQUEST_ACTIONS = new Set([\"InstantRequestToClosePosition\", \"RequestToClosePosition\"]);\n\n/**\n * Close `lastSeenAction` values that report the on-chain **fill** — the close\n * executed. Advances a closing row to {@link QuoteLifecycle.WRITE_ONCHAIN_CLOSE}.\n */\nconst CLOSE_FILL_ACTIONS = new Set([\"FillMarketOrderInstantClose\", \"FillLimitOrderClose\"]);\n\n/**\n * Close `lastSeenAction` values that report the close **anchored on-chain** without\n * a fill — a resting **limit** close (`InstantRequestToLimitClose`): the position\n * is being written to `CLOSE_PENDING` at the user's price but nothing filled yet.\n * Like a fill it advances to {@link QuoteLifecycle.WRITE_ONCHAIN_CLOSE} (\"writing\n * on-chain\"), but it is **not** a settle — no balance moves — so it stays out of\n * {@link CLOSE_FILL_ACTIONS} (and the settle-confirm chase).\n */\nconst CLOSE_ANCHOR_ACTIONS = new Set([\"InstantRequestToLimitClose\"]);\n\n/**\n * All `lastSeenAction` values that belong to the closing flow (request + anchor + fill).\n */\nconst CLOSE_ACTIONS = new Set([...CLOSE_REQUEST_ACTIONS, ...CLOSE_ANCHOR_ACTIONS, ...CLOSE_FILL_ACTIONS]);\n\n/**\n * `lastSeenAction` values that belong to the **cancel** flow — cancelling a resting\n * order rather than closing a position.\n *\n * Only `RequestToCancelQuote` is confirmed against a live solver frame. The other\n * three are the contract's remaining cancel paths (`forceCancelQuote`,\n * `expireQuote`, the solver's own `acceptCancelRequest`); it is **not** confirmed\n * that the hedger publishes a frame for any of them — observed history for a\n * cancelled quote contained the request frame only. They are listed so that a\n * vendor that does emit them is handled, and cost nothing when it does not.\n */\nconst CANCEL_ACTIONS = new Set([\n  \"RequestToCancelQuote\",\n  /** TODO(vendor-verify): unconfirmed — never observed on the Rasa notifications stream. */\n  \"AcceptCancelRequest\",\n  /** TODO(vendor-verify): unconfirmed — never observed on the Rasa notifications stream. */\n  \"ForceCancelQuote\",\n  /** TODO(vendor-verify): unconfirmed — never observed on the Rasa notifications stream. */\n  \"ExpireQuote\",\n]);\n\n/**\n * Rank of each closing-stage lifecycle, used to advance a close monotonically and\n * to detect that a row is currently \"in a close\" (rank &gt; 0). Higher = further\n * along; `WRITE_ONCHAIN_CLOSE` is the furthest in-flight stage. Once the on-chain\n * read reflects the close the row leaves the closing flow at `ONCHAIN`\n * (`quoteStatus: CLOSE_PENDING`, rank 0), so a replayed close notification then\n * matches nothing to advance.\n */\nconst CLOSE_STAGE_RANK: Partial<Record<QuoteLifecycle, number>> = {\n  [QuoteLifecycle.OPTIMISTIC_CLOSE]: 1,\n  [QuoteLifecycle.CLOSE_PRICE_FILLED]: 2,\n  [QuoteLifecycle.WRITE_ONCHAIN_CLOSE]: 3,\n};\n\n/** The closing-stage rank of a lifecycle (0 when it is not a closing stage). */\nfunction closeStageRank(lifecycle: QuoteLifecycle): number {\n  return CLOSE_STAGE_RANK[lifecycle] ?? 0;\n}\n\n/**\n * The kind of quote action a notification reports, derived from its\n * `lastSeenAction`. Consumers use this to scope cache invalidation to the reads a\n * notification can actually affect — an open-anchor event never changes the\n * pending-instant-close feed, and vice versa.\n */\nexport type QuoteNotificationActionKind = \"open\" | \"close\" | \"other\";\n\n/**\n * Classify a notification's `lastSeenAction` into the quote flow it belongs to.\n *\n * Open-side actions (anchoring an open, or the `InstantRFQ` price fill) classify\n * as `\"open\"`; close-request/fill actions classify as `\"close\"`; anything else\n * (including failures and unknown actions) is `\"other\"`.\n *\n * @param action - The notification's `lastSeenAction` (may be `null`/absent).\n * @returns The quote flow the action belongs to.\n *\n * @example\n * ```ts\n * if (classifyQuoteNotificationAction(n.lastSeenAction) === \"close\") invalidateCloses();\n * ```\n */\nexport function classifyQuoteNotificationAction(action: string | null | undefined): QuoteNotificationActionKind {\n  if (!action) return \"other\";\n  if (OPEN_ANCHOR_ACTIONS.has(action) || PRICE_FILL_ACTIONS.has(action)) return \"open\";\n  if (CLOSE_ACTIONS.has(action)) return \"close\";\n  return \"other\";\n}\n\n/**\n * Whether a notification's `lastSeenAction` is an open **anchor** — the quote\n * landed on-chain (`SendQuoteTransaction` / `SendQuote` / `FillLimitOrderOpen`),\n * as opposed to the earlier off-chain `InstantRFQ` price fill. This is the\n * \"second\" notification of a send flow: the temp id now has a real on-chain quote\n * id. Use it to refetch reads that only change once the quote exists on-chain —\n * e.g. the pending-quotes (resting limit orders) list.\n *\n * @param action - The notification's `lastSeenAction` (may be `null`/absent).\n * @returns `true` for an open-anchor action, otherwise `false`.\n *\n * @example\n * ```ts\n * if (n.type === NotificationType.SUCCESS && isOpenAnchorAction(n.lastSeenAction)) refetchPending();\n * ```\n */\nexport function isOpenAnchorAction(action: string | null | undefined): boolean {\n  return action != null && OPEN_ANCHOR_ACTIONS.has(action);\n}\n\n/**\n * Whether a notification's `lastSeenAction` is a close **fill** — the close actually\n * executed (`FillMarketOrderInstantClose` / `FillLimitOrderClose`), as opposed to a\n * close *request*. Narrower than {@link classifyQuoteNotificationAction} `=== \"close\"`,\n * which also matches the request. Use this to react only once the close has filled —\n * e.g. to start chasing the on-chain settle, which only begins after the fill.\n *\n * @param action - The notification's `lastSeenAction` (may be `null`/absent).\n * @returns `true` for a close-fill action, otherwise `false`.\n *\n * @example\n * ```ts\n * if (isCloseFillAction(n.lastSeenAction)) startCloseConfirmChase(n.quoteId);\n * ```\n */\nexport function isCloseFillAction(action: string | null | undefined): boolean {\n  return action != null && CLOSE_FILL_ACTIONS.has(action);\n}\n\n/**\n * Whether a notification's `lastSeenAction` belongs to the **cancel** flow —\n * cancelling a resting order (`RequestToCancelQuote` and the other cancel paths).\n *\n * Broader than {@link classifyQuoteNotificationAction}, which reports every cancel\n * action as `\"other\"` — deliberately, since a cancel frame must not mutate a row\n * (the chain is the authority on whether the cancel landed).\n *\n * Cancel is the one flow whose **confirming** transaction is sent by someone else:\n * `requestToCancelQuote` on a `LOCKED` quote only moves it to `CANCEL_PENDING` and\n * leaves it in `partyAPendingQuotes`; the solver's later `acceptCancelRequest` is\n * what sets `CANCELED` and removes it — and that transaction is not announced on\n * the notifications stream. A consumer that reacts to frames alone therefore shows\n * a cancelled order forever. Use this to start chasing the on-chain read.\n *\n * @param action - The notification's `lastSeenAction` (may be `null`/absent).\n * @returns `true` for a cancel-flow action, otherwise `false`.\n *\n * @example\n * ```ts\n * if (isCancelAction(n.lastSeenAction)) startCancelConfirmChase(n.quoteId);\n * ```\n */\nexport function isCancelAction(action: string | null | undefined): boolean {\n  return action != null && CANCEL_ACTIONS.has(action);\n}\n\n/**\n * Decide whether a notification refers to a given unified row, matching first by\n * on-chain quote id and then by the pre-chain temp id.\n */\nfunction notificationMatchesQuote(quote: UnifiedQuote, n: Notification): boolean {\n  if (quote.quoteId !== undefined && n.quoteId === `${quote.quoteId}`) return true;\n  if (quote.tempQuoteId !== undefined && quote.tempQuoteId === n.tempQuoteId) return true;\n  return false;\n}\n\n/**\n * Apply one notification to a single matched {@link UnifiedQuote}, returning a\n * new row with the linked ids, filled prices, and advanced lifecycle.\n */\nfunction applyToMatched(quote: UnifiedQuote, n: Notification): UnifiedQuote {\n  const next: UnifiedQuote = { ...quote };\n  const onchainId = n.quoteId && n.quoteId !== `${n.tempQuoteId}` ? BigInt(n.quoteId) : undefined;\n\n  if (onchainId !== undefined && next.quoteId === undefined) {\n    next.quoteId = onchainId;\n    next.key = `onchain:${onchainId}`;\n    next.origin = \"onchain\";\n  }\n  if (next.tempQuoteId === undefined && n.tempQuoteId !== 0) {\n    next.tempQuoteId = n.tempQuoteId;\n  }\n  if (n.vaAddress) {\n    next.vaAddress = n.vaAddress as UnifiedQuote[\"vaAddress\"];\n  }\n\n  const action = n.lastSeenAction ?? \"\";\n\n  if (n.type === NotificationType.FAILED) {\n    /**\n     * A failure is an *event*, not a durable state of a quote that exists, so we do\n     * not flash `FAILED` in the common cases:\n     * - a failed *action* on a confirmed on-chain row (e.g. a rejected partial\n     *   close) leaves the position `OPENED` — it stays put and defers to the polled\n     *   status (notifications are replayed every tick, so stamping `FAILED` here\n     *   would pin a live position and block any retry);\n     * - a failed *open* that never anchored simply has no quote — its optimistic row\n     *   vanishes on its own once the hedger drops the pending open (active-quotes\n     *   only), with no `FAILED` flicker.\n     *\n     * The only row we mark `FAILED` is one the chain was told anchored\n     * (`origin === \"onchain\"`, `quoteId` set) but the read never returned\n     * (`raw.onchain` absent) — a reverted anchor — so it drops out of the retained\n     * anchor set instead of hanging at `WRITE_ONCHAIN` forever.\n     */\n    if (next.origin === \"onchain\" && next.raw.onchain === undefined) {\n      next.lifecycle = QuoteLifecycle.FAILED;\n    }\n    return next;\n  }\n  if (n.type !== NotificationType.SUCCESS) {\n    return next;\n  }\n  if (CLOSE_ACTIONS.has(action)) {\n    if (n.avgPriceClose) {\n      next.avgClosedPrice = next.avgClosedPrice ?? toWeiBigInt(n.avgPriceClose);\n    }\n    /**\n     * Advance the close stage from the notification: the request\n     * (`InstantRequestToClosePosition`) → `CLOSE_PRICE_FILLED` (solver accepted),\n     * the fill (`FillMarketOrderInstantClose`) or the limit-close anchor\n     * (`InstantRequestToLimitClose`) → `WRITE_ONCHAIN_CLOSE` (writing on-chain).\n     *\n     * This only applies to a row that is **already in a closing stage** — the\n     * pending-instant-close overlay (the self-clearing in-flight signal from the\n     * hedger feed) puts an anchored row at `OPTIMISTIC_CLOSE` before notifications\n     * run — or to a not-yet-anchored off-chain row. Once the close settles, the\n     * feed drops, the overlay no longer runs, and the polled row is back at\n     * `ONCHAIN` (rank 0): these **replayed** close notifications then match nothing\n     * to advance, so a settled close never sticks (the bug the old `origin` guard\n     * prevented). The advance is monotonic on {@link closeStageRank}, so neither a\n     * replay nor the earlier request notification can regress the poll-confirmed\n     * `CLOSING`.\n     */\n    const stage =\n      CLOSE_FILL_ACTIONS.has(action) || CLOSE_ANCHOR_ACTIONS.has(action)\n        ? QuoteLifecycle.WRITE_ONCHAIN_CLOSE\n        : QuoteLifecycle.CLOSE_PRICE_FILLED;\n    const inClosingFlow = closeStageRank(next.lifecycle) > 0 || next.origin !== \"onchain\";\n    if (inClosingFlow && closeStageRank(stage) > closeStageRank(next.lifecycle)) {\n      next.lifecycle = stage;\n    }\n    return next;\n  }\n  if (OPEN_ANCHOR_ACTIONS.has(action)) {\n    if (n.avgPriceOpen) {\n      next.openedPrice = toWeiBigInt(n.avgPriceOpen);\n    }\n    /**\n     * The notification reports the quote anchored on-chain, but the on-chain read\n     * may not have returned its struct yet. Surface `WRITE_ONCHAIN` — \"anchored,\n     * awaiting the RPC\" — until the polled struct arrives (`raw.onchain` present),\n     * at which point reconciliation collapses this onto the real on-chain row and\n     * its polled status wins. An already-anchored row (struct present) keeps its\n     * polled lifecycle.\n     */\n    if (next.raw.onchain === undefined) next.lifecycle = QuoteLifecycle.WRITE_ONCHAIN;\n    return next;\n  }\n  if (PRICE_FILL_ACTIONS.has(action)) {\n    if (n.avgPriceOpen) {\n      next.openedPrice = toWeiBigInt(n.avgPriceOpen);\n    }\n    next.lifecycle = next.origin === \"onchain\" ? next.lifecycle : QuoteLifecycle.PRICE_FILLED;\n    return next;\n  }\n  return next;\n}\n\n/**\n * Apply a single notification to a list of {@link UnifiedQuote}s, returning a new\n * list (pure — inputs are never mutated).\n *\n * The notification is matched to a row by on-chain quote id, falling back to the\n * pre-chain temp id, which is how an optimistic row gets linked to its on-chain\n * quote (`temp:<id>` → `onchain:<id>`). On the matched row it:\n *\n * - links `tempQuoteId` ↔ `quoteId` and rekeys it once the on-chain id appears;\n * - fills `openedPrice` and advances to `PRICE_FILLED` on `InstantRFQ` success;\n * - advances to `ONCHAIN` on `SendQuoteTransaction` (open-anchor) success;\n * - advances the close stage on a row already in the closing flow (or an\n *   off-chain row): the request → `CLOSE_PRICE_FILLED`, the fill →\n *   `WRITE_ONCHAIN_CLOSE`, monotonically. A settled close (polled back to\n *   `ONCHAIN`) is no longer in a closing stage, so the replayed close\n *   notifications match nothing to advance and never re-stick it;\n * - advances to `FAILED` **only for an anchored-but-unread row whose anchor reverted**\n *   (`origin === \"onchain\"`, `raw.onchain` absent). A failed close on a confirmed\n *   position stays put (defers to the poll), and a failed open's optimistic row just\n *   vanishes when the hedger drops it — failure is an event, not a durable state.\n *\n * @param quotes - The current unified rows.\n * @param n - The normalized notification to apply.\n * @returns A new list with the matched row updated; the same list (by content) when nothing matched.\n *\n * @example\n * ```ts\n * const next = applyNotificationToQuotes(quotes, notification);\n * ```\n */\nexport function applyNotificationToQuotes(quotes: UnifiedQuote[], n: Notification): UnifiedQuote[] {\n  return quotes.map((quote) => (notificationMatchesQuote(quote, n) ? applyToMatched(quote, n) : quote));\n}\n"],"mappings":";;;;AAOA,IAAM,IAAsB,IAAI,IAAI;CAAC;CAAwB;CAAa;AAAoB,CAAC,GAMzF,IAAqB,IAAI,IAAI,CAAC,YAAY,CAAC,GAO3C,IAAwB,IAAI,IAAI,CAAC,iCAAiC,wBAAwB,CAAC,GAM3F,IAAqB,IAAI,IAAI,CAAC,+BAA+B,qBAAqB,CAAC,GAUnF,IAAuB,IAAI,IAAI,CAAC,4BAA4B,CAAC,GAK7D,IAAgB,IAAI,IAAI;CAAC,GAAG;CAAuB,GAAG;CAAsB,GAAG;AAAkB,CAAC,GAalG,IAAiB,IAAI,IAAI;CAC7B;CAEA;CAEA;CAEA;AACF,CAAC,GAUK,IAA4D;EAC/D,EAAe,mBAAmB;EAClC,EAAe,qBAAqB;EACpC,EAAe,sBAAsB;AACxC;AAGA,SAAS,EAAe,GAAmC;CACzD,OAAO,EAAiB,MAAc;AACxC;AAyBA,SAAgB,EAAgC,GAAgE;CAI9G,OAHK,IACD,EAAoB,IAAI,CAAM,KAAK,EAAmB,IAAI,CAAM,IAAU,SAC1E,EAAc,IAAI,CAAM,IAAU,UAC/B,UAHa;AAItB;AAkBA,SAAgB,EAAmB,GAA4C;CAC7E,OAAO,KAAU,QAAQ,EAAoB,IAAI,CAAM;AACzD;AAiBA,SAAgB,EAAkB,GAA4C;CAC5E,OAAO,KAAU,QAAQ,EAAmB,IAAI,CAAM;AACxD;AAyBA,SAAgB,EAAe,GAA4C;CACzE,OAAO,KAAU,QAAQ,EAAe,IAAI,CAAM;AACpD;AAMA,SAAS,EAAyB,GAAqB,GAA0B;CAG/E,OAFI,EAAM,YAAY,KAAA,KAAa,EAAE,YAAY,GAAG,EAAM,aACtD,EAAM,gBAAgB,KAAA,KAAa,EAAM,gBAAgB,EAAE;AAEjE;AAMA,SAAS,EAAe,GAAqB,GAA+B;CAC1E,IAAM,IAAqB,EAAE,GAAG,EAAM,GAChC,IAAY,EAAE,WAAW,EAAE,YAAY,GAAG,EAAE,gBAAgB,OAAO,EAAE,OAAO,IAAI,KAAA;CAUtF,AARI,MAAc,KAAA,KAAa,EAAK,YAAY,KAAA,MAC9C,EAAK,UAAU,GACf,EAAK,MAAM,WAAW,KACtB,EAAK,SAAS,YAEZ,EAAK,gBAAgB,KAAA,KAAa,EAAE,gBAAgB,MACtD,EAAK,cAAc,EAAE,cAEnB,EAAE,cACJ,EAAK,YAAY,EAAE;CAGrB,IAAM,IAAS,EAAE,kBAAkB;CAEnC,IAAI,EAAE,SAAS,EAAiB,QAoB9B,OAHI,EAAK,WAAW,aAAa,EAAK,IAAI,YAAY,KAAA,MACpD,EAAK,YAAY,EAAe,SAE3B;CAET,IAAI,EAAE,SAAS,EAAiB,SAC9B,OAAO;CAET,IAAI,EAAc,IAAI,CAAM,GAAG;EAC7B,AAAI,EAAE,kBACJ,EAAK,iBAAiB,EAAK,kBAAkB,EAAY,EAAE,aAAa;EAmB1E,IAAM,IACJ,EAAmB,IAAI,CAAM,KAAK,EAAqB,IAAI,CAAM,IAC7D,EAAe,sBACf,EAAe;EAKrB,QAJsB,EAAe,EAAK,SAAS,IAAI,KAAK,EAAK,WAAW,cACvD,EAAe,CAAK,IAAI,EAAe,EAAK,SAAS,MACxE,EAAK,YAAY,IAEZ;CACT;CAuBA,OAtBI,EAAoB,IAAI,CAAM,KAC5B,EAAE,iBACJ,EAAK,cAAc,EAAY,EAAE,YAAY,IAU3C,EAAK,IAAI,YAAY,KAAA,MAAW,EAAK,YAAY,EAAe,gBAC7D,KAEL,EAAmB,IAAI,CAAM,KAC3B,EAAE,iBACJ,EAAK,cAAc,EAAY,EAAE,YAAY,IAE/C,EAAK,YAAY,EAAK,WAAW,YAAY,EAAK,YAAY,EAAe,cACtE,KAEF;AACT;AAgCA,SAAgB,EAA0B,GAAwB,GAAiC;CACjG,OAAO,EAAO,KAAK,MAAW,EAAyB,GAAO,CAAC,IAAI,EAAe,GAAO,CAAC,IAAI,CAAM;AACtG"}

package/dist/quotes/close-planning/index.d.ts

@@ -0,0 +1,5 @@
+export * from './min-remaining-quantity.js';
+export * from './plan-group-close/index.js';
+export * from './to-close-candidates.js';
+export * from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/quotes/close-planning/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/quotes/close-planning/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,SAAS,CAAC"}

package/dist/quotes/close-planning/min-remaining-quantity.d.ts

@@ -0,0 +1,26 @@
+import { UnifiedQuote } from '../unified-quote.js';
+/**
+ * Smallest open quantity a quote may keep after a partial close, wei.
+ *
+ * The contract accepts a partial close only when the remaining position's
+ * partyA-locked value stays above the symbol's minimum (perps-core v0.8.5
+ * `LibQuoteClose.closeQuote`: `lockedValues.totalForPartyA() == 0 ||
+ * lockedValues.totalForPartyA() >= minAcceptableQuoteValue` — "Remaining quote
+ * value is low"). Locked values shrink proportionally with the closed amount,
+ * so the size bound is:
+ *
+ * `remaining ≥ openQuantity × minAcceptableQuoteValue / lockedForPartyA`
+ *
+ * rounded **up** (a remainder one wei short would revert). `lockedForPartyA` is
+ * the current `cva + lf + partyAmm`.
+ *
+ * Returns `openQuantity` (i.e. "full close only") when the quote has no
+ * partyA-locked value on record — without a margin basis no partial remainder
+ * can be proven acceptable.
+ *
+ * @param quote - The quote being partially closed.
+ * @param minAcceptableQuoteValue - The symbol's `minAcceptableQuoteValue`, wei.
+ * @returns The minimum acceptable remainder, wei.
+ */
+export declare function minRemainingQuantityOf(quote: UnifiedQuote, minAcceptableQuoteValue: bigint): bigint;
+//# sourceMappingURL=min-remaining-quantity.d.ts.map

package/dist/quotes/close-planning/min-remaining-quantity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"min-remaining-quantity.d.ts","sourceRoot":"","sources":["../../../src/quotes/close-planning/min-remaining-quantity.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAWrD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,YAAY,EAAE,uBAAuB,EAAE,MAAM,GAAG,MAAM,CAKnG"}

package/dist/quotes/close-planning/min-remaining-quantity.js

@@ -0,0 +1,12 @@
+//#region src/quotes/close-planning/min-remaining-quantity.ts
+function e(e, t) {
+	return (e + t - 1n) / t;
+}
+function t(t, n) {
+	let r = t.lockedValues.cva + t.lockedValues.lf + t.lockedValues.partyAmm;
+	return r <= 0n ? t.openQuantity : e(t.openQuantity * n, r);
+}
+//#endregion
+export { t as minRemainingQuantityOf };
+
+//# sourceMappingURL=min-remaining-quantity.js.map

package/dist/quotes/close-planning/min-remaining-quantity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"min-remaining-quantity.js","names":[],"sources":["../../../src/quotes/close-planning/min-remaining-quantity.ts"],"sourcesContent":["import type { UnifiedQuote } from \"../unified-quote\";\n\n/**\n * Integer division rounding **up** (toward positive infinity). JavaScript has\n * no built-in ceiling for `bigint` — `/` always truncates, and `Math.ceil`\n * neither accepts `bigint` nor survives the 2^53 precision limit of `number`.\n */\nfunction ceilDiv(numerator: bigint, denominator: bigint): bigint {\n  return (numerator + denominator - 1n) / denominator;\n}\n\n/**\n * Smallest open quantity a quote may keep after a partial close, wei.\n *\n * The contract accepts a partial close only when the remaining position's\n * partyA-locked value stays above the symbol's minimum (perps-core v0.8.5\n * `LibQuoteClose.closeQuote`: `lockedValues.totalForPartyA() == 0 ||\n * lockedValues.totalForPartyA() >= minAcceptableQuoteValue` — \"Remaining quote\n * value is low\"). Locked values shrink proportionally with the closed amount,\n * so the size bound is:\n *\n * `remaining ≥ openQuantity × minAcceptableQuoteValue / lockedForPartyA`\n *\n * rounded **up** (a remainder one wei short would revert). `lockedForPartyA` is\n * the current `cva + lf + partyAmm`.\n *\n * Returns `openQuantity` (i.e. \"full close only\") when the quote has no\n * partyA-locked value on record — without a margin basis no partial remainder\n * can be proven acceptable.\n *\n * @param quote - The quote being partially closed.\n * @param minAcceptableQuoteValue - The symbol's `minAcceptableQuoteValue`, wei.\n * @returns The minimum acceptable remainder, wei.\n */\nexport function minRemainingQuantityOf(quote: UnifiedQuote, minAcceptableQuoteValue: bigint): bigint {\n  const lockedForPartyA = quote.lockedValues.cva + quote.lockedValues.lf + quote.lockedValues.partyAmm;\n  if (lockedForPartyA <= 0n) return quote.openQuantity;\n  // Round up — rounding down would allow a remainder that reverts on-chain.\n  return ceilDiv(quote.openQuantity * minAcceptableQuoteValue, lockedForPartyA);\n}\n"],"mappings":";AAOA,SAAS,EAAQ,GAAmB,GAA6B;CAC/D,QAAQ,IAAY,IAAc,MAAM;AAC1C;AAyBA,SAAgB,EAAuB,GAAqB,GAAyC;CACnG,IAAM,IAAkB,EAAM,aAAa,MAAM,EAAM,aAAa,KAAK,EAAM,aAAa;CAG5F,OAFI,KAAmB,KAAW,EAAM,eAEjC,EAAQ,EAAM,eAAe,GAAyB,CAAe;AAC9E"}

package/dist/quotes/close-planning/plan-group-close/index.d.ts

@@ -0,0 +1,2 @@
+export * from './plan-group-close.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/quotes/close-planning/plan-group-close/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/quotes/close-planning/plan-group-close/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC"}

package/dist/quotes/close-planning/plan-group-close/plan-group-close.d.ts

@@ -0,0 +1,32 @@
+import { GroupCloseCandidate, PlanGroupCloseResult } from '../types.js';
+/**
+ * Plan an **exact** partial close of `targetQuantity` across a group's child
+ * quotes, touching as few quotes as reasonably possible.
+ *
+ * Greedy single pass over candidates ordered by {@link compareCandidates}
+ * (largest first). Per candidate:
+ *
+ * - amount left ≥ its open size → close it **fully**;
+ * - otherwise close the largest **partial** that leaves no dust
+ *   (`openQuantity − minRemainingQuantity`), and spill any excess to the next
+ *   candidate.
+ *
+ * The plan either sums to the target exactly or fails — it never closes more
+ * or less than asked. Failure reasons: `exceeds-open` (target above the
+ * group's open size), `nothing-to-close` (no candidates / non-positive
+ * target), `dust-locked` (every remaining child is at its dust cap; the
+ * failure carries `closeableQuantity`, the largest amount that would have
+ * worked). Pure and deterministic; input order does not matter.
+ *
+ * @param candidates - Closable children (see `toGroupCloseCandidates`).
+ * @param targetQuantity - Exact amount to close, wei.
+ * @returns The allocation plan, or a typed failure.
+ *
+ * @example
+ * ```ts
+ * const plan = planGroupClose(candidates, 2_800000000000000000n);
+ * if (plan.feasible) await executeAllocations(plan.allocations);
+ * ```
+ */
+export declare function planGroupClose(candidates: readonly GroupCloseCandidate[], targetQuantity: bigint): PlanGroupCloseResult;
+//# sourceMappingURL=plan-group-close.d.ts.map

package/dist/quotes/close-planning/plan-group-close/plan-group-close.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-group-close.d.ts","sourceRoot":"","sources":["../../../../src/quotes/close-planning/plan-group-close/plan-group-close.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAwB,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAYhG;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,SAAS,mBAAmB,EAAE,EAC1C,cAAc,EAAE,MAAM,GACrB,oBAAoB,CAiDtB"}

package/dist/quotes/close-planning/plan-group-close/plan-group-close.js

@@ -0,0 +1,60 @@
+//#region src/quotes/close-planning/plan-group-close/plan-group-close.ts
+function e(e, t) {
+	return e.openQuantity === t.openQuantity ? e.key < t.key ? -1 : +(e.key > t.key) : e.openQuantity > t.openQuantity ? -1 : 1;
+}
+function t(t, n) {
+	let r = t.filter((e) => e.openQuantity > 0n), i = r.reduce((e, t) => e + t.openQuantity, 0n);
+	if (n <= 0n || r.length === 0) return {
+		feasible: !1,
+		reason: "nothing-to-close",
+		totalOpen: i,
+		closeableQuantity: 0n
+	};
+	if (n > i) return {
+		feasible: !1,
+		reason: "exceeds-open",
+		totalOpen: i,
+		closeableQuantity: i
+	};
+	if (n === i) return {
+		feasible: !0,
+		allocations: r.map((e) => ({
+			key: e.key,
+			closeQuantity: e.openQuantity,
+			kind: "full"
+		}))
+	};
+	let a = [...r].sort(e), o = [], s = n;
+	for (let e of a) {
+		if (s === 0n) break;
+		if (s >= e.openQuantity) {
+			o.push({
+				key: e.key,
+				closeQuantity: e.openQuantity,
+				kind: "full"
+			}), s -= e.openQuantity;
+			continue;
+		}
+		let t = e.openQuantity - e.minRemainingQuantity;
+		if (t <= 0n) continue;
+		let n = s < t ? s : t;
+		o.push({
+			key: e.key,
+			closeQuantity: n,
+			kind: "partial"
+		}), s -= n;
+	}
+	return s > 0n ? {
+		feasible: !1,
+		reason: "dust-locked",
+		totalOpen: i,
+		closeableQuantity: n - s
+	} : {
+		feasible: !0,
+		allocations: o
+	};
+}
+//#endregion
+export { t as planGroupClose };
+
+//# sourceMappingURL=plan-group-close.js.map

package/dist/quotes/close-planning/plan-group-close/plan-group-close.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-group-close.js","names":[],"sources":["../../../../src/quotes/close-planning/plan-group-close/plan-group-close.ts"],"sourcesContent":["import type { GroupCloseAllocation, GroupCloseCandidate, PlanGroupCloseResult } from \"../types\";\n\n/**\n * Execution order for the greedy pass: largest open size first — consuming the\n * biggest quotes reaches the target with the fewest quotes touched. Equal sizes\n * tie-break on `key` for determinism.\n */\nfunction compareCandidates(a: GroupCloseCandidate, b: GroupCloseCandidate): number {\n  if (a.openQuantity === b.openQuantity) return a.key < b.key ? -1 : a.key > b.key ? 1 : 0;\n  return a.openQuantity > b.openQuantity ? -1 : 1;\n}\n\n/**\n * Plan an **exact** partial close of `targetQuantity` across a group's child\n * quotes, touching as few quotes as reasonably possible.\n *\n * Greedy single pass over candidates ordered by {@link compareCandidates}\n * (largest first). Per candidate:\n *\n * - amount left ≥ its open size → close it **fully**;\n * - otherwise close the largest **partial** that leaves no dust\n *   (`openQuantity − minRemainingQuantity`), and spill any excess to the next\n *   candidate.\n *\n * The plan either sums to the target exactly or fails — it never closes more\n * or less than asked. Failure reasons: `exceeds-open` (target above the\n * group's open size), `nothing-to-close` (no candidates / non-positive\n * target), `dust-locked` (every remaining child is at its dust cap; the\n * failure carries `closeableQuantity`, the largest amount that would have\n * worked). Pure and deterministic; input order does not matter.\n *\n * @param candidates - Closable children (see `toGroupCloseCandidates`).\n * @param targetQuantity - Exact amount to close, wei.\n * @returns The allocation plan, or a typed failure.\n *\n * @example\n * ```ts\n * const plan = planGroupClose(candidates, 2_800000000000000000n);\n * if (plan.feasible) await executeAllocations(plan.allocations);\n * ```\n */\nexport function planGroupClose(\n  candidates: readonly GroupCloseCandidate[],\n  targetQuantity: bigint,\n): PlanGroupCloseResult {\n  const open = candidates.filter((candidate) => candidate.openQuantity > 0n);\n  const totalOpen = open.reduce((sum, candidate) => sum + candidate.openQuantity, 0n);\n\n  if (targetQuantity <= 0n || open.length === 0) {\n    return { feasible: false, reason: \"nothing-to-close\", totalOpen, closeableQuantity: 0n };\n  }\n  if (targetQuantity > totalOpen) {\n    return { feasible: false, reason: \"exceeds-open\", totalOpen, closeableQuantity: totalOpen };\n  }\n  if (targetQuantity === totalOpen) {\n    return {\n      feasible: true,\n      allocations: open.map((candidate) => ({\n        key: candidate.key,\n        closeQuantity: candidate.openQuantity,\n        kind: \"full\",\n      })),\n    };\n  }\n\n  const sorted = [...open].sort(compareCandidates);\n  const allocations: GroupCloseAllocation[] = [];\n  let remaining = targetQuantity;\n\n  for (const candidate of sorted) {\n    if (remaining === 0n) break;\n    if (remaining >= candidate.openQuantity) {\n      allocations.push({ key: candidate.key, closeQuantity: candidate.openQuantity, kind: \"full\" });\n      remaining -= candidate.openQuantity;\n      continue;\n    }\n    // Largest partial that leaves an acceptable remainder; ≤ 0 ⇒ full-close-only child, skip.\n    const cap = candidate.openQuantity - candidate.minRemainingQuantity;\n    if (cap <= 0n) continue;\n    const take = remaining < cap ? remaining : cap;\n    allocations.push({ key: candidate.key, closeQuantity: take, kind: \"partial\" });\n    remaining -= take;\n  }\n\n  if (remaining > 0n) {\n    return {\n      feasible: false,\n      reason: \"dust-locked\",\n      totalOpen,\n      closeableQuantity: targetQuantity - remaining,\n    };\n  }\n  return { feasible: true, allocations };\n}\n"],"mappings":";AAOA,SAAS,EAAkB,GAAwB,GAAgC;CAEjF,OADI,EAAE,iBAAiB,EAAE,eAAqB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAE,MAAM,EAAE,OACtE,EAAE,eAAe,EAAE,eAAe,KAAK;AAChD;AA+BA,SAAgB,EACd,GACA,GACsB;CACtB,IAAM,IAAO,EAAW,QAAQ,MAAc,EAAU,eAAe,EAAE,GACnE,IAAY,EAAK,QAAQ,GAAK,MAAc,IAAM,EAAU,cAAc,EAAE;CAElF,IAAI,KAAkB,MAAM,EAAK,WAAW,GAC1C,OAAO;EAAE,UAAU;EAAO,QAAQ;EAAoB;EAAW,mBAAmB;CAAG;CAEzF,IAAI,IAAiB,GACnB,OAAO;EAAE,UAAU;EAAO,QAAQ;EAAgB;EAAW,mBAAmB;CAAU;CAE5F,IAAI,MAAmB,GACrB,OAAO;EACL,UAAU;EACV,aAAa,EAAK,KAAK,OAAe;GACpC,KAAK,EAAU;GACf,eAAe,EAAU;GACzB,MAAM;EACR,EAAE;CACJ;CAGF,IAAM,IAAS,CAAC,GAAG,CAAI,EAAE,KAAK,CAAiB,GACzC,IAAsC,CAAC,GACzC,IAAY;CAEhB,KAAK,IAAM,KAAa,GAAQ;EAC9B,IAAI,MAAc,IAAI;EACtB,IAAI,KAAa,EAAU,cAAc;GAEvC,AADA,EAAY,KAAK;IAAE,KAAK,EAAU;IAAK,eAAe,EAAU;IAAc,MAAM;GAAO,CAAC,GAC5F,KAAa,EAAU;GACvB;EACF;EAEA,IAAM,IAAM,EAAU,eAAe,EAAU;EAC/C,IAAI,KAAO,IAAI;EACf,IAAM,IAAO,IAAY,IAAM,IAAY;EAE3C,AADA,EAAY,KAAK;GAAE,KAAK,EAAU;GAAK,eAAe;GAAM,MAAM;EAAU,CAAC,GAC7E,KAAa;CACf;CAUA,OARI,IAAY,KACP;EACL,UAAU;EACV,QAAQ;EACR;EACA,mBAAmB,IAAiB;CACtC,IAEK;EAAE,UAAU;EAAM;CAAY;AACvC"}

package/dist/quotes/close-planning/to-close-candidates.d.ts

@@ -0,0 +1,17 @@
+import { UnifiedQuote } from '../unified-quote.js';
+import { GroupCloseCandidate } from './types.js';
+/**
+ * Build {@link GroupCloseCandidate}s for {@link planGroupClose} from a group's
+ * child quotes.
+ *
+ * Only children that can actually receive a close order qualify: anchored
+ * on-chain (`quoteId` known), status `OPENED` (a `CLOSE_PENDING` child already
+ * has a close in flight), and open size left. Each candidate carries its
+ * contract min-remainder (see {@link minRemainingQuantityOf}).
+ *
+ * @param quotes - The group's child quotes.
+ * @param minAcceptableQuoteValue - The symbol's `minAcceptableQuoteValue`, wei.
+ * @returns Candidates for the planner, in the input order.
+ */
+export declare function toGroupCloseCandidates(quotes: readonly UnifiedQuote[], minAcceptableQuoteValue: bigint): GroupCloseCandidate[];
+//# sourceMappingURL=to-close-candidates.d.ts.map

package/dist/quotes/close-planning/to-close-candidates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-close-candidates.d.ts","sourceRoot":"","sources":["../../../src/quotes/close-planning/to-close-candidates.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,SAAS,CAAC;AAEnD;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,SAAS,YAAY,EAAE,EAC/B,uBAAuB,EAAE,MAAM,GAC9B,mBAAmB,EAAE,CAavB"}

package/dist/quotes/close-planning/to-close-candidates.js

@@ -0,0 +1,16 @@
+import { QuoteStatus as e } from "../../symmio-contracts/symmio/types.js";
+import { minRemainingQuantityOf as t } from "./min-remaining-quantity.js";
+//#region src/quotes/close-planning/to-close-candidates.ts
+function n(n, r) {
+	let i = [];
+	for (let a of n) a.quoteId !== void 0 && a.quoteStatus === e.OPENED && (a.openQuantity <= 0n || i.push({
+		key: a.key,
+		openQuantity: a.openQuantity,
+		minRemainingQuantity: t(a, r)
+	}));
+	return i;
+}
+//#endregion
+export { n as toGroupCloseCandidates };
+
+//# sourceMappingURL=to-close-candidates.js.map

package/dist/quotes/close-planning/to-close-candidates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"to-close-candidates.js","names":[],"sources":["../../../src/quotes/close-planning/to-close-candidates.ts"],"sourcesContent":["import { QuoteStatus } from \"../../symmio-contracts/symmio/types\";\nimport type { UnifiedQuote } from \"../unified-quote\";\nimport { minRemainingQuantityOf } from \"./min-remaining-quantity\";\nimport type { GroupCloseCandidate } from \"./types\";\n\n/**\n * Build {@link GroupCloseCandidate}s for {@link planGroupClose} from a group's\n * child quotes.\n *\n * Only children that can actually receive a close order qualify: anchored\n * on-chain (`quoteId` known), status `OPENED` (a `CLOSE_PENDING` child already\n * has a close in flight), and open size left. Each candidate carries its\n * contract min-remainder (see {@link minRemainingQuantityOf}).\n *\n * @param quotes - The group's child quotes.\n * @param minAcceptableQuoteValue - The symbol's `minAcceptableQuoteValue`, wei.\n * @returns Candidates for the planner, in the input order.\n */\nexport function toGroupCloseCandidates(\n  quotes: readonly UnifiedQuote[],\n  minAcceptableQuoteValue: bigint,\n): GroupCloseCandidate[] {\n  const candidates: GroupCloseCandidate[] = [];\n  for (const quote of quotes) {\n    if (quote.quoteId === undefined) continue;\n    if (quote.quoteStatus !== QuoteStatus.OPENED) continue;\n    if (quote.openQuantity <= 0n) continue;\n    candidates.push({\n      key: quote.key,\n      openQuantity: quote.openQuantity,\n      minRemainingQuantity: minRemainingQuantityOf(quote, minAcceptableQuoteValue),\n    });\n  }\n  return candidates;\n}\n"],"mappings":";;;AAkBA,SAAgB,EACd,GACA,GACuB;CACvB,IAAM,IAAoC,CAAC;CAC3C,KAAK,IAAM,KAAS,GACd,EAAM,YAAY,KAAA,KAClB,EAAM,gBAAgB,EAAY,WAClC,EAAM,gBAAgB,MAC1B,EAAW,KAAK;EACd,KAAK,EAAM;EACX,cAAc,EAAM;EACpB,sBAAsB,EAAuB,GAAO,CAAuB;CAC7E,CAAC;CAEH,OAAO;AACT"}

package/dist/quotes/close-planning/types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * One closable child position offered to {@link planGroupClose}. All amounts
+ * are 18-decimal wei `bigint`.
+ */
+export interface GroupCloseCandidate {
+    /** Stable child identity (`UnifiedQuote.key`). */
+    key: string;
+    /** Remaining open size (`quantity − closedAmount`), wei. */
+    openQuantity: bigint;
+    /**
+     * Smallest remainder this child may keep after a partial close, wei — derived
+     * from the symbol's `minAcceptableQuoteValue` (see `minRemainingQuantityOf`).
+     * `0` means any remainder is acceptable; a value ≥ `openQuantity` means the
+     * child can only be closed in full.
+     */
+    minRemainingQuantity: bigint;
+}
+/** Close amount {@link planGroupClose} assigned to one child. */
+export interface GroupCloseAllocation {
+    /** Stable child identity (`UnifiedQuote.key`). */
+    key: string;
+    /** Amount to close, wei. */
+    closeQuantity: bigint;
+    /** `full` when `closeQuantity` equals the child's `openQuantity`. */
+    kind: "full" | "partial";
+}
+/** Why {@link planGroupClose} could not produce an exact plan. */
+export type PlanGroupCloseFailureReason = 
+/** The target exceeds the group's total open quantity. */
+"exceeds-open"
+/** No candidate has open size (or the target is not positive). */
+ | "nothing-to-close"
+/** Every remaining child sits at its dust cap — the exact target is unreachable. */
+ | "dust-locked";
+/** Failure result of {@link planGroupClose}. Nothing should be closed. */
+export interface PlanGroupCloseFailure {
+    feasible: false;
+    reason: PlanGroupCloseFailureReason;
+    /** Σ open quantity across candidates, wei. */
+    totalOpen: bigint;
+    /** Largest amount ≤ target the group could actually close, wei — for error messages / UI caps. */
+    closeableQuantity: bigint;
+}
+/** Success result of {@link planGroupClose}: Σ `closeQuantity` equals the target exactly. */
+export interface PlanGroupCloseSuccess {
+    feasible: true;
+    /** Per-child close amounts, in execution order (largest first). */
+    allocations: GroupCloseAllocation[];
+}
+/** Result of {@link planGroupClose}. */
+export type PlanGroupCloseResult = PlanGroupCloseSuccess | PlanGroupCloseFailure;
+//# sourceMappingURL=types.d.ts.map

package/dist/quotes/close-planning/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/quotes/close-planning/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,kDAAkD;IAClD,GAAG,EAAE,MAAM,CAAC;IACZ,4DAA4D;IAC5D,YAAY,EAAE,MAAM,CAAC;IACrB;;;;;OAKG;IACH,oBAAoB,EAAE,MAAM,CAAC;CAC9B;AAED,iEAAiE;AACjE,MAAM,WAAW,oBAAoB;IACnC,kDAAkD;IAClD,GAAG,EAAE,MAAM,CAAC;IACZ,4BAA4B;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;CAC1B;AAED,kEAAkE;AAClE,MAAM,MAAM,2BAA2B;AACrC,0DAA0D;AACxD,cAAc;AAChB,kEAAkE;GAChE,kBAAkB;AACpB,oFAAoF;GAClF,aAAa,CAAC;AAElB,0EAA0E;AAC1E,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,KAAK,CAAC;IAChB,MAAM,EAAE,2BAA2B,CAAC;IACpC,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC;IAClB,kGAAkG;IAClG,iBAAiB,EAAE,MAAM,CAAC;CAC3B;AAED,6FAA6F;AAC7F,MAAM,WAAW,qBAAqB;IACpC,QAAQ,EAAE,IAAI,CAAC;IACf,mEAAmE;IACnE,WAAW,EAAE,oBAAoB,EAAE,CAAC;CACrC;AAED,wCAAwC;AACxC,MAAM,MAAM,oBAAoB,GAAG,qBAAqB,GAAG,qBAAqB,CAAC"}

package/dist/quotes/get-quote-events-by-type/types.d.ts

@@ -22,6 +22,16 @@ export declare enum QuoteEventType {
  * can label and lay it out per type.
  */
 export declare const PRICE_HISTORY_EVENT_TYPES: readonly QuoteEventType[];
+/**
+ * Every event type that settles funding on a quote — the per-tick rows behind a
+ * position's funding history.
+ *
+ * A subset of {@link PRICE_HISTORY_EVENT_TYPES}: it drops `SETTLE_UPNL` (an
+ * open-price recompute that moves no funding) and keeps only the two charge
+ * events, each of which carries `fundingPaid` / `fundingReceived` / `rate` in its
+ * metadata. Pair with `getQuotesEventsByType` for a whole {@link QuoteGroup}.
+ */
+export declare const FUNDING_HISTORY_EVENT_TYPES: readonly QuoteEventType[];
 /**
  * One decoded `QuoteEvent` row. `type` identifies which event family this row
  * belongs to (price update vs funding charge); the decoded metadata fields are

package/dist/quotes/get-quote-events-by-type/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/quotes/get-quote-events-by-type/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEhC;;;;GAIG;AACH,oBAAY,cAAc;IACxB,uEAAuE;IACvE,UAAU,gBAAgB;IAC1B,qFAAqF;IACrF,iBAAiB,wBAAwB;IACzC,2EAA2E;IAC3E,2BAA2B,mCAAmC;CAC/D;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,EAAE,SAAS,cAAc,EAI9D,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,0EAA0E;IAC1E,IAAI,EAAE,cAAc,CAAC;IACrB,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wCAAwC;IACxC,WAAW,CAAC,EAAE,GAAG,CAAC;IAClB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4EAA4E;IAC5E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6EAA6E;IAC7E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,4FAA4F;IAC5F,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/quotes/get-quote-events-by-type/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAEhC;;;;GAIG;AACH,oBAAY,cAAc;IACxB,uEAAuE;IACvE,UAAU,gBAAgB;IAC1B,qFAAqF;IACrF,iBAAiB,wBAAwB;IACzC,2EAA2E;IAC3E,2BAA2B,mCAAmC;CAC/D;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,EAAE,SAAS,cAAc,EAI9D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,EAAE,SAAS,cAAc,EAGhE,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC5B,+DAA+D;IAC/D,OAAO,EAAE,MAAM,CAAC;IAChB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC;IAChB,0EAA0E;IAC1E,IAAI,EAAE,cAAc,CAAC;IACrB,wCAAwC;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,oCAAoC;IACpC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wCAAwC;IACxC,WAAW,CAAC,EAAE,GAAG,CAAC;IAClB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4EAA4E;IAC5E,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,6EAA6E;IAC7E,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,4FAA4F;IAC5F,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6EAA6E;IAC7E,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B"}

package/dist/quotes/get-quote-events-by-type/types.js

@@ -5,8 +5,8 @@ var e = /* @__PURE__ */ function(e) {
 	"SETTLE_UPNL",
 	"CHARGE_FUNDING_RATE",
 	"CHARGE_ACCUMULATED_FUNDING_FEE"
-];
+], n = ["CHARGE_FUNDING_RATE", "CHARGE_ACCUMULATED_FUNDING_FEE"];
 //#endregion
-export { t as PRICE_HISTORY_EVENT_TYPES, e as QuoteEventType };
+export { n as FUNDING_HISTORY_EVENT_TYPES, t as PRICE_HISTORY_EVENT_TYPES, e as QuoteEventType };
 
 //# sourceMappingURL=types.js.map

package/dist/quotes/get-quote-events-by-type/types.js.map

@@ -1 +1 @@
-{"version":3,"file":"types.js","names":[],"sources":["../../../src/quotes/get-quote-events-by-type/types.ts"],"sourcesContent":["import type { Hex } from \"viem\";\n\n/**\n * Subgraph `QuoteEvent.type` values for non-terminal events that touch a quote's\n * open price or funding. Terminal close/liquidation events live on\n * {@link \"QuoteCloseEventType\"} (see `getQuoteHistory`).\n */\nexport enum QuoteEventType {\n  /** Open-price recompute on a partial close (settle unrealized PnL). */\n  SettleUpnl = \"SETTLE_UPNL\",\n  /** Periodic funding-rate tick (carries a `rate` and the resulting paid/received). */\n  ChargeFundingRate = \"CHARGE_FUNDING_RATE\",\n  /** Catch-up charge of accumulated funding that was previously deferred. */\n  ChargeAccumulatedFundingFee = \"CHARGE_ACCUMULATED_FUNDING_FEE\",\n}\n\n/**\n * Every event type that contributes to a quote's open-price history.\n *\n * Includes both explicit price-recompute events (`SETTLE_UPNL`) and funding-rate\n * charges (`CHARGE_FUNDING_RATE`, `CHARGE_ACCUMULATED_FUNDING_FEE`) — funding\n * ticks also adjust the open price as a side effect, so they belong in the same\n * timeline. Each row carries the {@link QuoteEventType} discriminant so the UI\n * can label and lay it out per type.\n */\nexport const PRICE_HISTORY_EVENT_TYPES: readonly QuoteEventType[] = [\n  QuoteEventType.SettleUpnl,\n  QuoteEventType.ChargeFundingRate,\n  QuoteEventType.ChargeAccumulatedFundingFee,\n];\n\n/**\n * One decoded `QuoteEvent` row. `type` identifies which event family this row\n * belongs to (price update vs funding charge); the decoded metadata fields are\n * present whenever the underlying JSON carried them.\n *\n * All amount and price fields are 18-decimal-wei `bigint`.\n */\nexport interface QuoteEventRow {\n  /** Subgraph `QuoteEvent.id` (stable; use as the React key). */\n  eventId: string;\n  /** On-chain quote id this row belongs to. */\n  quoteId: bigint;\n  /** Event-type discriminant — tells the UI which fields it cares about. */\n  type: QuoteEventType;\n  /** Event block timestamp in seconds. */\n  timestamp: number;\n  /** Block number, when available. */\n  blockNumber?: bigint;\n  /** Transaction hash, when available. */\n  transaction?: Hex;\n  /** New open price after the event (wei), when present in metadata. */\n  newPrice?: bigint;\n  /** Open price before the event (wei), when present in metadata. */\n  prevPrice?: bigint;\n  /** Remaining open quantity at the event (wei), when present in metadata. */\n  openQuantity?: bigint;\n  /** Funding partyA paid in this event (wei), when present in metadata. */\n  fundingPaid?: bigint;\n  /** Funding partyA received in this event (wei), when present in metadata. */\n  fundingReceived?: bigint;\n  /** Funding rate applied for the tick (signed `int256` as wei), when present in metadata. */\n  rate?: bigint;\n  /** Raw metadata JSON string from the subgraph, preserved for power users. */\n  rawMetadata: string | null;\n}\n"],"mappings":";AAOA,IAAY,IAAL,yBAAA,GAAA;QAEL,EAAA,aAAA,eAEA,EAAA,oBAAA,uBAEA,EAAA,8BAAA;AACF,EAAA,CAAA,CAAA,GAWa,IAAuD;;;;AAIpE"}
+{"version":3,"file":"types.js","names":[],"sources":["../../../src/quotes/get-quote-events-by-type/types.ts"],"sourcesContent":["import type { Hex } from \"viem\";\n\n/**\n * Subgraph `QuoteEvent.type` values for non-terminal events that touch a quote's\n * open price or funding. Terminal close/liquidation events live on\n * {@link \"QuoteCloseEventType\"} (see `getQuoteHistory`).\n */\nexport enum QuoteEventType {\n  /** Open-price recompute on a partial close (settle unrealized PnL). */\n  SettleUpnl = \"SETTLE_UPNL\",\n  /** Periodic funding-rate tick (carries a `rate` and the resulting paid/received). */\n  ChargeFundingRate = \"CHARGE_FUNDING_RATE\",\n  /** Catch-up charge of accumulated funding that was previously deferred. */\n  ChargeAccumulatedFundingFee = \"CHARGE_ACCUMULATED_FUNDING_FEE\",\n}\n\n/**\n * Every event type that contributes to a quote's open-price history.\n *\n * Includes both explicit price-recompute events (`SETTLE_UPNL`) and funding-rate\n * charges (`CHARGE_FUNDING_RATE`, `CHARGE_ACCUMULATED_FUNDING_FEE`) — funding\n * ticks also adjust the open price as a side effect, so they belong in the same\n * timeline. Each row carries the {@link QuoteEventType} discriminant so the UI\n * can label and lay it out per type.\n */\nexport const PRICE_HISTORY_EVENT_TYPES: readonly QuoteEventType[] = [\n  QuoteEventType.SettleUpnl,\n  QuoteEventType.ChargeFundingRate,\n  QuoteEventType.ChargeAccumulatedFundingFee,\n];\n\n/**\n * Every event type that settles funding on a quote — the per-tick rows behind a\n * position's funding history.\n *\n * A subset of {@link PRICE_HISTORY_EVENT_TYPES}: it drops `SETTLE_UPNL` (an\n * open-price recompute that moves no funding) and keeps only the two charge\n * events, each of which carries `fundingPaid` / `fundingReceived` / `rate` in its\n * metadata. Pair with `getQuotesEventsByType` for a whole {@link QuoteGroup}.\n */\nexport const FUNDING_HISTORY_EVENT_TYPES: readonly QuoteEventType[] = [\n  QuoteEventType.ChargeFundingRate,\n  QuoteEventType.ChargeAccumulatedFundingFee,\n];\n\n/**\n * One decoded `QuoteEvent` row. `type` identifies which event family this row\n * belongs to (price update vs funding charge); the decoded metadata fields are\n * present whenever the underlying JSON carried them.\n *\n * All amount and price fields are 18-decimal-wei `bigint`.\n */\nexport interface QuoteEventRow {\n  /** Subgraph `QuoteEvent.id` (stable; use as the React key). */\n  eventId: string;\n  /** On-chain quote id this row belongs to. */\n  quoteId: bigint;\n  /** Event-type discriminant — tells the UI which fields it cares about. */\n  type: QuoteEventType;\n  /** Event block timestamp in seconds. */\n  timestamp: number;\n  /** Block number, when available. */\n  blockNumber?: bigint;\n  /** Transaction hash, when available. */\n  transaction?: Hex;\n  /** New open price after the event (wei), when present in metadata. */\n  newPrice?: bigint;\n  /** Open price before the event (wei), when present in metadata. */\n  prevPrice?: bigint;\n  /** Remaining open quantity at the event (wei), when present in metadata. */\n  openQuantity?: bigint;\n  /** Funding partyA paid in this event (wei), when present in metadata. */\n  fundingPaid?: bigint;\n  /** Funding partyA received in this event (wei), when present in metadata. */\n  fundingReceived?: bigint;\n  /** Funding rate applied for the tick (signed `int256` as wei), when present in metadata. */\n  rate?: bigint;\n  /** Raw metadata JSON string from the subgraph, preserved for power users. */\n  rawMetadata: string | null;\n}\n"],"mappings":";AAOA,IAAY,IAAL,yBAAA,GAAA;QAEL,EAAA,aAAA,eAEA,EAAA,oBAAA,uBAEA,EAAA,8BAAA;AACF,EAAA,CAAA,CAAA,GAWa,IAAuD;;;;AAIpE,GAWa,IAAyD,CAAA,uBAAA,gCAGtE"}

package/dist/quotes/get-quote-funding/get-quote-funding.d.ts

@@ -1,6 +1,15 @@
 import { Config } from '../../core/config/index.js';
 import { ChainIdParameter, Compute } from '../../shared/types/properties.js';
 import { QuoteFundingData } from './types.js';
+/**
+ * Maximum number of quote ids sent in one `QuotesFunding` request.
+ *
+ * The Graph caps a `first` argument at 1000 entities per query (and silently
+ * defaults to 100 when `first` is omitted), so {@link getQuoteFunding} chunks
+ * its input at this size and merges the responses. Exported so callers that
+ * size their own batches (and tests) can reuse the exact ceiling.
+ */
+export declare const QUOTES_FUNDING_MAX_IDS_PER_REQUEST = 1000;
 /**
  * Parameters for {@link getQuoteFunding}.
  */
@@ -17,8 +26,20 @@ export interface GetQuoteFundingReturnType {
 }
 /**
  * Read funding totals (`userPaidFunding`, `userReceivedFunding`) for a batch of
- * quotes from the analytics subgraph, in a single round-trip. Filters by the
- * protocol-level `quoteId` scalar so callers never need the diamond address.
+ * quotes from the analytics subgraph. Filters by the protocol-level `quoteId`
+ * scalar so callers never need the diamond address.
+ *
+ * The action **pages internally**: `quoteIds` is chunked into requests of at
+ * most {@link QUOTES_FUNDING_MAX_IDS_PER_REQUEST} ids, issued concurrently, and
+ * the responses are merged. Callers pass the full id list — however long — and
+ * never need to chunk it themselves. (Without an explicit `first`, The Graph
+ * caps a query at 100 entities, which silently truncated large batches; the
+ * extras then surfaced as `missingQuoteIds` and any caller that ignored
+ * completeness rendered a wrong total.)
+ *
+ * The returned funding is what the analytics subgraph has **settled to date**:
+ * funding accrued since the quote's last funding charge is not indexed and is
+ * therefore not included.
  *
  * Returns both the resolved rows and any input ids the subgraph did not yet
  * surface — callers (typically the React layer) decide whether to refetch on
@@ -26,9 +47,10 @@ export interface GetQuoteFundingReturnType {
  *
  * @param config - The SDK config.
  * @param parameters - Quote ids and optional chain id.
- * @returns Funding rows plus the input ids the subgraph did not return.
+ * @returns Funding rows (merged across all internal requests) plus the input ids
+ *   the subgraph did not return, computed across the full input set.
  * @throws {SymmError} when the chain has no analytics subgraph.
- * @throws {SymmApiError} when the subgraph request fails.
+ * @throws {SymmApiError} when any subgraph request fails.
  *
  * @example
  * ```ts