@symmio/trading-react 1.1.0 → 3.0.0

package/dist/quotes/confirm-hold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"confirm-hold.js","names":[],"sources":["../../src/quotes/confirm-hold.ts"],"sourcesContent":["import { QuoteLifecycle, QuoteStatus, type UnifiedQuote } from \"@symmio/trading-core\";\n\n/**\n * Next interval (ms) for a confirm-hold backoff: double the current delay, capped\n * at `max`. After the immediate refetch the schedule is `first`, `first * 2`, … up to\n * `max`, then steady at `max` until the hold is released.\n *\n * @param current - the current backoff interval (ms).\n * @param max - the ceiling interval (ms).\n */\nexport function nextConfirmDelay(current: number, max: number): number {\n  return Math.min(current * 2, max);\n}\n\n/**\n * One close-confirm hold entry: its deadline (ms epoch) plus the `closedAmount`\n * the position had **when the fill was seen**. The chase (and the row's\n * `WRITE_ONCHAIN_CLOSE` retention) releases the moment the on-chain `closedAmount`\n * advances past this baseline — a **partial** settle back to a live position —\n * the same as a full settle (row removed) or a `CLOSE_PENDING` status.\n */\nexport interface CloseConfirmEntry {\n  deadline: number;\n  baseClosed: bigint;\n}\n\n/**\n * Whether the chain has acknowledged a close for a quote that is **still present**\n * in the active set. Releases the close-confirm hold when the on-chain status\n * reflects the pending close (`quoteStatus` `CLOSE_PENDING` / `CANCEL_CLOSE_PENDING`),\n * the quote is terminally `CLOSED`, or `closedAmount` caught up to the full\n * `quantity`. A quote that dropped out of the active set entirely (a full close)\n * is handled by the caller, not here.\n */\nexport function isCloseConfirmedOnchain(quote: UnifiedQuote): boolean {\n  if (quote.lifecycle === QuoteLifecycle.CLOSED) return true;\n  if (quote.quoteStatus === QuoteStatus.CLOSE_PENDING || quote.quoteStatus === QuoteStatus.CANCEL_CLOSE_PENDING) {\n    return true;\n  }\n  const closed = quote.closedAmount ?? 0n;\n  return quote.quantity > 0n && closed >= quote.quantity;\n}\n\n/**\n * Prune the close-confirm hold **in place** against the current active quotes.\n *\n * The hold keeps the managed-quotes on-chain reads accelerated after a close\n * notification until the chain reflects the close — it exists because a rasa\n * instant-close reports `FillMarketOrderInstantClose` while the on-chain read\n * still shows the quote OPENED, and the stateless reconcile would otherwise revert\n * the row to `ONCHAIN` and stop the accelerated poll before the settle lands.\n *\n * Deletes an entry when the chain confirms the close — the row dropped from the\n * active set (full close), or {@link isCloseConfirmedOnchain} for a still-present\n * row — or when its deadline has passed. Returns the ids dropped **only** because\n * their deadline expired without confirmation (a close that never settled), so the\n * caller can surface them; confirmed and absent entries are not returned.\n *\n * @param pending - map of on-chain quoteId → deadline (ms epoch); mutated in place.\n * @param quotes - the current reconciled active quotes.\n * @param now - current time (ms epoch), e.g. `Date.now()`.\n * @returns the quoteIds dropped due to an expired deadline.\n */\nexport function pruneCloseConfirmHold(\n  pending: Map<string, CloseConfirmEntry>,\n  quotes: readonly UnifiedQuote[],\n  now: number,\n): string[] {\n  if (pending.size === 0) return [];\n  const expired: string[] = [];\n  for (const [quoteId, { deadline, baseClosed }] of pending) {\n    const row = quotes.find((quote) => `${quote.quoteId}` === quoteId);\n    /* Released once the chain reflects the close: the row dropped (full settle),\n       the status/closed-amount confirms it, or `closedAmount` advanced past the\n       baseline captured at the fill — a partial settle back to a live position. */\n    if (!row || isCloseConfirmedOnchain(row) || (row.closedAmount ?? 0n) > baseClosed) {\n      pending.delete(quoteId);\n      continue;\n    }\n    if (now > deadline) {\n      pending.delete(quoteId);\n      expired.push(quoteId);\n    }\n  }\n  return expired;\n}\n\n/**\n * Whether the on-chain read has caught up with an anchored open: the row carries\n * the polled struct (`raw.onchain`), so `getPartyAOpenPositions` /\n * `getPartyAPendingQuotes` have actually returned the quote. A row that exists only\n * because a notification anchored it (`WRITE_ONCHAIN`, or a retained anchor) is\n * **not** confirmed — that row is precisely what the hold is waiting to replace.\n */\nexport function isOpenConfirmedOnchain(quote: UnifiedQuote): boolean {\n  return quote.raw.onchain !== undefined;\n}\n\n/**\n * Prune the open-confirm hold **in place** against the current active quotes.\n *\n * The hold chases the on-chain reads after an open-anchor notification\n * (`SendQuoteTransaction` / `SendQuote` / `FillLimitOrderOpen`) until the read\n * returns the quote. The solver emits that frame when it **broadcasts** the\n * transaction, so the single invalidation it triggers races the block and usually\n * loses; without the chase the position stays invisible until something else\n * happens to refetch, because with the notifications socket live there is no idle\n * poll and the accelerated retry only runs while a `WRITE_ONCHAIN` row exists —\n * which requires a pre-chain row from the hedger feed that may already be gone.\n *\n * Mirror of {@link pruneCloseConfirmHold} with one deliberate difference: for a\n * close, a row **absent** from the active set means the close landed; for an open,\n * absence is the very condition being chased, so it keeps the entry.\n *\n * @param pending - map of on-chain quoteId → deadline (ms epoch); mutated in place.\n * @param quotes - the current reconciled active quotes.\n * @param now - current time (ms epoch), e.g. `Date.now()`.\n * @returns the quoteIds dropped due to an expired deadline (an anchor the read never confirmed).\n */\nexport function pruneOpenConfirmHold(\n  pending: Map<string, number>,\n  quotes: readonly UnifiedQuote[],\n  now: number,\n): string[] {\n  if (pending.size === 0) return [];\n  const expired: string[] = [];\n  for (const [quoteId, deadline] of pending) {\n    const row = quotes.find((quote) => `${quote.quoteId}` === quoteId);\n    if (row && isOpenConfirmedOnchain(row)) {\n      pending.delete(quoteId);\n      continue;\n    }\n    if (now > deadline) {\n      pending.delete(quoteId);\n      expired.push(quoteId);\n    }\n  }\n  return expired;\n}\n\n/**\n * Whether the chain has settled a cancel for a quote that is **still present** in the\n * active set — only the terminal `CLOSED` lifecycle counts (`CANCELED` / `EXPIRED` /\n * `CLOSED` on-chain). A quote that dropped out of the active set entirely is the\n * normal outcome and is handled by the caller.\n *\n * Deliberately **not** released on `quoteStatus !== CANCEL_PENDING`: the hold is\n * registered off the cancel-request notification, which the solver publishes around\n * the time the request transaction is broadcast, so the read at that moment usually\n * still says `LOCKED`. Releasing on \"not CANCEL_PENDING\" would end the chase on that\n * stale pre-request read and leave the row stuck exactly as before. Holding through\n * `LOCKED` → `CANCEL_PENDING` → gone is the point.\n */\nexport function isCancelConfirmedOnchain(quote: UnifiedQuote): boolean {\n  return quote.lifecycle === QuoteLifecycle.CLOSED;\n}\n\n/**\n * Prune the cancel-confirm hold **in place** against the current active quotes.\n *\n * The hold chases the on-chain reads after a cancel notification until the chain\n * settles the cancel. It exists because cancelling a `LOCKED` order is a\n * **two-transaction** flow of which only the first is announced:\n * `requestToCancelQuote` moves the quote to `CANCEL_PENDING` and leaves it in\n * `partyAPendingQuotes`, and the solver's later `acceptCancelRequest` — the one that\n * sets `CANCELED` and removes it — publishes no notification frame at all. With the\n * event channel live there is no idle poll and a `CANCEL_PENDING` row does not\n * accelerate anything (its lifecycle is the generic `ONCHAIN`), so without this chase\n * a cancelled order stays on screen until something unrelated happens to refetch.\n *\n * Same shape as {@link pruneCloseConfirmHold}: an entry whose row is **absent** from\n * the active set is confirmed (the accept removed it from the pending array), as is\n * one whose row went terminal ({@link isCancelConfirmedOnchain}). Returns the ids\n * dropped **only** because their deadline passed — a cancel the solver never answered\n * — so the caller can surface them.\n *\n * @param pending - map of on-chain quoteId → deadline (ms epoch); mutated in place.\n * @param quotes - the current reconciled active quotes.\n * @param now - current time (ms epoch), e.g. `Date.now()`.\n * @returns the quoteIds dropped due to an expired deadline.\n */\nexport function pruneCancelConfirmHold(\n  pending: Map<string, number>,\n  quotes: readonly UnifiedQuote[],\n  now: number,\n): string[] {\n  if (pending.size === 0) return [];\n  const expired: string[] = [];\n  for (const [quoteId, deadline] of pending) {\n    const row = quotes.find((quote) => `${quote.quoteId}` === quoteId);\n    if (!row || isCancelConfirmedOnchain(row)) {\n      pending.delete(quoteId);\n      continue;\n    }\n    if (now > deadline) {\n      pending.delete(quoteId);\n      expired.push(quoteId);\n    }\n  }\n  return expired;\n}\n"],"mappings":";;AAUA,SAAgB,EAAiB,GAAiB,GAAqB;CACrE,OAAO,KAAK,IAAI,IAAU,GAAG,CAAG;AAClC;AAsBA,SAAgB,EAAwB,GAA8B;CAEpE,IADI,EAAM,cAAc,EAAe,UACnC,EAAM,gBAAgB,EAAY,iBAAiB,EAAM,gBAAgB,EAAY,sBACvF,OAAO;CAET,IAAM,IAAS,EAAM,gBAAgB;CACrC,OAAO,EAAM,WAAW,MAAM,KAAU,EAAM;AAChD;AAsBA,SAAgB,EACd,GACA,GACA,GACU;CACV,IAAI,EAAQ,SAAS,GAAG,OAAO,CAAC;CAChC,IAAM,IAAoB,CAAC;CAC3B,KAAK,IAAM,CAAC,GAAS,EAAE,aAAU,oBAAiB,GAAS;EACzD,IAAM,IAAM,EAAO,MAAM,MAAU,GAAG,EAAM,cAAc,CAAO;EAIjE,IAAI,CAAC,KAAO,EAAwB,CAAG,MAAM,EAAI,gBAAgB,MAAM,GAAY;GACjF,EAAQ,OAAO,CAAO;GACtB;EACF;EACA,AAAI,IAAM,MACR,EAAQ,OAAO,CAAO,GACtB,EAAQ,KAAK,CAAO;CAExB;CACA,OAAO;AACT;AASA,SAAgB,EAAuB,GAA8B;CACnE,OAAO,EAAM,IAAI,YAAY,KAAA;AAC/B;AAuBA,SAAgB,EACd,GACA,GACA,GACU;CACV,IAAI,EAAQ,SAAS,GAAG,OAAO,CAAC;CAChC,IAAM,IAAoB,CAAC;CAC3B,KAAK,IAAM,CAAC,GAAS,MAAa,GAAS;EACzC,IAAM,IAAM,EAAO,MAAM,MAAU,GAAG,EAAM,cAAc,CAAO;EACjE,IAAI,KAAO,EAAuB,CAAG,GAAG;GACtC,EAAQ,OAAO,CAAO;GACtB;EACF;EACA,AAAI,IAAM,MACR,EAAQ,OAAO,CAAO,GACtB,EAAQ,KAAK,CAAO;CAExB;CACA,OAAO;AACT;AAeA,SAAgB,EAAyB,GAA8B;CACrE,OAAO,EAAM,cAAc,EAAe;AAC5C;AA0BA,SAAgB,EACd,GACA,GACA,GACU;CACV,IAAI,EAAQ,SAAS,GAAG,OAAO,CAAC;CAChC,IAAM,IAAoB,CAAC;CAC3B,KAAK,IAAM,CAAC,GAAS,MAAa,GAAS;EACzC,IAAM,IAAM,EAAO,MAAM,MAAU,GAAG,EAAM,cAAc,CAAO;EACjE,IAAI,CAAC,KAAO,EAAyB,CAAG,GAAG;GACzC,EAAQ,OAAO,CAAO;GACtB;EACF;EACA,AAAI,IAAM,MACR,EAAQ,OAAO,CAAO,GACtB,EAAQ,KAAK,CAAO;CAExB;CACA,OAAO;AACT"}

package/dist/quotes/index.d.ts

@@ -1,16 +1,30 @@
 export * from './optimistic-quotes-store.js';
 export * from './use-account-liquidation-price.js';
+export * from './use-account-upnl.js';
+export * from './use-close-quote-group.js';
+export * from './use-cool-downs-of-ma.js';
+export * from './use-force-cancel-close-request.js';
+export * from './use-force-cancel-quote.js';
+export * from './use-force-close.js';
+export * from './use-force-close-eligibility.js';
+export * from './use-force-close-params.js';
 export * from './use-grouped-quotes.js';
+export * from './use-limit-orders.js';
 export * from './use-managed-quotes.js';
 export * from './use-party-a-open-positions.js';
 export * from './use-party-a-pending-quotes.js';
 export * from './use-quote.js';
 export * from './use-quote-events-by-type.js';
 export * from './use-quote-funding.js';
+export * from './use-quote-group-funding.js';
+export * from './use-quote-group-funding-history.js';
+export * from './use-quote-group-margin-risk.js';
 export * from './use-quote-history.js';
 export * from './use-quote-platform-fee.js';
 export * from './use-quote-price-history.js';
 export * from './use-quote-upnl-and-pnl.js';
 export * from './use-quotes-funding.js';
+export * from './use-request-to-cancel-close-request.js';
+export * from './use-request-to-cancel-quote.js';
 export * from './use-subgraph-query.js';
 //# sourceMappingURL=index.d.ts.map

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,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,aAAa,CAAC;AAC5B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/quotes/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,aAAa,CAAC;AAC5B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,qBAAqB,CAAC;AACpC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uCAAuC,CAAC;AACtD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC"}

package/dist/quotes/use-account-upnl.d.ts

@@ -0,0 +1,66 @@
+import { ConfigParameter, SolverId } from '@symmio/trading-core';
+import { Address } from 'viem';
+/**
+ * Parameters for {@link useAccountUpnl}.
+ */
+export interface UseAccountUpnlParameters extends ConfigParameter {
+    /** The partyA whose open positions are summed. Disabled while undefined. */
+    account?: Address;
+    /** Target chain id. Defaults to the SDK's active chain. */
+    chainId?: number;
+    /** Solver whose markets + price provider value the positions. Defaults to the chain's default solver. */
+    solverId?: SolverId;
+    /** Compute only when `true`. Default `true`. */
+    enabled?: boolean;
+    /**
+     * Subscribe to the account's live notifications so the position set tracks
+     * opens/closes (and off-chain quotes anchoring on-chain) without a manual
+     * refresh. Mark prices are always live via the price socket.
+     * @default false
+     */
+    live?: boolean;
+}
+/**
+ * Value returned by {@link useAccountUpnl}.
+ */
+export interface UseAccountUpnlReturnType {
+    /**
+     * Σ unrealized PnL across the account's open positions — on-chain **and**
+     * off-chain (optimistic instant-opens) — signed wei. `undefined` until every
+     * priced position has a live mark price, so a half-priced sum is never
+     * mistaken for the real figure.
+     */
+    upnl: bigint | undefined;
+    /** Number of open positions contributing to the sum (`0` ⇒ `upnl` is `0n`). */
+    openPositionCount: number;
+    /** True while positions or markets are still loading. */
+    isLoading: boolean;
+    /** Refetch the underlying position + market reads (prices are a live socket). */
+    refetch: () => Promise<void>;
+}
+/**
+ * The account-level unrealized PnL, computed **inside the SDK** — no oracle
+ * round-trip: each open position's uPnL is `openQuantity × (mark − open)`
+ * (sign by side, via `calculateQuoteUpnlWei`) against the live mark price of
+ * whichever provider serves the resolved solver, and the account total is the
+ * sum. Positions come from the **managed (unified) pipeline**, so off-chain
+ * optimistic opens count from the moment they exist and hand over seamlessly
+ * once they anchor on-chain. Feed `upnl` to `calculateAvailableForOrder` for
+ * the spendable balance of a cross-margin account.
+ *
+ * A position without any price reference, with nothing left open, or whose
+ * market has no live tick yet keeps `upnl` at `undefined` until it is priced;
+ * an optimistic open is valued at its settled fill price when known, else its
+ * requested price.
+ *
+ * @example
+ * ```tsx
+ * const { upnl } = useAccountUpnl({ account: subAccount, live: true });
+ * const available =
+ *   balanceInfo && upnl !== undefined
+ *     ? calculateAvailableForOrder({ balanceInfo, upnl })
+ *     : undefined;
+ * ```
+ */
+export declare function useAccountUpnl(parameters?: UseAccountUpnlParameters): UseAccountUpnlReturnType;
+//# sourceMappingURL=use-account-upnl.d.ts.map

package/dist/quotes/use-account-upnl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-account-upnl.d.ts","sourceRoot":"","sources":["../../src/quotes/use-account-upnl.ts"],"names":[],"mappings":"AAEA,OAAO,EAA2C,KAAK,eAAe,EAAE,KAAK,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEpH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAMpC;;GAEG;AACH,MAAM,WAAW,wBAAyB,SAAQ,eAAe;IAC/D,4EAA4E;IAC5E,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,2DAA2D;IAC3D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,yGAAyG;IACzG,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,gDAAgD;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;OAKG;IACH,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;;;OAKG;IACH,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,+EAA+E;IAC/E,iBAAiB,EAAE,MAAM,CAAC;IAC1B,yDAAyD;IACzD,SAAS,EAAE,OAAO,CAAC;IACnB,iFAAiF;IACjF,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,cAAc,CAAC,UAAU,GAAE,wBAA6B,GAAG,wBAAwB,CAsFlG"}

package/dist/quotes/use-account-upnl.js

@@ -0,0 +1,73 @@
+"use client";
+import { useMarkets as e } from "../markets/use-markets.js";
+import { usePrices as t } from "../price-service/use-prices.js";
+import { useManagedQuotes as n } from "./use-managed-quotes.js";
+import { calculateQuoteUpnlWei as r, isActivePosition as i } from "@symmio/trading-core";
+import { useCallback as a, useMemo as o } from "react";
+import { parseUnits as s } from "viem";
+//#region src/quotes/use-account-upnl.ts
+function c(c = {}) {
+	let { account: l, chainId: u, solverId: d, enabled: f = !0, live: p = !1, ...m } = c, h = n({
+		partyA: l,
+		chainId: u,
+		live: p,
+		enabled: f && !!l
+	}), g = e({
+		...m,
+		chainId: u,
+		solverId: d
+	}), { refetch: _ } = h, { refetch: v } = g, y = a(async () => {
+		_(), await v();
+	}, [_, v]), b = o(() => h.quotes.filter((e) => i(e) && e.openQuantity > 0n && (e.openedPrice ?? e.requestedOpenPrice) > 0n), [h.quotes]), x = o(() => {
+		let e = /* @__PURE__ */ new Map();
+		for (let t of g.data ?? []) t.symbolId !== void 0 && t.name && e.set(String(t.symbolId), t.name);
+		return e;
+	}, [g.data]), S = o(() => {
+		let e = /* @__PURE__ */ new Set();
+		for (let t of b) {
+			let n = x.get(String(t.symbolId));
+			n && e.add(n);
+		}
+		return [...e];
+	}, [b, x]), { ticks: C } = t({
+		...m,
+		chainId: u,
+		solverId: d,
+		names: S,
+		enabled: f && S.length > 0
+	});
+	return {
+		upnl: o(() => {
+			if (b.length === 0) return 0n;
+			let e = 0n;
+			for (let t of b) {
+				let n = x.get(String(t.symbolId)), i = n ? C[n]?.markPrice : void 0;
+				if (i === void 0) return;
+				let a;
+				try {
+					a = s(i, 18);
+				} catch {
+					return;
+				}
+				e += r({
+					positionType: t.positionType,
+					openQuantity: t.openQuantity,
+					openedPrice: t.openedPrice ?? t.requestedOpenPrice,
+					markPrice: a
+				});
+			}
+			return e;
+		}, [
+			b,
+			x,
+			C
+		]),
+		openPositionCount: b.length,
+		isLoading: h.isLoading || g.isLoading,
+		refetch: y
+	};
+}
+//#endregion
+export { c as useAccountUpnl };
+
+//# sourceMappingURL=use-account-upnl.js.map

package/dist/quotes/use-account-upnl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-account-upnl.js","names":[],"sources":["../../src/quotes/use-account-upnl.ts"],"sourcesContent":["\"use client\";\n\nimport { calculateQuoteUpnlWei, isActivePosition, type ConfigParameter, type SolverId } from \"@symmio/trading-core\";\nimport { useCallback, useMemo } from \"react\";\nimport type { Address } from \"viem\";\nimport { parseUnits } from \"viem\";\nimport { useMarkets } from \"../markets/use-markets\";\nimport { usePrices } from \"../price-service/use-prices\";\nimport { useManagedQuotes } from \"./use-managed-quotes\";\n\n/**\n * Parameters for {@link useAccountUpnl}.\n */\nexport interface UseAccountUpnlParameters extends ConfigParameter {\n  /** The partyA whose open positions are summed. Disabled while undefined. */\n  account?: Address;\n  /** Target chain id. Defaults to the SDK's active chain. */\n  chainId?: number;\n  /** Solver whose markets + price provider value the positions. Defaults to the chain's default solver. */\n  solverId?: SolverId;\n  /** Compute only when `true`. Default `true`. */\n  enabled?: boolean;\n  /**\n   * Subscribe to the account's live notifications so the position set tracks\n   * opens/closes (and off-chain quotes anchoring on-chain) without a manual\n   * refresh. Mark prices are always live via the price socket.\n   * @default false\n   */\n  live?: boolean;\n}\n\n/**\n * Value returned by {@link useAccountUpnl}.\n */\nexport interface UseAccountUpnlReturnType {\n  /**\n   * Σ unrealized PnL across the account's open positions — on-chain **and**\n   * off-chain (optimistic instant-opens) — signed wei. `undefined` until every\n   * priced position has a live mark price, so a half-priced sum is never\n   * mistaken for the real figure.\n   */\n  upnl: bigint | undefined;\n  /** Number of open positions contributing to the sum (`0` ⇒ `upnl` is `0n`). */\n  openPositionCount: number;\n  /** True while positions or markets are still loading. */\n  isLoading: boolean;\n  /** Refetch the underlying position + market reads (prices are a live socket). */\n  refetch: () => Promise<void>;\n}\n\n/**\n * The account-level unrealized PnL, computed **inside the SDK** — no oracle\n * round-trip: each open position's uPnL is `openQuantity × (mark − open)`\n * (sign by side, via `calculateQuoteUpnlWei`) against the live mark price of\n * whichever provider serves the resolved solver, and the account total is the\n * sum. Positions come from the **managed (unified) pipeline**, so off-chain\n * optimistic opens count from the moment they exist and hand over seamlessly\n * once they anchor on-chain. Feed `upnl` to `calculateAvailableForOrder` for\n * the spendable balance of a cross-margin account.\n *\n * A position without any price reference, with nothing left open, or whose\n * market has no live tick yet keeps `upnl` at `undefined` until it is priced;\n * an optimistic open is valued at its settled fill price when known, else its\n * requested price.\n *\n * @example\n * ```tsx\n * const { upnl } = useAccountUpnl({ account: subAccount, live: true });\n * const available =\n *   balanceInfo && upnl !== undefined\n *     ? calculateAvailableForOrder({ balanceInfo, upnl })\n *     : undefined;\n * ```\n */\nexport function useAccountUpnl(parameters: UseAccountUpnlParameters = {}): UseAccountUpnlReturnType {\n  const { account, chainId, solverId, enabled = true, live = false, ...rest } = parameters;\n\n  // The unified pipeline: on-chain reads + off-chain instant-ops + live\n  // notifications reconciled into one lifecycle-tagged list. It owns the\n  // \"off-chain quote became on-chain\" transition this hook relies on.\n  const managed = useManagedQuotes({\n    partyA: account,\n    chainId,\n    live,\n    enabled: enabled && Boolean(account),\n  });\n  const marketsQuery = useMarkets({ ...rest, chainId, solverId });\n\n  const { refetch: refetchManaged } = managed;\n  const { refetch: refetchMarkets } = marketsQuery;\n  const refetch = useCallback(async () => {\n    refetchManaged();\n    await refetchMarkets();\n  }, [refetchManaged, refetchMarkets]);\n\n  /** Open positions (both origins) that can carry uPnL: open size + a price reference. */\n  const openPositions = useMemo(\n    () =>\n      managed.quotes.filter(\n        (quote) =>\n          isActivePosition(quote) && quote.openQuantity > 0n && (quote.openedPrice ?? quote.requestedOpenPrice) > 0n,\n      ),\n    [managed.quotes],\n  );\n\n  const nameBySymbolId = useMemo(() => {\n    const map = new Map<string, string>();\n    for (const market of marketsQuery.data ?? []) {\n      if (market.symbolId !== undefined && market.name) map.set(String(market.symbolId), market.name);\n    }\n    return map;\n  }, [marketsQuery.data]);\n\n  const names = useMemo(() => {\n    const unique = new Set<string>();\n    for (const position of openPositions) {\n      const name = nameBySymbolId.get(String(position.symbolId));\n      if (name) unique.add(name);\n    }\n    return [...unique];\n  }, [openPositions, nameBySymbolId]);\n\n  const { ticks } = usePrices({\n    ...rest,\n    chainId,\n    solverId,\n    names,\n    enabled: enabled && names.length > 0,\n  });\n\n  const upnl = useMemo<bigint | undefined>(() => {\n    if (openPositions.length === 0) return 0n;\n    let total = 0n;\n    for (const position of openPositions) {\n      const name = nameBySymbolId.get(String(position.symbolId));\n      const markPriceDecimal = name ? ticks[name]?.markPrice : undefined;\n      if (markPriceDecimal === undefined) return undefined;\n      let markPrice: bigint;\n      try {\n        markPrice = parseUnits(markPriceDecimal, 18);\n      } catch {\n        return undefined;\n      }\n      total += calculateQuoteUpnlWei({\n        positionType: position.positionType,\n        openQuantity: position.openQuantity,\n        // Settled fill price when known; an unfilled optimistic open is valued at its requested price.\n        openedPrice: position.openedPrice ?? position.requestedOpenPrice,\n        markPrice,\n      });\n    }\n    return total;\n  }, [openPositions, nameBySymbolId, ticks]);\n\n  return {\n    upnl,\n    openPositionCount: openPositions.length,\n    isLoading: managed.isLoading || marketsQuery.isLoading,\n    refetch,\n  };\n}\n"],"mappings":";;;;;;;;AA0EA,SAAgB,EAAe,IAAuC,CAAC,GAA6B;CAClG,IAAM,EAAE,YAAS,YAAS,aAAU,aAAU,IAAM,UAAO,IAAO,GAAG,MAAS,GAKxE,IAAU,EAAiB;EAC/B,QAAQ;EACR;EACA;EACA,SAAS,KAAW,EAAQ;CAC9B,CAAC,GACK,IAAe,EAAW;EAAE,GAAG;EAAM;EAAS;CAAS,CAAC,GAExD,EAAE,SAAS,MAAmB,GAC9B,EAAE,SAAS,MAAmB,GAC9B,IAAU,EAAY,YAAY;EAEtC,AADA,EAAe,GACf,MAAM,EAAe;CACvB,GAAG,CAAC,GAAgB,CAAc,CAAC,GAG7B,IAAgB,QAElB,EAAQ,OAAO,QACZ,MACC,EAAiB,CAAK,KAAK,EAAM,eAAe,OAAO,EAAM,eAAe,EAAM,sBAAsB,EAC5G,GACF,CAAC,EAAQ,MAAM,CACjB,GAEM,IAAiB,QAAc;EACnC,IAAM,oBAAM,IAAI,IAAoB;EACpC,KAAK,IAAM,KAAU,EAAa,QAAQ,CAAC,GACzC,AAAI,EAAO,aAAa,KAAA,KAAa,EAAO,QAAM,EAAI,IAAI,OAAO,EAAO,QAAQ,GAAG,EAAO,IAAI;EAEhG,OAAO;CACT,GAAG,CAAC,EAAa,IAAI,CAAC,GAEhB,IAAQ,QAAc;EAC1B,IAAM,oBAAS,IAAI,IAAY;EAC/B,KAAK,IAAM,KAAY,GAAe;GACpC,IAAM,IAAO,EAAe,IAAI,OAAO,EAAS,QAAQ,CAAC;GACzD,AAAI,KAAM,EAAO,IAAI,CAAI;EAC3B;EACA,OAAO,CAAC,GAAG,CAAM;CACnB,GAAG,CAAC,GAAe,CAAc,CAAC,GAE5B,EAAE,aAAU,EAAU;EAC1B,GAAG;EACH;EACA;EACA;EACA,SAAS,KAAW,EAAM,SAAS;CACrC,CAAC;CA0BD,OAAO;EACL,MAzBW,QAAkC;GAC7C,IAAI,EAAc,WAAW,GAAG,OAAO;GACvC,IAAI,IAAQ;GACZ,KAAK,IAAM,KAAY,GAAe;IACpC,IAAM,IAAO,EAAe,IAAI,OAAO,EAAS,QAAQ,CAAC,GACnD,IAAmB,IAAO,EAAM,IAAO,YAAY,KAAA;IACzD,IAAI,MAAqB,KAAA,GAAW;IACpC,IAAI;IACJ,IAAI;KACF,IAAY,EAAW,GAAkB,EAAE;IAC7C,QAAQ;KACN;IACF;IACA,KAAS,EAAsB;KAC7B,cAAc,EAAS;KACvB,cAAc,EAAS;KAEvB,aAAa,EAAS,eAAe,EAAS;KAC9C;IACF,CAAC;GACH;GACA,OAAO;EACT,GAAG;GAAC;GAAe;GAAgB;EAAK,CAGtC;EACA,mBAAmB,EAAc;EACjC,WAAW,EAAQ,aAAa,EAAa;EAC7C;CACF;AACF"}

package/dist/quotes/use-close-quote-group.d.ts

@@ -0,0 +1,126 @@
+import { ConfigParameter, PlanGroupCloseFailure, QuoteGroup } from '@symmio/trading-core';
+import { Address } from 'viem';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+/**
+ * Lifecycle of one child close inside a group close:
+ * `queued` → `closing` (submitted in the bulk request, awaiting its close-fill
+ * notification) → `closed` (fill notification received), or `failed` (the bulk
+ * submit or the close itself errored).
+ */
+export type CloseQuoteGroupStepStatus = "queued" | "closing" | "closed" | "failed";
+/** Live state of one child close inside a group close run. */
+export interface CloseQuoteGroupStep {
+    /** Child identity (`UnifiedQuote.key`). */
+    key: string;
+    /** On-chain quote id of the child. */
+    quoteId: bigint;
+    /** Planned close amount, wei. */
+    closeQuantity: bigint;
+    /** `full` when the child closes entirely, `partial` otherwise. */
+    kind: "full" | "partial";
+    /** Current lifecycle stage of this child close. */
+    status: CloseQuoteGroupStepStatus;
+    /** Normalized error, when `status` is `failed`. */
+    error?: SymmioRequestError;
+}
+/** Overall lifecycle of a group close run. */
+export type CloseQuoteGroupStatus = "idle" | "closing" | "success" | "failed";
+/** Inputs for one {@link UseCloseQuoteGroupReturnType.close} run. */
+export interface CloseQuoteGroupParameters {
+    /** The group whose children are being closed. */
+    group: QuoteGroup;
+    /** Exact total quantity to close across the group, wei. */
+    targetQuantity: bigint;
+    /**
+     * The symbol's `minAcceptableQuoteValue` (wei) — the dust floor a partially
+     * closed child must keep. Read it from the market info of the group's symbol.
+     */
+    minAcceptableQuoteValue: bigint;
+    /** Slippage tolerance percent forwarded to every child close (e.g. `5`). */
+    slippage: number;
+    /** Pre-fetched mark price (decimal string) forwarded to every child close. */
+    markPrice?: string;
+    /** Delegated session key to submit the closes from, when delegation is active. */
+    from?: Address;
+    /**
+     * Account whose live notification stream reports the close fills — pass the
+     * **sub-account** when closing Virtual Account quotes (the VA frames arrive
+     * on its owning sub-account's stream). Defaults to the first child's
+     * `vaAddress ?? partyA`.
+     */
+    notificationsAccount?: Address;
+    /** Chain override; defaults to the connected chain. */
+    chainId?: number;
+}
+/**
+ * Submission outcome of one {@link UseCloseQuoteGroupReturnType.close} run.
+ * Resolves when the bulk request carrying every child close has been
+ * **submitted** — settlement is confirmed asynchronously per child (its
+ * close-fill notification), tracked via `status` / `steps` /
+ * `progressPercent` on the hook.
+ */
+export interface CloseQuoteGroupSummary {
+    /** `true` when every planned child close was submitted successfully. */
+    ok: boolean;
+    /** Σ quantity already confirmed closed at resolve time, wei. */
+    closedQuantity: bigint;
+    /** Per-child final states. Empty when planning already failed. */
+    steps: CloseQuoteGroupStep[];
+    /** Present when the plan itself was infeasible — nothing was closed. */
+    planFailure?: PlanGroupCloseFailure;
+    /** The error that stopped the run, when `ok` is `false` and a close failed. */
+    error?: SymmioRequestError;
+}
+/** Return type of {@link useCloseQuoteGroup}. */
+export interface UseCloseQuoteGroupReturnType {
+    /** Plan and execute a group close. Resolves with the run's summary (never rejects). */
+    close: (parameters: CloseQuoteGroupParameters) => Promise<CloseQuoteGroupSummary>;
+    /** Clear the run state back to `idle`. No-op while a run is in flight. */
+    reset: () => void;
+    /** Overall run lifecycle. */
+    status: CloseQuoteGroupStatus;
+    /** `true` while a run is in flight. */
+    isClosing: boolean;
+    /** Quantity-weighted completion, `0`–`100` (2-decimal resolution). */
+    progressPercent: number;
+    /** Σ quantity closed so far in the current/last run, wei. */
+    closedQuantity: bigint;
+    /** The run's target, wei (`0` while idle). */
+    targetQuantity: bigint;
+    /** Per-child close states of the current/last run, in execution order. */
+    steps: CloseQuoteGroupStep[];
+    /** Planning failure of the last run, when the plan was infeasible. */
+    planFailure?: PlanGroupCloseFailure;
+    /** The error that stopped the last run, when a child close failed. */
+    error?: SymmioRequestError;
+}
+/** Parameters for {@link useCloseQuoteGroup}. */
+export type UseCloseQuoteGroupParameters = ConfigParameter;
+/**
+ * Close an exact quantity across a grouped position, child by child.
+ *
+ * The run first plans the allocation with `planGroupClose` (largest child
+ * first; every partially closed child keeps at least the symbol's
+ * `minAcceptableQuoteValue`; the plan sums to the target exactly or fails
+ * without closing anything). It then submits **every allocation in one bulk
+ * request** (`instantCloseBulkAuto` — n operations, one endpoint call). A
+ * submitted child stays `closing` until its close settles: the hook watches
+ * the account's live notifications and flips the child to `closed` — advancing
+ * `closedQuantity` / `progressPercent` — when its **close fill** frame arrives
+ * (`lastSeenAction: FillMarketOrderInstantClose` / `FillLimitOrderClose` with
+ * `success`); `status` becomes `success` once every child confirms, and a
+ * `failed` frame fails that step and the run. A rejected bulk submit fails the
+ * whole run at once.
+ *
+ * @example
+ * ```tsx
+ * const { close, status, progressPercent, steps } = useCloseQuoteGroup();
+ * const summary = await close({
+ *   group, targetQuantity: parseUnits("2.8", 18),
+ *   minAcceptableQuoteValue: market.minAcceptableQuoteValue, slippage: 5,
+ * });
+ * if (!summary.ok) showError(summary.planFailure ?? summary.error);
+ * ```
+ */
+export declare function useCloseQuoteGroup(parameters?: UseCloseQuoteGroupParameters): UseCloseQuoteGroupReturnType;
+//# sourceMappingURL=use-close-quote-group.d.ts.map

package/dist/quotes/use-close-quote-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-close-quote-group.d.ts","sourceRoot":"","sources":["../../src/quotes/use-close-quote-group.ts"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,eAAe,EAEpB,KAAK,qBAAqB,EAC1B,KAAK,UAAU,EAEhB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAGpC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAgBzE;;;;;GAKG;AACH,MAAM,MAAM,yBAAyB,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,CAAC;AAEnF,8DAA8D;AAC9D,MAAM,WAAW,mBAAmB;IAClC,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;IACZ,sCAAsC;IACtC,OAAO,EAAE,MAAM,CAAC;IAChB,iCAAiC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,kEAAkE;IAClE,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB,mDAAmD;IACnD,MAAM,EAAE,yBAAyB,CAAC;IAClC,mDAAmD;IACnD,KAAK,CAAC,EAAE,kBAAkB,CAAC;CAC5B;AAED,8CAA8C;AAC9C,MAAM,MAAM,qBAAqB,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE9E,qEAAqE;AACrE,MAAM,WAAW,yBAAyB;IACxC,iDAAiD;IACjD,KAAK,EAAE,UAAU,CAAC;IAClB,2DAA2D;IAC3D,cAAc,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,uBAAuB,EAAE,MAAM,CAAC;IAChC,4EAA4E;IAC5E,QAAQ,EAAE,MAAM,CAAC;IACjB,8EAA8E;IAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,kFAAkF;IAClF,IAAI,CAAC,EAAE,OAAO,CAAC;IACf;;;;;OAKG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,uDAAuD;IACvD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;GAMG;AACH,MAAM,WAAW,sBAAsB;IACrC,wEAAwE;IACxE,EAAE,EAAE,OAAO,CAAC;IACZ,gEAAgE;IAChE,cAAc,EAAE,MAAM,CAAC;IACvB,kEAAkE;IAClE,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAC7B,wEAAwE;IACxE,WAAW,CAAC,EAAE,qBAAqB,CAAC;IACpC,+EAA+E;IAC/E,KAAK,CAAC,EAAE,kBAAkB,CAAC;CAC5B;AAED,iDAAiD;AACjD,MAAM,WAAW,4BAA4B;IAC3C,uFAAuF;IACvF,KAAK,EAAE,CAAC,UAAU,EAAE,yBAAyB,KAAK,OAAO,CAAC,sBAAsB,CAAC,CAAC;IAClF,0EAA0E;IAC1E,KAAK,EAAE,MAAM,IAAI,CAAC;IAClB,6BAA6B;IAC7B,MAAM,EAAE,qBAAqB,CAAC;IAC9B,uCAAuC;IACvC,SAAS,EAAE,OAAO,CAAC;IACnB,sEAAsE;IACtE,eAAe,EAAE,MAAM,CAAC;IACxB,6DAA6D;IAC7D,cAAc,EAAE,MAAM,CAAC;IACvB,8CAA8C;IAC9C,cAAc,EAAE,MAAM,CAAC;IACvB,0EAA0E;IAC1E,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAC7B,sEAAsE;IACtE,WAAW,CAAC,EAAE,qBAAqB,CAAC;IACpC,sEAAsE;IACtE,KAAK,CAAC,EAAE,kBAAkB,CAAC;CAC5B;AAED,iDAAiD;AACjD,MAAM,MAAM,4BAA4B,GAAG,eAAe,CAAC;AAa3D;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,GAAE,4BAAiC,GAAG,4BAA4B,CA2L9G"}

package/dist/quotes/use-close-quote-group.js

@@ -0,0 +1,172 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as n } from "../errors/normalize-symm-error.js";
+import { useNotifications as r } from "../websocket/use-notifications.js";
+import { predicateMatch as i } from "../utils/predicate-match.js";
+import { NotificationType as a, getInstantClosesQueryKey as o, instantCloseBulkAutoMutationOptions as s, planGroupClose as c, toGroupCloseCandidates as l } from "@symmio/trading-core";
+import { useCallback as u, useMemo as d, useRef as f, useState as p } from "react";
+import { formatUnits as m } from "viem";
+import { useQueryClient as h } from "@tanstack/react-query";
+//#region src/quotes/use-close-quote-group.ts
+var g = 18, _ = new Set(["FillMarketOrderInstantClose", "FillLimitOrderClose"]), v = {
+	status: "idle",
+	steps: [],
+	closedQuantity: 0n,
+	targetQuantity: 0n
+};
+function y(y = {}) {
+	let b = t(y), x = e(), S = h(), [C, w] = p(v), T = f(v), E = f(!1), [D, O] = p(), k = f(void 0), A = u((e) => {
+		T.current = e, w(e);
+	}, []), j = u((e) => {
+		let t = T.current, r = t.steps.findIndex((t) => t.status === "closing" && String(t.quoteId) === e.quoteId);
+		if (r < 0) return;
+		let i = e.type === a.SUCCESS && e.lastSeenAction !== null && _.has(e.lastSeenAction), o = e.type === a.FAILED;
+		if (!i && !o) return;
+		let s = [...t.steps], c = t.closedQuantity;
+		if (i) {
+			let e = {
+				...s[r],
+				status: "closed"
+			};
+			c += e.closeQuantity, s[r] = e;
+			let n = s.every((e) => e.status === "closed"), i = t.status === "closing" && n ? "success" : t.status;
+			A({
+				...t,
+				steps: s,
+				closedQuantity: c,
+				status: i
+			});
+			return;
+		}
+		let l = n(Error(e.failureMessage ?? "Close failed on the solver."));
+		s[r] = {
+			...s[r],
+			status: "failed",
+			error: l
+		}, A({
+			...t,
+			steps: s,
+			status: "failed",
+			error: l
+		});
+	}, [A]);
+	r({
+		account: D,
+		chainId: k.current,
+		config: y.config,
+		enabled: !!D && C.steps.some((e) => e.status === "closing"),
+		onNotification: j
+	});
+	let M = u(async (e) => {
+		if (E.current || T.current.steps.some((e) => e.status === "closing")) return {
+			ok: !1,
+			closedQuantity: 0n,
+			steps: [],
+			error: n(/* @__PURE__ */ Error("A group close is already in flight."))
+		};
+		let { group: t, targetQuantity: r, minAcceptableQuoteValue: a, slippage: u, markPrice: d, from: f, notificationsAccount: p } = e, h = e.chainId ?? x, _ = c(l(t.quotes, a), r);
+		if (!_.feasible) return A({
+			status: "failed",
+			steps: [],
+			closedQuantity: 0n,
+			targetQuantity: r,
+			planFailure: _
+		}), {
+			ok: !1,
+			closedQuantity: 0n,
+			steps: [],
+			planFailure: _
+		};
+		let v = new Map(t.quotes.map((e) => [e.key, e])), y = _.allocations.map((e) => ({
+			key: e.key,
+			quoteId: v.get(e.key).quoteId,
+			closeQuantity: e.closeQuantity,
+			kind: e.kind,
+			status: "queued"
+		}));
+		E.current = !0;
+		let C = v.get(y[0].key);
+		k.current = h, O(p ?? C.vaAddress ?? C.partyA), A({
+			status: "closing",
+			steps: y.map((e) => ({
+				...e,
+				status: "closing"
+			})),
+			closedQuantity: 0n,
+			targetQuantity: r
+		});
+		let w = s(b);
+		try {
+			await w.mutationFn({
+				orders: y.map((e) => {
+					let t = v.get(e.key);
+					return {
+						partyA: t.vaAddress ?? t.partyA,
+						market: { id: Number(t.symbolId) },
+						positionType: t.positionType,
+						quoteId: e.quoteId,
+						quantityToClose: m(e.closeQuantity, g),
+						slippage: u,
+						markPrice: d
+					};
+				}),
+				from: f,
+				chainId: h
+			});
+		} catch (e) {
+			let t = n(e), r = T.current;
+			return A({
+				...r,
+				status: "failed",
+				steps: r.steps.map((e) => e.status === "closing" ? {
+					...e,
+					status: "failed",
+					error: t
+				} : e),
+				error: t
+			}), {
+				ok: !1,
+				closedQuantity: T.current.closedQuantity,
+				steps: [...T.current.steps],
+				error: t
+			};
+		} finally {
+			E.current = !1;
+		}
+		let D = b.getChainConfigKey(h);
+		S.invalidateQueries({ predicate: i(o, { configKey: D }) });
+		let j = T.current;
+		return j.status === "closing" && j.steps.every((e) => e.status === "closed") && A({
+			...j,
+			status: "success"
+		}), {
+			ok: !0,
+			closedQuantity: T.current.closedQuantity,
+			steps: [...T.current.steps]
+		};
+	}, [
+		A,
+		b,
+		x,
+		S
+	]), N = u(() => {
+		E.current || (k.current = void 0, O(void 0), A(v));
+	}, [A]), P = d(() => C.targetQuantity <= 0n ? 0 : Number(C.closedQuantity * 10000n / C.targetQuantity) / 100, [C.closedQuantity, C.targetQuantity]);
+	return {
+		close: M,
+		reset: N,
+		status: C.status,
+		isClosing: C.status === "closing",
+		progressPercent: P,
+		closedQuantity: C.closedQuantity,
+		targetQuantity: C.targetQuantity,
+		steps: C.steps,
+		planFailure: C.planFailure,
+		error: C.error
+	};
+}
+//#endregion
+export { y as useCloseQuoteGroup };
+
+//# sourceMappingURL=use-close-quote-group.js.map

package/dist/quotes/use-close-quote-group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-close-quote-group.js","names":[],"sources":["../../src/quotes/use-close-quote-group.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getInstantClosesQueryKey,\n  instantCloseBulkAutoMutationOptions,\n  NotificationType,\n  planGroupClose,\n  toGroupCloseCandidates,\n  type ConfigParameter,\n  type Notification,\n  type PlanGroupCloseFailure,\n  type QuoteGroup,\n  type UnifiedQuote,\n} from \"@symmio/trading-core\";\nimport { useQueryClient } from \"@tanstack/react-query\";\nimport { useCallback, useMemo, useRef, useState } from \"react\";\nimport type { Address } from \"viem\";\nimport { formatUnits } from \"viem\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\nimport { predicateMatch } from \"../utils\";\nimport { useNotifications } from \"../websocket/use-notifications\";\n\n/** Decimal places of an 18-decimal-wei fixed-point value. */\nconst WEI_DECIMALS = 18;\n\n/**\n * Solver `lastSeenAction` values that report a close **fill** — the moment a\n * close is actually done (mirrors the core notification classifier's fill set;\n * the request-stage actions are deliberately not here).\n */\nconst CLOSE_FILL_ACTIONS = new Set([\"FillMarketOrderInstantClose\", \"FillLimitOrderClose\"]);\n\n/**\n * Lifecycle of one child close inside a group close:\n * `queued` → `closing` (submitted in the bulk request, awaiting its close-fill\n * notification) → `closed` (fill notification received), or `failed` (the bulk\n * submit or the close itself errored).\n */\nexport type CloseQuoteGroupStepStatus = \"queued\" | \"closing\" | \"closed\" | \"failed\";\n\n/** Live state of one child close inside a group close run. */\nexport interface CloseQuoteGroupStep {\n  /** Child identity (`UnifiedQuote.key`). */\n  key: string;\n  /** On-chain quote id of the child. */\n  quoteId: bigint;\n  /** Planned close amount, wei. */\n  closeQuantity: bigint;\n  /** `full` when the child closes entirely, `partial` otherwise. */\n  kind: \"full\" | \"partial\";\n  /** Current lifecycle stage of this child close. */\n  status: CloseQuoteGroupStepStatus;\n  /** Normalized error, when `status` is `failed`. */\n  error?: SymmioRequestError;\n}\n\n/** Overall lifecycle of a group close run. */\nexport type CloseQuoteGroupStatus = \"idle\" | \"closing\" | \"success\" | \"failed\";\n\n/** Inputs for one {@link UseCloseQuoteGroupReturnType.close} run. */\nexport interface CloseQuoteGroupParameters {\n  /** The group whose children are being closed. */\n  group: QuoteGroup;\n  /** Exact total quantity to close across the group, wei. */\n  targetQuantity: bigint;\n  /**\n   * The symbol's `minAcceptableQuoteValue` (wei) — the dust floor a partially\n   * closed child must keep. Read it from the market info of the group's symbol.\n   */\n  minAcceptableQuoteValue: bigint;\n  /** Slippage tolerance percent forwarded to every child close (e.g. `5`). */\n  slippage: number;\n  /** Pre-fetched mark price (decimal string) forwarded to every child close. */\n  markPrice?: string;\n  /** Delegated session key to submit the closes from, when delegation is active. */\n  from?: Address;\n  /**\n   * Account whose live notification stream reports the close fills — pass the\n   * **sub-account** when closing Virtual Account quotes (the VA frames arrive\n   * on its owning sub-account's stream). Defaults to the first child's\n   * `vaAddress ?? partyA`.\n   */\n  notificationsAccount?: Address;\n  /** Chain override; defaults to the connected chain. */\n  chainId?: number;\n}\n\n/**\n * Submission outcome of one {@link UseCloseQuoteGroupReturnType.close} run.\n * Resolves when the bulk request carrying every child close has been\n * **submitted** — settlement is confirmed asynchronously per child (its\n * close-fill notification), tracked via `status` / `steps` /\n * `progressPercent` on the hook.\n */\nexport interface CloseQuoteGroupSummary {\n  /** `true` when every planned child close was submitted successfully. */\n  ok: boolean;\n  /** Σ quantity already confirmed closed at resolve time, wei. */\n  closedQuantity: bigint;\n  /** Per-child final states. Empty when planning already failed. */\n  steps: CloseQuoteGroupStep[];\n  /** Present when the plan itself was infeasible — nothing was closed. */\n  planFailure?: PlanGroupCloseFailure;\n  /** The error that stopped the run, when `ok` is `false` and a close failed. */\n  error?: SymmioRequestError;\n}\n\n/** Return type of {@link useCloseQuoteGroup}. */\nexport interface UseCloseQuoteGroupReturnType {\n  /** Plan and execute a group close. Resolves with the run's summary (never rejects). */\n  close: (parameters: CloseQuoteGroupParameters) => Promise<CloseQuoteGroupSummary>;\n  /** Clear the run state back to `idle`. No-op while a run is in flight. */\n  reset: () => void;\n  /** Overall run lifecycle. */\n  status: CloseQuoteGroupStatus;\n  /** `true` while a run is in flight. */\n  isClosing: boolean;\n  /** Quantity-weighted completion, `0`–`100` (2-decimal resolution). */\n  progressPercent: number;\n  /** Σ quantity closed so far in the current/last run, wei. */\n  closedQuantity: bigint;\n  /** The run's target, wei (`0` while idle). */\n  targetQuantity: bigint;\n  /** Per-child close states of the current/last run, in execution order. */\n  steps: CloseQuoteGroupStep[];\n  /** Planning failure of the last run, when the plan was infeasible. */\n  planFailure?: PlanGroupCloseFailure;\n  /** The error that stopped the last run, when a child close failed. */\n  error?: SymmioRequestError;\n}\n\n/** Parameters for {@link useCloseQuoteGroup}. */\nexport type UseCloseQuoteGroupParameters = ConfigParameter;\n\ninterface RunState {\n  status: CloseQuoteGroupStatus;\n  steps: CloseQuoteGroupStep[];\n  closedQuantity: bigint;\n  targetQuantity: bigint;\n  planFailure?: PlanGroupCloseFailure;\n  error?: SymmioRequestError;\n}\n\nconst IDLE: RunState = { status: \"idle\", steps: [], closedQuantity: 0n, targetQuantity: 0n };\n\n/**\n * Close an exact quantity across a grouped position, child by child.\n *\n * The run first plans the allocation with `planGroupClose` (largest child\n * first; every partially closed child keeps at least the symbol's\n * `minAcceptableQuoteValue`; the plan sums to the target exactly or fails\n * without closing anything). It then submits **every allocation in one bulk\n * request** (`instantCloseBulkAuto` — n operations, one endpoint call). A\n * submitted child stays `closing` until its close settles: the hook watches\n * the account's live notifications and flips the child to `closed` — advancing\n * `closedQuantity` / `progressPercent` — when its **close fill** frame arrives\n * (`lastSeenAction: FillMarketOrderInstantClose` / `FillLimitOrderClose` with\n * `success`); `status` becomes `success` once every child confirms, and a\n * `failed` frame fails that step and the run. A rejected bulk submit fails the\n * whole run at once.\n *\n * @example\n * ```tsx\n * const { close, status, progressPercent, steps } = useCloseQuoteGroup();\n * const summary = await close({\n *   group, targetQuantity: parseUnits(\"2.8\", 18),\n *   minAcceptableQuoteValue: market.minAcceptableQuoteValue, slippage: 5,\n * });\n * if (!summary.ok) showError(summary.planFailure ?? summary.error);\n * ```\n */\nexport function useCloseQuoteGroup(parameters: UseCloseQuoteGroupParameters = {}): UseCloseQuoteGroupReturnType {\n  const config = useSymmioConfig(parameters);\n  const connectedChainId = useSymmioChainId();\n  const queryClient = useQueryClient();\n  const [state, setState] = useState<RunState>(IDLE);\n  /** Mirror of `state` for the notification callback and the submit loop (single source). */\n  const runRef = useRef<RunState>(IDLE);\n  const inFlight = useRef(false);\n  /** Account whose notification stream confirms the run's closes. */\n  const [watchAccount, setWatchAccount] = useState<Address>();\n  const watchChainIdRef = useRef<number | undefined>(undefined);\n\n  const commit = useCallback((next: RunState) => {\n    runRef.current = next;\n    setState(next);\n  }, []);\n\n  /**\n   * Settlement tracking: a submitted child is finished when its close **fill**\n   * notification arrives — `lastSeenAction` of `FillMarketOrderInstantClose`\n   * (or `FillLimitOrderClose`) with a `success` status. That flips the step to\n   * `closed` and advances progress; the run finishes (`success`) once every\n   * step is closed. A `failed` frame for the quote marks the step (and run)\n   * failed instead. Request-stage frames (`InstantRequestToClosePosition`, …)\n   * are ignored.\n   */\n  const onNotification = useCallback(\n    (notification: Notification) => {\n      const run = runRef.current;\n      const index = run.steps.findIndex(\n        (step) => step.status === \"closing\" && String(step.quoteId) === notification.quoteId,\n      );\n      if (index < 0) return;\n\n      const isCloseFill =\n        notification.type === NotificationType.SUCCESS &&\n        notification.lastSeenAction !== null &&\n        CLOSE_FILL_ACTIONS.has(notification.lastSeenAction);\n      const isFailure = notification.type === NotificationType.FAILED;\n      if (!isCloseFill && !isFailure) return;\n\n      const steps = [...run.steps];\n      let closedQuantity = run.closedQuantity;\n      if (isCloseFill) {\n        const step = { ...steps[index]!, status: \"closed\" as const };\n        closedQuantity += step.closeQuantity;\n        steps[index] = step;\n        const allClosed = steps.every((entry) => entry.status === \"closed\");\n        const status = run.status === \"closing\" && allClosed ? \"success\" : run.status;\n        commit({ ...run, steps, closedQuantity, status });\n        return;\n      }\n      const error = normalizeSymmError(new Error(notification.failureMessage ?? \"Close failed on the solver.\"));\n      steps[index] = { ...steps[index]!, status: \"failed\", error };\n      commit({ ...run, steps, status: \"failed\", error });\n    },\n    [commit],\n  );\n\n  useNotifications({\n    account: watchAccount,\n    chainId: watchChainIdRef.current,\n    config: parameters.config,\n    // Listen while any submitted child still awaits its settle notifications —\n    // even after a later submit failed, the earlier closes keep confirming.\n    enabled: Boolean(watchAccount) && state.steps.some((step) => step.status === \"closing\"),\n    onNotification,\n  });\n\n  const close = useCallback(\n    async (runParameters: CloseQuoteGroupParameters): Promise<CloseQuoteGroupSummary> => {\n      if (inFlight.current || runRef.current.steps.some((step) => step.status === \"closing\")) {\n        return {\n          ok: false,\n          closedQuantity: 0n,\n          steps: [],\n          error: normalizeSymmError(new Error(\"A group close is already in flight.\")),\n        };\n      }\n\n      const { group, targetQuantity, minAcceptableQuoteValue, slippage, markPrice, from, notificationsAccount } =\n        runParameters;\n      const chainId = runParameters.chainId ?? connectedChainId;\n\n      const candidates = toGroupCloseCandidates(group.quotes, minAcceptableQuoteValue);\n      const plan = planGroupClose(candidates, targetQuantity);\n      if (!plan.feasible) {\n        commit({ status: \"failed\", steps: [], closedQuantity: 0n, targetQuantity, planFailure: plan });\n        return { ok: false, closedQuantity: 0n, steps: [], planFailure: plan };\n      }\n\n      const childByKey = new Map<string, UnifiedQuote>(group.quotes.map((quote) => [quote.key, quote]));\n      const steps: CloseQuoteGroupStep[] = plan.allocations.map((allocation) => ({\n        key: allocation.key,\n        // The planner only emits candidates built from anchored children, so the id is present.\n        quoteId: childByKey.get(allocation.key)!.quoteId!,\n        closeQuantity: allocation.closeQuantity,\n        kind: allocation.kind,\n        status: \"queued\",\n      }));\n\n      inFlight.current = true;\n      const firstChild = childByKey.get(steps[0]!.key)!;\n      watchChainIdRef.current = chainId;\n      setWatchAccount(notificationsAccount ?? firstChild.vaAddress ?? firstChild.partyA);\n\n      // Every allocation submits in ONE bulk round-trip, so all steps go `closing` together.\n      commit({\n        status: \"closing\",\n        steps: steps.map((step) => ({ ...step, status: \"closing\" as const })),\n        closedQuantity: 0n,\n        targetQuantity,\n      });\n\n      const base = instantCloseBulkAutoMutationOptions(config);\n      try {\n        await base.mutationFn({\n          orders: steps.map((step) => {\n            const child = childByKey.get(step.key)!;\n            return {\n              partyA: child.vaAddress ?? child.partyA,\n              market: { id: Number(child.symbolId) },\n              positionType: child.positionType,\n              quoteId: step.quoteId,\n              quantityToClose: formatUnits(step.closeQuantity, WEI_DECIMALS),\n              slippage,\n              markPrice,\n            };\n          }),\n          from,\n          chainId,\n        });\n      } catch (err) {\n        const error = normalizeSymmError(err);\n        const run = runRef.current;\n        commit({\n          ...run,\n          status: \"failed\",\n          steps: run.steps.map((step) =>\n            step.status === \"closing\" ? { ...step, status: \"failed\" as const, error } : step,\n          ),\n          error,\n        });\n        return { ok: false, closedQuantity: runRef.current.closedQuantity, steps: [...runRef.current.steps], error };\n      } finally {\n        inFlight.current = false;\n      }\n\n      // Surface the fresh closing rows immediately, exactly like the single-close hook.\n      const configKey = config.getChainConfigKey(chainId);\n      void queryClient.invalidateQueries({ predicate: predicateMatch(getInstantClosesQueryKey, { configKey }) });\n\n      // Submitted. Completion is notification-driven; fast fills may already have\n      // finished the run while the request was in flight.\n      const run = runRef.current;\n      if (run.status === \"closing\" && run.steps.every((step) => step.status === \"closed\")) {\n        commit({ ...run, status: \"success\" });\n      }\n      return { ok: true, closedQuantity: runRef.current.closedQuantity, steps: [...runRef.current.steps] };\n    },\n    [commit, config, connectedChainId, queryClient],\n  );\n\n  const reset = useCallback(() => {\n    if (inFlight.current) return;\n    watchChainIdRef.current = undefined;\n    setWatchAccount(undefined);\n    commit(IDLE);\n  }, [commit]);\n\n  const progressPercent = useMemo(() => {\n    if (state.targetQuantity <= 0n) return 0;\n    return Number((state.closedQuantity * 10_000n) / state.targetQuantity) / 100;\n  }, [state.closedQuantity, state.targetQuantity]);\n\n  return {\n    close,\n    reset,\n    status: state.status,\n    isClosing: state.status === \"closing\",\n    progressPercent,\n    closedQuantity: state.closedQuantity,\n    targetQuantity: state.targetQuantity,\n    steps: state.steps,\n    planFailure: state.planFailure,\n    error: state.error,\n  };\n}\n"],"mappings":";;;;;;;;;;;AA0BA,IAAM,IAAe,IAOf,IAAqB,IAAI,IAAI,CAAC,+BAA+B,qBAAqB,CAAC,GAiHnF,IAAiB;CAAE,QAAQ;CAAQ,OAAO,CAAC;CAAG,gBAAgB;CAAI,gBAAgB;AAAG;AA4B3F,SAAgB,EAAmB,IAA2C,CAAC,GAAiC;CAC9G,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAmB,EAAiB,GACpC,IAAc,EAAe,GAC7B,CAAC,GAAO,KAAY,EAAmB,CAAI,GAE3C,IAAS,EAAiB,CAAI,GAC9B,IAAW,EAAO,EAAK,GAEvB,CAAC,GAAc,KAAmB,EAAkB,GACpD,IAAkB,EAA2B,KAAA,CAAS,GAEtD,IAAS,GAAa,MAAmB;EAE7C,AADA,EAAO,UAAU,GACjB,EAAS,CAAI;CACf,GAAG,CAAC,CAAC,GAWC,IAAiB,GACpB,MAA+B;EAC9B,IAAM,IAAM,EAAO,SACb,IAAQ,EAAI,MAAM,WACrB,MAAS,EAAK,WAAW,aAAa,OAAO,EAAK,OAAO,MAAM,EAAa,OAC/E;EACA,IAAI,IAAQ,GAAG;EAEf,IAAM,IACJ,EAAa,SAAS,EAAiB,WACvC,EAAa,mBAAmB,QAChC,EAAmB,IAAI,EAAa,cAAc,GAC9C,IAAY,EAAa,SAAS,EAAiB;EACzD,IAAI,CAAC,KAAe,CAAC,GAAW;EAEhC,IAAM,IAAQ,CAAC,GAAG,EAAI,KAAK,GACvB,IAAiB,EAAI;EACzB,IAAI,GAAa;GACf,IAAM,IAAO;IAAE,GAAG,EAAM;IAAS,QAAQ;GAAkB;GAE3D,AADA,KAAkB,EAAK,eACvB,EAAM,KAAS;GACf,IAAM,IAAY,EAAM,OAAO,MAAU,EAAM,WAAW,QAAQ,GAC5D,IAAS,EAAI,WAAW,aAAa,IAAY,YAAY,EAAI;GACvE,EAAO;IAAE,GAAG;IAAK;IAAO;IAAgB;GAAO,CAAC;GAChD;EACF;EACA,IAAM,IAAQ,EAAuB,MAAM,EAAa,kBAAkB,6BAA6B,CAAC;EAExG,AADA,EAAM,KAAS;GAAE,GAAG,EAAM;GAAS,QAAQ;GAAU;EAAM,GAC3D,EAAO;GAAE,GAAG;GAAK;GAAO,QAAQ;GAAU;EAAM,CAAC;CACnD,GACA,CAAC,CAAM,CACT;CAEA,EAAiB;EACf,SAAS;EACT,SAAS,EAAgB;EACzB,QAAQ,EAAW;EAGnB,SAAS,EAAQ,KAAiB,EAAM,MAAM,MAAM,MAAS,EAAK,WAAW,SAAS;EACtF;CACF,CAAC;CAED,IAAM,IAAQ,EACZ,OAAO,MAA8E;EACnF,IAAI,EAAS,WAAW,EAAO,QAAQ,MAAM,MAAM,MAAS,EAAK,WAAW,SAAS,GACnF,OAAO;GACL,IAAI;GACJ,gBAAgB;GAChB,OAAO,CAAC;GACR,OAAO,EAAmB,gBAAI,MAAM,qCAAqC,CAAC;EAC5E;EAGF,IAAM,EAAE,UAAO,mBAAgB,4BAAyB,aAAU,cAAW,SAAM,4BACjF,GACI,IAAU,EAAc,WAAW,GAGnC,IAAO,EADM,EAAuB,EAAM,QAAQ,CAC5B,GAAY,CAAc;EACtD,IAAI,CAAC,EAAK,UAER,OADA,EAAO;GAAE,QAAQ;GAAU,OAAO,CAAC;GAAG,gBAAgB;GAAI;GAAgB,aAAa;EAAK,CAAC,GACtF;GAAE,IAAI;GAAO,gBAAgB;GAAI,OAAO,CAAC;GAAG,aAAa;EAAK;EAGvE,IAAM,IAAa,IAAI,IAA0B,EAAM,OAAO,KAAK,MAAU,CAAC,EAAM,KAAK,CAAK,CAAC,CAAC,GAC1F,IAA+B,EAAK,YAAY,KAAK,OAAgB;GACzE,KAAK,EAAW;GAEhB,SAAS,EAAW,IAAI,EAAW,GAAG,EAAG;GACzC,eAAe,EAAW;GAC1B,MAAM,EAAW;GACjB,QAAQ;EACV,EAAE;EAEF,EAAS,UAAU;EACnB,IAAM,IAAa,EAAW,IAAI,EAAM,GAAI,GAAG;EAK/C,AAJA,EAAgB,UAAU,GAC1B,EAAgB,KAAwB,EAAW,aAAa,EAAW,MAAM,GAGjF,EAAO;GACL,QAAQ;GACR,OAAO,EAAM,KAAK,OAAU;IAAE,GAAG;IAAM,QAAQ;GAAmB,EAAE;GACpE,gBAAgB;GAChB;EACF,CAAC;EAED,IAAM,IAAO,EAAoC,CAAM;EACvD,IAAI;GACF,MAAM,EAAK,WAAW;IACpB,QAAQ,EAAM,KAAK,MAAS;KAC1B,IAAM,IAAQ,EAAW,IAAI,EAAK,GAAG;KACrC,OAAO;MACL,QAAQ,EAAM,aAAa,EAAM;MACjC,QAAQ,EAAE,IAAI,OAAO,EAAM,QAAQ,EAAE;MACrC,cAAc,EAAM;MACpB,SAAS,EAAK;MACd,iBAAiB,EAAY,EAAK,eAAe,CAAY;MAC7D;MACA;KACF;IACF,CAAC;IACD;IACA;GACF,CAAC;EACH,SAAS,GAAK;GACZ,IAAM,IAAQ,EAAmB,CAAG,GAC9B,IAAM,EAAO;GASnB,OARA,EAAO;IACL,GAAG;IACH,QAAQ;IACR,OAAO,EAAI,MAAM,KAAK,MACpB,EAAK,WAAW,YAAY;KAAE,GAAG;KAAM,QAAQ;KAAmB;IAAM,IAAI,CAC9E;IACA;GACF,CAAC,GACM;IAAE,IAAI;IAAO,gBAAgB,EAAO,QAAQ;IAAgB,OAAO,CAAC,GAAG,EAAO,QAAQ,KAAK;IAAG;GAAM;EAC7G,UAAU;GACR,EAAS,UAAU;EACrB;EAGA,IAAM,IAAY,EAAO,kBAAkB,CAAO;EAClD,EAAiB,kBAAkB,EAAE,WAAW,EAAe,GAA0B,EAAE,aAAU,CAAC,EAAE,CAAC;EAIzG,IAAM,IAAM,EAAO;EAInB,OAHI,EAAI,WAAW,aAAa,EAAI,MAAM,OAAO,MAAS,EAAK,WAAW,QAAQ,KAChF,EAAO;GAAE,GAAG;GAAK,QAAQ;EAAU,CAAC,GAE/B;GAAE,IAAI;GAAM,gBAAgB,EAAO,QAAQ;GAAgB,OAAO,CAAC,GAAG,EAAO,QAAQ,KAAK;EAAE;CACrG,GACA;EAAC;EAAQ;EAAQ;EAAkB;CAAW,CAChD,GAEM,IAAQ,QAAkB;EAC1B,EAAS,YACb,EAAgB,UAAU,KAAA,GAC1B,EAAgB,KAAA,CAAS,GACzB,EAAO,CAAI;CACb,GAAG,CAAC,CAAM,CAAC,GAEL,IAAkB,QAClB,EAAM,kBAAkB,KAAW,IAChC,OAAQ,EAAM,iBAAiB,SAAW,EAAM,cAAc,IAAI,KACxE,CAAC,EAAM,gBAAgB,EAAM,cAAc,CAAC;CAE/C,OAAO;EACL;EACA;EACA,QAAQ,EAAM;EACd,WAAW,EAAM,WAAW;EAC5B;EACA,gBAAgB,EAAM;EACtB,gBAAgB,EAAM;EACtB,OAAO,EAAM;EACb,aAAa,EAAM;EACnB,OAAO,EAAM;CACf;AACF"}

package/dist/quotes/use-cool-downs-of-ma.d.ts

@@ -0,0 +1,26 @@
+import { ConfigParameter, GetCoolDownsOfMAOptions, GetCoolDownsOfMAReturnType } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+/**
+ * Parameters for {@link useCoolDownsOfMA}: the core query options (chain id,
+ * TanStack `query` overrides) plus an optional `config`.
+ */
+export type UseCoolDownsOfMAParameters = GetCoolDownsOfMAOptions & ConfigParameter;
+/** Return type of {@link useCoolDownsOfMA}. */
+export type UseCoolDownsOfMAReturnType = UseQueryResult<GetCoolDownsOfMAReturnType, SymmioRequestError>;
+/**
+ * Read the protocol cooldown periods (`coolDownsOfMA`) as a 4-tuple of seconds.
+ * **Index 1 is the force-cancel cooldown** — the delay after a quote enters
+ * `CANCEL_PENDING` before {@link useForceCancelQuote} becomes eligible
+ * (`now >= statusModifyTimestamp + coolDowns[1]`). These values rarely change,
+ * so a long `staleTime` is appropriate. Errors are normalized to
+ * {@link SymmioRequestError}.
+ *
+ * @example
+ * ```tsx
+ * const { data: coolDowns } = useCoolDownsOfMA();
+ * const forceCancelCooldown = coolDowns?.[1];
+ * ```
+ */
+export declare function useCoolDownsOfMA(parameters?: UseCoolDownsOfMAParameters): UseCoolDownsOfMAReturnType;
+//# sourceMappingURL=use-cool-downs-of-ma.d.ts.map

package/dist/quotes/use-cool-downs-of-ma.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-cool-downs-of-ma.d.ts","sourceRoot":"","sources":["../../src/quotes/use-cool-downs-of-ma.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,uBAAuB,EAC5B,KAAK,0BAA0B,EAChC,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAEtE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAIzE;;;GAGG;AACH,MAAM,MAAM,0BAA0B,GAAG,uBAAuB,GAAG,eAAe,CAAC;AAEnF,+CAA+C;AAC/C,MAAM,MAAM,0BAA0B,GAAG,cAAc,CAAC,0BAA0B,EAAE,kBAAkB,CAAC,CAAC;AAExG;;;;;;;;;;;;;GAaG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,GAAE,0BAA+B,GAAG,0BAA0B,CAkBxG"}

package/dist/quotes/use-cool-downs-of-ma.js

@@ -0,0 +1,27 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { normalizeSymmError as n } from "../errors/normalize-symm-error.js";
+import { getCoolDownsOfMAQueryOptions as r } from "@symmio/trading-core";
+import { useQuery as i } from "@tanstack/react-query";
+//#region src/quotes/use-cool-downs-of-ma.ts
+function a(a = {}) {
+	let o = t(a), s = e(), c = r(o, {
+		...a,
+		chainId: a.chainId ?? s
+	});
+	return i({
+		...c,
+		queryFn: async () => {
+			try {
+				return await c.queryFn();
+			} catch (e) {
+				throw n(e);
+			}
+		}
+	});
+}
+//#endregion
+export { a as useCoolDownsOfMA };
+
+//# sourceMappingURL=use-cool-downs-of-ma.js.map

package/dist/quotes/use-cool-downs-of-ma.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-cool-downs-of-ma.js","names":[],"sources":["../../src/quotes/use-cool-downs-of-ma.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getCoolDownsOfMAQueryOptions,\n  type ConfigParameter,\n  type GetCoolDownsOfMAOptions,\n  type GetCoolDownsOfMAReturnType,\n} from \"@symmio/trading-core\";\nimport { useQuery, type UseQueryResult } from \"@tanstack/react-query\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\n\n/**\n * Parameters for {@link useCoolDownsOfMA}: the core query options (chain id,\n * TanStack `query` overrides) plus an optional `config`.\n */\nexport type UseCoolDownsOfMAParameters = GetCoolDownsOfMAOptions & ConfigParameter;\n\n/** Return type of {@link useCoolDownsOfMA}. */\nexport type UseCoolDownsOfMAReturnType = UseQueryResult<GetCoolDownsOfMAReturnType, SymmioRequestError>;\n\n/**\n * Read the protocol cooldown periods (`coolDownsOfMA`) as a 4-tuple of seconds.\n * **Index 1 is the force-cancel cooldown** — the delay after a quote enters\n * `CANCEL_PENDING` before {@link useForceCancelQuote} becomes eligible\n * (`now >= statusModifyTimestamp + coolDowns[1]`). These values rarely change,\n * so a long `staleTime` is appropriate. Errors are normalized to\n * {@link SymmioRequestError}.\n *\n * @example\n * ```tsx\n * const { data: coolDowns } = useCoolDownsOfMA();\n * const forceCancelCooldown = coolDowns?.[1];\n * ```\n */\nexport function useCoolDownsOfMA(parameters: UseCoolDownsOfMAParameters = {}): UseCoolDownsOfMAReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const options = getCoolDownsOfMAQueryOptions(config, {\n    ...parameters,\n    chainId: parameters.chainId ?? chainId,\n  });\n\n  return useQuery({\n    ...options,\n    queryFn: async () => {\n      try {\n        return await options.queryFn();\n      } catch (err) {\n        throw normalizeSymmError(err);\n      }\n    },\n  }) as UseCoolDownsOfMAReturnType;\n}\n"],"mappings":";;;;;;;AAqCA,SAAgB,EAAiB,IAAyC,CAAC,GAA+B;CACxG,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAU,EAA6B,GAAQ;EACnD,GAAG;EACH,SAAS,EAAW,WAAW;CACjC,CAAC;CAED,OAAO,EAAS;EACd,GAAG;EACH,SAAS,YAAY;GACnB,IAAI;IACF,OAAO,MAAM,EAAQ,QAAQ;GAC/B,SAAS,GAAK;IACZ,MAAM,EAAmB,CAAG;GAC9B;EACF;CACF,CAAC;AACH"}