@symmio/trading-react 0.1.0

package/dist/quotes/use-grouped-quotes.d.ts

@@ -0,0 +1,55 @@
+import { GroupQuotesOptions, QuoteGroup, QuoteGroupingStrategy, UnifiedQuote } from '@symmio/trading-core';
+import { UseManagedQuotesParameters, UseManagedQuotesResult } from './use-managed-quotes';
+/**
+ * Parameters for {@link useGroupedQuotes}. Everything {@link useManagedQuotes}
+ * accepts, plus how to fold the resulting positions into groups.
+ */
+export interface UseGroupedQuotesParameters extends UseManagedQuotesParameters {
+    /**
+     * How to fold active positions into groups — a {@link SubAccountIsolationType}
+     * (the built-in strategies) or a custom `{ keyOf }`. Defaults to
+     * `MARKET_DIRECTION` (one group per market + side, the lowcap default).
+     *
+     * Passing a fresh `{ keyOf }` object every render recomputes the groups every
+     * render; memoize a custom strategy if that matters.
+     */
+    strategy?: QuoteGroupingStrategy;
+    /** Optional group-ordering override forwarded to `groupQuotes` (default newest-first). */
+    groupSort?: GroupQuotesOptions["sort"];
+}
+/**
+ * Value returned by {@link useGroupedQuotes} — the full {@link useManagedQuotes}
+ * result, plus the grouped positions and the flat pending orders.
+ */
+export interface UseGroupedQuotesResult extends UseManagedQuotesResult {
+    /** Active positions folded into {@link QuoteGroup}s under `strategy`, newest-first. */
+    groups: QuoteGroup[];
+    /** Resting/pending limit orders, kept flat (never grouped). */
+    pending: UnifiedQuote[];
+}
+/**
+ * Managed quotes for one sub-account, folded into grouped positions.
+ *
+ * Reads every quote source via {@link useManagedQuotes}, splits the merged list
+ * into active positions and pending orders (`partitionQuotes`), then folds the
+ * positions into {@link QuoteGroup}s under the chosen `strategy` (`groupQuotes`).
+ * Pending limit orders are returned flat in `pending` — the grouped-positions vs
+ * open-orders split. The full flat list stays available on `quotes`.
+ *
+ * All grouping is pure and runs in a `useMemo`, so the heavy work is the
+ * underlying reads, not the fold.
+ *
+ * @param parameters - Managed-quotes parameters plus `strategy` / `groupSort`.
+ * @returns The managed-quotes result extended with `groups` and `pending`.
+ *
+ * @example
+ * ```tsx
+ * const { groups, pending, isLoading } = useGroupedQuotes({ partyA });
+ * // groups[0].metrics.openQuantity, groups[0].metrics.weightedOpenPrice, …
+ *
+ * // group by market instead of market + side:
+ * useGroupedQuotes({ partyA, strategy: SubAccountIsolationType.MARKET });
+ * ```
+ */
+export declare function useGroupedQuotes(parameters: UseGroupedQuotesParameters): UseGroupedQuotesResult;
+//# sourceMappingURL=use-grouped-quotes.d.ts.map

package/dist/quotes/use-grouped-quotes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-grouped-quotes.d.ts","sourceRoot":"","sources":["../../src/quotes/use-grouped-quotes.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,UAAU,EACf,KAAK,qBAAqB,EAC1B,KAAK,YAAY,EAClB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EAAoB,KAAK,0BAA0B,EAAE,KAAK,sBAAsB,EAAE,MAAM,sBAAsB,CAAC;AAEtH;;;GAGG;AACH,MAAM,WAAW,0BAA2B,SAAQ,0BAA0B;IAC5E;;;;;;;OAOG;IACH,QAAQ,CAAC,EAAE,qBAAqB,CAAC;IACjC,0FAA0F;IAC1F,SAAS,CAAC,EAAE,kBAAkB,CAAC,MAAM,CAAC,CAAC;CACxC;AAED;;;GAGG;AACH,MAAM,WAAW,sBAAuB,SAAQ,sBAAsB;IACpE,uFAAuF;IACvF,MAAM,EAAE,UAAU,EAAE,CAAC;IACrB,+DAA+D;IAC/D,OAAO,EAAE,YAAY,EAAE,CAAC;CACzB;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,0BAA0B,GAAG,sBAAsB,CAW/F"}

package/dist/quotes/use-grouped-quotes.js

@@ -0,0 +1,21 @@
+"use client";
+import { useManagedQuotes as e } from "./use-managed-quotes.js";
+import { SubAccountIsolationType as t, groupQuotes as n, partitionQuotes as r } from "@symmio/trading-core";
+import { useMemo as i } from "react";
+//#region src/quotes/use-grouped-quotes.ts
+function a(a) {
+	let { strategy: o = t.MARKET_DIRECTION, groupSort: s, ...c } = a, l = e(c), { positions: u, pending: d } = i(() => r(l.quotes), [l.quotes]), f = i(() => n(u, o, s ? { sort: s } : void 0), [
+		u,
+		o,
+		s
+	]);
+	return {
+		...l,
+		groups: f,
+		pending: d
+	};
+}
+//#endregion
+export { a as useGroupedQuotes };
+
+//# sourceMappingURL=use-grouped-quotes.js.map

package/dist/quotes/use-grouped-quotes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-grouped-quotes.js","names":[],"sources":["../../src/quotes/use-grouped-quotes.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  groupQuotes,\n  partitionQuotes,\n  SubAccountIsolationType,\n  type GroupQuotesOptions,\n  type QuoteGroup,\n  type QuoteGroupingStrategy,\n  type UnifiedQuote,\n} from \"@symmio/trading-core\";\nimport { useMemo } from \"react\";\nimport { useManagedQuotes, type UseManagedQuotesParameters, type UseManagedQuotesResult } from \"./use-managed-quotes\";\n\n/**\n * Parameters for {@link useGroupedQuotes}. Everything {@link useManagedQuotes}\n * accepts, plus how to fold the resulting positions into groups.\n */\nexport interface UseGroupedQuotesParameters extends UseManagedQuotesParameters {\n  /**\n   * How to fold active positions into groups — a {@link SubAccountIsolationType}\n   * (the built-in strategies) or a custom `{ keyOf }`. Defaults to\n   * `MARKET_DIRECTION` (one group per market + side, the lowcap default).\n   *\n   * Passing a fresh `{ keyOf }` object every render recomputes the groups every\n   * render; memoize a custom strategy if that matters.\n   */\n  strategy?: QuoteGroupingStrategy;\n  /** Optional group-ordering override forwarded to `groupQuotes` (default newest-first). */\n  groupSort?: GroupQuotesOptions[\"sort\"];\n}\n\n/**\n * Value returned by {@link useGroupedQuotes} — the full {@link useManagedQuotes}\n * result, plus the grouped positions and the flat pending orders.\n */\nexport interface UseGroupedQuotesResult extends UseManagedQuotesResult {\n  /** Active positions folded into {@link QuoteGroup}s under `strategy`, newest-first. */\n  groups: QuoteGroup[];\n  /** Resting/pending limit orders, kept flat (never grouped). */\n  pending: UnifiedQuote[];\n}\n\n/**\n * Managed quotes for one sub-account, folded into grouped positions.\n *\n * Reads every quote source via {@link useManagedQuotes}, splits the merged list\n * into active positions and pending orders (`partitionQuotes`), then folds the\n * positions into {@link QuoteGroup}s under the chosen `strategy` (`groupQuotes`).\n * Pending limit orders are returned flat in `pending` — the grouped-positions vs\n * open-orders split. The full flat list stays available on `quotes`.\n *\n * All grouping is pure and runs in a `useMemo`, so the heavy work is the\n * underlying reads, not the fold.\n *\n * @param parameters - Managed-quotes parameters plus `strategy` / `groupSort`.\n * @returns The managed-quotes result extended with `groups` and `pending`.\n *\n * @example\n * ```tsx\n * const { groups, pending, isLoading } = useGroupedQuotes({ partyA });\n * // groups[0].metrics.openQuantity, groups[0].metrics.weightedOpenPrice, …\n *\n * // group by market instead of market + side:\n * useGroupedQuotes({ partyA, strategy: SubAccountIsolationType.MARKET });\n * ```\n */\nexport function useGroupedQuotes(parameters: UseGroupedQuotesParameters): UseGroupedQuotesResult {\n  const { strategy = SubAccountIsolationType.MARKET_DIRECTION, groupSort, ...managedParameters } = parameters;\n  const managed = useManagedQuotes(managedParameters);\n\n  const { positions, pending } = useMemo(() => partitionQuotes(managed.quotes), [managed.quotes]);\n  const groups = useMemo(\n    () => groupQuotes(positions, strategy, groupSort ? { sort: groupSort } : undefined),\n    [positions, strategy, groupSort],\n  );\n\n  return { ...managed, groups, pending };\n}\n"],"mappings":";;;;;AAmEA,SAAgB,EAAiB,GAAgE;CAC/F,IAAM,EAAE,cAAW,EAAwB,kBAAkB,cAAW,GAAG,MAAsB,GAC3F,IAAU,EAAiB,CAAiB,GAE5C,EAAE,cAAW,eAAY,QAAc,EAAgB,EAAQ,MAAM,GAAG,CAAC,EAAQ,MAAM,CAAC,GACxF,IAAS,QACP,EAAY,GAAW,GAAU,IAAY,EAAE,MAAM,EAAU,IAAI,KAAA,CAAS,GAClF;EAAC;EAAW;EAAU;CAAS,CACjC;CAEA,OAAO;EAAE,GAAG;EAAS;EAAQ;CAAQ;AACvC"}

package/dist/quotes/use-managed-quotes.d.ts

@@ -0,0 +1,108 @@
+import { SocketStatus, UnifiedQuote } from '@symmio/trading-core';
+import { Address } from 'viem';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Which underlying quote sources {@link useManagedQuotes} should read. Every
+ * source defaults to `true`; set one to `false` to skip its query/subscription
+ * entirely (e.g. a screen that never opens instant trades).
+ */
+export interface ManagedQuotesSources {
+    /** Read on-chain open positions via `usePartyAOpenPositions`. Default `true`. */
+    openPositions?: boolean;
+    /** Read on-chain pending quote ids (hydrated per-id) via `usePartyAPendingQuotes`. Default `true`. */
+    pendingQuotes?: boolean;
+    /** Read pending instant-opens from the hedger via `useInstantOpens`. Default `true`. */
+    instantOpens?: boolean;
+    /** Read pending instant-closes from the hedger via `useInstantCloses`. Default `true`. */
+    instantCloses?: boolean;
+}
+/**
+ * Parameters for {@link useManagedQuotes}.
+ */
+export interface UseManagedQuotesParameters {
+    /** Sub-account (partyA) to manage quotes for. The hook is idle until this is set. */
+    partyA?: Address;
+    /** Target chain id. Defaults to the connected chain. */
+    chainId?: number;
+    /**
+     * Opt-in idle polling cadence (ms). **Default off** — with `live` notifications the
+     * feature is events-first: it does not poll at idle, only (a) accelerates on-chain
+     * reads briefly while a row awaits on-chain confirmation (the RPC-lag retry), and
+     * (b) falls back to a baseline poll when the event channel is down. Set this to make
+     * it poll on a fixed cadence regardless (e.g. a live-inspector panel).
+     */
+    pollingInterval?: number;
+    /** Subscribe to the live notifications stream. Default `true`; set `false` for poll-only. */
+    live?: boolean;
+    /** Master switch. When `false` every source is idle regardless of `sources`. Default `true`. */
+    enabled?: boolean;
+    /**
+     * Union the sub-account's existing on-chain Virtual Accounts (VAs) — plus the
+     * predicted VAs of its pending instant-opens and any VAs seen on the
+     * notifications stream — into the on-chain reads. In lowcap each isolated
+     * position lives under a VA, so this is required to see the full picture.
+     * Default `true`.
+     */
+    includeVirtualAccounts?: boolean;
+    /** Extra accounts to read quotes across (e.g. VAs already known to the consumer). */
+    extraAccounts?: readonly Address[];
+    /** Per-source toggles; omit to read every source. */
+    sources?: ManagedQuotesSources;
+}
+/**
+ * Value returned by {@link useManagedQuotes}.
+ */
+export interface UseManagedQuotesResult {
+    /** Merged, de-duplicated, lifecycle-tagged rows, newest first. */
+    quotes: UnifiedQuote[];
+    /** The same rows indexed by their stable {@link UnifiedQuote.key}. */
+    byKey: Record<string, UnifiedQuote>;
+    /** The on-chain `partyA` accounts the quotes were read across (sub-account + VAs + predicted + extras). */
+    accounts: Address[];
+    /** `true` while any enabled source has not produced its first result. */
+    isLoading: boolean;
+    /** `true` while any enabled source is fetching (background refetch included). */
+    isFetching: boolean;
+    /** Live connection status of the notifications socket (`"closed"` when `live` is off). */
+    socketStatus: SocketStatus;
+    /** The first error surfaced by any source, normalized, or `null`. */
+    error: SymmioRequestError | null;
+    /** Force every enabled source to refetch immediately. */
+    refetch: () => void;
+}
+/**
+ * Orchestrate every quote source for one sub-account — fanned out across every
+ * account that holds its positions — into a single, stable, lifecycle-tagged
+ * table.
+ *
+ * In lowcap, isolated positions live under Virtual Accounts (VAs), so a
+ * sub-account's quotes are spread across its VAs rather than the sub-account
+ * itself. This resolves the full account set — the sub-account, its existing
+ * VAs (`useVirtualAccountsAddressesOfSubAccount`), the predicted VAs of its
+ * pending instant-opens (`getPredictedNextVirtualAccount`), VAs seen on the
+ * notifications stream, and any `extraAccounts` — then reads
+ * `getPartyAOpenPositions` and `getPartyAPendingQuotes` (+ per-id `getQuote`
+ * hydration) across that set via `useQueries`. Off-chain hedger reads
+ * (`useInstantOpens` / `useInstantCloses`) stay scoped to the sub-account.
+ *
+ * Every source is gated by `sources`, `enabled`, and a set `partyA`, then their
+ * snapshots flow through the pure core `reconcileQuotes` ("active quotes only" —
+ * a quote shows iff it is in a source this tick), stamping each optimistic
+ * instant-open with its predicted VA via `instantOpenVaByTempId`. Live
+ * notifications (via `useNotifications`, unless `live` is `false`) are applied in
+ * the same merge. With `live` notifications the feature is **events-first**: it does
+ * not poll at idle, only accelerating the on-chain reads briefly while a row awaits
+ * on-chain confirmation (`shouldAccelerateOnchainReads`, the RPC-lag retry), and
+ * falling back to a baseline poll only when the event channel is down.
+ *
+ * Optimistic instant-opens seeded into {@link useOptimisticQuotesStore} are
+ * merged in as extra `instantOpens` so a just-submitted trade shows instantly,
+ * then cleared once the same `tempQuoteId` lands on-chain.
+ *
+ * @example
+ * ```tsx
+ * const { quotes, accounts, socketStatus, isLoading } = useManagedQuotes({ partyA });
+ * ```
+ */
+export declare function useManagedQuotes(parameters: UseManagedQuotesParameters): UseManagedQuotesResult;
+//# sourceMappingURL=use-managed-quotes.d.ts.map

package/dist/quotes/use-managed-quotes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-managed-quotes.d.ts","sourceRoot":"","sources":["../../src/quotes/use-managed-quotes.ts"],"names":[],"mappings":"AAEA,OAAO,EAkBL,KAAK,YAAY,EACjB,KAAK,YAAY,EAClB,MAAM,sBAAsB,CAAC;AAG9B,OAAO,EAAc,KAAK,OAAO,EAAE,MAAM,MAAM,CAAC;AAGhD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAqDzE;;;;GAIG;AACH,MAAM,WAAW,oBAAoB;IACnC,iFAAiF;IACjF,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,sGAAsG;IACtG,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,wFAAwF;IACxF,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,0FAA0F;IAC1F,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,qFAAqF;IACrF,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,wDAAwD;IACxD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB,6FAA6F;IAC7F,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,gGAAgG;IAChG,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB;;;;;;OAMG;IACH,sBAAsB,CAAC,EAAE,OAAO,CAAC;IACjC,qFAAqF;IACrF,aAAa,CAAC,EAAE,SAAS,OAAO,EAAE,CAAC;IACnC,qDAAqD;IACrD,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,kEAAkE;IAClE,MAAM,EAAE,YAAY,EAAE,CAAC;IACvB,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IACpC,2GAA2G;IAC3G,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,yEAAyE;IACzE,SAAS,EAAE,OAAO,CAAC;IACnB,iFAAiF;IACjF,UAAU,EAAE,OAAO,CAAC;IACpB,0FAA0F;IAC1F,YAAY,EAAE,YAAY,CAAC;IAC3B,qEAAqE;IACrE,KAAK,EAAE,kBAAkB,GAAG,IAAI,CAAC;IACjC,yDAAyD;IACzD,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,0BAA0B,GAAG,sBAAsB,CAkhB/F"}

package/dist/quotes/use-managed-quotes.js

@@ -0,0 +1,314 @@
+"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 { predicateMatch as r } from "../utils/predicate-match.js";
+import { useVirtualAccountsAddressesOfSubAccount as i } from "../account-layer/use-virtual-accounts-addresses-of-sub-account.js";
+import { useInstantCloses as a } from "../instant-layer/use-instant-closes.js";
+import { useInstantOpens as ee } from "../instant-layer/use-instant-opens.js";
+import { useOptimisticQuotesStore as te } from "./optimistic-quotes-store.js";
+import { useNotifications as ne } from "../websocket/use-notifications.js";
+import { QuoteLifecycle as o, classifyQuoteNotificationAction as re, getInstantClosesQueryKey as ie, getInstantOpensQueryKey as s, getPartyAOpenPositionsQueryKey as c, getPartyAOpenPositionsQueryOptions as ae, getPartyAPendingQuotesQueryKey as l, getPartyAPendingQuotesQueryOptions as oe, getPredictedNextVirtualAccountQueryOptions as se, getQuoteQueryKey as ce, getQuoteQueryOptions as le, isolationTypeForSide as ue, reconcileQuotes as de, shouldAccelerateOnchainReads as fe } from "@symmio/trading-core";
+import { useCallback as pe, useEffect as u, useMemo as d, useRef as f, useState as me } from "react";
+import { getAddress as p } from "viem";
+import { useQueries as m, useQueryClient as he } from "@tanstack/react-query";
+//#region src/quotes/use-managed-quotes.ts
+var ge = 5e3, _e = 1500, ve = 100, ye = [], be = 250, xe = new Set([
+	o.OPTIMISTIC,
+	o.PRICE_FILLED,
+	o.WRITE_ONCHAIN
+]), Se = new Set([o.WRITE_ONCHAIN_CLOSE, o.CLOSING]);
+function h(o) {
+	let { partyA: h, chainId: Ce, pollingInterval: g, live: _ = !0, enabled: we = !0 } = o, v = t(), Te = e(), y = Ce ?? Te, b = o.includeVirtualAccounts ?? !0, Ee = o.extraAccounts, x = o.sources, S = x?.openPositions ?? !0, C = x?.pendingQuotes ?? !0, w = x?.instantOpens ?? !0, T = x?.instantCloses ?? !0, E = we && !!h, D = E && h ? `${y}:${h.toLowerCase()}` : void 0, [O, De] = me({ vas: [] }), k = O.owner === D ? O.vas : ye, A = he(), j = f(A);
+	j.current = A;
+	let Oe = v.getChainConfigKey(y), M = f(Oe);
+	M.current = Oe;
+	let N = f(void 0), P = f({
+		opens: !1,
+		closes: !1
+	}), F = f(void 0), I = f([]), L = f("closed"), R = te((e) => e.entries), ke = te((e) => e.clearSettled), Ae = _ && L.current === "open", z = g && g > 0 ? g : !1, je = F.current ? fe(F.current) : !1, B = E ? je ? _e : Ae ? z : z || ge : !1, Me = F.current?.quotes, Ne = Me?.some((e) => xe.has(e.lifecycle)) ?? !1, Pe = Me?.some((e) => Se.has(e.lifecycle)) ?? !1, Fe = (e) => !Ae && e ? _e : z, Ie = E && w ? Fe(Ne) : !1, Le = E && T ? Fe(Pe) : !1, V = ee({
+		partyA: h,
+		chainId: y,
+		query: {
+			enabled: E && w,
+			refetchInterval: Ie
+		}
+	}), H = a({
+		partyA: h,
+		chainId: y,
+		query: {
+			enabled: E && T,
+			refetchInterval: Le
+		}
+	}), U = i({
+		subAccount: h,
+		chainId: y,
+		query: {
+			enabled: E && b,
+			refetchInterval: B
+		}
+	}), Re = w ? V.data ?? [] : [], W = m({
+		queries: Re.map((e) => ({ ...se(v, {
+			subAccount: h,
+			chainId: y,
+			isolationType: ue(e.positionType),
+			symbolId: BigInt(e.marketId),
+			query: {
+				enabled: E && b,
+				refetchInterval: B
+			}
+		}) })),
+		combine: (e) => ({
+			byTempId: Re.reduce((t, n, r) => {
+				let i = e[r]?.data;
+				return i && (t[n.tempQuoteId] = p(i)), t;
+			}, {}),
+			addresses: e.map((e) => e.data).filter((e) => !!e),
+			isLoading: e.some((e) => e.isLoading),
+			isFetching: e.some((e) => e.isFetching)
+		})
+	}), [G, ze] = me([]), { status: K } = ne({
+		account: h,
+		chainId: y,
+		enabled: E && _,
+		onNotification: pe((e) => {
+			ze((t) => [...t, e].slice(-ve));
+			let t = re(e.lastSeenAction), n = P.current;
+			t === "open" ? n.opens = !0 : (t === "close" || (n.opens = !0), n.closes = !0), N.current && clearTimeout(N.current), N.current = setTimeout(() => {
+				let e = j.current, t = { configKey: M.current }, { opens: n, closes: i } = P.current;
+				P.current = {
+					opens: !1,
+					closes: !1
+				}, e.invalidateQueries({ predicate: r(c, t) }), e.invalidateQueries({ predicate: r(l, t) }), e.invalidateQueries({ predicate: r(ce, t) }), n && e.invalidateQueries({ predicate: r(s, t) }), i && e.invalidateQueries({ predicate: r(ie, t) });
+			}, be);
+		}, [])
+	});
+	L.current = K;
+	let Be = f(!1);
+	u(() => {
+		if (!(!_ || K !== "open")) {
+			if (Be.current) {
+				let e = j.current, t = { configKey: M.current };
+				e.invalidateQueries({ predicate: r(c, t) }), e.invalidateQueries({ predicate: r(l, t) }), e.invalidateQueries({ predicate: r(ce, t) }), e.invalidateQueries({ predicate: r(s, t) }), e.invalidateQueries({ predicate: r(ie, t) });
+			}
+			Be.current = !0;
+		}
+	}, [K, _]), u(() => () => {
+		N.current && clearTimeout(N.current);
+	}, []);
+	let q = d(() => {
+		let e = /* @__PURE__ */ new Set(), t = [];
+		for (let n of G) {
+			if (!n.vaAddress) continue;
+			let r = p(n.vaAddress), i = r.toLowerCase();
+			e.has(i) || (e.add(i), t.push(r));
+		}
+		return t;
+	}, [G]), J = d(() => {
+		if (!E || !h) return [];
+		let e = /* @__PURE__ */ new Set(), t = [], n = (n) => {
+			let r = p(n), i = r.toLowerCase();
+			e.has(i) || (e.add(i), t.push(r));
+		};
+		if (n(h), b) {
+			for (let e of U.data ?? []) n(e);
+			for (let e of W.addresses) n(e);
+			for (let e of q) n(e);
+			for (let e of k) n(e);
+		}
+		for (let e of Ee ?? []) n(e);
+		return t;
+	}, [
+		E,
+		h,
+		b,
+		U.data,
+		W.addresses,
+		q,
+		k,
+		Ee
+	]);
+	u(() => {
+		if (!D) return;
+		let e = [
+			...U.data ?? [],
+			...W.addresses,
+			...q
+		];
+		De((t) => {
+			let n = t.owner === D ? t.vas : [], r = new Set(n.map((e) => e.toLowerCase())), i = [...n], a = t.owner !== D;
+			for (let t of e) {
+				let e = p(t), n = e.toLowerCase();
+				r.has(n) || (r.add(n), i.push(e), a = !0);
+			}
+			return a ? {
+				owner: D,
+				vas: i
+			} : t;
+		});
+	}, [
+		D,
+		U.data,
+		W.addresses,
+		q
+	]);
+	let Y = m({
+		queries: J.map((e) => {
+			let t = ae(v, {
+				partyA: e,
+				chainId: y,
+				query: {
+					enabled: E && S,
+					refetchInterval: B
+				}
+			});
+			return {
+				...t,
+				queryFn: async () => {
+					try {
+						return await t.queryFn();
+					} catch (e) {
+						throw n(e);
+					}
+				}
+			};
+		}),
+		combine: (e) => ({
+			quotes: e.flatMap((e) => e.data ?? []),
+			isLoading: e.some((e) => e.isLoading),
+			isFetching: e.some((e) => e.isFetching),
+			error: e.find((e) => e.error)?.error ?? null,
+			refetch: () => e.forEach((e) => e.refetch())
+		})
+	}), X = m({
+		queries: J.map((e) => {
+			let t = oe(v, {
+				partyA: e,
+				chainId: y,
+				query: {
+					enabled: E && C,
+					refetchInterval: B
+				}
+			});
+			return {
+				...t,
+				queryFn: async () => {
+					try {
+						return await t.queryFn();
+					} catch (e) {
+						throw n(e);
+					}
+				}
+			};
+		}),
+		combine: (e) => ({
+			ids: e.flatMap((e) => e.data ?? []),
+			isLoading: e.some((e) => e.isLoading),
+			isFetching: e.some((e) => e.isFetching),
+			error: e.find((e) => e.error)?.error ?? null,
+			refetch: () => e.forEach((e) => e.refetch())
+		})
+	}), Z = m({
+		queries: X.ids.map((e) => {
+			let t = le(v, {
+				quoteId: e,
+				chainId: y,
+				query: {
+					enabled: E && C,
+					refetchInterval: B
+				}
+			});
+			return {
+				...t,
+				queryFn: async () => {
+					try {
+						return await t.queryFn();
+					} catch (e) {
+						throw n(e);
+					}
+				}
+			};
+		}),
+		combine: (e) => ({
+			quotes: e.map((e) => e.data).filter((e) => !!e),
+			isLoading: e.some((e) => e.isLoading),
+			isFetching: e.some((e) => e.isFetching),
+			error: e.find((e) => e.error)?.error ?? null
+		})
+	}), Q = d(() => {
+		if (!E || !h) return F.current = void 0, I.current = [], {
+			quotes: [],
+			links: {},
+			pendingAnchors: []
+		};
+		let e = [...V.data ?? [], ...Object.values(R)], t = de({
+			partyA: h,
+			onchainPositions: S ? Y.quotes : [],
+			onchainPendingQuotes: C ? Z.quotes : [],
+			instantOpens: w ? e : [],
+			instantCloses: T ? H.data ?? [] : [],
+			instantOpenVaByTempId: W.byTempId,
+			notifications: G,
+			retainedAnchors: I.current
+		});
+		return F.current = t, I.current = t.pendingAnchors, t;
+	}, [
+		E,
+		h,
+		Y.quotes,
+		Z.quotes,
+		V.data,
+		H.data,
+		W.byTempId,
+		R,
+		G,
+		S,
+		C,
+		w,
+		T
+	]), $ = d(() => {
+		let e = {};
+		for (let t of Q.quotes) e[t.key] = t;
+		return e;
+	}, [Q.quotes]);
+	u(() => {
+		let e = Object.keys(R).map(Number).filter((e) => {
+			let t = Q.links[e];
+			return t !== void 0 && $[t]?.raw.onchain !== void 0;
+		});
+		e.length > 0 && ke(e);
+	}, [
+		Q,
+		$,
+		R,
+		ke
+	]);
+	let Ve = E && b && U.isLoading || E && b && W.isLoading || E && S && Y.isLoading || E && C && (X.isLoading || Z.isLoading) || E && w && V.isLoading || E && T && H.isLoading, He = b && (U.isFetching || W.isFetching) || S && Y.isFetching || C && (X.isFetching || Z.isFetching) || w && V.isFetching || T && H.isFetching, Ue = Y.error ?? X.error ?? Z.error ?? U.error ?? V.error ?? H.error ?? null, We = Y.refetch, Ge = X.refetch, Ke = pe(() => {
+		b && U.refetch(), S && We(), C && Ge(), w && V.refetch(), T && H.refetch();
+	}, [
+		b,
+		S,
+		C,
+		w,
+		T,
+		U,
+		We,
+		Ge,
+		V,
+		H
+	]);
+	return {
+		quotes: Q.quotes,
+		byKey: $,
+		accounts: J,
+		isLoading: !!Ve,
+		isFetching: !!He,
+		socketStatus: _ ? K : "closed",
+		error: Ue,
+		refetch: Ke
+	};
+}
+//#endregion
+export { h as useManagedQuotes };
+
+//# sourceMappingURL=use-managed-quotes.js.map

package/dist/quotes/use-managed-quotes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-managed-quotes.js","names":[],"sources":["../../src/quotes/use-managed-quotes.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  classifyQuoteNotificationAction,\n  getInstantClosesQueryKey,\n  getInstantOpensQueryKey,\n  getPartyAOpenPositionsQueryKey,\n  getPartyAOpenPositionsQueryOptions,\n  getPartyAPendingQuotesQueryKey,\n  getPartyAPendingQuotesQueryOptions,\n  getPredictedNextVirtualAccountQueryOptions,\n  getQuoteQueryKey,\n  getQuoteQueryOptions,\n  isolationTypeForSide,\n  QuoteLifecycle,\n  reconcileQuotes,\n  shouldAccelerateOnchainReads,\n  type Notification,\n  type Quote,\n  type ReconcileQuotesResult,\n  type SocketStatus,\n  type UnifiedQuote,\n} from \"@symmio/trading-core\";\nimport { useQueries, useQueryClient } from \"@tanstack/react-query\";\nimport { useCallback, useEffect, useMemo, useRef, useState } from \"react\";\nimport { getAddress, type Address } from \"viem\";\nimport { useVirtualAccountsAddressesOfSubAccount } from \"../account-layer/use-virtual-accounts-addresses-of-sub-account\";\nimport { normalizeSymmError } from \"../errors/normalize-symm-error\";\nimport type { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useInstantCloses } from \"../instant-layer/use-instant-closes\";\nimport { useInstantOpens } from \"../instant-layer/use-instant-opens\";\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\";\nimport { useOptimisticQuotesStore } from \"./optimistic-quotes-store\";\n\n/**\n * Baseline poll interval (ms) used **only as a fallback** when the live event channel\n * is unavailable (`live` is off, or the notifications socket is not `open`). With the\n * socket up the feature is events-first: there is no idle on-chain poll unless the\n * consumer opts into one via `pollingInterval`.\n */\nconst FALLBACK_POLLING_INTERVAL = 5_000;\n\n/** Accelerated quote-polling interval (ms) while a row is mid-transition. */\nconst ACCELERATED_POLLING_INTERVAL = 1_500;\n\n/**\n * Cap on the live-notification buffer fed back into the merge. Reconciliation is\n * idempotent over already-applied notifications, so only a recent window is kept\n * to bound memory and reprocessing.\n *\n * TODO: check this and packages/trading-react/src/quotes/use-managed-quotes.ts#L188-L206\n */\nconst NOTIFICATION_BUFFER_LIMIT = 100;\n\n/** Stable empty array so the `accounts` memo doesn't churn while no VAs are retained. */\nconst NO_RETAINED_VAS: readonly Address[] = [];\n\n/** Debounce (ms) for coalescing a burst of notifications into one set of read invalidations. */\nconst NOTIFICATION_INVALIDATE_DEBOUNCE = 250;\n\n/**\n * Lifecycle stages that mean an open is in flight, so the hedger instant-opens\n * feed is worth polling. Outside these stages the feed has nothing new (a\n * settled position is tracked by the on-chain reads), so polling it is wasted.\n */\nconst OPEN_INTENT_LIFECYCLES = new Set<QuoteLifecycle>([\n  QuoteLifecycle.OPTIMISTIC,\n  QuoteLifecycle.PRICE_FILLED,\n  QuoteLifecycle.WRITE_ONCHAIN,\n]);\n\n/**\n * Lifecycle stages that mean a close is in flight, so the hedger instant-closes\n * feed is worth polling. Outside these stages there is no pending close, so\n * polling the feed (merely holding open positions) is wasted.\n */\nconst CLOSE_INTENT_LIFECYCLES = new Set<QuoteLifecycle>([QuoteLifecycle.WRITE_ONCHAIN_CLOSE, QuoteLifecycle.CLOSING]);\n\n/**\n * Which underlying quote sources {@link useManagedQuotes} should read. Every\n * source defaults to `true`; set one to `false` to skip its query/subscription\n * entirely (e.g. a screen that never opens instant trades).\n */\nexport interface ManagedQuotesSources {\n  /** Read on-chain open positions via `usePartyAOpenPositions`. Default `true`. */\n  openPositions?: boolean;\n  /** Read on-chain pending quote ids (hydrated per-id) via `usePartyAPendingQuotes`. Default `true`. */\n  pendingQuotes?: boolean;\n  /** Read pending instant-opens from the hedger via `useInstantOpens`. Default `true`. */\n  instantOpens?: boolean;\n  /** Read pending instant-closes from the hedger via `useInstantCloses`. Default `true`. */\n  instantCloses?: boolean;\n}\n\n/**\n * Parameters for {@link useManagedQuotes}.\n */\nexport interface UseManagedQuotesParameters {\n  /** Sub-account (partyA) to manage quotes for. The hook is idle until this is set. */\n  partyA?: Address;\n  /** Target chain id. Defaults to the connected chain. */\n  chainId?: number;\n  /**\n   * Opt-in idle polling cadence (ms). **Default off** — with `live` notifications the\n   * feature is events-first: it does not poll at idle, only (a) accelerates on-chain\n   * reads briefly while a row awaits on-chain confirmation (the RPC-lag retry), and\n   * (b) falls back to a baseline poll when the event channel is down. Set this to make\n   * it poll on a fixed cadence regardless (e.g. a live-inspector panel).\n   */\n  pollingInterval?: number;\n  /** Subscribe to the live notifications stream. Default `true`; set `false` for poll-only. */\n  live?: boolean;\n  /** Master switch. When `false` every source is idle regardless of `sources`. Default `true`. */\n  enabled?: boolean;\n  /**\n   * Union the sub-account's existing on-chain Virtual Accounts (VAs) — plus the\n   * predicted VAs of its pending instant-opens and any VAs seen on the\n   * notifications stream — into the on-chain reads. In lowcap each isolated\n   * position lives under a VA, so this is required to see the full picture.\n   * Default `true`.\n   */\n  includeVirtualAccounts?: boolean;\n  /** Extra accounts to read quotes across (e.g. VAs already known to the consumer). */\n  extraAccounts?: readonly Address[];\n  /** Per-source toggles; omit to read every source. */\n  sources?: ManagedQuotesSources;\n}\n\n/**\n * Value returned by {@link useManagedQuotes}.\n */\nexport interface UseManagedQuotesResult {\n  /** Merged, de-duplicated, lifecycle-tagged rows, newest first. */\n  quotes: UnifiedQuote[];\n  /** The same rows indexed by their stable {@link UnifiedQuote.key}. */\n  byKey: Record<string, UnifiedQuote>;\n  /** The on-chain `partyA` accounts the quotes were read across (sub-account + VAs + predicted + extras). */\n  accounts: Address[];\n  /** `true` while any enabled source has not produced its first result. */\n  isLoading: boolean;\n  /** `true` while any enabled source is fetching (background refetch included). */\n  isFetching: boolean;\n  /** Live connection status of the notifications socket (`\"closed\"` when `live` is off). */\n  socketStatus: SocketStatus;\n  /** The first error surfaced by any source, normalized, or `null`. */\n  error: SymmioRequestError | null;\n  /** Force every enabled source to refetch immediately. */\n  refetch: () => void;\n}\n\n/**\n * Orchestrate every quote source for one sub-account — fanned out across every\n * account that holds its positions — into a single, stable, lifecycle-tagged\n * table.\n *\n * In lowcap, isolated positions live under Virtual Accounts (VAs), so a\n * sub-account's quotes are spread across its VAs rather than the sub-account\n * itself. This resolves the full account set — the sub-account, its existing\n * VAs (`useVirtualAccountsAddressesOfSubAccount`), the predicted VAs of its\n * pending instant-opens (`getPredictedNextVirtualAccount`), VAs seen on the\n * notifications stream, and any `extraAccounts` — then reads\n * `getPartyAOpenPositions` and `getPartyAPendingQuotes` (+ per-id `getQuote`\n * hydration) across that set via `useQueries`. Off-chain hedger reads\n * (`useInstantOpens` / `useInstantCloses`) stay scoped to the sub-account.\n *\n * Every source is gated by `sources`, `enabled`, and a set `partyA`, then their\n * snapshots flow through the pure core `reconcileQuotes` (\"active quotes only\" —\n * a quote shows iff it is in a source this tick), stamping each optimistic\n * instant-open with its predicted VA via `instantOpenVaByTempId`. Live\n * notifications (via `useNotifications`, unless `live` is `false`) are applied in\n * the same merge. With `live` notifications the feature is **events-first**: it does\n * not poll at idle, only accelerating the on-chain reads briefly while a row awaits\n * on-chain confirmation (`shouldAccelerateOnchainReads`, the RPC-lag retry), and\n * falling back to a baseline poll only when the event channel is down.\n *\n * Optimistic instant-opens seeded into {@link useOptimisticQuotesStore} are\n * merged in as extra `instantOpens` so a just-submitted trade shows instantly,\n * then cleared once the same `tempQuoteId` lands on-chain.\n *\n * @example\n * ```tsx\n * const { quotes, accounts, socketStatus, isLoading } = useManagedQuotes({ partyA });\n * ```\n */\nexport function useManagedQuotes(parameters: UseManagedQuotesParameters): UseManagedQuotesResult {\n  const { partyA, chainId, pollingInterval, live = true, enabled = true } = parameters;\n  const config = useSymmioConfig();\n  const defaultChainId = useSymmioChainId();\n  const resolvedChainId = chainId ?? defaultChainId;\n  const includeVirtualAccounts = parameters.includeVirtualAccounts ?? true;\n  const extraAccounts = parameters.extraAccounts;\n  const sources = parameters.sources;\n  const wantOpenPositions = sources?.openPositions ?? true;\n  const wantPendingQuotes = sources?.pendingQuotes ?? true;\n  const wantInstantOpens = sources?.instantOpens ?? true;\n  const wantInstantCloses = sources?.instantCloses ?? true;\n  const active = enabled && Boolean(partyA);\n\n  /**\n   * Identity of the current account set's owner. VA retention (below) is scoped\n   * to this `(chainId, partyA)` so switching sub-accounts never carries another\n   * account's VAs into the read set.\n   */\n  const retentionOwner = active && partyA ? `${resolvedChainId}:${partyA.toLowerCase()}` : undefined;\n\n  /**\n   * VAs retained across the optimistic→on-chain hand-off. A predicted VA leaves\n   * `predictedVas` the instant its instant-open lands on-chain (the hedger drops\n   * the pending open), while `getVirtualAccountsAddressesOfSubAccount` and the\n   * notification `va_address` can lag a poll behind — so without retention we'd\n   * stop polling the exact VA the position just landed in, and the row would\n   * vanish for a tick before reappearing as its `ONCHAIN` twin. VAs are\n   * append-only on-chain, so once discovered we keep reading them while the owner\n   * is unchanged. See reference-va-address-resolution in agent memory.\n   */\n  const [retained, setRetained] = useState<{ owner?: string; vas: Address[] }>({ vas: [] });\n  const retainedVas = retained.owner === retentionOwner ? retained.vas : NO_RETAINED_VAS;\n\n  /**\n   * Notification-driven invalidation. Reads are kept in sync off the live\n   * notifications stream — not polling — so the feature works with polling off.\n   * `queryClient` and the cache scope (`configKey`) are mirrored into refs so the\n   * `onNotification` callback below can stay referentially stable (a new callback\n   * identity would resubscribe the socket). The debounce timer coalesces a burst\n   * of notifications into one invalidation pass.\n   */\n  const queryClient = useQueryClient();\n  const queryClientRef = useRef(queryClient);\n  queryClientRef.current = queryClient;\n  const configKey = config.getChainConfigKey(resolvedChainId);\n  const configKeyRef = useRef(configKey);\n  configKeyRef.current = configKey;\n  const invalidateTimerRef = useRef<ReturnType<typeof setTimeout> | undefined>(undefined);\n  /**\n   * Which hedger feeds a debounced notification burst should invalidate. A burst\n   * can mix open and close events, so the kinds are accumulated here across the\n   * debounce window and read (then reset) when the timer fires — scoping the\n   * invalidation to the feeds the events can actually affect.\n   */\n  const pendingInvalidationRef = useRef<{ opens: boolean; closes: boolean }>({ opens: false, closes: false });\n\n  /**\n   * Last reconciliation result, kept in a ref so it survives renders without\n   * triggering one. Its only remaining job is to feed\n   * {@link shouldAccelerateOnchainReads} (and the feed-intent gates) the previous\n   * tick's result, since the source queries set their `refetchInterval` before this\n   * render's result exists. (\"Active quotes only\" dropped the grace window, and\n   * `links` are recomputed fresh on each merge.)\n   */\n  const previousRef = useRef<ReconcileQuotesResult | undefined>(undefined);\n\n  /**\n   * Rows anchored on a prior tick (a notification set their `quoteId`) but not yet\n   * returned by the on-chain read — the previous merge's `pendingAnchors`. Fed back\n   * into {@link reconcileQuotes} so an anchored row keeps showing while the RPC\n   * catches up, instead of vanishing once the hedger drops its pending open. Held in\n   * a ref so it survives renders without triggering one; the source query that\n   * dropped the row drives the recompute that reads it.\n   */\n  const retainedAnchorsRef = useRef<UnifiedQuote[]>([]);\n\n  /**\n   * Last tick's socket status, read one render behind (like `previousRef`) to decide\n   * whether the live event channel is up. Updated right after `useNotifications` below.\n   * When the channel is live the feature is events-first (no idle poll); when it is\n   * down we fall back to polling so state still advances without notifications.\n   */\n  const socketStatusRef = useRef<SocketStatus>(\"closed\");\n\n  const optimisticEntries = useOptimisticQuotesStore((state) => state.entries);\n  const clearSettled = useOptimisticQuotesStore((state) => state.clearSettled);\n\n  /** Live event channel = subscribed (`live`) and the socket was `open` last render. */\n  const eventChannelLive = live && socketStatusRef.current === \"open\";\n  /** Consumer's opt-in idle cadence (off by default). */\n  const idleInterval = pollingInterval && pollingInterval > 0 ? pollingInterval : false;\n\n  /**\n   * On-chain reads accelerate to {@link ACCELERATED_POLLING_INTERVAL} **only** while a\n   * row awaits on-chain confirmation (`WRITE_ONCHAIN` / `WRITE_ONCHAIN_CLOSE` /\n   * `CLOSING`) — the RPC-lag retry. Otherwise: no idle poll when the event channel is\n   * live (events drive updates) unless the consumer opted into `idleInterval`; a\n   * baseline fallback when the channel is down so state still progresses. Read from the\n   * previous result because the queries set their interval before this render's result\n   * exists (an on-chain poll / notification re-render advances it a tick later).\n   */\n  const accelerateOnchain = previousRef.current ? shouldAccelerateOnchainReads(previousRef.current) : false;\n  const onchainIdleInterval = eventChannelLive ? idleInterval : idleInterval || FALLBACK_POLLING_INTERVAL;\n  const refetchInterval = active ? (accelerateOnchain ? ACCELERATED_POLLING_INTERVAL : onchainIdleInterval) : false;\n\n  /**\n   * Hedger feeds are event-driven while the channel is live: the open/close mutation\n   * invalidates the matching feed once and the notifications advance the stage, so they\n   * do not poll (unless the consumer opted into `idleInterval`). When the channel is\n   * down they poll while the matching flow is in flight, to track it without\n   * notifications. `hasOpenIntent` / `hasCloseIntent` come from the previous tick.\n   */\n  const previousQuotes = previousRef.current?.quotes;\n  const hasOpenIntent = previousQuotes?.some((quote) => OPEN_INTENT_LIFECYCLES.has(quote.lifecycle)) ?? false;\n  const hasCloseIntent = previousQuotes?.some((quote) => CLOSE_INTENT_LIFECYCLES.has(quote.lifecycle)) ?? false;\n  const feedInterval = (hasIntent: boolean) =>\n    !eventChannelLive && hasIntent ? ACCELERATED_POLLING_INTERVAL : idleInterval;\n  const instantOpensInterval = active && wantInstantOpens ? feedInterval(hasOpenIntent) : false;\n  const instantClosesInterval = active && wantInstantCloses ? feedInterval(hasCloseIntent) : false;\n\n  /**\n   * Off-chain hedger reads — always scoped to the sub-account, never the VAs. Kept\n   * `enabled` so a mutation's `onSuccess` invalidation can fetch them on demand, but\n   * polled only while the matching flow is in flight (see the interval gates above).\n   */\n  const instantOpens = useInstantOpens({\n    partyA: partyA as Address,\n    chainId: resolvedChainId,\n    query: { enabled: active && wantInstantOpens, refetchInterval: instantOpensInterval },\n  });\n\n  const instantCloses = useInstantCloses({\n    partyA: partyA as Address,\n    chainId: resolvedChainId,\n    query: { enabled: active && wantInstantCloses, refetchInterval: instantClosesInterval },\n  });\n\n  /** The sub-account's existing on-chain VAs. Empty (harmless) when `partyA` is itself a VA. */\n  const virtualAccounts = useVirtualAccountsAddressesOfSubAccount({\n    subAccount: partyA,\n    chainId: resolvedChainId,\n    query: { enabled: active && includeVirtualAccounts, refetchInterval },\n  });\n\n  /**\n   * Brand-new-VA bridge: a position can open in a market the sub-account has\n   * never traded, landing in a freshly created VA that is not yet in\n   * `getVirtualAccountsAddressesOfSubAccount`. The predicted VA below covers it\n   * while the instant-open is pending; once it lands on-chain the hedger drops the\n   * open and the prediction with it, so VA retention (`retained`, above) keeps the\n   * VA in the poll set across the hand-off — the row transitions to `ONCHAIN` in\n   * place instead of flickering out and back.\n   */\n\n  /**\n   * Predict the VA each pending instant-open will land in. The set of opens is\n   * dynamic, but `useQueries` over a dynamic array is allowed — the hook count\n   * stays one regardless of length.\n   */\n  const pendingOpens = wantInstantOpens ? (instantOpens.data ?? []) : [];\n  const predictedVas = useQueries({\n    queries: pendingOpens.map((open) => ({\n      ...getPredictedNextVirtualAccountQueryOptions(config, {\n        subAccount: partyA,\n        chainId: resolvedChainId,\n        isolationType: isolationTypeForSide(open.positionType),\n        symbolId: BigInt(open.marketId),\n        query: { enabled: active && includeVirtualAccounts, refetchInterval },\n      }),\n    })),\n    combine: (results) => ({\n      byTempId: pendingOpens.reduce<Record<number, Address>>((map, open, index) => {\n        const predicted = results[index]?.data;\n        if (predicted) map[open.tempQuoteId] = getAddress(predicted);\n        return map;\n      }, {}),\n      addresses: results.map((result) => result.data).filter((address): address is Address => Boolean(address)),\n      isLoading: results.some((result) => result.isLoading),\n      isFetching: results.some((result) => result.isFetching),\n    }),\n  });\n\n  const [notifications, setNotifications] = useState<Notification[]>([]);\n  const { status: socketStatus } = useNotifications({\n    account: partyA,\n    chainId: resolvedChainId,\n    enabled: active && live,\n    onNotification: useCallback((notification: Notification) => {\n      setNotifications((prev) => [...prev, notification].slice(-NOTIFICATION_BUFFER_LIMIT));\n      /**\n       * Refetch the authoritative reads off the live event so both tables stay in\n       * sync without polling. The on-chain reads always refresh (any lifecycle event\n       * can change them); the hedger feeds refresh only for the matching flow, so an\n       * open event never re-fetches the closes feed and vice versa. Kinds are\n       * accumulated across the debounce window because a burst can mix open and close\n       * events. Scoped to this chain (`configKey`); React Query dedups concurrent\n       * refetches of the same query.\n       */\n      const kind = classifyQuoteNotificationAction(notification.lastSeenAction);\n      const pending = pendingInvalidationRef.current;\n      if (kind === \"open\") pending.opens = true;\n      else if (kind === \"close\") pending.closes = true;\n      else {\n        pending.opens = true;\n        pending.closes = true;\n      }\n      if (invalidateTimerRef.current) clearTimeout(invalidateTimerRef.current);\n      invalidateTimerRef.current = setTimeout(() => {\n        const client = queryClientRef.current;\n        const scope = { configKey: configKeyRef.current };\n        const { opens, closes } = pendingInvalidationRef.current;\n        pendingInvalidationRef.current = { opens: false, closes: false };\n        void client.invalidateQueries({ predicate: predicateMatch(getPartyAOpenPositionsQueryKey, scope) });\n        void client.invalidateQueries({ predicate: predicateMatch(getPartyAPendingQuotesQueryKey, scope) });\n        void client.invalidateQueries({ predicate: predicateMatch(getQuoteQueryKey, scope) });\n        if (opens) void client.invalidateQueries({ predicate: predicateMatch(getInstantOpensQueryKey, scope) });\n        if (closes) void client.invalidateQueries({ predicate: predicateMatch(getInstantClosesQueryKey, scope) });\n      }, NOTIFICATION_INVALIDATE_DEBOUNCE);\n    }, []),\n  });\n\n  /** Mirror the live socket status into the ref the interval gating reads next render. */\n  socketStatusRef.current = socketStatus;\n\n  /**\n   * One-shot re-sync when the notifications socket **reconnects**. The stream does not\n   * replay messages missed while it was down, so on a re-`open` we invalidate the reads\n   * once to catch up — this replaces a continuous fallback poll. The first connect is\n   * skipped (the queries already fetched on mount).\n   */\n  const hasBeenOpenRef = useRef(false);\n  useEffect(() => {\n    if (!live || socketStatus !== \"open\") return;\n    if (hasBeenOpenRef.current) {\n      const client = queryClientRef.current;\n      const scope = { configKey: configKeyRef.current };\n      void client.invalidateQueries({ predicate: predicateMatch(getPartyAOpenPositionsQueryKey, scope) });\n      void client.invalidateQueries({ predicate: predicateMatch(getPartyAPendingQuotesQueryKey, scope) });\n      void client.invalidateQueries({ predicate: predicateMatch(getQuoteQueryKey, scope) });\n      void client.invalidateQueries({ predicate: predicateMatch(getInstantOpensQueryKey, scope) });\n      void client.invalidateQueries({ predicate: predicateMatch(getInstantClosesQueryKey, scope) });\n    }\n    hasBeenOpenRef.current = true;\n  }, [socketStatus, live]);\n\n  /** Clear the pending invalidation timer on unmount. */\n  useEffect(() => {\n    return () => {\n      if (invalidateTimerRef.current) clearTimeout(invalidateTimerRef.current);\n    };\n  }, []);\n\n  /** Distinct VA addresses seen on the notifications stream. */\n  const notificationVas = useMemo<Address[]>(() => {\n    const seen = new Set<string>();\n    const result: Address[] = [];\n    for (const notification of notifications) {\n      if (!notification.vaAddress) continue;\n      const checksummed = getAddress(notification.vaAddress);\n      const lower = checksummed.toLowerCase();\n      if (seen.has(lower)) continue;\n      seen.add(lower);\n      result.push(checksummed);\n    }\n    return result;\n  }, [notifications]);\n\n  /**\n   * The deduplicated (case-insensitive), checksummed set of on-chain accounts to\n   * read quotes across — the sub-account, its VAs, the predicted VAs, the\n   * notification VAs, and any extras. Order: sub-account first, then the rest.\n   */\n  const accounts = useMemo<Address[]>(() => {\n    if (!active || !partyA) return [];\n    const seen = new Set<string>();\n    const result: Address[] = [];\n    const add = (address: Address) => {\n      const checksummed = getAddress(address);\n      const lower = checksummed.toLowerCase();\n      if (seen.has(lower)) return;\n      seen.add(lower);\n      result.push(checksummed);\n    };\n    add(partyA);\n    if (includeVirtualAccounts) {\n      for (const virtualAccount of virtualAccounts.data ?? []) add(virtualAccount);\n      for (const predicted of predictedVas.addresses) add(predicted);\n      for (const notificationVa of notificationVas) add(notificationVa);\n      for (const retainedVa of retainedVas) add(retainedVa);\n    }\n    for (const extra of extraAccounts ?? []) add(extra);\n    return result;\n  }, [\n    active,\n    partyA,\n    includeVirtualAccounts,\n    virtualAccounts.data,\n    predictedVas.addresses,\n    notificationVas,\n    retainedVas,\n    extraAccounts,\n  ]);\n\n  /**\n   * Accumulate every VA we discover (list + predicted + notification) into the\n   * retained set so none ever leaves the poll set mid-hand-off. Monotonic per\n   * owner; resets when the owner `(chainId, partyA)` changes. Setting state only\n   * when something new appears keeps this from looping.\n   */\n  useEffect(() => {\n    if (!retentionOwner) return;\n    const discovered = [...(virtualAccounts.data ?? []), ...predictedVas.addresses, ...notificationVas];\n    setRetained((prev) => {\n      const carryOver = prev.owner === retentionOwner ? prev.vas : [];\n      const seen = new Set(carryOver.map((address) => address.toLowerCase()));\n      const next = [...carryOver];\n      let changed = prev.owner !== retentionOwner;\n      for (const va of discovered) {\n        const checksummed = getAddress(va);\n        const lower = checksummed.toLowerCase();\n        if (seen.has(lower)) continue;\n        seen.add(lower);\n        next.push(checksummed);\n        changed = true;\n      }\n      return changed ? { owner: retentionOwner, vas: next } : prev;\n    });\n  }, [retentionOwner, virtualAccounts.data, predictedVas.addresses, notificationVas]);\n\n  /** On-chain open positions, fanned out across every account, flattened to one `Quote[]`. */\n  const openPositions = useQueries({\n    queries: accounts.map((account) => {\n      const options = getPartyAOpenPositionsQueryOptions(config, {\n        partyA: account,\n        chainId: resolvedChainId,\n        query: { enabled: active && wantOpenPositions, refetchInterval },\n      });\n      return {\n        ...options,\n        queryFn: async () => {\n          try {\n            return await options.queryFn();\n          } catch (err) {\n            throw normalizeSymmError(err);\n          }\n        },\n      };\n    }),\n    combine: (results) => ({\n      quotes: results.flatMap((result) => result.data ?? []),\n      isLoading: results.some((result) => result.isLoading),\n      isFetching: results.some((result) => result.isFetching),\n      error: (results.find((result) => result.error)?.error as SymmioRequestError | undefined) ?? null,\n      refetch: () => results.forEach((result) => result.refetch()),\n    }),\n  });\n  /** Pending quote ids, fanned out across every account, then hydrated per id. */\n  const pendingQuoteIds = useQueries({\n    queries: accounts.map((account) => {\n      const options = getPartyAPendingQuotesQueryOptions(config, {\n        partyA: account,\n        chainId: resolvedChainId,\n        query: { enabled: active && wantPendingQuotes, refetchInterval },\n      });\n      return {\n        ...options,\n        queryFn: async () => {\n          try {\n            return await options.queryFn();\n          } catch (err) {\n            throw normalizeSymmError(err);\n          }\n        },\n      };\n    }),\n    combine: (results) => ({\n      ids: results.flatMap((result) => result.data ?? []),\n      isLoading: results.some((result) => result.isLoading),\n      isFetching: results.some((result) => result.isFetching),\n      error: (results.find((result) => result.error)?.error as SymmioRequestError | undefined) ?? null,\n      refetch: () => results.forEach((result) => result.refetch()),\n    }),\n  });\n\n  const hydratedPending = useQueries({\n    queries: pendingQuoteIds.ids.map((quoteId) => {\n      const options = getQuoteQueryOptions(config, {\n        quoteId,\n        chainId: resolvedChainId,\n        query: { enabled: active && wantPendingQuotes, refetchInterval },\n      });\n      return {\n        ...options,\n        queryFn: async () => {\n          try {\n            return await options.queryFn();\n          } catch (err) {\n            throw normalizeSymmError(err);\n          }\n        },\n      };\n    }),\n    combine: (results) => ({\n      quotes: results.map((result) => result.data).filter((quote): quote is Quote => Boolean(quote)),\n      isLoading: results.some((result) => result.isLoading),\n      isFetching: results.some((result) => result.isFetching),\n      error: (results.find((result) => result.error)?.error as SymmioRequestError | undefined) ?? null,\n    }),\n  });\n\n  const result = useMemo<ReconcileQuotesResult>(() => {\n    if (!active || !partyA) {\n      previousRef.current = undefined;\n      retainedAnchorsRef.current = [];\n      return { quotes: [], links: {}, pendingAnchors: [] };\n    }\n    const seededInstantOpens = [...(instantOpens.data ?? []), ...Object.values(optimisticEntries)];\n    const next = reconcileQuotes({\n      partyA,\n      onchainPositions: wantOpenPositions ? openPositions.quotes : [],\n      onchainPendingQuotes: wantPendingQuotes ? hydratedPending.quotes : [],\n      instantOpens: wantInstantOpens ? seededInstantOpens : [],\n      instantCloses: wantInstantCloses ? (instantCloses.data ?? []) : [],\n      instantOpenVaByTempId: predictedVas.byTempId,\n      notifications,\n      retainedAnchors: retainedAnchorsRef.current,\n    });\n    previousRef.current = next;\n    retainedAnchorsRef.current = next.pendingAnchors;\n    return next;\n  }, [\n    active,\n    partyA,\n    openPositions.quotes,\n    hydratedPending.quotes,\n    instantOpens.data,\n    instantCloses.data,\n    predictedVas.byTempId,\n    optimisticEntries,\n    notifications,\n    wantOpenPositions,\n    wantPendingQuotes,\n    wantInstantOpens,\n    wantInstantCloses,\n  ]);\n\n  const byKey = useMemo<Record<string, UnifiedQuote>>(() => {\n    const map: Record<string, UnifiedQuote> = {};\n    for (const quote of result.quotes) map[quote.key] = quote;\n    return map;\n  }, [result.quotes]);\n\n  /**\n   * Drop optimistic seeds once their `tempQuoteId` has been **confirmed by the\n   * on-chain read** — the linked row carries the polled struct (`raw.onchain`).\n   * Clearing on the notification link alone would drop the seed while the row is\n   * still `WRITE_ONCHAIN`, before any source but the notification holds it, so the\n   * row would flicker out until the RPC catches up.\n   */\n  useEffect(() => {\n    const settled = Object.keys(optimisticEntries)\n      .map(Number)\n      .filter((tempQuoteId) => {\n        const key = result.links[tempQuoteId];\n        return key !== undefined && byKey[key]?.raw.onchain !== undefined;\n      });\n    if (settled.length > 0) clearSettled(settled);\n  }, [result, byKey, optimisticEntries, clearSettled]);\n\n  const isLoading =\n    (active && includeVirtualAccounts && virtualAccounts.isLoading) ||\n    (active && includeVirtualAccounts && predictedVas.isLoading) ||\n    (active && wantOpenPositions && openPositions.isLoading) ||\n    (active && wantPendingQuotes && (pendingQuoteIds.isLoading || hydratedPending.isLoading)) ||\n    (active && wantInstantOpens && instantOpens.isLoading) ||\n    (active && wantInstantCloses && instantCloses.isLoading);\n\n  const isFetching =\n    (includeVirtualAccounts && (virtualAccounts.isFetching || predictedVas.isFetching)) ||\n    (wantOpenPositions && openPositions.isFetching) ||\n    (wantPendingQuotes && (pendingQuoteIds.isFetching || hydratedPending.isFetching)) ||\n    (wantInstantOpens && instantOpens.isFetching) ||\n    (wantInstantCloses && instantCloses.isFetching);\n\n  const error =\n    openPositions.error ??\n    pendingQuoteIds.error ??\n    hydratedPending.error ??\n    virtualAccounts.error ??\n    instantOpens.error ??\n    instantCloses.error ??\n    null;\n\n  /**\n   * `openPositions` / `pendingQuoteIds` are `useQueries` fan-outs (no single\n   * query handle), so their combined results expose a `refetch` that fires every\n   * per-account query. Refetching the ids re-drives the per-id hydration.\n   */\n  const refetchOpenPositions = openPositions.refetch;\n  const refetchPendingQuoteIds = pendingQuoteIds.refetch;\n  const refetch = useCallback(() => {\n    if (includeVirtualAccounts) virtualAccounts.refetch();\n    if (wantOpenPositions) refetchOpenPositions();\n    if (wantPendingQuotes) refetchPendingQuoteIds();\n    if (wantInstantOpens) instantOpens.refetch();\n    if (wantInstantCloses) instantCloses.refetch();\n  }, [\n    includeVirtualAccounts,\n    wantOpenPositions,\n    wantPendingQuotes,\n    wantInstantOpens,\n    wantInstantCloses,\n    virtualAccounts,\n    refetchOpenPositions,\n    refetchPendingQuoteIds,\n    instantOpens,\n    instantCloses,\n  ]);\n\n  return {\n    quotes: result.quotes,\n    byKey,\n    accounts,\n    isLoading: Boolean(isLoading),\n    isFetching: Boolean(isFetching),\n    socketStatus: live ? socketStatus : \"closed\",\n    error,\n    refetch,\n  };\n}\n"],"mappings":"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"}

package/dist/quotes/use-party-a-open-positions.d.ts

@@ -0,0 +1,23 @@
+import { ConfigParameter, GetPartyAOpenPositionsOptions, GetPartyAOpenPositionsReturnType } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error';
+/**
+ * Parameters for {@link usePartyAOpenPositions}: the core query options (partyA,
+ * pagination, chain id, TanStack `query` overrides) plus an optional `config`.
+ */
+export type UsePartyAOpenPositionsParameters = GetPartyAOpenPositionsOptions & ConfigParameter;
+/** Return type of {@link usePartyAOpenPositions}. */
+export type UsePartyAOpenPositionsReturnType = UseQueryResult<GetPartyAOpenPositionsReturnType, SymmioRequestError>;
+/**
+ * Read a partyA's open positions (full `Quote` structs) from the SYMMIO core.
+ * `partyA` is a SubAccount (Majors) or Virtual Account (VibeCaps). The query is
+ * disabled until `partyA` is set. `chainId` defaults to the connected chain.
+ * Errors are normalized to {@link SymmioRequestError}.
+ *
+ * @example
+ * ```tsx
+ * const { data: positions, isLoading } = usePartyAOpenPositions({ partyA: "0xva…" });
+ * ```
+ */
+export declare function usePartyAOpenPositions(parameters?: UsePartyAOpenPositionsParameters): UsePartyAOpenPositionsReturnType;
+//# sourceMappingURL=use-party-a-open-positions.d.ts.map

package/dist/quotes/use-party-a-open-positions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-party-a-open-positions.d.ts","sourceRoot":"","sources":["../../src/quotes/use-party-a-open-positions.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,6BAA6B,EAClC,KAAK,gCAAgC,EACtC,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,gCAAgC,GAAG,6BAA6B,GAAG,eAAe,CAAC;AAE/F,qDAAqD;AACrD,MAAM,MAAM,gCAAgC,GAAG,cAAc,CAAC,gCAAgC,EAAE,kBAAkB,CAAC,CAAC;AAEpH;;;;;;;;;;GAUG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,GAAE,gCAAqC,GAChD,gCAAgC,CAkBlC"}