@agg-build/hooks 4.26.0 → 4.27.0

package/dist/withdraw--f5kYKJA.mjs

@@ -0,0 +1,1474 @@
+import { S as shouldInvalidateBalancesForOrderEvent, _ as invalidateBalanceQueries, c as useAggBalanceState, d as useAggUiConfig, l as useAggClient, r as useDepositAddresses, t as useSyncBalances, v as invalidatePositionQueries, w as executionKeys, x as invalidateUserMoneyState, y as invalidateUserActivityQueries } from "./use-sync-balances-BkcqInJh.mjs";
+import { CandleBuilder } from "@agg-build/sdk";
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, useSyncExternalStore } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region src/candle-store.ts
+const MAX_BUILDERS = 60;
+const builders = /* @__PURE__ */ new Map();
+/**
+* LRU-bounded store for per-market CandleBuilders.
+* Fed from WS provider (onDelta/onSnapshot/onTrade).
+* Read from useLiveCandles and SDK-only partners.
+*/
+function getOrCreateBuilder(marketId) {
+	const existing = builders.get(marketId);
+	if (existing) {
+		builders.delete(marketId);
+		builders.set(marketId, existing);
+		return existing;
+	}
+	evict();
+	const builder = new CandleBuilder();
+	builders.set(marketId, builder);
+	return builder;
+}
+function getBuilder(marketId) {
+	return builders.get(marketId);
+}
+function resetAllBuilders() {
+	for (const builder of builders.values()) builder.reset();
+}
+function evict() {
+	if (builders.size < MAX_BUILDERS) return;
+	const oldest = builders.keys().next().value;
+	if (oldest) {
+		builders.get(oldest)?.dispose();
+		builders.delete(oldest);
+	}
+}
+/** On-demand counts only; no candle arrays escape through diagnostics. */
+function getCandleStoreDiagnostics() {
+	return {
+		builders: builders.size,
+		retainedCandles: [...builders.values()].reduce((total, builder) => total + [
+			"1m",
+			"5m",
+			"1h",
+			"1d"
+		].reduce((count, interval) => count + builder.getClosed(interval).length + (builder.getForming(interval) ? 1 : 0), 0), 0),
+		maxBuilders: MAX_BUILDERS
+	};
+}
+//#endregion
+//#region src/market-data/live-cache.ts
+const MAX_TRADES = 50;
+const createMarketLiveState = (marketId, overrides) => ({
+	marketId,
+	orderbook: null,
+	orderbookSnapshotVersion: 0,
+	orderbookError: null,
+	trades: [],
+	isConnected: false,
+	integrity: "ok",
+	...overrides
+});
+const withLiveOrderbook = (data, orderbook, source) => {
+	const current = data ?? createMarketLiveState(orderbook.marketId);
+	return {
+		...current,
+		orderbook,
+		orderbookSnapshotVersion: source === "snapshot" ? current.orderbookSnapshotVersion + 1 : current.orderbookSnapshotVersion,
+		orderbookError: null,
+		integrity: "ok"
+	};
+};
+const withLiveOrderbookError = (data, marketId, orderbookError) => {
+	const current = data ?? createMarketLiveState(marketId);
+	if (current.orderbookError === orderbookError && current.marketId === marketId) return current;
+	return {
+		...current,
+		marketId,
+		orderbookError
+	};
+};
+const withLiveIntegrity = (data, integrity) => {
+	if (!data) return data;
+	if (data.integrity === integrity) return data;
+	return {
+		...data,
+		integrity
+	};
+};
+const withLiveTrade = (data, trade) => {
+	const current = data ?? createMarketLiveState(trade.outcomeId);
+	const trades = [trade, ...current.trades].slice(0, MAX_TRADES);
+	return {
+		...current,
+		trades
+	};
+};
+//#endregion
+//#region src/market-data/query-keys.ts
+const marketDataKeys = {
+	all: () => ["market-data"],
+	live: (marketId) => [
+		"market-data",
+		"live",
+		marketId
+	],
+	livePrefix: () => ["market-data", "live"],
+	orderbook: (marketId, selectionKey, depth) => [
+		"market-data",
+		"orderbook",
+		marketId,
+		selectionKey ?? null,
+		depth ?? null
+	],
+	orderbookPrefix: (marketId) => marketId == null ? ["market-data", "orderbook"] : [
+		"market-data",
+		"orderbook",
+		marketId
+	],
+	orderbookQuote: (marketId, side, size) => [
+		"market-data",
+		"orderbook-quote",
+		marketId,
+		side,
+		size
+	],
+	/**
+	* Stable per `{marketId, interval, rangeKey}`. Deliberately excludes the
+	* concrete `startTs`/`endTs` of the rolling window — those advance every
+	* candle bucket, and including them would mint a fresh key on every
+	* rollover, defeating React Query's cache on tab/page revisits. The
+	* current window is passed to `queryFn` via closure instead, and
+	* `refetchInterval` advances the data under the stable key.
+	*/
+	chart: (marketId, interval, rangeKey, countBack) => [
+		"market-data",
+		"chart",
+		marketId,
+		interval,
+		rangeKey,
+		countBack ?? null
+	],
+	chartPrefix: (marketId, interval) => {
+		if (!marketId) return ["market-data", "chart"];
+		if (!interval) return [
+			"market-data",
+			"chart",
+			marketId
+		];
+		return [
+			"market-data",
+			"chart",
+			marketId,
+			interval
+		];
+	}
+};
+//#endregion
+//#region src/market-data/live-store.ts
+const LIVE_RETENTION = {
+	maxInactiveSnapshots: 32,
+	maxInactiveLevels: 16384,
+	inactiveTtlMs: 5e3,
+	maxEntries: 300
+};
+const levelEntries = (state) => {
+	const book = state.orderbook;
+	return book ? (book.bids?.length ?? 0) + (book.asks?.length ?? 0) + Object.values(book.venueOrderbooks ?? {}).reduce((n, venue) => n + venue.bids.length + venue.asks.length, 0) : 0;
+};
+const hasSnapshot = (state) => !!state.orderbook || !!state.candles || state.trades.length > 0;
+/** Stable per-outcome snapshots; inactive depth is bounded separately from active subscribers. */
+var MarketLiveStore = class {
+	constructor(seed) {
+		this.seed = seed;
+		this.connectionState = false;
+		this.connectionGeneration = 0;
+		this.states = /* @__PURE__ */ new Map();
+		this.listeners = /* @__PURE__ */ new Map();
+		this.touched = /* @__PURE__ */ new Map();
+		this.needsPrune = false;
+	}
+	ensure(id) {
+		let state = this.states.get(id);
+		if (state && !this.listeners.has(id) && Date.now() - (this.touched.get(id) ?? 0) >= LIVE_RETENTION.inactiveTtlMs) {
+			this.drop(id);
+			state = void 0;
+		}
+		if (!state) {
+			const seed = this.seed?.(id);
+			state = {
+				...createMarketLiveState(id, {
+					isConnected: this.connectionState,
+					...seed
+				}),
+				connectionGeneration: this.connectionGeneration,
+				orderbookGeneration: seed?.orderbook ? -1 : this.connectionGeneration
+			};
+			this.states.set(id, state);
+			this.touched.set(id, Date.now());
+			this.needsPrune = true;
+		}
+		return state;
+	}
+	get(id) {
+		const state = this.ensure(id);
+		this.touched.set(id, Date.now());
+		if (this.needsPrune) this.prune(/* @__PURE__ */ new Set([id]));
+		return state;
+	}
+	/** Read retained data without creating a state, keeping it alive, or observing updates. */
+	peek(id) {
+		if (!this.listeners.has(id) && Date.now() - (this.touched.get(id) ?? 0) >= LIVE_RETENTION.inactiveTtlMs) return void 0;
+		return this.states.get(id);
+	}
+	/** Protect a render's whole selection before useSyncExternalStore subscribes. */
+	getMany(ids) {
+		const result = ids.map((id) => {
+			const state = this.ensure(id);
+			this.touched.set(id, Date.now());
+			return state;
+		});
+		if (this.needsPrune) this.prune(new Set(ids));
+		return result;
+	}
+	update(id, updater) {
+		const previous = this.ensure(id);
+		const next = updater(previous);
+		if (!next || next === previous) return;
+		const bookChanged = next.orderbook && (!previous.orderbook || next.orderbook.seq !== previous.orderbook.seq || next.orderbook.checksum !== previous.orderbook.checksum || next.orderbook.timestamp !== previous.orderbook.timestamp || next.orderbookSnapshotVersion !== previous.orderbookSnapshotVersion);
+		this.states.set(id, bookChanged ? {
+			...next,
+			orderbookGeneration: this.connectionGeneration
+		} : next);
+		if (bookChanged || next.candles !== previous.candles || next.trades !== previous.trades) this.touched.set(id, Date.now());
+		for (const listener of this.listeners.get(id) ?? []) listener();
+		if (!this.listeners.has(id) || this.needsPrune) this.prune(/* @__PURE__ */ new Set([id]));
+	}
+	connected(connected) {
+		if (connected && !this.connectionState) this.connectionGeneration++;
+		this.connectionState = connected;
+		for (const id of [...this.states.keys()]) this.update(id, (state) => state.isConnected === connected && state.connectionGeneration === this.connectionGeneration ? state : {
+			...state,
+			isConnected: connected,
+			connectionGeneration: this.connectionGeneration,
+			...connected ? {} : { candles: void 0 }
+		});
+	}
+	subscribe(ids, listener) {
+		for (const id of ids) {
+			const set = this.listeners.get(id) ?? /* @__PURE__ */ new Set();
+			set.add(listener);
+			this.listeners.set(id, set);
+			this.touched.set(id, Date.now());
+		}
+		return () => {
+			for (const id of ids) {
+				const set = this.listeners.get(id);
+				set?.delete(listener);
+				if (!set?.size) {
+					this.listeners.delete(id);
+					this.touched.set(id, Date.now());
+				}
+			}
+			this.prune();
+		};
+	}
+	getDiagnostics() {
+		const inactive = [...this.states].filter(([id]) => !this.listeners.has(id));
+		return {
+			entries: this.states.size,
+			activeEntries: this.listeners.size,
+			cachedBooks: [...this.states.values()].filter((state) => state.orderbook).length,
+			cachedLevelEntries: [...this.states.values()].reduce((n, state) => n + levelEntries(state), 0),
+			inactiveSnapshots: inactive.filter(([, state]) => hasSnapshot(state)).length,
+			inactiveLevelEntries: inactive.reduce((n, [, state]) => n + levelEntries(state), 0),
+			limits: LIVE_RETENTION
+		};
+	}
+	drop(id) {
+		this.states.delete(id);
+		this.touched.delete(id);
+	}
+	prune(protectedIds = /* @__PURE__ */ new Set()) {
+		this.needsPrune = false;
+		if (this.timer) clearTimeout(this.timer);
+		this.timer = void 0;
+		const now = Date.now();
+		const inactive = [...this.states].filter(([id]) => !this.listeners.has(id) && !protectedIds.has(id)).sort(([a], [b]) => (this.touched.get(a) ?? 0) - (this.touched.get(b) ?? 0));
+		let count = inactive.filter(([, state]) => hasSnapshot(state)).length;
+		let levels = inactive.reduce((n, [, state]) => n + levelEntries(state), 0);
+		for (const [id, state] of inactive) if (now - (this.touched.get(id) ?? 0) >= LIVE_RETENTION.inactiveTtlMs || this.states.size > LIVE_RETENTION.maxEntries || count > LIVE_RETENTION.maxInactiveSnapshots || levels > LIVE_RETENTION.maxInactiveLevels) {
+			if (hasSnapshot(state)) count--;
+			levels -= levelEntries(state);
+			this.drop(id);
+		}
+		let nextExpiry = Infinity;
+		for (const id of this.states.keys()) if (!this.listeners.has(id)) nextExpiry = Math.min(nextExpiry, (this.touched.get(id) ?? now) + LIVE_RETENTION.inactiveTtlMs);
+		if (Number.isFinite(nextExpiry)) this.timer = setTimeout(() => {
+			this.timer = void 0;
+			this.prune();
+		}, Math.max(1, nextExpiry - now));
+	}
+};
+const stores = /* @__PURE__ */ new WeakMap();
+function getMarketLiveStore(client) {
+	let store = stores.get(client);
+	if (!store) {
+		store = new MarketLiveStore((id) => client.getQueryData?.(marketDataKeys.live(id)));
+		stores.set(client, store);
+	}
+	return store;
+}
+function useLiveStates(ids) {
+	const store = getMarketLiveStore(useQueryClient());
+	const key = JSON.stringify(ids);
+	const selector = useMemo(() => {
+		const selectedIds = JSON.parse(key);
+		let previous = [];
+		return {
+			subscribe: (listener) => store.subscribe(selectedIds, listener),
+			get: () => {
+				const next = store.getMany(selectedIds).map((data) => ({ data }));
+				if (next.length === previous.length && next.every((entry, index) => entry.data === previous[index]?.data)) return previous;
+				previous = next;
+				return next;
+			}
+		};
+	}, [key, store]);
+	return useSyncExternalStore(selector.subscribe, selector.get, selector.get);
+}
+/** Keep acknowledged closed tails until REST history catches up; empty batches never erase them. */
+function mergeCandleTails(previous, next) {
+	return Object.fromEntries([
+		"1m",
+		"5m",
+		"1h",
+		"1d"
+	].map((interval) => {
+		const oldClosed = previous?.[interval].closed ?? [];
+		const incoming = next[interval].closed;
+		const closed = incoming.length ? [...new Map([...oldClosed, ...incoming].map((candle) => [candle.openTime, candle])).values()].sort((a, b) => a.openTime - b.openTime).slice(-500) : oldClosed;
+		return [interval, {
+			forming: next[interval].forming,
+			closed
+		}];
+	}));
+}
+//#endregion
+//#region src/market-data/market-resolution-cache.ts
+const isRecord = (value) => {
+	return typeof value === "object" && value !== null;
+};
+const NESTED_COLLECTION_FIELDS = [
+	"pages",
+	"data",
+	"markets",
+	"events",
+	"venueMarkets"
+];
+const marketContainsOutcomeId = (market, outcomeId) => {
+	if (!isRecord(market)) return false;
+	const outcomes = market.venueMarketOutcomes;
+	if (!Array.isArray(outcomes)) return false;
+	return outcomes.some((outcome) => isRecord(outcome) && outcome.id === outcomeId);
+};
+/**
+* Deep-search arbitrary query data for a venue market that holds `outcomeId`.
+* Used both to decide which cached queries to optimistically patch and as the
+* `invalidateQueries` predicate.
+*/
+const cachedDataContainsOutcomeId = (data, outcomeId) => {
+	if (Array.isArray(data)) return data.some((entry) => cachedDataContainsOutcomeId(entry, outcomeId));
+	if (!isRecord(data)) return false;
+	if (marketContainsOutcomeId(data, outcomeId)) return true;
+	return NESTED_COLLECTION_FIELDS.some((field) => {
+		const value = data[field];
+		return Array.isArray(value) && value.some((entry) => cachedDataContainsOutcomeId(entry, outcomeId));
+	});
+};
+const normalizeLabel = (label) => {
+	return typeof label === "string" ? label.trim().toLowerCase() : "";
+};
+/**
+* Match a local outcome to the resolution payload by external identifier first
+* (authoritative on-chain token id) then by label — the WS event carries
+* `externalIdentifier`/`label`, never the internal `id` per outcome.
+*/
+const findResolvedOutcome = (resolvedOutcomes, outcome) => {
+	const externalIdentifier = outcome.externalIdentifier;
+	if (typeof externalIdentifier === "string" && externalIdentifier.length > 0) {
+		const matchedByExternalId = resolvedOutcomes.find((resolved) => resolved.externalIdentifier === externalIdentifier);
+		if (matchedByExternalId) return matchedByExternalId;
+	}
+	const label = normalizeLabel(outcome.label);
+	if (label) return resolvedOutcomes.find((resolved) => normalizeLabel(resolved.label) === label) ?? null;
+	return null;
+};
+const applyWinnersToOutcomes = (outcomes, resolution) => {
+	let changed = false;
+	const next = outcomes.map((outcome) => {
+		if (!isRecord(outcome)) return outcome;
+		const resolved = findResolvedOutcome(resolution.outcomes, outcome);
+		if (!resolved) return outcome;
+		const nextWinner = resolved.winner === true;
+		if (outcome.winner === nextWinner) return outcome;
+		changed = true;
+		return {
+			...outcome,
+			winner: nextWinner
+		};
+	});
+	return changed ? next : outcomes;
+};
+const applyResolutionToMarket = (market, resolution) => {
+	const outcomes = market.venueMarketOutcomes;
+	if (!Array.isArray(outcomes)) return market;
+	if (!outcomes.some((outcome) => isRecord(outcome) && outcome.id === resolution.outcomeId)) return market;
+	const nextOutcomes = applyWinnersToOutcomes(outcomes, resolution);
+	if (!(market.status !== resolution.status) && nextOutcomes === outcomes) return market;
+	return {
+		...market,
+		status: resolution.status,
+		venueMarketOutcomes: nextOutcomes
+	};
+};
+/**
+* Return a structurally-shared copy of `data` with the resolved market marked
+* `status: resolved|closed` and its outcomes' `winner` flags stamped from the
+* WS payload. Untouched branches keep their original reference (no spurious
+* re-renders). Returns the original `data` when nothing matched.
+*/
+const applyResolutionToCachedData = (data, resolution) => {
+	if (Array.isArray(data)) {
+		let changed = false;
+		const next = data.map((entry) => {
+			const updated = applyResolutionToCachedData(entry, resolution);
+			if (updated !== entry) changed = true;
+			return updated;
+		});
+		return changed ? next : data;
+	}
+	if (!isRecord(data)) return data;
+	if (Array.isArray(data.venueMarketOutcomes)) return applyResolutionToMarket(data, resolution);
+	let changed = false;
+	const next = { ...data };
+	for (const field of NESTED_COLLECTION_FIELDS) {
+		const value = data[field];
+		if (!Array.isArray(value)) continue;
+		const updated = applyResolutionToCachedData(value, resolution);
+		if (updated !== value) {
+			next[field] = updated;
+			changed = true;
+		}
+	}
+	return changed ? next : data;
+};
+//#endregion
+//#region src/market-data/history-retention.ts
+const DEFAULT_HISTORY_RETENTION = {
+	maxInactiveQueries: 16,
+	maxInactivePoints: 2e4
+};
+const owners = /* @__PURE__ */ new WeakMap();
+const isHistory = (key) => key[0] === "market-data" && key[1] === "chart";
+const points = (data) => {
+	const chart = data;
+	return chart?.venues ? Object.values(chart.venues).reduce((total, venue) => total + venue.candles.length + (venue.liveCandle ? 1 : 0), 0) : 0;
+};
+/** Read-only diagnostics for chart policy only; ordinary REST and user caches are excluded. */
+function getChartHistoryRetentionStats(client) {
+	const queries = client.getQueryCache().findAll({ queryKey: marketDataKeys.chartPrefix() });
+	const active = queries.filter((query) => query.getObserversCount() > 0);
+	const inactive = queries.filter((query) => query.getObserversCount() === 0);
+	const owner = owners.get(client);
+	return {
+		activeQueries: active.length,
+		inactiveQueries: inactive.length,
+		activePoints: active.reduce((sum, query) => sum + points(query.state.data), 0),
+		inactivePoints: inactive.reduce((sum, query) => sum + points(query.state.data), 0),
+		inFlightQueries: queries.filter((query) => query.state.fetchStatus === "fetching").length,
+		trackedQueries: owner?.touched.size ?? 0,
+		evictedQueries: owner?.evicted ?? 0,
+		limits: owner?.limits ?? DEFAULT_HISTORY_RETENTION
+	};
+}
+/** One reusable policy owner per QueryClient. Called by the hooks provider, never the demo app. */
+function installChartHistoryRetention(client, limits = DEFAULT_HISTORY_RETENTION) {
+	let owner = owners.get(client);
+	if (!owner) {
+		owner = {
+			refs: 0,
+			clock: Date.now(),
+			touched: /* @__PURE__ */ new Map(),
+			evicted: 0,
+			queued: false,
+			pruning: false,
+			limits,
+			unsubscribe: () => {},
+			prune: () => {}
+		};
+		owners.set(client, owner);
+		const current = owner;
+		const prune = () => {
+			if (current.pruning) return;
+			current.pruning = true;
+			try {
+				const inactive = client.getQueryCache().findAll({ queryKey: marketDataKeys.chartPrefix() }).filter((query) => query.getObserversCount() === 0).sort((a, b) => (current.touched.get(a.queryHash) ?? a.state.dataUpdatedAt) - (current.touched.get(b.queryHash) ?? b.state.dataUpdatedAt));
+				let count = inactive.length;
+				let totalPoints = inactive.reduce((sum, query) => sum + points(query.state.data), 0);
+				for (const query of inactive) {
+					if (count <= current.limits.maxInactiveQueries && totalPoints <= current.limits.maxInactivePoints) break;
+					if (query.getObserversCount() > 0) continue;
+					count--;
+					totalPoints -= points(query.state.data);
+					current.evicted++;
+					current.touched.delete(query.queryHash);
+					client.removeQueries({
+						queryKey: query.queryKey,
+						exact: true
+					});
+				}
+			} finally {
+				current.pruning = false;
+			}
+		};
+		current.prune = prune;
+		const schedule = () => {
+			if (current.queued) return;
+			current.queued = true;
+			queueMicrotask(() => {
+				current.queued = false;
+				prune();
+			});
+		};
+		current.unsubscribe = client.getQueryCache().subscribe((event) => {
+			if (!isHistory(event.query.queryKey)) return;
+			if (event.type === "removed") current.touched.delete(event.query.queryHash);
+			else if (event.type === "observerAdded" || event.type === "updated" || event.type === "added") {
+				current.clock = Math.max(current.clock + 1, Date.now());
+				current.touched.set(event.query.queryHash, current.clock);
+			}
+			if (!current.pruning) schedule();
+		});
+		schedule();
+	}
+	owner.refs++;
+	const current = owner;
+	let released = false;
+	return () => {
+		if (released) return;
+		released = true;
+		if (--current.refs > 0) return;
+		queueMicrotask(() => {
+			if (current.refs > 0) return;
+			current.prune();
+			current.unsubscribe();
+			owners.delete(client);
+		});
+	};
+}
+//#endregion
+//#region src/core/providers/ws-provider.tsx
+const AggWebSocketContext = createContext(null);
+const AggWebSocketConnectionContext = createContext(false);
+const AggWsUserEventContext = createContext(null);
+const snapshotUnavailableOutcomeIdPattern = /snapshot unavailable for\s+([^\s]+)/i;
+const resolveSnapshotUnavailableOutcomeId = (errorMessage) => {
+	const matchedOutcomeId = snapshotUnavailableOutcomeIdPattern.exec(errorMessage)?.[1];
+	if (!matchedOutcomeId) return null;
+	return matchedOutcomeId.replace(/[.,;:!?]+$/, "");
+};
+function useAggWebSocket() {
+	return useContext(AggWebSocketContext);
+}
+function useAggWebSocketConnectionState() {
+	return useContext(AggWebSocketConnectionContext);
+}
+function useOnOrderSubmitted(callback) {
+	const listeners = useContext(AggWsUserEventContext);
+	const callbackRef = useRef(callback);
+	callbackRef.current = callback;
+	useEffect(() => {
+		if (!listeners || !callbackRef.current) return;
+		const handler = (msg) => {
+			callbackRef.current?.(msg);
+		};
+		return listeners.addOrderSubmittedListener(handler);
+	}, [listeners, callback !== null]);
+}
+function useOnBalanceUpdate(callback) {
+	const listeners = useContext(AggWsUserEventContext);
+	const callbackRef = useRef(callback);
+	callbackRef.current = callback;
+	useEffect(() => {
+		if (!listeners || !callbackRef.current) return;
+		const handler = (msg) => {
+			callbackRef.current?.(msg);
+		};
+		return listeners.addBalanceUpdateListener(handler);
+	}, [listeners, callback !== null]);
+}
+function useOnOrderEvent(callback) {
+	const listeners = useContext(AggWsUserEventContext);
+	const callbackRef = useRef(callback);
+	callbackRef.current = callback;
+	useEffect(() => {
+		if (!listeners || !callbackRef.current) return;
+		const handler = (msg) => {
+			callbackRef.current?.(msg);
+		};
+		return listeners.addOrderEventListener(handler);
+	}, [listeners, callback !== null]);
+}
+function useOnRedeemEvent(callback) {
+	const listeners = useContext(AggWsUserEventContext);
+	const callbackRef = useRef(callback);
+	callbackRef.current = callback;
+	useEffect(() => {
+		if (!listeners || !callbackRef.current) return;
+		const handler = (msg) => {
+			callbackRef.current?.(msg);
+		};
+		return listeners.addRedeemEventListener(handler);
+	}, [listeners, callback !== null]);
+}
+function useOnWithdrawalLifecycle(callback) {
+	const listeners = useContext(AggWsUserEventContext);
+	const callbackRef = useRef(callback);
+	callbackRef.current = callback;
+	useEffect(() => {
+		if (!listeners || !callbackRef.current) return;
+		const handler = (msg) => {
+			callbackRef.current?.(msg);
+		};
+		return listeners.addWithdrawalLifecycleListener(handler);
+	}, [listeners, callback !== null]);
+}
+function AggWebSocketProvider({ children }) {
+	const client = useAggClient();
+	const { enableWebsocketsLogs } = useAggUiConfig();
+	const queryClient = useQueryClient();
+	const liveStore = getMarketLiveStore(queryClient);
+	useEffect(() => installChartHistoryRetention(queryClient), [queryClient]);
+	const [ws, setWs] = useState(null);
+	const [isConnected, setIsConnected] = useState(false);
+	const [isClientAuthenticated, setIsClientAuthenticated] = useState(client.isAuthenticated);
+	const wsRef = useRef(null);
+	const resyncDeadlineByMarketRef = useRef(/* @__PURE__ */ new Map());
+	const lastBalanceInvalidationAtRef = useRef(0);
+	useEffect(() => {
+		setIsClientAuthenticated(client.isAuthenticated);
+		return client.onAuthStateChange((authenticated) => {
+			setIsClientAuthenticated(authenticated);
+		});
+	}, [client]);
+	const orderSubmittedListenersRef = useRef(/* @__PURE__ */ new Set());
+	const balanceUpdateListenersRef = useRef(/* @__PURE__ */ new Set());
+	const orderEventListenersRef = useRef(/* @__PURE__ */ new Set());
+	const redeemEventListenersRef = useRef(/* @__PURE__ */ new Set());
+	const withdrawalLifecycleListenersRef = useRef(/* @__PURE__ */ new Set());
+	const userEventListeners = useMemo(() => ({
+		addOrderSubmittedListener: (cb) => {
+			orderSubmittedListenersRef.current.add(cb);
+			return () => {
+				orderSubmittedListenersRef.current.delete(cb);
+			};
+		},
+		addBalanceUpdateListener: (cb) => {
+			balanceUpdateListenersRef.current.add(cb);
+			return () => {
+				balanceUpdateListenersRef.current.delete(cb);
+			};
+		},
+		addOrderEventListener: (cb) => {
+			orderEventListenersRef.current.add(cb);
+			return () => {
+				orderEventListenersRef.current.delete(cb);
+			};
+		},
+		addRedeemEventListener: (cb) => {
+			redeemEventListenersRef.current.add(cb);
+			return () => {
+				redeemEventListenersRef.current.delete(cb);
+			};
+		},
+		addWithdrawalLifecycleListener: (cb) => {
+			withdrawalLifecycleListenersRef.current.add(cb);
+			return () => {
+				withdrawalLifecycleListenersRef.current.delete(cb);
+			};
+		}
+	}), []);
+	const syncLiveQuery = useCallback((marketId, updater) => {
+		liveStore.update(marketId, (previous) => updater(previous));
+	}, [liveStore]);
+	const invalidateBalanceCaches = useCallback(() => {
+		const now = Date.now();
+		if (now - lastBalanceInvalidationAtRef.current < 750) return;
+		lastBalanceInvalidationAtRef.current = now;
+		invalidateBalanceQueries(queryClient);
+	}, [queryClient]);
+	const invalidatePositionCaches = useCallback(() => {
+		invalidatePositionQueries(queryClient);
+	}, [queryClient]);
+	const invalidateActivityCaches = useCallback(() => {
+		invalidateUserActivityQueries(queryClient);
+	}, [queryClient]);
+	const invalidateResolutionCaches = useCallback((resolution) => {
+		const { outcomeId } = resolution;
+		syncLiveQuery(outcomeId, (previous) => {
+			if (!previous) return previous;
+			return {
+				...previous,
+				orderbook: null,
+				orderbookSnapshotVersion: previous.orderbookSnapshotVersion + 1,
+				orderbookError: null,
+				integrity: "ok"
+			};
+		});
+		const affectedQueries = queryClient.getQueryCache().findAll({ predicate: (query) => cachedDataContainsOutcomeId(query.state.data, outcomeId) });
+		for (const query of affectedQueries) queryClient.setQueryData(query.queryKey, (previous) => applyResolutionToCachedData(previous, resolution));
+		queryClient.invalidateQueries({
+			queryKey: ["midpoints"],
+			refetchType: "all"
+		});
+		queryClient.invalidateQueries({
+			queryKey: ["venue-market-midpoints"],
+			refetchType: "all"
+		});
+		queryClient.invalidateQueries({
+			queryKey: ["venue-event"],
+			refetchType: "all"
+		});
+		queryClient.invalidateQueries({
+			queryKey: ["venue-markets"],
+			refetchType: "all"
+		});
+		queryClient.invalidateQueries({
+			queryKey: ["events"],
+			refetchType: "all"
+		});
+		queryClient.invalidateQueries({
+			queryKey: ["event-list"],
+			refetchType: "all"
+		});
+		queryClient.invalidateQueries({
+			queryKey: ["search"],
+			refetchType: "all"
+		});
+		queryClient.invalidateQueries({
+			predicate: (query) => cachedDataContainsOutcomeId(query.state.data, outcomeId),
+			refetchType: "all"
+		});
+	}, [queryClient, syncLiveQuery]);
+	const publishLocalCandles = useCallback((id) => {
+		const builder = getOrCreateBuilder(id);
+		const candles = Object.fromEntries([
+			"1m",
+			"5m",
+			"1h",
+			"1d"
+		].map((interval) => [interval, {
+			forming: builder.getForming(interval) ? { ...builder.getForming(interval) } : null,
+			closed: builder.getClosed(interval).slice(-2)
+		}]));
+		liveStore.update(id, (previous) => ({
+			...previous,
+			candles
+		}));
+	}, [liveStore]);
+	const callbacks = useMemo(() => ({
+		onMarketView: (view) => {
+			if (view.book && view.integrity === "ok") resyncDeadlineByMarketRef.current.delete(view.outcomeId);
+			liveStore.update(view.outcomeId, (previous) => ({
+				...view.book ? withLiveOrderbook(previous, view.book, view.snapshot ? "snapshot" : "delta") : previous,
+				integrity: view.integrity,
+				candles: mergeCandleTails(previous.candles, view.candles),
+				receivedAtMs: view.receivedAtMs,
+				trades: [...view.trades, ...previous.trades].slice(0, 50)
+			}));
+			getOrCreateBuilder(view.outcomeId).replaceTail(view.candles);
+		},
+		onSnapshot: (marketId, book) => {
+			if (wsRef.current?.processesCandles) return;
+			resyncDeadlineByMarketRef.current.delete(marketId);
+			syncLiveQuery(marketId, (previous) => withLiveOrderbook(previous, book, "snapshot"));
+			if (!wsRef.current?.processesCandles && book.midpoint != null) {
+				getOrCreateBuilder(marketId).addMidpoint(book.midpoint, book.timestamp);
+				publishLocalCandles(marketId);
+			}
+		},
+		onDelta: (marketId, book) => {
+			if (wsRef.current?.processesCandles) return;
+			resyncDeadlineByMarketRef.current.delete(marketId);
+			syncLiveQuery(marketId, (previous) => withLiveOrderbook(previous, book, "delta"));
+			if (!wsRef.current?.processesCandles && book.midpoint != null) {
+				getOrCreateBuilder(marketId).addMidpoint(book.midpoint, book.timestamp);
+				publishLocalCandles(marketId);
+			}
+		},
+		onTrade: (trade) => {
+			if (wsRef.current?.processesCandles) return;
+			syncLiveQuery(trade.outcomeId, (previous) => withLiveTrade(previous, trade));
+			if (!wsRef.current?.processesCandles) {
+				getOrCreateBuilder(trade.outcomeId).addTrade(trade.price, trade.size, trade.timestamp);
+				publishLocalCandles(trade.outcomeId);
+			}
+		},
+		onHeartbeat: () => {
+			const now = Date.now();
+			resyncDeadlineByMarketRef.current.forEach((deadline, marketId) => {
+				if (deadline > now) return;
+				wsRef.current?.resnapshot(marketId);
+				resyncDeadlineByMarketRef.current.set(marketId, now + 35e3);
+			});
+		},
+		onDiagnostics: (event) => {
+			if (event.type !== "seq_gap" && event.type !== "checksum_mismatch") return;
+			const id = event.outcomeId ?? event.marketId;
+			resyncDeadlineByMarketRef.current.set(id, Date.now() + 35e3);
+			syncLiveQuery(id, (previous) => withLiveIntegrity(previous, "resyncing"));
+		},
+		onOrderSubmitted: (msg) => {
+			for (const listener of orderSubmittedListenersRef.current) listener(msg);
+		},
+		onBalanceUpdate: (msg) => {
+			if (isClientAuthenticated) {
+				invalidateBalanceCaches();
+				invalidateActivityCaches();
+			}
+			for (const listener of balanceUpdateListenersRef.current) listener(msg);
+		},
+		onOrderEvent: (msg) => {
+			if (isClientAuthenticated) {
+				const currentUserId = client.user?.id ?? null;
+				if (shouldInvalidateBalancesForOrderEvent(msg, currentUserId)) {
+					invalidateBalanceCaches();
+					invalidatePositionCaches();
+				}
+			}
+			for (const listener of orderEventListenersRef.current) listener(msg);
+		},
+		onRedeemEvent: (msg) => {
+			for (const listener of redeemEventListenersRef.current) listener(msg);
+		},
+		onWithdrawalLifecycle: (msg) => {
+			if (isClientAuthenticated) invalidateBalanceCaches();
+			for (const listener of withdrawalLifecycleListenersRef.current) listener(msg);
+		},
+		onMarketResolved: (msg) => {
+			invalidateResolutionCaches(msg);
+			if (isClientAuthenticated) {
+				invalidateBalanceCaches();
+				invalidatePositionCaches();
+				invalidateActivityCaches();
+			}
+		},
+		onError: (msg) => {
+			const outcomeId = resolveSnapshotUnavailableOutcomeId(msg.message);
+			if (!outcomeId) return;
+			syncLiveQuery(outcomeId, (previous) => withLiveOrderbookError(previous, outcomeId, msg.message));
+		},
+		onConnectionStateChange: (connected) => {
+			setIsConnected(connected);
+			if (connected) queryClient.invalidateQueries({
+				queryKey: marketDataKeys.chartPrefix(),
+				refetchType: "active"
+			});
+			else resetAllBuilders();
+			liveStore.connected(connected);
+		}
+	}), [
+		client,
+		invalidateActivityCaches,
+		invalidateBalanceCaches,
+		invalidatePositionCaches,
+		invalidateResolutionCaches,
+		isClientAuthenticated,
+		queryClient,
+		syncLiveQuery,
+		liveStore,
+		publishLocalCandles
+	]);
+	const callbacksRef = useRef(callbacks);
+	callbacksRef.current = callbacks;
+	useEffect(() => {
+		wsRef.current?.setCallbacks(callbacks);
+	}, [callbacks]);
+	useEffect(() => {
+		let instance = null;
+		const resyncDeadlineByMarket = resyncDeadlineByMarketRef.current;
+		try {
+			instance = client.createWebSocket(callbacksRef.current, { enableLogs: enableWebsocketsLogs });
+		} catch {
+			console.warn("[AggUI] WebSocket connection could not be established. Ensure wsUrl is configured in createAggClient(). Real-time features (live prices, order updates) are disabled.");
+			setWs(null);
+			wsRef.current = null;
+			setIsConnected(false);
+			return;
+		}
+		instance.setHostDiagnostics?.(() => ({
+			live: liveStore.getDiagnostics(),
+			history: getChartHistoryRetentionStats(queryClient),
+			candles: getCandleStoreDiagnostics()
+		}));
+		setWs(instance);
+		wsRef.current = instance;
+		return () => {
+			instance?.destroy();
+			if (wsRef.current === instance) wsRef.current = null;
+			resyncDeadlineByMarket.clear();
+			setWs(null);
+			setIsConnected(false);
+		};
+	}, [
+		client,
+		enableWebsocketsLogs,
+		isClientAuthenticated,
+		liveStore,
+		queryClient
+	]);
+	return /* @__PURE__ */ jsx(AggWebSocketConnectionContext.Provider, {
+		value: isConnected,
+		children: /* @__PURE__ */ jsx(AggWsUserEventContext.Provider, {
+			value: userEventListeners,
+			children: /* @__PURE__ */ jsx(AggWebSocketContext.Provider, {
+				value: ws,
+				children
+			})
+		})
+	});
+}
+//#endregion
+//#region src/execution/use-withdraw-managed.ts
+/**
+* Mutation hook for withdrawing funds from managed wallets. On submission
+* success the backend has already debited the managed-side balance and
+* recorded the activity row, so we invalidate the full money-state cache
+* surface (balances, positions, activity). Terminal lifecycle invalidation
+* is handled separately by `useWithdrawalLifecycle`.
+*/
+function useWithdrawManaged(options) {
+	const client = useAggClient();
+	const queryClient = useQueryClient();
+	return useMutation({
+		mutationFn: (params) => client.withdrawManaged(params),
+		onSuccess: (data) => {
+			invalidateUserMoneyState(queryClient);
+			options?.onSuccess?.(data);
+		},
+		onError: options?.onError
+	});
+}
+//#endregion
+//#region src/execution/use-managed-balances.ts
+/**
+* Query hook for fetching unified managed wallet balances across all chains.
+*/
+function useManagedBalances(options) {
+	const client = useAggClient();
+	const { enabled = true, mode, custody } = options ?? {};
+	const params = {
+		...mode ? { mode } : {},
+		...custody ? { custody } : {}
+	};
+	const query = useQuery({
+		queryKey: executionKeys.balances(mode, custody),
+		queryFn: () => client.getManagedBalances(Object.keys(params).length ? params : void 0),
+		enabled,
+		staleTime: 1e4,
+		refetchInterval: mode === "paper" ? false : 5e3,
+		refetchIntervalInBackground: false,
+		gcTime: 3e5,
+		retry: 1
+	});
+	return {
+		...query,
+		balances: query.data
+	};
+}
+//#endregion
+//#region src/withdraw/use-withdraw-flow.ts
+const EVM_ADDRESS_REGEX = /^0x[a-fA-F0-9]{40}$/;
+const SOLANA_ADDRESS_REGEX = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/;
+/** Solana mainnet chain id (mirrors `CHAIN_IDS.SOLANA` in `@app/balance`). */
+const SOLANA_CHAIN_ID = 792703809;
+/**
+* Chain IDs the withdrawal pipeline can settle on. Mirrors
+* `WITHDRAWAL_SUPPORTED_CHAIN_IDS` in `@app/balance` (api). Solana is
+* supported as a destination — the API resolves the SPL USDC mint and
+* Relay's cross-chain quotes accept base58 recipients (no on-chain
+* forwarder for Solana, so the lifecycle path skips that step). Keep this
+* set in lock-step with the api-side constant.
+*/
+const WITHDRAWAL_SUPPORTED_CHAIN_IDS = /* @__PURE__ */ new Set([
+	1,
+	137,
+	42161,
+	8453,
+	56,
+	SOLANA_CHAIN_ID,
+	1337
+]);
+const isValidDestinationAddress = (address, chainId) => {
+	if (chainId === SOLANA_CHAIN_ID) return SOLANA_ADDRESS_REGEX.test(address);
+	return EVM_ADDRESS_REGEX.test(address);
+};
+/**
+* Classify a recipient address by chain family so the network picker can
+* auto-select the matching chain and disable the others. EVM addresses are
+* unambiguous (`0x…` — `0` isn't in the base58 alphabet, so they can never
+* match the Solana regex), so we test EVM first. Returns null until the input
+* is a structurally complete address of either family — partial/garbage input
+* leaves every network enabled.
+*/
+const detectDestinationAddressKind = (address) => {
+	const trimmed = address.trim();
+	if (!trimmed) return null;
+	if (EVM_ADDRESS_REGEX.test(trimmed)) return "evm";
+	if (SOLANA_ADDRESS_REGEX.test(trimmed)) return "solana";
+	return null;
+};
+const DEFAULT_WITHDRAW_SUMMARY = {
+	amountReceived: "",
+	network: "",
+	toWallet: "",
+	fees: "—"
+};
+const formatRawTokenAmount = (rawAmount, decimals) => {
+	if (!rawAmount) return "0";
+	const raw = BigInt(rawAmount);
+	const divisor = BigInt(`1${"0".repeat(decimals)}`);
+	const whole = raw / divisor;
+	const remainder = raw % divisor;
+	if (remainder === BigInt(0)) return whole.toString();
+	return `${whole.toString()}.${remainder.toString().padStart(decimals, "0").replace(/0+$/, "")}`;
+};
+const formatRawTokenAmountForDisplay = (rawAmount, decimals, fractionDigits = 2) => {
+	const [wholePart, fractionalPart = ""] = formatRawTokenAmount(rawAmount, decimals).split(".");
+	return `${wholePart}.${fractionalPart.padEnd(fractionDigits, "0").slice(0, fractionDigits)}`;
+};
+const parseTokenAmountToRaw = (amount, decimals) => {
+	const normalizedAmount = amount.trim();
+	if (!normalizedAmount || !/^\d*(?:\.\d*)?$/.test(normalizedAmount)) return null;
+	const [wholePart = "0", fractionalPart = ""] = normalizedAmount.split(".");
+	if (fractionalPart.length > decimals) return null;
+	const normalizedWhole = wholePart === "" ? "0" : wholePart;
+	const normalizedFraction = fractionalPart.padEnd(decimals, "0");
+	try {
+		return `${BigInt(normalizedWhole)}${normalizedFraction}`.replace(/^0+(?=\d)/, "");
+	} catch {
+		return null;
+	}
+};
+const shortenAddress = (address) => address.length > 12 ? `${address.slice(0, 6)}...${address.slice(-4)}` : address;
+function useWithdrawFlow(options) {
+	const { open, onOpenChange } = options;
+	const { totalBalance } = useAggBalanceState();
+	const { balances } = useManagedBalances({ enabled: open });
+	const { supportedChains } = useDepositAddresses({ enabled: open });
+	const withdrawMutation = useWithdrawManaged();
+	const syncBalances = useSyncBalances();
+	const ws = useAggWebSocket();
+	useEffect(() => {
+		if (!open) return;
+		syncBalances.mutate(void 0, { onError: () => {} });
+	}, [open]);
+	const [withdrawDestination, setWithdrawDestination] = useState("");
+	const [withdrawAmount, setWithdrawAmount] = useState("");
+	const [withdrawToken, setWithdrawToken] = useState("USDC");
+	const [withdrawNetwork, setWithdrawNetwork] = useState("");
+	const [withdrawSummary, setWithdrawSummary] = useState(DEFAULT_WITHDRAW_SUMMARY);
+	const [withdrawalId, setWithdrawalId] = useState(null);
+	const [isMax, setIsMax] = useState(false);
+	const detectedAddressKind = useMemo(() => detectDestinationAddressKind(withdrawDestination), [withdrawDestination]);
+	const networkOptions = useMemo(() => (supportedChains ?? []).filter((chain) => WITHDRAWAL_SUPPORTED_CHAIN_IDS.has(chain.chainId)).map((chain) => {
+		const value = String(chain.chainId);
+		const isSolana = chain.chainId === SOLANA_CHAIN_ID;
+		const disabled = detectedAddressKind === "solana" ? !isSolana : detectedAddressKind === "evm" ? isSolana : false;
+		return {
+			value,
+			label: chain.name,
+			disabled
+		};
+	}), [supportedChains, detectedAddressKind]);
+	const firstEnabledNetwork = networkOptions.find((option) => !option.disabled)?.value ?? networkOptions[0]?.value ?? "";
+	const isCurrentNetworkSelectable = networkOptions.some((option) => option.value === withdrawNetwork && !option.disabled);
+	const resolvedWithdrawNetwork = isCurrentNetworkSelectable ? withdrawNetwork : firstEnabledNetwork;
+	useEffect(() => {
+		if (!networkOptions.length) return;
+		if (!isCurrentNetworkSelectable && firstEnabledNetwork) setWithdrawNetwork(firstEnabledNetwork);
+	}, [
+		networkOptions,
+		isCurrentNetworkSelectable,
+		firstEnabledNetwork
+	]);
+	const tokenOptions = useMemo(() => {
+		const selectedChainId = Number(resolvedWithdrawNetwork);
+		const supportedTokensForNetwork = supportedChains?.find((chain) => chain.chainId === selectedChainId)?.tokens ?? [];
+		const withdrawableSymbols = new Set(supportedTokensForNetwork.map((token) => token.symbol));
+		return (balances?.cash ?? []).filter((cashEntry) => withdrawableSymbols.has(cashEntry.tokenSymbol)).map((cashEntry) => ({
+			value: cashEntry.tokenSymbol,
+			label: cashEntry.tokenSymbol
+		}));
+	}, [
+		balances,
+		resolvedWithdrawNetwork,
+		supportedChains
+	]);
+	const resolvedWithdrawToken = tokenOptions.some((option) => option.value === withdrawToken) ? withdrawToken : tokenOptions[0]?.value || "";
+	useEffect(() => {
+		if (!tokenOptions.length) return;
+		if (!tokenOptions.some((option) => option.value === withdrawToken)) setWithdrawToken(tokenOptions[0].value);
+	}, [tokenOptions, withdrawToken]);
+	const selectedCashEntry = useMemo(() => balances?.cash.find((cashEntry) => cashEntry.tokenSymbol === resolvedWithdrawToken), [balances, resolvedWithdrawToken]);
+	const selectedTokenDecimals = useMemo(() => {
+		const selectedChainId = Number(resolvedWithdrawNetwork);
+		return supportedChains?.find((chain) => chain.chainId === selectedChainId)?.tokens.find((token) => token.symbol === resolvedWithdrawToken)?.decimals ?? selectedCashEntry?.decimals ?? 6;
+	}, [
+		resolvedWithdrawNetwork,
+		resolvedWithdrawToken,
+		selectedCashEntry?.decimals,
+		supportedChains
+	]);
+	const exactBalance = useMemo(() => {
+		if (!selectedCashEntry) return "0";
+		return formatRawTokenAmount(selectedCashEntry.totalRaw, selectedCashEntry.decimals);
+	}, [selectedCashEntry]);
+	const balanceDisplay = useMemo(() => {
+		if (!selectedCashEntry) return `0.00 ${resolvedWithdrawToken || withdrawToken}`;
+		return `${formatRawTokenAmountForDisplay(selectedCashEntry.totalRaw, selectedCashEntry.decimals)} ${resolvedWithdrawToken}`;
+	}, [
+		resolvedWithdrawToken,
+		selectedCashEntry,
+		withdrawToken
+	]);
+	const resetFlowState = useCallback(() => {
+		setWithdrawDestination("");
+		setWithdrawAmount("");
+		setWithdrawToken("USDC");
+		setWithdrawNetwork("");
+		setWithdrawSummary(DEFAULT_WITHDRAW_SUMMARY);
+		setWithdrawalId(null);
+		setIsMax(false);
+	}, []);
+	const handleWithdrawOpenChange = useCallback((isOpen) => {
+		if (!isOpen) resetFlowState();
+		onOpenChange(isOpen);
+	}, [onOpenChange, resetFlowState]);
+	useEffect(() => {
+		if (!open) resetFlowState();
+	}, [open, resetFlowState]);
+	const handleWithdrawProvider = useCallback(async () => {
+		const destinationChainId = Number(resolvedWithdrawNetwork);
+		const trimmedDestination = withdrawDestination.trim();
+		const amountRaw = parseTokenAmountToRaw(withdrawAmount, selectedTokenDecimals);
+		if (!amountRaw || BigInt(amountRaw) <= BigInt(0)) throw new Error("Enter a withdrawal amount greater than zero.");
+		if (!Number.isFinite(destinationChainId) || destinationChainId <= 0) throw new Error("Select a destination network.");
+		if (!isValidDestinationAddress(trimmedDestination, destinationChainId)) throw new Error(`Enter ${destinationChainId === SOLANA_CHAIN_ID ? "a Solana wallet address (base58, 32–44 chars)" : "an EVM destination address (0x… 40 hex chars)"}.`);
+		if (selectedCashEntry) {
+			const scaleBy = (n, exp) => {
+				if (exp <= 0) return n;
+				return n * BigInt(`1${"0".repeat(exp)}`);
+			};
+			const balanceInDestFrame = (() => {
+				const native = BigInt(selectedCashEntry.totalRaw);
+				if (selectedCashEntry.decimals === selectedTokenDecimals) return native;
+				if (selectedCashEntry.decimals > selectedTokenDecimals) return native / scaleBy(BigInt(1), selectedCashEntry.decimals - selectedTokenDecimals);
+				return scaleBy(native, selectedTokenDecimals - selectedCashEntry.decimals);
+			})();
+			if (!isMax && BigInt(amountRaw) > balanceInDestFrame) throw new Error("Withdrawal amount exceeds your available balance.");
+		}
+		ws?.connect();
+		await new Promise((resolve, reject) => {
+			withdrawMutation.mutate({
+				amountRaw,
+				tokenSymbol: resolvedWithdrawToken,
+				destinationAddress: trimmedDestination,
+				destinationChainId,
+				...isMax ? { max: true } : {}
+			}, {
+				onSuccess: (data) => {
+					setWithdrawalId(data.withdrawalId);
+					resolve();
+				},
+				onError: reject
+			});
+		});
+		setWithdrawSummary({
+			amountReceived: `${formatRawTokenAmountForDisplay(amountRaw, selectedTokenDecimals)} ${resolvedWithdrawToken}`,
+			network: supportedChains?.find((chain) => chain.chainId === destinationChainId)?.name ?? resolvedWithdrawNetwork,
+			toWallet: shortenAddress(trimmedDestination),
+			fees: "—"
+		});
+	}, [
+		isMax,
+		resolvedWithdrawNetwork,
+		resolvedWithdrawToken,
+		selectedCashEntry,
+		selectedTokenDecimals,
+		supportedChains,
+		withdrawAmount,
+		withdrawDestination,
+		withdrawMutation,
+		ws
+	]);
+	return {
+		open,
+		onOpenChange: handleWithdrawOpenChange,
+		withdrawFlow: {
+			balance: totalBalance,
+			balanceDisplay,
+			amount: withdrawAmount,
+			destinationWallet: withdrawDestination,
+			tokenOptions,
+			networkOptions,
+			selectedToken: resolvedWithdrawToken,
+			selectedNetwork: resolvedWithdrawNetwork,
+			purchaseSummary: withdrawSummary,
+			withdrawalId,
+			isMax
+		},
+		onWithdrawDestinationChange: setWithdrawDestination,
+		onWithdrawAmountChange: useCallback((v) => {
+			setIsMax(false);
+			setWithdrawAmount(v);
+		}, []),
+		onWithdrawTokenChange: setWithdrawToken,
+		onWithdrawNetworkChange: setWithdrawNetwork,
+		onMaxClick: useCallback(() => {
+			setIsMax(true);
+			setWithdrawAmount(exactBalance === "0" ? "0" : exactBalance);
+		}, [exactBalance]),
+		onSelectWithdrawProvider: useCallback(async (_providerId) => handleWithdrawProvider(), [handleWithdrawProvider]),
+		onDoneWithdraw: useCallback(() => handleWithdrawOpenChange(false), [handleWithdrawOpenChange])
+	};
+}
+//#endregion
+//#region src/withdraw/use-withdraw-estimate.ts
+/**
+* Natively estimates withdrawal fees, network reserves, and the expected net
+* amount to be received based on the selected token, destination network,
+* and transfer amount.
+*/
+function useWithdrawEstimate({ amount, selectedToken, selectedNetwork }) {
+	return useMemo(() => {
+		const numAmount = Number(amount);
+		if (!amount || isNaN(numAmount) || numAmount <= 0 || !selectedToken || !selectedNetwork) return null;
+		const network = selectedNetwork.toLowerCase();
+		let feeVal = .1;
+		let reserveVal = .2;
+		if (network === "1" || network === "mainnet" || network === "ethereum") {
+			feeVal = 1.22;
+			reserveVal = .3;
+		} else if (network === "137" || network === "polygon") {
+			feeVal = .05;
+			reserveVal = .15;
+		} else if (network === "42161" || network === "arbitrum") {
+			feeVal = .05;
+			reserveVal = .15;
+		} else if (network === "8453" || network === "base") {
+			feeVal = .05;
+			reserveVal = .15;
+		} else if (network === "56" || network === "bnb" || network === "bsc") {
+			feeVal = .1;
+			reserveVal = .2;
+		} else if (network === "792703809" || network === "solana") {
+			feeVal = .01;
+			reserveVal = .04;
+		} else if (network === "1337" || network === "hyperliquid") {
+			feeVal = .02;
+			reserveVal = .08;
+		}
+		const youReceiveVal = Math.max(0, numAmount - feeVal);
+		return {
+			estimatedFees: `~$${feeVal.toFixed(2)}`,
+			networkReserve: `~$${reserveVal.toFixed(2)}`,
+			youReceive: `~${youReceiveVal.toFixed(2)} ${selectedToken}`
+		};
+	}, [
+		amount,
+		selectedToken,
+		selectedNetwork
+	]);
+}
+//#endregion
+//#region src/withdraw/use-withdrawal-lifecycle.ts
+const INITIAL_STATE = {
+	pending: true,
+	status: null,
+	requestedAmountRaw: null,
+	completedAmountRaw: null,
+	feeRaw: null,
+	terminal: false,
+	lastLeg: null,
+	legs: [],
+	errorMessage: null,
+	timestamp: null
+};
+/**
+* Convert a leg row from the REST status response into the WS lifecycle leg
+* shape so a single state mapping handles both. The REST leg includes the
+* type/status fields the WS event omits in the legs[] array — they line up
+* cleanly because the WS leg type is a superset.
+*/
+const restLegToWsLeg = (leg) => ({
+	sourceChainId: leg.sourceChainId,
+	destChainId: leg.destChainId,
+	type: leg.type,
+	status: leg.status,
+	amountRaw: leg.amountRaw,
+	txHash: leg.txHash,
+	bridgeOperationId: leg.bridgeOperationId
+});
+/**
+* Merge the new event's leg-state into the existing `legs[]`.
+*
+* - If the event carries a full `legs[]` snapshot (pending / terminal
+*   rollup), it replaces — the server's snapshot is authoritative.
+* - If it carries only a `leg` delta, find the matching row by
+*   (sourceChainId, destChainId, type) and replace it; if no row matches
+*   (the delta arrived before any snapshot listed the leg), append it.
+*   This preserves the timeline UI between snapshots — without this,
+*   intermediate `submitted`/`confirmed` deltas would wipe `legs[]` to
+*   `[]` and the per-leg checklist would collapse mid-flow.
+* - If neither is present, leave the existing `legs[]` untouched.
+*/
+const mergeLegs = (prev, snapshot, delta) => {
+	if (snapshot) return snapshot;
+	if (!delta) return prev;
+	const idx = prev.findIndex((l) => l.sourceChainId === delta.sourceChainId && l.destChainId === delta.destChainId && l.type === delta.type);
+	if (idx === -1) return [...prev, delta];
+	const next = prev.slice();
+	next[idx] = delta;
+	return next;
+};
+const restToLifecycleState = (response) => {
+	return {
+		pending: false,
+		status: response.status,
+		requestedAmountRaw: response.requested.amountRaw,
+		completedAmountRaw: response.completedAmountRaw ?? null,
+		feeRaw: response.expected.feeRaw ?? null,
+		terminal: response.status === "completed" || response.status === "partial" || response.status === "failed",
+		lastLeg: null,
+		legs: response.legs.map(restLegToWsLeg),
+		errorMessage: response.errorMessage ?? null,
+		timestamp: 0
+	};
+};
+/**
+* Subscribes to `withdrawal_lifecycle` WS events for a single `withdrawalId`
+* and exposes the latest snapshot. Returns a stable `pending` initial state
+* until the first matching event arrives.
+*
+* Pass `null` for `withdrawalId` to disable the subscription (e.g. before
+* the user has submitted a withdrawal). Switching the `withdrawalId` resets
+* the state so a stale snapshot from a prior withdrawal can never bleed
+* across.
+*
+* **Backfill behavior**: on mount with a non-null `withdrawalId`, and again
+* whenever the WS connection re-opens, the hook calls
+* `GET /execution/withdrawals/:id` to recover any lifecycle events that fired
+* before the listener was attached or while the socket was disconnected. WS
+* events always win over REST snapshots (REST stamps as `timestamp: 0`), so a
+* race between the two never regresses to a stale state.
+*/
+function useWithdrawalLifecycle(withdrawalId) {
+	const client = useAggClient();
+	const wsConnected = useAggWebSocketConnectionState();
+	const queryClient = useQueryClient();
+	const [state, setState] = useState(INITIAL_STATE);
+	const stateRef = useRef(state);
+	stateRef.current = state;
+	const balanceRefetchedForRef = useRef(null);
+	useEffect(() => {
+		setState(INITIAL_STATE);
+	}, [withdrawalId]);
+	useEffect(() => {
+		if (!withdrawalId) return;
+		let cancelled = false;
+		(async () => {
+			try {
+				const response = await client.getWithdrawalStatus(withdrawalId);
+				if (cancelled) return;
+				if (response.withdrawalId !== withdrawalId) return;
+				const current = stateRef.current;
+				if (current.timestamp != null && current.timestamp > 0) return;
+				setState(restToLifecycleState(response));
+			} catch {}
+		})();
+		return () => {
+			cancelled = true;
+		};
+	}, [
+		client,
+		withdrawalId,
+		wsConnected
+	]);
+	useOnWithdrawalLifecycle(useMemo(() => {
+		if (!withdrawalId) return null;
+		return (msg) => {
+			if (msg.withdrawalId !== withdrawalId) return;
+			setState((prev) => ({
+				pending: false,
+				status: msg.status,
+				requestedAmountRaw: msg.requestedAmountRaw ?? prev.requestedAmountRaw,
+				completedAmountRaw: msg.completedAmountRaw ?? prev.completedAmountRaw,
+				feeRaw: msg.feeRaw ?? null,
+				terminal: msg.terminal,
+				lastLeg: msg.leg ?? null,
+				legs: mergeLegs(prev.legs, msg.legs, msg.leg),
+				errorMessage: msg.errorMessage ?? null,
+				timestamp: msg.timestamp
+			}));
+		};
+	}, [withdrawalId]));
+	useEffect(() => {
+		if (!withdrawalId) return;
+		if (!state.terminal) return;
+		if (balanceRefetchedForRef.current === withdrawalId) return;
+		balanceRefetchedForRef.current = withdrawalId;
+		invalidateUserMoneyState(queryClient);
+		client.syncManagedBalances().catch(() => {});
+	}, [
+		client,
+		queryClient,
+		state.terminal,
+		withdrawalId
+	]);
+	return {
+		state,
+		reset: useCallback(() => setState(INITIAL_STATE), [])
+	};
+}
+//#endregion
+//#region src/withdraw/use-withdraw-preview.ts
+/**
+* Live withdrawal preview backed by the API (`POST /execution/withdraw/preview`).
+* Disabled until amount/token/chain/address are present and amount is non-zero.
+* The backend caches identical previews for 15s; FE debounce keeps Relay calls
+* bounded. Returns the real fee + receive amount, replacing the hardcoded
+* `useWithdrawEstimate`.
+*/
+function useWithdrawPreview({ amountRaw, tokenSymbol, destinationChainId, destinationAddress, max }) {
+	const client = useAggClient();
+	const enabled = !!amountRaw && BigInt(amountRaw || "0") > BigInt(0) && !!tokenSymbol && !!destinationChainId && !!destinationAddress;
+	return useQuery({
+		queryKey: [
+			"withdraw-preview",
+			tokenSymbol,
+			amountRaw,
+			destinationChainId,
+			destinationAddress,
+			max ?? false
+		],
+		enabled,
+		staleTime: 15e3,
+		queryFn: () => client.withdrawPreview({
+			amountRaw,
+			tokenSymbol,
+			destinationChainId,
+			destinationAddress,
+			...max ? { max: true } : {}
+		})
+	});
+}
+//#endregion
+export { marketDataKeys as _, useManagedBalances as a, getOrCreateBuilder as b, useAggWebSocket as c, useOnOrderEvent as d, useOnOrderSubmitted as f, useLiveStates as g, getMarketLiveStore as h, useWithdrawFlow as i, useAggWebSocketConnectionState as l, useOnWithdrawalLifecycle as m, useWithdrawalLifecycle as n, useWithdrawManaged as o, useOnRedeemEvent as p, useWithdrawEstimate as r, AggWebSocketProvider as s, useWithdrawPreview as t, useOnBalanceUpdate as u, createMarketLiveState as v, getBuilder as y };
+
+//# sourceMappingURL=withdraw--f5kYKJA.mjs.map