@symmio/trading-react 1.1.0 → 3.0.0

package/dist/tpsl/settled-side.d.ts

@@ -0,0 +1,31 @@
+import { TpSlConditionalOrderType } from '@symmio/trading-core';
+import { TpSlRecord } from './tpsl-store.js';
+/**
+ * Whether the handler has acknowledged a **write** on this side — the shared
+ * store moved it out of the optimistic `confirming` / `pending` window into a
+ * live state.
+ *
+ * The store is fed by every TP/SL signal (any WebSocket subscription's
+ * `applyNotification`, and the success refetch's `setRows`), so a run step that
+ * reads it resolves no matter which signal delivered the update — even when the
+ * run hook's own subscription never received the frame.
+ *
+ * `"pending"` counts: the handler holds the order, which is what the write was
+ * waiting to learn, and it is one of the states the fallback sweep explicitly
+ * asks for. `"killed"` does not appear here because no signal can produce it —
+ * `toQuoteTpSl` maps a killed row to "no active order" and the frame parser has
+ * no such state.
+ */
+export declare function isWriteSideSettled(record: TpSlRecord, side: TpSlConditionalOrderType): boolean;
+/**
+ * Whether the handler has confirmed a **cancel** on this side — the store shows
+ * it gone.
+ *
+ * Keyed on `state === "canceled"` only, never on an empty trigger value: a
+ * blank/unseeded record also has an empty value, and that must not read as a
+ * confirmed cancel. Both real signals resolve here — the WebSocket `cancel`
+ * frame maps to `"canceled"`, and a post-cancel refetch that returns no rows
+ * folds (via `toQuoteTpSl`) to `"canceled"` too.
+ */
+export declare function isCancelSideSettled(record: TpSlRecord, side: TpSlConditionalOrderType): boolean;
+//# sourceMappingURL=settled-side.d.ts.map

package/dist/tpsl/settled-side.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settled-side.d.ts","sourceRoot":"","sources":["../../src/tpsl/settled-side.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAS/C;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,wBAAwB,GAAG,OAAO,CAG9F;AAED;;;;;;;;;GASG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,UAAU,EAAE,IAAI,EAAE,wBAAwB,GAAG,OAAO,CAE/F"}

package/dist/tpsl/settled-side.js

@@ -0,0 +1,21 @@
+//#region src/tpsl/settled-side.ts
+function e(e, t) {
+	return t === "take_profit" ? {
+		state: e.tpState,
+		value: e.tp
+	} : {
+		state: e.slState,
+		value: e.sl
+	};
+}
+function t(t, n) {
+	let { state: r } = e(t, n);
+	return r === "new" || r === "pending" || r === "triggered";
+}
+function n(t, n) {
+	return e(t, n).state === "canceled";
+}
+//#endregion
+export { n as isCancelSideSettled, t as isWriteSideSettled };
+
+//# sourceMappingURL=settled-side.js.map

package/dist/tpsl/settled-side.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settled-side.js","names":[],"sources":["../../src/tpsl/settled-side.ts"],"sourcesContent":["import type { TpSlConditionalOrderType } from \"@symmio/trading-core\";\nimport type { TpSlRecord } from \"./tpsl-store\";\n\n/** A side's confirmed lifecycle state and trigger value, off a folded record. */\nfunction sideOf(record: TpSlRecord, side: TpSlConditionalOrderType): { state: string; value: string } {\n  return side === \"take_profit\"\n    ? { state: record.tpState, value: record.tp }\n    : { state: record.slState, value: record.sl };\n}\n\n/**\n * Whether the handler has acknowledged a **write** on this side — the shared\n * store moved it out of the optimistic `confirming` / `pending` window into a\n * live state.\n *\n * The store is fed by every TP/SL signal (any WebSocket subscription's\n * `applyNotification`, and the success refetch's `setRows`), so a run step that\n * reads it resolves no matter which signal delivered the update — even when the\n * run hook's own subscription never received the frame.\n *\n * `\"pending\"` counts: the handler holds the order, which is what the write was\n * waiting to learn, and it is one of the states the fallback sweep explicitly\n * asks for. `\"killed\"` does not appear here because no signal can produce it —\n * `toQuoteTpSl` maps a killed row to \"no active order\" and the frame parser has\n * no such state.\n */\nexport function isWriteSideSettled(record: TpSlRecord, side: TpSlConditionalOrderType): boolean {\n  const { state } = sideOf(record, side);\n  return state === \"new\" || state === \"pending\" || state === \"triggered\";\n}\n\n/**\n * Whether the handler has confirmed a **cancel** on this side — the store shows\n * it gone.\n *\n * Keyed on `state === \"canceled\"` only, never on an empty trigger value: a\n * blank/unseeded record also has an empty value, and that must not read as a\n * confirmed cancel. Both real signals resolve here — the WebSocket `cancel`\n * frame maps to `\"canceled\"`, and a post-cancel refetch that returns no rows\n * folds (via `toQuoteTpSl`) to `\"canceled\"` too.\n */\nexport function isCancelSideSettled(record: TpSlRecord, side: TpSlConditionalOrderType): boolean {\n  return sideOf(record, side).state === \"canceled\";\n}\n"],"mappings":";AAIA,SAAS,EAAO,GAAoB,GAAkE;CACpG,OAAO,MAAS,gBACZ;EAAE,OAAO,EAAO;EAAS,OAAO,EAAO;CAAG,IAC1C;EAAE,OAAO,EAAO;EAAS,OAAO,EAAO;CAAG;AAChD;AAkBA,SAAgB,EAAmB,GAAoB,GAAyC;CAC9F,IAAM,EAAE,aAAU,EAAO,GAAQ,CAAI;CACrC,OAAO,MAAU,SAAS,MAAU,aAAa,MAAU;AAC7D;AAYA,SAAgB,EAAoB,GAAoB,GAAyC;CAC/F,OAAO,EAAO,GAAQ,CAAI,EAAE,UAAU;AACxC"}

package/dist/tpsl/tpsl-fallback-poll.d.ts

@@ -0,0 +1,74 @@
+import { Config } from '@symmio/trading-core';
+import { Address } from 'viem';
+import { TpSlWaitingSide } from './apply-tpsl-search-snapshot.js';
+/**
+ * How long the WebSocket report gets on its own before the sweep starts, in
+ * milliseconds.
+ *
+ * The sweep is a fallback, not a second opinion: while a report can still
+ * plausibly arrive, asking the handler adds load and answers nothing the socket
+ * was not about to say. A report that has not landed within this window is not
+ * coming, and only then is it worth reading the handler directly.
+ */
+export declare const TPSL_FALLBACK_POLL_DELAY_MS = 30000;
+/** Default cadence of the fallback sweep once it has started, in milliseconds. */
+export declare const TPSL_FALLBACK_POLL_INTERVAL_MS = 2000;
+/** A side the caller is waiting on, plus the account whose stream should report it. */
+export interface TpSlPollWaitingSide extends TpSlWaitingSide {
+    /** Virtual Account that owns the order — the handler's `party_a_address`. */
+    account: Address;
+}
+/** Parameters for {@link startTpSlFallbackPoll}. */
+export interface StartTpSlFallbackPollParameters {
+    /**
+     * The sides still awaiting confirmation, re-read on every tick and again
+     * when a response lands. Returning an empty list stops the sweep.
+     */
+    getWaiting: () => readonly TpSlPollWaitingSide[];
+    /** Chain override; defaults to the config's default chain. */
+    chainId?: number;
+    /**
+     * How long to leave the report alone before the first sweep. Defaults to
+     * {@link TPSL_FALLBACK_POLL_DELAY_MS}. `0` sweeps after one interval.
+     */
+    delayMs?: number;
+    /** Tick cadence after the first sweep. Defaults to {@link TPSL_FALLBACK_POLL_INTERVAL_MS}. `0` disables. */
+    intervalMs?: number;
+}
+/** Handle returned by {@link startTpSlFallbackPoll}. */
+export interface TpSlFallbackPoll {
+    /** Stop this lease. Idempotent; safe to call after the sweep already ended. */
+    stop: () => void;
+}
+/**
+ * Poll the TP/SL handler for the orders a run is waiting on, as a fallback for
+ * a WebSocket report that never arrives.
+ *
+ * One `POST /api/v5/search/` per distinct Virtual Account per tick — never one
+ * per leg — and results are folded into the shared TP/SL store, which is what
+ * both the run's waiter and every mounted cell reconcile against. Leases on the
+ * same `(config, chain, account)` share one loop and one in-flight request, so
+ * a set-run and a cancel-run confirming on the same account still cost one
+ * request between them.
+ *
+ * The sweep is single-flight (a tick that finds a request in flight reschedules
+ * rather than stacking), backs off exponentially on handler errors, and stops
+ * as soon as `getWaiting()` comes back empty — as well as on `stop()`.
+ *
+ * @param config - The SDK config; also the scope the loops are registered under.
+ * @param parameters - The waiting-side probe, chain override and cadence.
+ * @returns A handle whose `stop()` releases this lease.
+ *
+ * @example
+ * ```ts
+ * const poll = startTpSlFallbackPoll(config, {
+ *   getWaiting: () => waitingSidesOf(runRef.current.steps),
+ * });
+ * // later, when the run resolves:
+ * poll.stop();
+ * ```
+ */
+export declare function startTpSlFallbackPoll(config: Config, parameters: StartTpSlFallbackPollParameters): TpSlFallbackPoll;
+/** Tear down every sweep loop. Intended for tests only. */
+export declare function __resetTpSlFallbackPolls(config: Config): void;
+//# sourceMappingURL=tpsl-fallback-poll.d.ts.map

package/dist/tpsl/tpsl-fallback-poll.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tpsl-fallback-poll.d.ts","sourceRoot":"","sources":["../../src/tpsl/tpsl-fallback-poll.ts"],"names":[],"mappings":"AAAA,OAAO,EAAoB,KAAK,MAAM,EAAE,MAAM,sBAAsB,CAAC;AACrE,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,EAA2B,KAAK,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAE7F;;;;;;;;GAQG;AACH,eAAO,MAAM,2BAA2B,QAAS,CAAC;AAElD,kFAAkF;AAClF,eAAO,MAAM,8BAA8B,OAAQ,CAAC;AAQpD,uFAAuF;AACvF,MAAM,WAAW,mBAAoB,SAAQ,eAAe;IAC1D,6EAA6E;IAC7E,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,oDAAoD;AACpD,MAAM,WAAW,+BAA+B;IAC9C;;;OAGG;IACH,UAAU,EAAE,MAAM,SAAS,mBAAmB,EAAE,CAAC;IACjD,8DAA8D;IAC9D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4GAA4G;IAC5G,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,wDAAwD;AACxD,MAAM,WAAW,gBAAgB;IAC/B,+EAA+E;IAC/E,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB;AAmCD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,+BAA+B,GAAG,gBAAgB,CAgInH;AAED,2DAA2D;AAC3D,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAO7D"}

package/dist/tpsl/tpsl-fallback-poll.js

@@ -0,0 +1,101 @@
+import { applyTpSlSearchSnapshot as e } from "./apply-tpsl-search-snapshot.js";
+import { searchTpSlOrders as t } from "@symmio/trading-core";
+var n = 1e4, r = 3e4, i = /* @__PURE__ */ new WeakMap();
+function a(e) {
+	let t = i.get(e);
+	return t || (t = /* @__PURE__ */ new Map(), i.set(e, t)), t;
+}
+function o(i, o) {
+	let s = o.intervalMs ?? 2e3;
+	if (s <= 0) return { stop: () => {} };
+	let c = o.delayMs ?? 3e4, l = {
+		getWaiting: o.getWaiting,
+		delayMs: c,
+		intervalMs: s,
+		disposed: !1
+	}, u = a(i), d = /* @__PURE__ */ new Set(), f;
+	try {
+		f = i.getChainConfig(o.chainId).chainId;
+	} catch {
+		return { stop: () => {} };
+	}
+	function p(e) {
+		return `${f}:${e.toLowerCase()}`;
+	}
+	function m(e) {
+		let t = /* @__PURE__ */ new Map();
+		for (let n of e) t.set(p(n.account), n.account);
+		return t;
+	}
+	function h(e, t, n, r) {
+		e.timer === void 0 && (e.timer = setTimeout(() => {
+			e.timer = void 0, y(e, t, n);
+		}, r));
+	}
+	function g(e, t) {
+		e.timer !== void 0 && clearTimeout(e.timer), e.timer = void 0, u.delete(t);
+	}
+	function _(e, t) {
+		let n = [];
+		for (let r of e.leases) {
+			if (r.disposed) {
+				e.leases.delete(r);
+				continue;
+			}
+			for (let e of r.getWaiting()) p(e.account) === t && n.push(e);
+		}
+		return n;
+	}
+	function v(e) {
+		let t = Infinity;
+		for (let n of e.leases) n.disposed || (t = Math.min(t, n.intervalMs));
+		return Number.isFinite(t) ? t : s;
+	}
+	async function y(a, o, s) {
+		if (u.get(o) === a) {
+			if (a.leases.size === 0) return g(a, o);
+			if (a.inFlight) return h(a, o, s, v(a));
+			if (_(a, o).length === 0) return g(a, o);
+			a.inFlight = !0;
+			try {
+				let r = await t(i, {
+					account: s,
+					chainId: f,
+					timeoutMs: n
+				});
+				a.failures = 0, e(_(a, o), r);
+			} catch {
+				a.failures += 1;
+			} finally {
+				a.inFlight = !1;
+			}
+			if (u.get(o) === a) {
+				if (_(a, o).length === 0) return g(a, o);
+				h(a, o, s, a.failures === 0 ? v(a) : Math.min(v(a) * 2 ** a.failures, r));
+			}
+		}
+	}
+	for (let [e, t] of m(o.getWaiting())) {
+		let n = u.get(e);
+		n || (n = {
+			timer: void 0,
+			inFlight: !1,
+			failures: 0,
+			leases: /* @__PURE__ */ new Set()
+		}, u.set(e, n)), n.leases.add(l), d.add(e), h(n, e, t, Math.max(l.delayMs, l.intervalMs));
+	}
+	return { stop: () => {
+		if (!l.disposed) {
+			l.disposed = !0;
+			for (let e of d) {
+				let t = u.get(e);
+				t && (t.leases.delete(l), t.leases.size === 0 && g(t, e));
+			}
+			d.clear();
+		}
+	} };
+}
+//#endregion
+export { o as startTpSlFallbackPoll };
+
+//# sourceMappingURL=tpsl-fallback-poll.js.map

package/dist/tpsl/tpsl-fallback-poll.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tpsl-fallback-poll.js","names":[],"sources":["../../src/tpsl/tpsl-fallback-poll.ts"],"sourcesContent":["import { searchTpSlOrders, type Config } from \"@symmio/trading-core\";\nimport type { Address } from \"viem\";\nimport { applyTpSlSearchSnapshot, type TpSlWaitingSide } from \"./apply-tpsl-search-snapshot\";\n\n/**\n * How long the WebSocket report gets on its own before the sweep starts, in\n * milliseconds.\n *\n * The sweep is a fallback, not a second opinion: while a report can still\n * plausibly arrive, asking the handler adds load and answers nothing the socket\n * was not about to say. A report that has not landed within this window is not\n * coming, and only then is it worth reading the handler directly.\n */\nexport const TPSL_FALLBACK_POLL_DELAY_MS = 30_000;\n\n/** Default cadence of the fallback sweep once it has started, in milliseconds. */\nexport const TPSL_FALLBACK_POLL_INTERVAL_MS = 2_000;\n\n/** How long one sweep may take before it counts as a failed tick. */\nconst REQUEST_TIMEOUT_MS = 10_000;\n\n/** Backoff ceiling — a handler that keeps failing is polled every 30s, not every 2s. */\nconst MAX_BACKOFF_MS = 30_000;\n\n/** A side the caller is waiting on, plus the account whose stream should report it. */\nexport interface TpSlPollWaitingSide extends TpSlWaitingSide {\n  /** Virtual Account that owns the order — the handler's `party_a_address`. */\n  account: Address;\n}\n\n/** Parameters for {@link startTpSlFallbackPoll}. */\nexport interface StartTpSlFallbackPollParameters {\n  /**\n   * The sides still awaiting confirmation, re-read on every tick and again\n   * when a response lands. Returning an empty list stops the sweep.\n   */\n  getWaiting: () => readonly TpSlPollWaitingSide[];\n  /** Chain override; defaults to the config's default chain. */\n  chainId?: number;\n  /**\n   * How long to leave the report alone before the first sweep. Defaults to\n   * {@link TPSL_FALLBACK_POLL_DELAY_MS}. `0` sweeps after one interval.\n   */\n  delayMs?: number;\n  /** Tick cadence after the first sweep. Defaults to {@link TPSL_FALLBACK_POLL_INTERVAL_MS}. `0` disables. */\n  intervalMs?: number;\n}\n\n/** Handle returned by {@link startTpSlFallbackPoll}. */\nexport interface TpSlFallbackPoll {\n  /** Stop this lease. Idempotent; safe to call after the sweep already ended. */\n  stop: () => void;\n}\n\n/** One account's sweep loop, shared by every lease that wants that account. */\ninterface Hub {\n  timer: ReturnType<typeof setTimeout> | undefined;\n  inFlight: boolean;\n  failures: number;\n  leases: Set<Lease>;\n}\n\ninterface Lease {\n  getWaiting: () => readonly TpSlPollWaitingSide[];\n  delayMs: number;\n  intervalMs: number;\n  disposed: boolean;\n}\n\n/**\n * Sweep loops, scoped to a `Config` rather than to the module.\n *\n * Mirrors core's socket pool: a `WeakMap` keyed on the config means loops never\n * leak across config instances and die with the config that owns them, instead\n * of living in an app-wide singleton.\n */\nconst registries = new WeakMap<Config, Map<string, Hub>>();\n\nfunction registryOf(config: Config): Map<string, Hub> {\n  let registry = registries.get(config);\n  if (!registry) {\n    registry = new Map();\n    registries.set(config, registry);\n  }\n  return registry;\n}\n\n/**\n * Poll the TP/SL handler for the orders a run is waiting on, as a fallback for\n * a WebSocket report that never arrives.\n *\n * One `POST /api/v5/search/` per distinct Virtual Account per tick — never one\n * per leg — and results are folded into the shared TP/SL store, which is what\n * both the run's waiter and every mounted cell reconcile against. Leases on the\n * same `(config, chain, account)` share one loop and one in-flight request, so\n * a set-run and a cancel-run confirming on the same account still cost one\n * request between them.\n *\n * The sweep is single-flight (a tick that finds a request in flight reschedules\n * rather than stacking), backs off exponentially on handler errors, and stops\n * as soon as `getWaiting()` comes back empty — as well as on `stop()`.\n *\n * @param config - The SDK config; also the scope the loops are registered under.\n * @param parameters - The waiting-side probe, chain override and cadence.\n * @returns A handle whose `stop()` releases this lease.\n *\n * @example\n * ```ts\n * const poll = startTpSlFallbackPoll(config, {\n *   getWaiting: () => waitingSidesOf(runRef.current.steps),\n * });\n * // later, when the run resolves:\n * poll.stop();\n * ```\n */\nexport function startTpSlFallbackPoll(config: Config, parameters: StartTpSlFallbackPollParameters): TpSlFallbackPoll {\n  const intervalMs = parameters.intervalMs ?? TPSL_FALLBACK_POLL_INTERVAL_MS;\n  if (intervalMs <= 0) return { stop: () => {} };\n  const delayMs = parameters.delayMs ?? TPSL_FALLBACK_POLL_DELAY_MS;\n\n  const lease: Lease = { getWaiting: parameters.getWaiting, delayMs, intervalMs, disposed: false };\n  const registry = registryOf(config);\n  /** Hubs this lease joined, so `stop()` releases exactly those. */\n  const joined = new Set<string>();\n\n  /**\n   * Resolve the chain once, so a caller that passes it explicitly and one that\n   * omits it land on the same hub instead of opening two loops.\n   */\n  let chainId: number;\n  try {\n    chainId = config.getChainConfig(parameters.chainId).chainId;\n  } catch {\n    // An unconfigured chain can never answer; there is nothing to poll.\n    return { stop: () => {} };\n  }\n\n  function hubKeyFor(account: Address): string {\n    return `${chainId}:${account.toLowerCase()}`;\n  }\n\n  /** The accounts this lease currently needs, deduped. */\n  function accountsOf(sides: readonly TpSlPollWaitingSide[]): Map<string, Address> {\n    const accounts = new Map<string, Address>();\n    for (const side of sides) accounts.set(hubKeyFor(side.account), side.account);\n    return accounts;\n  }\n\n  function schedule(hub: Hub, key: string, account: Address, delayMs: number): void {\n    if (hub.timer !== undefined) return;\n    hub.timer = setTimeout(() => {\n      hub.timer = undefined;\n      void tick(hub, key, account);\n    }, delayMs);\n  }\n\n  function stopHub(hub: Hub, key: string): void {\n    if (hub.timer !== undefined) clearTimeout(hub.timer);\n    hub.timer = undefined;\n    registry.delete(key);\n  }\n\n  /** The union of every live lease's waiting sides for one account. */\n  function waitingFor(hub: Hub, key: string): TpSlPollWaitingSide[] {\n    const sides: TpSlPollWaitingSide[] = [];\n    for (const entry of hub.leases) {\n      if (entry.disposed) {\n        hub.leases.delete(entry);\n        continue;\n      }\n      for (const side of entry.getWaiting()) {\n        if (hubKeyFor(side.account) === key) sides.push(side);\n      }\n    }\n    return sides;\n  }\n\n  /** The shortest cadence any live lease asked for. */\n  function cadenceOf(hub: Hub): number {\n    let cadence = Number.POSITIVE_INFINITY;\n    for (const entry of hub.leases) {\n      if (!entry.disposed) cadence = Math.min(cadence, entry.intervalMs);\n    }\n    return Number.isFinite(cadence) ? cadence : intervalMs;\n  }\n\n  async function tick(hub: Hub, key: string, account: Address): Promise<void> {\n    if (registry.get(key) !== hub) return;\n    if (hub.leases.size === 0) return stopHub(hub, key);\n    if (hub.inFlight) return schedule(hub, key, account, cadenceOf(hub));\n\n    const wanted = waitingFor(hub, key);\n    if (wanted.length === 0) return stopHub(hub, key);\n\n    hub.inFlight = true;\n    try {\n      const snapshot = await searchTpSlOrders(config, { account, chainId, timeoutMs: REQUEST_TIMEOUT_MS });\n      hub.failures = 0;\n      // Re-read the waiting set: a WebSocket frame may have settled these sides\n      // while the request was in flight, and a response must never speak for a\n      // side that is no longer confirming.\n      applyTpSlSearchSnapshot(waitingFor(hub, key), snapshot);\n    } catch {\n      hub.failures += 1;\n    } finally {\n      hub.inFlight = false;\n    }\n\n    if (registry.get(key) !== hub) return;\n    if (waitingFor(hub, key).length === 0) return stopHub(hub, key);\n    const backoff = hub.failures === 0 ? cadenceOf(hub) : Math.min(cadenceOf(hub) * 2 ** hub.failures, MAX_BACKOFF_MS);\n    schedule(hub, key, account, backoff);\n  }\n\n  for (const [key, account] of accountsOf(parameters.getWaiting())) {\n    let hub = registry.get(key);\n    if (!hub) {\n      hub = { timer: undefined, inFlight: false, failures: 0, leases: new Set() };\n      registry.set(key, hub);\n    }\n    hub.leases.add(lease);\n    joined.add(key);\n    /**\n     * The first sweep waits out `delayMs` — the window the report owns. A hub\n     * another lease already armed keeps its schedule; whichever lease got there\n     * first set the clock.\n     */\n    schedule(hub, key, account, Math.max(lease.delayMs, lease.intervalMs));\n  }\n\n  return {\n    stop: () => {\n      if (lease.disposed) return;\n      lease.disposed = true;\n      for (const key of joined) {\n        const hub = registry.get(key);\n        if (!hub) continue;\n        hub.leases.delete(lease);\n        if (hub.leases.size === 0) stopHub(hub, key);\n      }\n      joined.clear();\n    },\n  };\n}\n\n/** Tear down every sweep loop. Intended for tests only. */\nexport function __resetTpSlFallbackPolls(config: Config): void {\n  const registry = registries.get(config);\n  if (!registry) return;\n  for (const [key, hub] of registry) {\n    if (hub.timer !== undefined) clearTimeout(hub.timer);\n    registry.delete(key);\n  }\n}\n"],"mappings":"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"}

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

@@ -1,4 +1,45 @@
 import { QuoteTpSlRow, TpSlInfoState, TpSlNotification, TpSlPriceType } from '@symmio/trading-core';
+/**
+ * How long a `"confirming"` write survives a REST snapshot that does not list
+ * it yet, in milliseconds.
+ *
+ * A refetch issued right after a POST routinely lands before the handler has
+ * registered the order. Without this window the empty snapshot would fold to
+ * `"canceled"` and erase the price the trader just set, so the side holds its
+ * `"confirming"` state until a report arrives, the rows list it, or the window
+ * closes.
+ *
+ * Deliberately longer than `DEFAULT_TPSL_CONFIRMATION_TIMEOUT_MS`: a grouped
+ * run must reach its own deadline and release the guard itself, rather than
+ * having the guard expire underneath it. This is the backstop for every other
+ * caller, which has no deadline of its own.
+ */
+export declare const TPSL_CONFIRMING_GUARD_MS = 90000;
+/** What a side is waiting for while it is `"confirming"`, and since when. */
+export interface TpSlConfirmation {
+    /** `"write"` — an order was submitted. `"cancel"` — a live order was cancelled. */
+    intent: "write" | "cancel";
+    /** Epoch milliseconds the side entered `"confirming"`. */
+    at: number;
+    /** Trigger price the write submitted — the evidence a snapshot must show. */
+    price?: string;
+    /**
+     * Market price precision the write was signed at.
+     *
+     * The handler is sent — and stores — the trigger price rounded to this many
+     * decimals, so a seed carrying more of them describes the same order. Without
+     * it, a trader who types `0.00693` into a 4-decimal market would never see
+     * their write confirmed: the rows come back `0.0069` and no comparison of the
+     * two raw strings can tell "rounded" from "different".
+     */
+    pricePrecision?: number;
+    /** Price type the write submitted. */
+    priceType?: TpSlPriceType;
+    /** Handler-issued id the write was told to expect, when the POST returned one. */
+    cohQuoteId?: string;
+}
+/** One side of a quote's TP/SL record. */
+export type TpSlSideKey = "tp" | "sl";
 /**
  * One quote's folded TP/SL state. The same record instance is referenced from
  * every id that resolves to it via {@link TpSlStoreState.index} — the caller
@@ -24,6 +65,10 @@ export interface TpSlRecord {
     slState: TpSlInfoState;
     tpCohQuoteId?: string;
     slCohQuoteId?: string;
+    /** Set while `tpState` is `"confirming"`; cleared as soon as the side resolves. */
+    tpConfirm?: TpSlConfirmation;
+    /** Set while `slState` is `"confirming"`; cleared as soon as the side resolves. */
+    slConfirm?: TpSlConfirmation;
 }
 /** Internal identity of a record — opaque string, never leaks to consumers. */
 type TpSlRecordKey = string;
@@ -37,20 +82,59 @@ export interface TpSlStoreState {
     index: Map<bigint, TpSlRecordKey>;
     /** Read a record via any id. Returns `undefined` when the id is unknown. */
     get(id: bigint): TpSlRecord | undefined;
-    /** Fold the raw handler rows into snapshot fields and commit under `id`. */
+    /**
+     * Fold the raw handler rows for **one quote** into snapshot fields and commit
+     * under `id`, then alias the rows' `quote_id` onto the same record.
+     *
+     * A side left `"confirming"` by a `"write"` is held rather than cleared until
+     * the rows show the submitted order — see {@link TPSL_CONFIRMING_GUARD_MS}.
+     * A `"cancel"` is confirmed by absence, so an authoritative snapshot still
+     * resolves both intents.
+     *
+     * Pass only one quote's rows. An account-wide page would alias a foreign
+     * `quote_id` onto this record and merge two legs into one — use
+     * {@link setRowsForSides} for those.
+     */
     setRows(id: bigint, rows: QuoteTpSlRow[]): void;
+    /**
+     * {@link setRows} restricted to `sides`, and without the `quote_id` aliasing.
+     *
+     * The entry point for a snapshot whose authority is partial — an
+     * account-scoped search that this caller only trusts for the sides it is
+     * waiting on. Sides outside `sides` are left exactly as they were, so a page
+     * that lags on an unrelated side cannot blank a live order.
+     */
+    setRowsForSides(id: bigint, rows: QuoteTpSlRow[], sides: readonly TpSlSideKey[]): void;
     /**
      * Mark a side as "POST accepted, awaiting handler acknowledgement". Sets
      * `tpState` / `slState` to `"confirming"` directly. Optional `patch`
      * seeds the trigger price / priceType / cohQuoteId so the UI can show
      * the target value during the confirming window; a later
      * {@link applyNotification} transitions the state to the wire report.
+     *
+     * `patch.intent` says what the side is waiting for — default `"write"`.
+     * Cancels must pass `"cancel"`, otherwise the write guard in
+     * {@link setRows} would keep holding a side the handler has already removed.
+     *
+     * A write's `price` / `priceType` / `cohQuoteId` are also kept as the
+     * evidence a later snapshot must show before the side counts as confirmed,
+     * so a stale row cannot settle an edit that never landed.
      */
-    markConfirming(id: bigint, side: "tp" | "sl", patch?: {
+    markConfirming(id: bigint, side: TpSlSideKey, patch?: {
         price?: string;
+        pricePrecision?: number;
         priceType?: TpSlPriceType;
         cohQuoteId?: string;
+        intent?: TpSlConfirmation["intent"];
     }): void;
+    /**
+     * Drop a side's confirmation guard without touching its rendered state, so
+     * the next {@link setRows} writes the handler's rows through unheld.
+     *
+     * Called when a run gives up waiting for the report: the REST snapshot — even
+     * an empty one — becomes the truth again.
+     */
+    clearConfirming(id: bigint, side: TpSlSideKey): void;
     /**
      * Apply a WS notification to the record's side state (and optionally its
      * trigger price when `details.trigger_price` is present). Maps the raw
@@ -78,6 +162,18 @@ export declare const useTpSlStore: import('zustand').UseBoundStore<import('zusta
  * another id linked to the same record).
  */
 export declare function useTpSlRecord(id: bigint | undefined): TpSlRecord | undefined;
+/**
+ * Selector hook: subscribe to the records addressed by `ids`, in input order.
+ * The grouped counterpart of {@link useTpSlRecord} — one subscription for N
+ * children, which a `.map` over children could not do legally anyway.
+ *
+ * Shallow-compared, so an unrelated record's update does not re-render the
+ * group. Pass a stable `ids` array (memoize it) to avoid recomputing per render.
+ *
+ * @param ids - Quote ids, on-chain or temp. `undefined` entries yield `undefined`.
+ * @returns One record (or `undefined`) per input id, in the same order.
+ */
+export declare function useTpSlRecords(ids: readonly (bigint | undefined)[]): Array<TpSlRecord | undefined>;
 /** Reset the store — intended for tests only. */
 export declare function __resetTpSlStore(): void;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"tpsl-store.d.ts","sourceRoot":"","sources":["../../src/tpsl/tpsl-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,YAAY,EAEZ,aAAa,EACb,gBAAgB,EAChB,aAAa,EACd,MAAM,sBAAsB,CAAC;AAI9B;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,aAAa,CAAC;IAC3B,WAAW,EAAE,aAAa,CAAC;IAC3B,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,+EAA+E;AAC/E,KAAK,aAAa,GAAG,MAAM,CAAC;AAE5B;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,GAAG,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;IACxC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAElC,4EAA4E;IAC5E,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;IAExC,4EAA4E;IAC5E,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC;IAEhD;;;;;;OAMG;IACH,cAAc,CACZ,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,IAAI,GAAG,IAAI,EACjB,KAAK,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,aAAa,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE,GACzE,IAAI,CAAC;IAER;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAEpE;;;;OAIG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAoCD;;;;GAIG;AACH,eAAO,MAAM,YAAY,6EA4LvB,CAAC;AAEH;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAM5E;AAED,iDAAiD;AACjD,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC"}
+{"version":3,"file":"tpsl-store.d.ts","sourceRoot":"","sources":["../../src/tpsl/tpsl-store.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,YAAY,EAEZ,aAAa,EACb,gBAAgB,EAChB,aAAa,EACd,MAAM,sBAAsB,CAAC;AAK9B;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,wBAAwB,QAAS,CAAC;AAE/C,6EAA6E;AAC7E,MAAM,WAAW,gBAAgB;IAC/B,mFAAmF;IACnF,MAAM,EAAE,OAAO,GAAG,QAAQ,CAAC;IAC3B,0DAA0D;IAC1D,EAAE,EAAE,MAAM,CAAC;IACX,6EAA6E;IAC7E,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;;;;;;OAQG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,sCAAsC;IACtC,SAAS,CAAC,EAAE,aAAa,CAAC;IAC1B,kFAAkF;IAClF,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,0CAA0C;AAC1C,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,IAAI,CAAC;AAYtC;;;;;;;;;GASG;AACH,MAAM,WAAW,UAAU;IACzB,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,8DAA8D;IAC9D,WAAW,CAAC,EAAE,MAAM,CAAC;IAErB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,aAAa,CAAC;IAC3B,WAAW,EAAE,aAAa,CAAC;IAC3B,OAAO,EAAE,aAAa,CAAC;IACvB,OAAO,EAAE,aAAa,CAAC;IACvB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,mFAAmF;IACnF,SAAS,CAAC,EAAE,gBAAgB,CAAC;IAC7B,mFAAmF;IACnF,SAAS,CAAC,EAAE,gBAAgB,CAAC;CAC9B;AAED,+EAA+E;AAC/E,KAAK,aAAa,GAAG,MAAM,CAAC;AAE5B;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,OAAO,EAAE,GAAG,CAAC,aAAa,EAAE,UAAU,CAAC,CAAC;IACxC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAElC,4EAA4E;IAC5E,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAAC;IAExC;;;;;;;;;;;;OAYG;IACH,OAAO,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,GAAG,IAAI,CAAC;IAEhD;;;;;;;OAOG;IACH,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,KAAK,EAAE,SAAS,WAAW,EAAE,GAAG,IAAI,CAAC;IAEvF;;;;;;;;;;;;;;OAcG;IACH,cAAc,CACZ,EAAE,EAAE,MAAM,EACV,IAAI,EAAE,WAAW,EACjB,KAAK,CAAC,EAAE;QACN,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,SAAS,CAAC,EAAE,aAAa,CAAC;QAC1B,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,MAAM,CAAC,EAAE,gBAAgB,CAAC,QAAQ,CAAC,CAAC;KACrC,GACA,IAAI,CAAC;IAER;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC;IAErD;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,EAAE,MAAM,EAAE,YAAY,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAEpE;;;;OAIG;IACH,IAAI,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAClC;AAkKD;;;;GAIG;AACH,eAAO,MAAM,YAAY,6EA8NvB,CAAC;AAEH;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,MAAM,GAAG,SAAS,GAAG,UAAU,GAAG,SAAS,CAM5E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,GAAG,KAAK,CAAC,UAAU,GAAG,SAAS,CAAC,CAUlG;AAED,iDAAiD;AACjD,wBAAgB,gBAAgB,IAAI,IAAI,CAEvC"}