@symmio/trading-react 1.1.0 → 3.0.0

package/dist/solvers/use-solver-capabilities.js

@@ -0,0 +1,30 @@
+"use client";
+import { useSymmioChainId as e } from "../provider/use-symmio-chain-id.js";
+import { useSymmioConfig as t } from "../provider/use-symmio-config.js";
+import { getSolverCapabilities as n, supportsGroupClose as r, supportsLimitOrder as i } from "@symmio/trading-core";
+//#region src/solvers/use-solver-capabilities.ts
+function a(r = {}) {
+	let i = t(r), a = e();
+	return n(i, {
+		chainId: r.chainId ?? a,
+		solverId: r.solverId
+	});
+}
+function o(n = {}) {
+	let i = t(n), a = e();
+	return r(i, {
+		chainId: n.chainId ?? a,
+		solverId: n.solverId
+	});
+}
+function s(n = {}) {
+	let r = t(n), a = e();
+	return i(r, {
+		chainId: n.chainId ?? a,
+		solverId: n.solverId
+	});
+}
+//#endregion
+export { a as useSolverCapabilities, o as useSupportsGroupClose, s as useSupportsLimitOrder };
+
+//# sourceMappingURL=use-solver-capabilities.js.map

package/dist/solvers/use-solver-capabilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-solver-capabilities.js","names":[],"sources":["../../src/solvers/use-solver-capabilities.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getSolverCapabilities,\n  supportsGroupClose,\n  supportsLimitOrder,\n  type ConfigParameter,\n  type SolverCapabilities,\n  type SolverId,\n} from \"@symmio/trading-core\";\nimport { useSymmioChainId } from \"../provider/use-symmio-chain-id\";\nimport { useSymmioConfig } from \"../provider/use-symmio-config\";\n\n/** Parameters for {@link useSolverCapabilities} / {@link useSupportsGroupClose}. */\nexport interface UseSolverCapabilitiesParameters extends ConfigParameter {\n  /** Chain to check; defaults to the connected chain. */\n  chainId?: number;\n  /** Solver to check; defaults to the chain's default solver. */\n  solverId?: SolverId;\n}\n\n/**\n * Resolve the target solver's {@link SolverCapabilities}. Use it to gate UI on\n * what the solver supports (e.g. hide the group-close flow when unsupported).\n *\n * @example\n * ```tsx\n * const { groupClose } = useSolverCapabilities();\n * if (!groupClose) return null;\n * ```\n */\nexport function useSolverCapabilities(parameters: UseSolverCapabilitiesParameters = {}): SolverCapabilities {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  return getSolverCapabilities(config, { chainId: parameters.chainId ?? chainId, solverId: parameters.solverId });\n}\n\n/**\n * Whether the target solver supports group close (close a market + side cohort\n * in one flow). Shorthand for `useSolverCapabilities().groupClose`; gate the\n * group-close toggle / step on it so rasa (cross-margin) hides it.\n */\nexport function useSupportsGroupClose(parameters: UseSolverCapabilitiesParameters = {}): boolean {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  return supportsGroupClose(config, { chainId: parameters.chainId ?? chainId, solverId: parameters.solverId });\n}\n\n/**\n * Whether the target solver supports limit orders (majors / rasa). Shorthand for\n * `useSolverCapabilities().limitOrder`; gate the limit-order form on it.\n */\nexport function useSupportsLimitOrder(parameters: UseSolverCapabilitiesParameters = {}): boolean {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  return supportsLimitOrder(config, { chainId: parameters.chainId ?? chainId, solverId: parameters.solverId });\n}\n"],"mappings":";;;;;AA+BA,SAAgB,EAAsB,IAA8C,CAAC,GAAuB;CAC1G,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB;CACjC,OAAO,EAAsB,GAAQ;EAAE,SAAS,EAAW,WAAW;EAAS,UAAU,EAAW;CAAS,CAAC;AAChH;AAOA,SAAgB,EAAsB,IAA8C,CAAC,GAAY;CAC/F,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB;CACjC,OAAO,EAAmB,GAAQ;EAAE,SAAS,EAAW,WAAW;EAAS,UAAU,EAAW;CAAS,CAAC;AAC7G;AAMA,SAAgB,EAAsB,IAA8C,CAAC,GAAY;CAC/F,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB;CACjC,OAAO,EAAmB,GAAQ;EAAE,SAAS,EAAW,WAAW;EAAS,UAAU,EAAW;CAAS,CAAC;AAC7G"}

package/dist/solvers/use-solver-revenue.d.ts

@@ -0,0 +1,28 @@
+import { ConfigParameter, GetSolverRevenueOptions, GetSolverRevenueReturnType } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+/** Parameters for {@link useSolverRevenue}: the core query options plus an optional `config`. */
+export type UseSolverRevenueParameters = GetSolverRevenueOptions & ConfigParameter;
+/** Return type of {@link useSolverRevenue}: revenue totals for the window. */
+export type UseSolverRevenueReturnType = UseQueryResult<GetSolverRevenueReturnType, SymmioRequestError>;
+/**
+ * Read one market's revenue totals from the connected chain's solver.
+ *
+ * The result splits into a hedger-fee share and a funding share whose sum is
+ * `totalRevenue`, all as plain dollar numbers. `recordCount` separates "this
+ * window earned nothing" from "there is no data for this window".
+ *
+ * `symbolId` is required: the current solver generation serves revenue **per
+ * market only** — the protocol-wide `/revenue` aggregate no longer exists.
+ *
+ * Enigma-only; a rasa-kind solver fails with `UNSUPPORTED_BY_SOLVER`. Errors are
+ * normalized to {@link SymmioRequestError}.
+ *
+ * @example
+ * ```tsx
+ * const lifetime = useSolverRevenue({ symbolId: 1 });
+ * const day = useSolverRevenue({ symbolId: 1, timeRange: "24h" });
+ * ```
+ */
+export declare function useSolverRevenue(parameters: UseSolverRevenueParameters): UseSolverRevenueReturnType;
+//# sourceMappingURL=use-solver-revenue.d.ts.map

package/dist/solvers/use-solver-revenue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-solver-revenue.d.ts","sourceRoot":"","sources":["../../src/solvers/use-solver-revenue.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,iGAAiG;AACjG,MAAM,MAAM,0BAA0B,GAAG,uBAAuB,GAAG,eAAe,CAAC;AAEnF,8EAA8E;AAC9E,MAAM,MAAM,0BAA0B,GAAG,cAAc,CAAC,0BAA0B,EAAE,kBAAkB,CAAC,CAAC;AAExG;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,0BAA0B,GAAG,0BAA0B,CAkBnG"}

package/dist/solvers/use-solver-revenue.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 { getSolverRevenueQueryOptions as r } from "@symmio/trading-core";
+import { useQuery as i } from "@tanstack/react-query";
+//#region src/solvers/use-solver-revenue.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 useSolverRevenue };
+
+//# sourceMappingURL=use-solver-revenue.js.map

package/dist/solvers/use-solver-revenue.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-solver-revenue.js","names":[],"sources":["../../src/solvers/use-solver-revenue.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getSolverRevenueQueryOptions,\n  type ConfigParameter,\n  type GetSolverRevenueOptions,\n  type GetSolverRevenueReturnType,\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/** Parameters for {@link useSolverRevenue}: the core query options plus an optional `config`. */\nexport type UseSolverRevenueParameters = GetSolverRevenueOptions & ConfigParameter;\n\n/** Return type of {@link useSolverRevenue}: revenue totals for the window. */\nexport type UseSolverRevenueReturnType = UseQueryResult<GetSolverRevenueReturnType, SymmioRequestError>;\n\n/**\n * Read one market's revenue totals from the connected chain's solver.\n *\n * The result splits into a hedger-fee share and a funding share whose sum is\n * `totalRevenue`, all as plain dollar numbers. `recordCount` separates \"this\n * window earned nothing\" from \"there is no data for this window\".\n *\n * `symbolId` is required: the current solver generation serves revenue **per\n * market only** — the protocol-wide `/revenue` aggregate no longer exists.\n *\n * Enigma-only; a rasa-kind solver fails with `UNSUPPORTED_BY_SOLVER`. Errors are\n * normalized to {@link SymmioRequestError}.\n *\n * @example\n * ```tsx\n * const lifetime = useSolverRevenue({ symbolId: 1 });\n * const day = useSolverRevenue({ symbolId: 1, timeRange: \"24h\" });\n * ```\n */\nexport function useSolverRevenue(parameters: UseSolverRevenueParameters): UseSolverRevenueReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const options = getSolverRevenueQueryOptions(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 UseSolverRevenueReturnType;\n}\n"],"mappings":";;;;;;;AAuCA,SAAgB,EAAiB,GAAoE;CACnG,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"}

package/dist/symbols/index.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/symbols/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC"}

package/dist/symbols/use-symbols.d.ts

@@ -0,0 +1,25 @@
+import { ConfigParameter, GetSymbolsOptions, GetSymbolsReturnType } from '@symmio/trading-core';
+import { UseQueryResult } from '@tanstack/react-query';
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+/**
+ * Parameters for {@link useSymbols}: the core query options plus an optional
+ * `config`.
+ */
+export type UseSymbolsParameters = GetSymbolsOptions & ConfigParameter;
+/** Return type of {@link useSymbols}. */
+export type UseSymbolsReturnType = UseQueryResult<GetSymbolsReturnType, SymmioRequestError>;
+/**
+ * Read the tradable symbol catalogue from the active chain's solver in one call.
+ * Surfaces a normalized row per symbol — id, name, precisions, leverage, fees,
+ * and per-side trading state — filtered and paged by the given parameters.
+ *
+ * Does not poll by default; pass `query.refetchInterval` to opt into polling.
+ *
+ * @example
+ * ```tsx
+ * const { data } = useSymbols({ search: "BTC" });
+ * const btc = data?.find((s) => s.name === "BTCUSDT");
+ * ```
+ */
+export declare function useSymbols(parameters?: UseSymbolsParameters): UseSymbolsReturnType;
+//# sourceMappingURL=use-symbols.d.ts.map

package/dist/symbols/use-symbols.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-symbols.d.ts","sourceRoot":"","sources":["../../src/symbols/use-symbols.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EAC1B,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,oBAAoB,GAAG,iBAAiB,GAAG,eAAe,CAAC;AAEvE,yCAAyC;AACzC,MAAM,MAAM,oBAAoB,GAAG,cAAc,CAAC,oBAAoB,EAAE,kBAAkB,CAAC,CAAC;AAE5F;;;;;;;;;;;;GAYG;AACH,wBAAgB,UAAU,CAAC,UAAU,GAAE,oBAAyB,GAAG,oBAAoB,CAkBtF"}

package/dist/symbols/use-symbols.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 { getSymbolsQueryOptions as r } from "@symmio/trading-core";
+import { useQuery as i } from "@tanstack/react-query";
+//#region src/symbols/use-symbols.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 useSymbols };
+
+//# sourceMappingURL=use-symbols.js.map

package/dist/symbols/use-symbols.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-symbols.js","names":[],"sources":["../../src/symbols/use-symbols.ts"],"sourcesContent":["\"use client\";\n\nimport {\n  getSymbolsQueryOptions,\n  type ConfigParameter,\n  type GetSymbolsOptions,\n  type GetSymbolsReturnType,\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 useSymbols}: the core query options plus an optional\n * `config`.\n */\nexport type UseSymbolsParameters = GetSymbolsOptions & ConfigParameter;\n\n/** Return type of {@link useSymbols}. */\nexport type UseSymbolsReturnType = UseQueryResult<GetSymbolsReturnType, SymmioRequestError>;\n\n/**\n * Read the tradable symbol catalogue from the active chain's solver in one call.\n * Surfaces a normalized row per symbol — id, name, precisions, leverage, fees,\n * and per-side trading state — filtered and paged by the given parameters.\n *\n * Does not poll by default; pass `query.refetchInterval` to opt into polling.\n *\n * @example\n * ```tsx\n * const { data } = useSymbols({ search: \"BTC\" });\n * const btc = data?.find((s) => s.name === \"BTCUSDT\");\n * ```\n */\nexport function useSymbols(parameters: UseSymbolsParameters = {}): UseSymbolsReturnType {\n  const config = useSymmioConfig(parameters);\n  const chainId = useSymmioChainId();\n  const options = getSymbolsQueryOptions(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 UseSymbolsReturnType;\n}\n"],"mappings":";;;;;;;AAoCA,SAAgB,EAAW,IAAmC,CAAC,GAAyB;CACtF,IAAM,IAAS,EAAgB,CAAU,GACnC,IAAU,EAAiB,GAC3B,IAAU,EAAuB,GAAQ;EAC7C,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"}

package/dist/tpsl/apply-tpsl-search-snapshot.d.ts

@@ -0,0 +1,33 @@
+import { SearchTpSlOrdersReturnType, TpSlConditionalOrderType } from '@symmio/trading-core';
+/** One side of one quote a run is still waiting on. */
+export interface TpSlWaitingSide {
+    /** The quote's addressable id — on-chain, or the hedger temp id. */
+    quoteId: bigint;
+    /** Which side. */
+    side: TpSlConditionalOrderType;
+    /** What the wait is for: an order appearing, or an order disappearing. */
+    intent: "write" | "cancel";
+    /** For a cancel, the handler id that must be gone. */
+    cohQuoteId?: string;
+}
+/**
+ * Fold an account-scoped search response into the shared TP/SL store, on
+ * behalf of the sides a run is still waiting on.
+ *
+ * Three rules keep an account-wide page from doing damage:
+ *
+ * 1. **Rows are attributed per quote.** `toQuoteTpSl` ignores `quote_id` and
+ *    folds whatever array it is handed into one pair, so the rows are grouped
+ *    first — otherwise one leg's stop-loss would land on another leg.
+ * 2. **Only the waiting sides are written.** A page that lags on a side nobody
+ *    asked about must not blank the live order sitting there.
+ * 3. **Absence is only meaningful on a complete page.** A truncated response
+ *    proves nothing about what is missing, so it contributes positive rows only
+ *    and cancels wait for a clean tick.
+ *
+ * @param waiting - The sides still confirming, from the run's live step list.
+ * @param snapshot - One account's search result.
+ * @returns The quote ids that were written.
+ */
+export declare function applyTpSlSearchSnapshot(waiting: readonly TpSlWaitingSide[], snapshot: SearchTpSlOrdersReturnType): bigint[];
+//# sourceMappingURL=apply-tpsl-search-snapshot.d.ts.map

package/dist/tpsl/apply-tpsl-search-snapshot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-tpsl-search-snapshot.d.ts","sourceRoot":"","sources":["../../src/tpsl/apply-tpsl-search-snapshot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,0BAA0B,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AAG/G,uDAAuD;AACvD,MAAM,WAAW,eAAe;IAC9B,oEAAoE;IACpE,OAAO,EAAE,MAAM,CAAC;IAChB,kBAAkB;IAClB,IAAI,EAAE,wBAAwB,CAAC;IAC/B,0EAA0E;IAC1E,MAAM,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC3B,sDAAsD;IACtD,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAOD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,QAAQ,EAAE,0BAA0B,GACnC,MAAM,EAAE,CAkBV"}

package/dist/tpsl/apply-tpsl-search-snapshot.js

@@ -0,0 +1,51 @@
+import { useTpSlStore as e } from "./tpsl-store.js";
+//#region src/tpsl/apply-tpsl-search-snapshot.ts
+function t(e) {
+	return e === "take_profit" ? "tp" : "sl";
+}
+function n(n, s) {
+	if (n.length === 0) return [];
+	let c = e.getState(), l = a(s.orders), u = [];
+	for (let [e, a] of o(n)) {
+		let n = i(l, e, a), o = a.filter((e) => r(e, n, s.isComplete));
+		o.length !== 0 && (c.setRowsForSides(e, n, o.map((e) => t(e.side))), u.push(e));
+	}
+	return u;
+}
+function r(e, t, n) {
+	let r = t.some((t) => t.conditional_order_type === e.side);
+	return e.intent === "write" ? r : n ? e.cohQuoteId === void 0 ? !r : !t.some((t) => t.conditional_order_type === e.side && t.coh_quote_id === e.cohQuoteId) : !1;
+}
+function i(t, n, r) {
+	let i = t.get(n);
+	if (i) return i;
+	let a = e.getState(), o = a.get(n);
+	for (let [e, n] of t) {
+		let t = a.get(e);
+		if (o !== void 0 && t !== void 0 && t === o) return n;
+		let i = r.map((e) => e.cohQuoteId).filter(Boolean);
+		if (i.length > 0 && n.some((e) => i.includes(e.coh_quote_id))) return n;
+	}
+	return [];
+}
+function a(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		if (n.quote_id === void 0 || n.quote_id === null) continue;
+		let e = BigInt(n.quote_id), r = t.get(e);
+		r ? r.push(n) : t.set(e, [n]);
+	}
+	return t;
+}
+function o(e) {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = t.get(n.quoteId);
+		e ? e.push(n) : t.set(n.quoteId, [n]);
+	}
+	return t;
+}
+//#endregion
+export { n as applyTpSlSearchSnapshot };
+
+//# sourceMappingURL=apply-tpsl-search-snapshot.js.map

package/dist/tpsl/apply-tpsl-search-snapshot.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply-tpsl-search-snapshot.js","names":[],"sources":["../../src/tpsl/apply-tpsl-search-snapshot.ts"],"sourcesContent":["import type { QuoteTpSlRow, SearchTpSlOrdersReturnType, TpSlConditionalOrderType } from \"@symmio/trading-core\";\nimport { useTpSlStore, type TpSlSideKey } from \"./tpsl-store\";\n\n/** One side of one quote a run is still waiting on. */\nexport interface TpSlWaitingSide {\n  /** The quote's addressable id — on-chain, or the hedger temp id. */\n  quoteId: bigint;\n  /** Which side. */\n  side: TpSlConditionalOrderType;\n  /** What the wait is for: an order appearing, or an order disappearing. */\n  intent: \"write\" | \"cancel\";\n  /** For a cancel, the handler id that must be gone. */\n  cohQuoteId?: string;\n}\n\n/** `tp` / `sl` for a conditional-order type. */\nfunction sideKeyOf(side: TpSlConditionalOrderType): TpSlSideKey {\n  return side === \"take_profit\" ? \"tp\" : \"sl\";\n}\n\n/**\n * Fold an account-scoped search response into the shared TP/SL store, on\n * behalf of the sides a run is still waiting on.\n *\n * Three rules keep an account-wide page from doing damage:\n *\n * 1. **Rows are attributed per quote.** `toQuoteTpSl` ignores `quote_id` and\n *    folds whatever array it is handed into one pair, so the rows are grouped\n *    first — otherwise one leg's stop-loss would land on another leg.\n * 2. **Only the waiting sides are written.** A page that lags on a side nobody\n *    asked about must not blank the live order sitting there.\n * 3. **Absence is only meaningful on a complete page.** A truncated response\n *    proves nothing about what is missing, so it contributes positive rows only\n *    and cancels wait for a clean tick.\n *\n * @param waiting - The sides still confirming, from the run's live step list.\n * @param snapshot - One account's search result.\n * @returns The quote ids that were written.\n */\nexport function applyTpSlSearchSnapshot(\n  waiting: readonly TpSlWaitingSide[],\n  snapshot: SearchTpSlOrdersReturnType,\n): bigint[] {\n  if (waiting.length === 0) return [];\n  const store = useTpSlStore.getState();\n  const byQuoteId = groupRowsByQuoteId(snapshot.orders);\n  const written: bigint[] = [];\n\n  for (const [quoteId, sides] of groupWaitingByQuote(waiting)) {\n    const rows = rowsForQuote(byQuoteId, quoteId, sides);\n    const applicable = sides.filter((entry) => isSideApplicable(entry, rows, snapshot.isComplete));\n    if (applicable.length === 0) continue;\n    store.setRowsForSides(\n      quoteId,\n      rows,\n      applicable.map((entry) => sideKeyOf(entry.side)),\n    );\n    written.push(quoteId);\n  }\n  return written;\n}\n\n/**\n * Whether this tick may speak for a side.\n *\n * A write is applied whenever its row is present — that is the evidence the\n * store's own guard then checks.\n *\n * A cancel is applied only from a complete page on which **this side's** order\n * is gone. The handler id alone cannot decide it: this deployment issues one\n * `coh_quote_id` per quote, so cancelling a take-profit while the stop-loss\n * stays live leaves that id on the surviving row — matching on the id alone\n * would keep the cancel unconfirmed until it timed out, having actually\n * succeeded. Pairing the id with the side keeps the check honest whichever way\n * the handler assigns ids.\n */\nfunction isSideApplicable(entry: TpSlWaitingSide, rows: readonly QuoteTpSlRow[], isComplete: boolean): boolean {\n  const present = rows.some((row) => row.conditional_order_type === entry.side);\n  if (entry.intent === \"write\") return present;\n  if (!isComplete) return false;\n  if (entry.cohQuoteId !== undefined) {\n    return !rows.some((row) => row.conditional_order_type === entry.side && row.coh_quote_id === entry.cohQuoteId);\n  }\n  return !present;\n}\n\n/**\n * The rows belonging to one quote.\n *\n * Matched by `quote_id` first, then — for a quote the handler still keys under\n * an id this client has not linked yet — by the handler id a waiting cancel is\n * targeting. Both lookups must resolve to something real; comparing two unknown\n * ids would attribute a foreign row to this leg.\n */\nfunction rowsForQuote(\n  byQuoteId: Map<bigint, QuoteTpSlRow[]>,\n  quoteId: bigint,\n  sides: readonly TpSlWaitingSide[],\n): QuoteTpSlRow[] {\n  const direct = byQuoteId.get(quoteId);\n  if (direct) return direct;\n  const store = useTpSlStore.getState();\n  const target = store.get(quoteId);\n  for (const [rowQuoteId, rows] of byQuoteId) {\n    const linked = store.get(rowQuoteId);\n    if (target !== undefined && linked !== undefined && linked === target) return rows;\n    const expected = sides.map((entry) => entry.cohQuoteId).filter(Boolean);\n    if (expected.length > 0 && rows.some((row) => expected.includes(row.coh_quote_id))) return rows;\n  }\n  return [];\n}\n\n/** Group a page's rows by their on-chain quote id. */\nfunction groupRowsByQuoteId(rows: readonly QuoteTpSlRow[]): Map<bigint, QuoteTpSlRow[]> {\n  const grouped = new Map<bigint, QuoteTpSlRow[]>();\n  for (const row of rows) {\n    if (row.quote_id === undefined || row.quote_id === null) continue;\n    const id = BigInt(row.quote_id);\n    const bucket = grouped.get(id);\n    if (bucket) bucket.push(row);\n    else grouped.set(id, [row]);\n  }\n  return grouped;\n}\n\n/** Group the waiting sides by the quote they belong to. */\nfunction groupWaitingByQuote(waiting: readonly TpSlWaitingSide[]): Map<bigint, TpSlWaitingSide[]> {\n  const grouped = new Map<bigint, TpSlWaitingSide[]>();\n  for (const entry of waiting) {\n    const bucket = grouped.get(entry.quoteId);\n    if (bucket) bucket.push(entry);\n    else grouped.set(entry.quoteId, [entry]);\n  }\n  return grouped;\n}\n"],"mappings":";;AAgBA,SAAS,EAAU,GAA6C;CAC9D,OAAO,MAAS,gBAAgB,OAAO;AACzC;AAqBA,SAAgB,EACd,GACA,GACU;CACV,IAAI,EAAQ,WAAW,GAAG,OAAO,CAAC;CAClC,IAAM,IAAQ,EAAa,SAAS,GAC9B,IAAY,EAAmB,EAAS,MAAM,GAC9C,IAAoB,CAAC;CAE3B,KAAK,IAAM,CAAC,GAAS,MAAU,EAAoB,CAAO,GAAG;EAC3D,IAAM,IAAO,EAAa,GAAW,GAAS,CAAK,GAC7C,IAAa,EAAM,QAAQ,MAAU,EAAiB,GAAO,GAAM,EAAS,UAAU,CAAC;EACzF,EAAW,WAAW,MAC1B,EAAM,gBACJ,GACA,GACA,EAAW,KAAK,MAAU,EAAU,EAAM,IAAI,CAAC,CACjD,GACA,EAAQ,KAAK,CAAO;CACtB;CACA,OAAO;AACT;AAgBA,SAAS,EAAiB,GAAwB,GAA+B,GAA8B;CAC7G,IAAM,IAAU,EAAK,MAAM,MAAQ,EAAI,2BAA2B,EAAM,IAAI;CAM5E,OALI,EAAM,WAAW,UAAgB,IAChC,IACD,EAAM,eAAe,KAAA,IAGlB,CAAC,IAFC,CAAC,EAAK,MAAM,MAAQ,EAAI,2BAA2B,EAAM,QAAQ,EAAI,iBAAiB,EAAM,UAAU,IAFvF;AAK1B;AAUA,SAAS,EACP,GACA,GACA,GACgB;CAChB,IAAM,IAAS,EAAU,IAAI,CAAO;CACpC,IAAI,GAAQ,OAAO;CACnB,IAAM,IAAQ,EAAa,SAAS,GAC9B,IAAS,EAAM,IAAI,CAAO;CAChC,KAAK,IAAM,CAAC,GAAY,MAAS,GAAW;EAC1C,IAAM,IAAS,EAAM,IAAI,CAAU;EACnC,IAAI,MAAW,KAAA,KAAa,MAAW,KAAA,KAAa,MAAW,GAAQ,OAAO;EAC9E,IAAM,IAAW,EAAM,KAAK,MAAU,EAAM,UAAU,EAAE,OAAO,OAAO;EACtE,IAAI,EAAS,SAAS,KAAK,EAAK,MAAM,MAAQ,EAAS,SAAS,EAAI,YAAY,CAAC,GAAG,OAAO;CAC7F;CACA,OAAO,CAAC;AACV;AAGA,SAAS,EAAmB,GAA4D;CACtF,IAAM,oBAAU,IAAI,IAA4B;CAChD,KAAK,IAAM,KAAO,GAAM;EACtB,IAAI,EAAI,aAAa,KAAA,KAAa,EAAI,aAAa,MAAM;EACzD,IAAM,IAAK,OAAO,EAAI,QAAQ,GACxB,IAAS,EAAQ,IAAI,CAAE;EAC7B,AAAI,IAAQ,EAAO,KAAK,CAAG,IACtB,EAAQ,IAAI,GAAI,CAAC,CAAG,CAAC;CAC5B;CACA,OAAO;AACT;AAGA,SAAS,EAAoB,GAAqE;CAChG,IAAM,oBAAU,IAAI,IAA+B;CACnD,KAAK,IAAM,KAAS,GAAS;EAC3B,IAAM,IAAS,EAAQ,IAAI,EAAM,OAAO;EACxC,AAAI,IAAQ,EAAO,KAAK,CAAK,IACxB,EAAQ,IAAI,EAAM,SAAS,CAAC,CAAK,CAAC;CACzC;CACA,OAAO;AACT"}

package/dist/tpsl/await-tpsl-confirmation.d.ts

@@ -0,0 +1,77 @@
+import { SymmioRequestError } from '../errors/symmio-request-error.js';
+/**
+ * How long a grouped run waits for confirmation before giving up, in
+ * milliseconds.
+ *
+ * Sized to cover both halves of the wait: the report owns the first
+ * `TPSL_FALLBACK_POLL_DELAY_MS` (30s) alone, and the fallback sweep then reads
+ * the handler every couple of seconds for the remainder. Cutting this short
+ * would fail steps the sweep had barely begun to check.
+ */
+export declare const DEFAULT_TPSL_CONFIRMATION_TIMEOUT_MS = 60000;
+/**
+ * How long the fallback refetch gets to land before the run gives up on the
+ * steps that are still unconfirmed, in milliseconds.
+ */
+export declare const TPSL_CONFIRMATION_REFETCH_GRACE_MS = 5000;
+/** Options for {@link awaitTpSlConfirmation}. */
+export interface AwaitTpSlConfirmationOptions {
+    /** Reconcile the run's steps against the store. Called on every store change. */
+    settle: () => void;
+    /** Whether any step is still waiting. Read straight after `settle`. */
+    hasPending: () => boolean;
+    /** Refetch the handler's rows — the fallback when no report arrives. */
+    onTimeout: () => void;
+    /** Give up on whatever is still pending after the fallback had its grace window. */
+    onExpire: () => void;
+    /**
+     * Called once, only when there is genuinely something to wait for. Return a
+     * disposer to tear down whatever it started.
+     *
+     * The seam the fallback sweep hangs off: it starts when the wait starts and
+     * is disposed by the same `finish()` that resolves the wait, so it cannot
+     * outlive the run — including when the component that began the run has
+     * unmounted. Throwing from either the hook or its disposer is swallowed; this
+     * function's contract is that it never rejects.
+     */
+    onWait?: () => (() => void) | void;
+    /** Report deadline. Defaults to {@link DEFAULT_TPSL_CONFIRMATION_TIMEOUT_MS}. */
+    timeoutMs?: number;
+    /**
+     * Fallback grace window. Defaults to {@link TPSL_CONFIRMATION_REFETCH_GRACE_MS},
+     * capped at `timeoutMs` — a caller who only waits a moment for the report
+     * does not then wait longer than that for the refetch.
+     */
+    graceMs?: number;
+}
+/**
+ * Resolve once every step of a TP/SL run has been confirmed — or once the run
+ * has stopped waiting for the ones that never were.
+ *
+ * The wait is driven by the shared TP/SL store rather than by a React effect,
+ * so it survives the component unmounting mid-run (a trader closing the modal)
+ * and still terminates. Two deadlines bound it: at `timeoutMs` the handler's
+ * rows are refetched, and `graceMs` later whatever is still pending is failed.
+ *
+ * @param options - The run's reconcile/pending probes and its two fallbacks.
+ * @returns Resolves when nothing is pending. Never rejects.
+ *
+ * @example
+ * ```ts
+ * await awaitTpSlConfirmation({
+ *   settle: () => reconcileSteps(),
+ *   hasPending: () => runRef.current.steps.some((step) => step.status === "confirming"),
+ *   onTimeout: () => void invalidateTpSlReads(queryClient, ids),
+ *   onExpire: () => failPendingSteps(),
+ * });
+ * ```
+ */
+export declare function awaitTpSlConfirmation(options: AwaitTpSlConfirmationOptions): Promise<void>;
+/**
+ * `SymmioRequestError.code` of a step the handler accepted but never reported
+ * on. Distinguishes "we stopped waiting" from "the request was rejected".
+ */
+export declare const TPSL_CONFIRMATION_TIMEOUT_CODE = "TPSL_CONFIRMATION_TIMEOUT";
+/** The error a step carries when the handler never confirmed it. */
+export declare function tpslConfirmationTimeoutError(): SymmioRequestError;
+//# sourceMappingURL=await-tpsl-confirmation.d.ts.map

package/dist/tpsl/await-tpsl-confirmation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"await-tpsl-confirmation.d.ts","sourceRoot":"","sources":["../../src/tpsl/await-tpsl-confirmation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AAGpE;;;;;;;;GAQG;AACH,eAAO,MAAM,oCAAoC,QAAS,CAAC;AAE3D;;;GAGG;AACH,eAAO,MAAM,kCAAkC,OAAQ,CAAC;AAExD,iDAAiD;AACjD,MAAM,WAAW,4BAA4B;IAC3C,iFAAiF;IACjF,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,uEAAuE;IACvE,UAAU,EAAE,MAAM,OAAO,CAAC;IAC1B,wEAAwE;IACxE,SAAS,EAAE,MAAM,IAAI,CAAC;IACtB,oFAAoF;IACpF,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB;;;;;;;;;OASG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,IAAI,CAAC,GAAG,IAAI,CAAC;IACnC,iFAAiF;IACjF,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,4BAA4B,GAAG,OAAO,CAAC,IAAI,CAAC,CAqD1F;AAED;;;GAGG;AACH,eAAO,MAAM,8BAA8B,8BAA8B,CAAC;AAE1E,oEAAoE;AACpE,wBAAgB,4BAA4B,IAAI,kBAAkB,CAMjE"}

package/dist/tpsl/await-tpsl-confirmation.js

@@ -0,0 +1,42 @@
+import { SymmioRequestError as e } from "../errors/symmio-request-error.js";
+import { useTpSlStore as t } from "./tpsl-store.js";
+//#region src/tpsl/await-tpsl-confirmation.ts
+var n = 6e4, r = 5e3;
+function i(e) {
+	let { settle: i, hasPending: a, onTimeout: o, onExpire: s, onWait: c, timeoutMs: l = n, graceMs: u = Math.min(r, l) } = e;
+	return i(), a() ? new Promise((e) => {
+		let n = !1, r, d;
+		try {
+			d = c?.();
+		} catch {
+			d = void 0;
+		}
+		let f = () => {
+			if (!n) {
+				n = !0, p(), clearTimeout(m), r !== void 0 && clearTimeout(r);
+				try {
+					d?.();
+				} catch {}
+				e();
+			}
+		}, p = t.subscribe(() => {
+			i(), a() || f();
+		}), m = setTimeout(() => {
+			o(), r = setTimeout(() => {
+				s(), f();
+			}, u);
+		}, l);
+	}) : Promise.resolve();
+}
+var a = "TPSL_CONFIRMATION_TIMEOUT";
+function o() {
+	return new e({
+		kind: "sdk",
+		code: a,
+		message: "The handler never confirmed this order. Check the position's exits before retrying."
+	});
+}
+//#endregion
+export { n as DEFAULT_TPSL_CONFIRMATION_TIMEOUT_MS, a as TPSL_CONFIRMATION_TIMEOUT_CODE, i as awaitTpSlConfirmation, o as tpslConfirmationTimeoutError };
+
+//# sourceMappingURL=await-tpsl-confirmation.js.map

package/dist/tpsl/await-tpsl-confirmation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"await-tpsl-confirmation.js","names":[],"sources":["../../src/tpsl/await-tpsl-confirmation.ts"],"sourcesContent":["import { SymmioRequestError } from \"../errors/symmio-request-error\";\nimport { useTpSlStore } from \"./tpsl-store\";\n\n/**\n * How long a grouped run waits for confirmation before giving up, in\n * milliseconds.\n *\n * Sized to cover both halves of the wait: the report owns the first\n * `TPSL_FALLBACK_POLL_DELAY_MS` (30s) alone, and the fallback sweep then reads\n * the handler every couple of seconds for the remainder. Cutting this short\n * would fail steps the sweep had barely begun to check.\n */\nexport const DEFAULT_TPSL_CONFIRMATION_TIMEOUT_MS = 60_000;\n\n/**\n * How long the fallback refetch gets to land before the run gives up on the\n * steps that are still unconfirmed, in milliseconds.\n */\nexport const TPSL_CONFIRMATION_REFETCH_GRACE_MS = 5_000;\n\n/** Options for {@link awaitTpSlConfirmation}. */\nexport interface AwaitTpSlConfirmationOptions {\n  /** Reconcile the run's steps against the store. Called on every store change. */\n  settle: () => void;\n  /** Whether any step is still waiting. Read straight after `settle`. */\n  hasPending: () => boolean;\n  /** Refetch the handler's rows — the fallback when no report arrives. */\n  onTimeout: () => void;\n  /** Give up on whatever is still pending after the fallback had its grace window. */\n  onExpire: () => void;\n  /**\n   * Called once, only when there is genuinely something to wait for. Return a\n   * disposer to tear down whatever it started.\n   *\n   * The seam the fallback sweep hangs off: it starts when the wait starts and\n   * is disposed by the same `finish()` that resolves the wait, so it cannot\n   * outlive the run — including when the component that began the run has\n   * unmounted. Throwing from either the hook or its disposer is swallowed; this\n   * function's contract is that it never rejects.\n   */\n  onWait?: () => (() => void) | void;\n  /** Report deadline. Defaults to {@link DEFAULT_TPSL_CONFIRMATION_TIMEOUT_MS}. */\n  timeoutMs?: number;\n  /**\n   * Fallback grace window. Defaults to {@link TPSL_CONFIRMATION_REFETCH_GRACE_MS},\n   * capped at `timeoutMs` — a caller who only waits a moment for the report\n   * does not then wait longer than that for the refetch.\n   */\n  graceMs?: number;\n}\n\n/**\n * Resolve once every step of a TP/SL run has been confirmed — or once the run\n * has stopped waiting for the ones that never were.\n *\n * The wait is driven by the shared TP/SL store rather than by a React effect,\n * so it survives the component unmounting mid-run (a trader closing the modal)\n * and still terminates. Two deadlines bound it: at `timeoutMs` the handler's\n * rows are refetched, and `graceMs` later whatever is still pending is failed.\n *\n * @param options - The run's reconcile/pending probes and its two fallbacks.\n * @returns Resolves when nothing is pending. Never rejects.\n *\n * @example\n * ```ts\n * await awaitTpSlConfirmation({\n *   settle: () => reconcileSteps(),\n *   hasPending: () => runRef.current.steps.some((step) => step.status === \"confirming\"),\n *   onTimeout: () => void invalidateTpSlReads(queryClient, ids),\n *   onExpire: () => failPendingSteps(),\n * });\n * ```\n */\nexport function awaitTpSlConfirmation(options: AwaitTpSlConfirmationOptions): Promise<void> {\n  const {\n    settle,\n    hasPending,\n    onTimeout,\n    onExpire,\n    onWait,\n    timeoutMs = DEFAULT_TPSL_CONFIRMATION_TIMEOUT_MS,\n    graceMs = Math.min(TPSL_CONFIRMATION_REFETCH_GRACE_MS, timeoutMs),\n  } = options;\n\n  settle();\n  if (!hasPending()) return Promise.resolve();\n\n  return new Promise<void>((resolve) => {\n    let settled = false;\n    let graceTimer: ReturnType<typeof setTimeout> | undefined;\n\n    /** Started only now that the wait is real; disposed on every exit path. */\n    let disposeWait: (() => void) | void;\n    try {\n      disposeWait = onWait?.();\n    } catch {\n      disposeWait = undefined;\n    }\n\n    const finish = () => {\n      if (settled) return;\n      settled = true;\n      unsubscribe();\n      clearTimeout(deadline);\n      if (graceTimer !== undefined) clearTimeout(graceTimer);\n      try {\n        disposeWait?.();\n      } catch {\n        // A failing disposer must not turn a resolved wait into a rejection.\n      }\n      resolve();\n    };\n\n    const unsubscribe = useTpSlStore.subscribe(() => {\n      settle();\n      if (!hasPending()) finish();\n    });\n\n    const deadline = setTimeout(() => {\n      onTimeout();\n      graceTimer = setTimeout(() => {\n        onExpire();\n        finish();\n      }, graceMs);\n    }, timeoutMs);\n  });\n}\n\n/**\n * `SymmioRequestError.code` of a step the handler accepted but never reported\n * on. Distinguishes \"we stopped waiting\" from \"the request was rejected\".\n */\nexport const TPSL_CONFIRMATION_TIMEOUT_CODE = \"TPSL_CONFIRMATION_TIMEOUT\";\n\n/** The error a step carries when the handler never confirmed it. */\nexport function tpslConfirmationTimeoutError(): SymmioRequestError {\n  return new SymmioRequestError({\n    kind: \"sdk\",\n    code: TPSL_CONFIRMATION_TIMEOUT_CODE,\n    message: \"The handler never confirmed this order. Check the position's exits before retrying.\",\n  });\n}\n"],"mappings":";;;AAYA,IAAa,IAAuC,KAMvC,IAAqC;AAuDlD,SAAgB,EAAsB,GAAsD;CAC1F,IAAM,EACJ,WACA,eACA,cACA,aACA,WACA,eAAY,GACZ,aAAU,KAAK,IAAI,GAAoC,CAAS,MAC9D;CAKJ,OAHA,EAAO,GACF,EAAW,IAET,IAAI,SAAe,MAAY;EACpC,IAAI,IAAU,IACV,GAGA;EACJ,IAAI;GACF,IAAc,IAAS;EACzB,QAAQ;GACN,IAAc,KAAA;EAChB;EAEA,IAAM,UAAe;GACf,QAIJ;IAHA,IAAU,IACV,EAAY,GACZ,aAAa,CAAQ,GACjB,MAAe,KAAA,KAAW,aAAa,CAAU;IACrD,IAAI;KACF,IAAc;IAChB,QAAQ,CAER;IACA,EAAQ;GAN6C;EAOvD,GAEM,IAAc,EAAa,gBAAgB;GAE/C,AADA,EAAO,GACF,EAAW,KAAG,EAAO;EAC5B,CAAC,GAEK,IAAW,iBAAiB;GAEhC,AADA,EAAU,GACV,IAAa,iBAAiB;IAE5B,AADA,EAAS,GACT,EAAO;GACT,GAAG,CAAO;EACZ,GAAG,CAAS;CACd,CAAC,IAxCyB,QAAQ,QAAQ;AAyC5C;AAMA,IAAa,IAAiC;AAG9C,SAAgB,IAAmD;CACjE,OAAO,IAAI,EAAmB;EAC5B,MAAM;EACN,MAAM;EACN,SAAS;CACX,CAAC;AACH"}

package/dist/tpsl/index.d.ts

@@ -1,9 +1,20 @@
+export * from './apply-tpsl-search-snapshot.js';
+export * from './await-tpsl-confirmation.js';
+export * from './invalidate-tpsl.js';
 export * from './to-quote-tpsl.js';
+export * from './tpsl-fallback-poll.js';
 export * from './tpsl-store.js';
+export * from './use-delete-quote-group-tpsl.js';
 export * from './use-delete-quote-tpsl.js';
+export * from './use-quote-group-tpsl.js';
+export * from './use-quote-group-tpsl-editor.js';
 export * from './use-quote-tpsl.js';
+export * from './use-search-tpsl-orders.js';
+export * from './use-set-quote-group-tpsl.js';
 export * from './use-set-quote-tpsl.js';
 export * from './use-tpsl-config.js';
 export * from './use-tpsl-signing-spec.js';
+export * from './use-tpsl-supported.js';
+export * from './use-watch-tpsl-accounts.js';
 export * from './use-watch-tpsl-notifications.js';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tpsl/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,cAAc,CAAC;AAC7B,cAAc,yBAAyB,CAAC;AACxC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tpsl/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,+BAA+B,CAAC;AAC9C,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC"}

package/dist/tpsl/invalidate-tpsl.d.ts

@@ -0,0 +1,23 @@
+import { QueryClient } from '@tanstack/react-query';
+/**
+ * Refetch the folded TP/SL reads for the given quotes.
+ *
+ * Call this after a successful set or cancel: the handler's REST rows are the
+ * authoritative state, so refetching them overwrites the optimistic
+ * `confirming` overlay `markConfirming` left in the store. Without it a box
+ * resolves only when the live WebSocket frame arrives — and stays stuck
+ * `confirming` (or keeps showing a cancelled value) whenever that frame is
+ * missed.
+ *
+ * The `getQuoteTpSl` query key is matched by **shape**, not through
+ * `getQuoteTpSlQueryKey`, because that factory throws on a partial (it
+ * stringifies `quoteId`). Only the passed quotes' reads are invalidated, so an
+ * unrelated market's TP/SL box is never disturbed.
+ *
+ * @param queryClient - The active TanStack query client.
+ * @param quoteIds - On-chain quote ids whose TP/SL reads should refetch. `0n`
+ *   sentinels are ignored.
+ * @returns Resolves when the matching queries have been marked stale.
+ */
+export declare function invalidateTpSlReads(queryClient: QueryClient, quoteIds: readonly bigint[]): Promise<void>;
+//# sourceMappingURL=invalidate-tpsl.d.ts.map

package/dist/tpsl/invalidate-tpsl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidate-tpsl.d.ts","sourceRoot":"","sources":["../../src/tpsl/invalidate-tpsl.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,WAAW,EAAE,QAAQ,EAAE,SAAS,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAWxG"}

package/dist/tpsl/invalidate-tpsl.js

@@ -0,0 +1,14 @@
+//#region src/tpsl/invalidate-tpsl.ts
+function e(e, t) {
+	let n = new Set(t.filter((e) => e !== 0n).map((e) => e.toString()));
+	return n.size === 0 ? Promise.resolve() : e.invalidateQueries({ predicate: (e) => {
+		let t = e.queryKey;
+		if (!Array.isArray(t) || t[0] !== "getQuoteTpSl") return !1;
+		let r = t[1];
+		return typeof r?.quoteId == "string" && n.has(r.quoteId);
+	} });
+}
+//#endregion
+export { e as invalidateTpSlReads };
+
+//# sourceMappingURL=invalidate-tpsl.js.map

package/dist/tpsl/invalidate-tpsl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"invalidate-tpsl.js","names":[],"sources":["../../src/tpsl/invalidate-tpsl.ts"],"sourcesContent":["import type { QueryClient } from \"@tanstack/react-query\";\n\n/**\n * Refetch the folded TP/SL reads for the given quotes.\n *\n * Call this after a successful set or cancel: the handler's REST rows are the\n * authoritative state, so refetching them overwrites the optimistic\n * `confirming` overlay `markConfirming` left in the store. Without it a box\n * resolves only when the live WebSocket frame arrives — and stays stuck\n * `confirming` (or keeps showing a cancelled value) whenever that frame is\n * missed.\n *\n * The `getQuoteTpSl` query key is matched by **shape**, not through\n * `getQuoteTpSlQueryKey`, because that factory throws on a partial (it\n * stringifies `quoteId`). Only the passed quotes' reads are invalidated, so an\n * unrelated market's TP/SL box is never disturbed.\n *\n * @param queryClient - The active TanStack query client.\n * @param quoteIds - On-chain quote ids whose TP/SL reads should refetch. `0n`\n *   sentinels are ignored.\n * @returns Resolves when the matching queries have been marked stale.\n */\nexport function invalidateTpSlReads(queryClient: QueryClient, quoteIds: readonly bigint[]): Promise<void> {\n  const ids = new Set(quoteIds.filter((id) => id !== 0n).map((id) => id.toString()));\n  if (ids.size === 0) return Promise.resolve();\n  return queryClient.invalidateQueries({\n    predicate: (query) => {\n      const key = query.queryKey;\n      if (!Array.isArray(key) || key[0] !== \"getQuoteTpSl\") return false;\n      const params = key[1] as { quoteId?: string } | undefined;\n      return typeof params?.quoteId === \"string\" && ids.has(params.quoteId);\n    },\n  });\n}\n"],"mappings":";AAsBA,SAAgB,EAAoB,GAA0B,GAA4C;CACxG,IAAM,IAAM,IAAI,IAAI,EAAS,QAAQ,MAAO,MAAO,EAAE,EAAE,KAAK,MAAO,EAAG,SAAS,CAAC,CAAC;CAEjF,OADI,EAAI,SAAS,IAAU,QAAQ,QAAQ,IACpC,EAAY,kBAAkB,EACnC,YAAY,MAAU;EACpB,IAAM,IAAM,EAAM;EAClB,IAAI,CAAC,MAAM,QAAQ,CAAG,KAAK,EAAI,OAAO,gBAAgB,OAAO;EAC7D,IAAM,IAAS,EAAI;EACnB,OAAO,OAAO,GAAQ,WAAY,YAAY,EAAI,IAAI,EAAO,OAAO;CACtE,EACF,CAAC;AACH"}

package/dist/tpsl/match-tpsl-notification.d.ts

@@ -0,0 +1,27 @@
+import { TpSlNotification } from '@symmio/trading-core';
+/**
+ * Resolve which of `ids` a TP/SL notification belongs to.
+ *
+ * A quote is addressable by several ids over its life (the hedger's negative
+ * `tempQuoteId` before it anchors, the on-chain `quoteId` after), and the store
+ * aliases every id it has learned onto one record. So the match runs through
+ * the store's index and compares records by reference — a frame carrying the
+ * temp id still lands on a child now addressed by its on-chain id.
+ *
+ * When the store has no record for a candidate yet (the very first "seed"
+ * frame), it falls back to comparing the raw ids on the frame.
+ *
+ * @param notification - The normalized TP/SL frame.
+ * @param ids - Candidate quote ids, in the caller's own order.
+ * @returns The first matching id, or `undefined` when the frame is unrelated.
+ */
+export declare function matchTpSlNotification(notification: TpSlNotification, ids: readonly (bigint | undefined)[]): bigint | undefined;
+/**
+ * Learn the `tempQuoteId ↔ quoteId` pairing a frame carries, so both ids
+ * resolve to the same store record from now on. No-op when the frame only
+ * carries one identifier.
+ *
+ * @param notification - The normalized TP/SL frame.
+ */
+export declare function linkTpSlNotificationIds(notification: TpSlNotification): void;
+//# sourceMappingURL=match-tpsl-notification.d.ts.map

package/dist/tpsl/match-tpsl-notification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-tpsl-notification.d.ts","sourceRoot":"","sources":["../../src/tpsl/match-tpsl-notification.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAG7D;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CACnC,YAAY,EAAE,gBAAgB,EAC9B,GAAG,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,GACnC,MAAM,GAAG,SAAS,CAqBpB;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,YAAY,EAAE,gBAAgB,GAAG,IAAI,CAG5E"}

package/dist/tpsl/match-tpsl-notification.js

@@ -0,0 +1,22 @@
+"use client";
+import { useTpSlStore as e } from "./tpsl-store.js";
+//#region src/tpsl/match-tpsl-notification.ts
+function t(t, n) {
+	let r = e.getState();
+	for (let e of n) {
+		if (e === void 0 || e === 0n) continue;
+		let n = r.get(e);
+		if (!n) {
+			if (t.primaryIdentifier === Number(e) || t.secondaryIdentifier === Number(e) || t.quoteId === Number(e)) return e;
+			continue;
+		}
+		if (t.primaryIdentifier !== 0 && r.get(BigInt(t.primaryIdentifier)) === n || t.secondaryIdentifier !== 0 && r.get(BigInt(t.secondaryIdentifier)) === n) return e;
+	}
+}
+function n(t) {
+	t.primaryIdentifier === 0 || t.secondaryIdentifier === 0 || e.getState().link(BigInt(t.primaryIdentifier), BigInt(t.secondaryIdentifier));
+}
+//#endregion
+export { n as linkTpSlNotificationIds, t as matchTpSlNotification };
+
+//# sourceMappingURL=match-tpsl-notification.js.map

package/dist/tpsl/match-tpsl-notification.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"match-tpsl-notification.js","names":[],"sources":["../../src/tpsl/match-tpsl-notification.ts"],"sourcesContent":["\"use client\";\n\nimport type { TpSlNotification } from \"@symmio/trading-core\";\nimport { useTpSlStore } from \"./tpsl-store\";\n\n/**\n * Resolve which of `ids` a TP/SL notification belongs to.\n *\n * A quote is addressable by several ids over its life (the hedger's negative\n * `tempQuoteId` before it anchors, the on-chain `quoteId` after), and the store\n * aliases every id it has learned onto one record. So the match runs through\n * the store's index and compares records by reference — a frame carrying the\n * temp id still lands on a child now addressed by its on-chain id.\n *\n * When the store has no record for a candidate yet (the very first \"seed\"\n * frame), it falls back to comparing the raw ids on the frame.\n *\n * @param notification - The normalized TP/SL frame.\n * @param ids - Candidate quote ids, in the caller's own order.\n * @returns The first matching id, or `undefined` when the frame is unrelated.\n */\nexport function matchTpSlNotification(\n  notification: TpSlNotification,\n  ids: readonly (bigint | undefined)[],\n): bigint | undefined {\n  const store = useTpSlStore.getState();\n  for (const id of ids) {\n    if (id === undefined || id === 0n) continue;\n    const target = store.get(id);\n    if (!target) {\n      if (\n        notification.primaryIdentifier === Number(id) ||\n        notification.secondaryIdentifier === Number(id) ||\n        notification.quoteId === Number(id)\n      ) {\n        return id;\n      }\n      continue;\n    }\n    if (notification.primaryIdentifier !== 0 && store.get(BigInt(notification.primaryIdentifier)) === target) return id;\n    if (notification.secondaryIdentifier !== 0 && store.get(BigInt(notification.secondaryIdentifier)) === target) {\n      return id;\n    }\n  }\n  return undefined;\n}\n\n/**\n * Learn the `tempQuoteId ↔ quoteId` pairing a frame carries, so both ids\n * resolve to the same store record from now on. No-op when the frame only\n * carries one identifier.\n *\n * @param notification - The normalized TP/SL frame.\n */\nexport function linkTpSlNotificationIds(notification: TpSlNotification): void {\n  if (notification.primaryIdentifier === 0 || notification.secondaryIdentifier === 0) return;\n  useTpSlStore.getState().link(BigInt(notification.primaryIdentifier), BigInt(notification.secondaryIdentifier));\n}\n"],"mappings":";;;AAqBA,SAAgB,EACd,GACA,GACoB;CACpB,IAAM,IAAQ,EAAa,SAAS;CACpC,KAAK,IAAM,KAAM,GAAK;EACpB,IAAI,MAAO,KAAA,KAAa,MAAO,IAAI;EACnC,IAAM,IAAS,EAAM,IAAI,CAAE;EAC3B,IAAI,CAAC,GAAQ;GACX,IACE,EAAa,sBAAsB,OAAO,CAAE,KAC5C,EAAa,wBAAwB,OAAO,CAAE,KAC9C,EAAa,YAAY,OAAO,CAAE,GAElC,OAAO;GAET;EACF;EAEA,IADI,EAAa,sBAAsB,KAAK,EAAM,IAAI,OAAO,EAAa,iBAAiB,CAAC,MAAM,KAC9F,EAAa,wBAAwB,KAAK,EAAM,IAAI,OAAO,EAAa,mBAAmB,CAAC,MAAM,GACpG,OAAO;CAEX;AAEF;AASA,SAAgB,EAAwB,GAAsC;CACxE,EAAa,sBAAsB,KAAK,EAAa,wBAAwB,KACjF,EAAa,SAAS,EAAE,KAAK,OAAO,EAAa,iBAAiB,GAAG,OAAO,EAAa,mBAAmB,CAAC;AAC/G"}

package/dist/tpsl/run-with-concurrency.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Run `worker` over `items` with at most `limit` in flight, preserving start
+ * order. A `limit` of `1` is a plain sequential loop.
+ *
+ * The worker is expected to swallow its own errors — this helper has no
+ * short-circuit on rejection, because one failed item must never abandon the
+ * rest (which is exactly what `Promise.all` over raw promises would do).
+ *
+ * `shouldStop` is the deliberate exception: it is consulted before each item is
+ * picked up, so a caller can abort the remaining work on a condition it decides
+ * (for example a wallet signature the user rejected — prompting again for every
+ * remaining item is worse than stopping).
+ *
+ * @param items - Work items.
+ * @param limit - Maximum concurrent workers. Values below `1` are treated as `1`.
+ * @param worker - Invoked once per item.
+ * @param shouldStop - Optional abort predicate, checked before each item starts.
+ */
+export declare function runWithConcurrency<T>(items: readonly T[], limit: number, worker: (item: T) => Promise<void>, shouldStop?: () => boolean): Promise<void>;
+//# sourceMappingURL=run-with-concurrency.d.ts.map

package/dist/tpsl/run-with-concurrency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-with-concurrency.d.ts","sourceRoot":"","sources":["../../src/tpsl/run-with-concurrency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,kBAAkB,CAAC,CAAC,EACxC,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC,IAAI,CAAC,EAClC,UAAU,CAAC,EAAE,MAAM,OAAO,GACzB,OAAO,CAAC,IAAI,CAAC,CAYf"}

package/dist/tpsl/run-with-concurrency.js

@@ -0,0 +1,15 @@
+//#region src/tpsl/run-with-concurrency.ts
+async function e(e, t, n, r) {
+	let i = Math.max(1, Math.trunc(t)), a = 0, o = Array.from({ length: Math.min(i, e.length) }, async () => {
+		for (; a < e.length;) {
+			if (r?.()) return;
+			let t = a;
+			a += 1, await n(e[t]);
+		}
+	});
+	await Promise.all(o);
+}
+//#endregion
+export { e as runWithConcurrency };
+
+//# sourceMappingURL=run-with-concurrency.js.map

package/dist/tpsl/run-with-concurrency.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-with-concurrency.js","names":[],"sources":["../../src/tpsl/run-with-concurrency.ts"],"sourcesContent":["/**\n * Run `worker` over `items` with at most `limit` in flight, preserving start\n * order. A `limit` of `1` is a plain sequential loop.\n *\n * The worker is expected to swallow its own errors — this helper has no\n * short-circuit on rejection, because one failed item must never abandon the\n * rest (which is exactly what `Promise.all` over raw promises would do).\n *\n * `shouldStop` is the deliberate exception: it is consulted before each item is\n * picked up, so a caller can abort the remaining work on a condition it decides\n * (for example a wallet signature the user rejected — prompting again for every\n * remaining item is worse than stopping).\n *\n * @param items - Work items.\n * @param limit - Maximum concurrent workers. Values below `1` are treated as `1`.\n * @param worker - Invoked once per item.\n * @param shouldStop - Optional abort predicate, checked before each item starts.\n */\nexport async function runWithConcurrency<T>(\n  items: readonly T[],\n  limit: number,\n  worker: (item: T) => Promise<void>,\n  shouldStop?: () => boolean,\n): Promise<void> {\n  const size = Math.max(1, Math.trunc(limit));\n  let cursor = 0;\n  const lanes = Array.from({ length: Math.min(size, items.length) }, async () => {\n    while (cursor < items.length) {\n      if (shouldStop?.()) return;\n      const index = cursor;\n      cursor += 1;\n      await worker(items[index]!);\n    }\n  });\n  await Promise.all(lanes);\n}\n"],"mappings":";AAkBA,eAAsB,EACpB,GACA,GACA,GACA,GACe;CACf,IAAM,IAAO,KAAK,IAAI,GAAG,KAAK,MAAM,CAAK,CAAC,GACtC,IAAS,GACP,IAAQ,MAAM,KAAK,EAAE,QAAQ,KAAK,IAAI,GAAM,EAAM,MAAM,EAAE,GAAG,YAAY;EAC7E,OAAO,IAAS,EAAM,SAAQ;GAC5B,IAAI,IAAa,GAAG;GACpB,IAAM,IAAQ;GAEd,AADA,KAAU,GACV,MAAM,EAAO,EAAM,EAAO;EAC5B;CACF,CAAC;CACD,MAAM,QAAQ,IAAI,CAAK;AACzB"}