@velora-dex/widget 0.8.1 → 0.8.3-dev.0

package/dist/hooks/swap/tradeFlow/useTwapFlow.js

@@ -1,370 +1,358 @@
 import { useLogger as e } from "../../../core/logger.js";
-import { isBridgePrice as t, useSubscribeToDeltaPrice as n } from "../prices/delta/queries/useDeltaPriceQuery.js";
-import { isETHaddress as r } from "../../../tokens/utils/eth.js";
-import { useTwapSide as i } from "../../../core/twap/state/twapSideAtom.js";
-import { useTwapReceiverAddressValue as a } from "../../../core/twap/state/twapReceiverAddressAtom.js";
-import { HALF_MINUTE_MS as o } from "../../../lib/constants/time.js";
-import { getTwapAmountsFromPrice as s, produceTwapDeadlines as ee } from "../../../lib/utils/twap.js";
+import { useSubscribeToDeltaPrice as t } from "../prices/delta/queries/useDeltaPriceQuery.js";
+import { isETHaddress as n } from "../../../tokens/utils/eth.js";
+import { useTwapSide as r } from "../../../core/twap/state/twapSideAtom.js";
+import { useTwapReceiverAddressValue as i } from "../../../core/twap/state/twapReceiverAddressAtom.js";
+import { HALF_MINUTE_MS as a } from "../../../lib/constants/time.js";
+import { getTwapAmountsFromPrice as o, produceTwapDeadlines as s } from "../../../lib/utils/twap.js";
 import { useTwapDuration as c, useTwapSlippage as l } from "../../../core/twap/state/twapParamsAtom.js";
 import { useWidgetEvents as u } from "../../../core/state/widgetEventsAtom.js";
-import { getOverallOrderStatus as d, getSwapSideFromDeltaPrice as te } from "../prices/delta/orders/utils.js";
+import { getOverallOrderStatus as d, getSwapSideFromDeltaPrice as ee } from "../prices/delta/orders/utils.js";
 import { useWatchDeltaAuction as f } from "../prices/delta/queries/useWatchDeltaOrder.js";
 import { amountAfterSlippage as p } from "../../../lib/utils/slippage.js";
 import { useMinViemClient as m } from "../../useMinViemClient.js";
 import { usePartner as h } from "../../usePartner.js";
 import { useTwapPrices as g } from "../prices/useTwapPrices.js";
 import { useEnsureTxReceipt as _ } from "../../txs/queries/useAwaitTx.js";
-import { useCancelOrWithdrawAndCancelDeltaOrder as v } from "../prices/delta/mutations/useCancelOrWithdrawAndCancelDeltaOrder.js";
-import { UserCancelledError as y } from "./common/errors.js";
-import { useMarkPermit1Or2NonceAsUsed as b } from "./common/useSignPermit1Or2.js";
-import { useApproveOrPermit as x } from "./common/useApproveOrPermit.js";
-import { shouldApproveOrBatch as S } from "./common/usePreSignAndSubmitDeltaOrder.js";
-import { useReferrer as C } from "../../useReferrer.js";
-import { useCreateAndSubmitTwapOrder as w } from "../prices/delta/mutations/twap/useCreateTwapOrder.js";
-import { usePreSignAndSubmitTwapOrder as T } from "../prices/delta/mutations/twap/usePreSignAndSubmitTwapOrder.js";
-import { useDepositAndSubmitTwapOrder as ne } from "../prices/delta/mutations/twap/useDepositAndSubmitTwapOrder.js";
-import { DEFAULT_DELTA_BRIDGE as re } from "../prices/delta/bridge/const.js";
-import { useRef as ie } from "react";
-import { useMutation as ae } from "@tanstack/react-query";
-import { assert as E } from "ts-essentials";
-import "@velora-dex/sdk";
+import { useCancelOrWithdrawAndCancelDeltaOrder as te } from "../prices/delta/mutations/useCancelOrWithdrawAndCancelDeltaOrder.js";
+import { UserCancelledError as v } from "./common/errors.js";
+import { useMarkPermit1Or2NonceAsUsed as y } from "./common/useSignPermit1Or2.js";
+import { useApproveOrPermit as ne } from "./common/useApproveOrPermit.js";
+import { shouldApproveOrBatch as b } from "./common/usePreSignAndSubmitDeltaOrder.js";
+import { useReferrer as x } from "../../useReferrer.js";
+import { useCreateAndSubmitTwapOrder as S } from "../prices/delta/mutations/twap/useCreateTwapOrder.js";
+import { usePreSignAndSubmitTwapOrder as re } from "../prices/delta/mutations/twap/usePreSignAndSubmitTwapOrder.js";
+import { useDepositAndSubmitTwapOrder as ie } from "../prices/delta/mutations/twap/useDepositAndSubmitTwapOrder.js";
+import { useRef as ae } from "react";
+import { useMutation as oe } from "@tanstack/react-query";
+import { assert as C } from "ts-essentials";
 import "viem";
-import { useAccount as oe } from "wagmi";
+import { useAccount as se } from "wagmi";
 //#region src/hooks/swap/tradeFlow/useTwapFlow.ts
-var se = "twapOrder", ce = "runTwapOrderFlow";
-function D({ twapPrice: p }) {
-	let D = e("TwapFlow"), { queryKey: ue, price: de, chainId: O, refetch: fe, totalSrcAmount: pe, side: me, numSlices: k, priceParams: he } = g({ enabled: !1 }), A = de || p, ge = i(), _e = me || ge, { approval: j, signPermit: M, approveTxMut: N, signPermitMut: P, events: F } = x({
-		srcToken: A?.srcToken,
+var w = "twapOrder", ce = "runTwapOrderFlow";
+function T({ twapPrice: p }) {
+	let T = e("TwapFlow"), { queryKey: ue, price: de, chainId: E, refetch: fe, totalSrcAmount: pe, side: me, numSlices: D, priceParams: he } = g({ enabled: !1 }), O = de || p, ge = r(), _e = me || ge, { approval: k, signPermit: A, approveTxMut: j, signPermitMut: M, events: N } = ne({
+		srcToken: O?.inputToken.address,
 		srcAmount: pe,
 		spenderContractType: "ParaswapDelta",
 		swapSide: _e,
 		tradeMode: "twap",
-		chainId: O,
+		chainId: E,
 		tryPermit2: !1
-	}), { address: I } = oe(), { minClient: L } = m({
-		chainId: O,
-		account: I
-	}), R = w({
-		chainId: O,
-		account: I,
-		client: L,
+	}), { address: P } = se(), { minClient: F } = m({
+		chainId: E,
+		account: P
+	}), I = S({
+		chainId: E,
+		account: P,
+		client: F,
 		mutationOptions: {
 			onSuccess: (e) => {
-				D.log("Create Twap Order success", e);
+				T.log("Create Twap Order success", e);
 			},
 			onError: (e) => {
-				D.error("Create Twap Order error", e);
+				T.error("Create Twap Order error", e);
 			}
 		}
-	}), z = {
-		order: R.order,
-		isCreatingOrder: R.isCreatingOrder,
-		isPostingOrder: R.isPostingOrder,
-		isOrderSent: R.isOrderSent,
-		isPending: R.isPending,
-		isError: R.isError,
-		isSuccess: R.isSuccess,
-		error: R.error
-	}, { twapOrderPreSign: B, canBatchTxs: ve, isConnectedToSafe: ye, preSignAndSubmitTwapOrder: be, reset: V } = T({
-		chainId: O,
-		account: I,
-		logger: D,
-		viemClient: L
-	}), { twapOrderDeposit: H, reset: xe, depositAndSubmitTwapOrder: Se } = ne({
-		chainId: O,
-		account: I,
-		logger: D,
-		viemClient: L
-	}), U = {
-		order: z.order || B.order || H.order,
-		isPostingOrder: z.isPostingOrder || B.postingOrder.isPostingOrder || H.postingOrder.isPostingOrder,
-		isCreatingOrder: z.isCreatingOrder || B.isCreatingOrder || H.isCreatingOrder,
-		isOrderSent: z.isOrderSent || B.isOrderSent || H.isOrderSent,
-		isPending: z.isPending || B.isPending || H.isPending,
-		isError: z.isError || B.isError || H.isError,
-		isSuccess: z.isSuccess || B.isSuccess || H.isSuccess,
-		error: z.error || B.error || H.error
-	}, W = f({
-		orderId: U.order?.id,
-		refetchInterval: o,
+	}), L = {
+		order: I.order,
+		isCreatingOrder: I.isCreatingOrder,
+		isPostingOrder: I.isPostingOrder,
+		isOrderSent: I.isOrderSent,
+		isPending: I.isPending,
+		isError: I.isError,
+		isSuccess: I.isSuccess,
+		error: I.error
+	}, { twapOrderPreSign: R, canBatchTxs: ve, isConnectedToSafe: ye, preSignAndSubmitTwapOrder: be, reset: z } = re({
+		chainId: E,
+		account: P,
+		logger: T,
+		viemClient: F
+	}), { twapOrderDeposit: B, reset: V, depositAndSubmitTwapOrder: xe } = ie({
+		chainId: E,
+		account: P,
+		logger: T,
+		viemClient: F
+	}), H = {
+		order: L.order || R.order || B.order,
+		isPostingOrder: L.isPostingOrder || R.postingOrder.isPostingOrder || B.postingOrder.isPostingOrder,
+		isCreatingOrder: L.isCreatingOrder || R.isCreatingOrder || B.isCreatingOrder,
+		isOrderSent: L.isOrderSent || R.isOrderSent || B.isOrderSent,
+		isPending: L.isPending || R.isPending || B.isPending,
+		isError: L.isError || R.isError || B.isError,
+		isSuccess: L.isSuccess || R.isSuccess || B.isSuccess,
+		error: L.error || R.error || B.error
+	}, U = f({
+		orderId: H.order?.id,
+		refetchInterval: a,
 		onAuctionSuccess: (e) => {
-			D.log("Twap Order success", e);
+			T.log("Twap Order success", e);
 		},
 		onAuctionFailure: (e) => {
-			D.log("Twap Order failure", e);
+			T.log("Twap Order failure", e);
 		},
 		onUpdatedAuction: (e) => {
-			D.log("Twap Order updated", e);
+			T.log("Twap Order updated", e);
 		}
-	}), G = W.data ? d(W.data) : null, K = {
-		sentOrder: U.order,
-		lastOrderState: W.data,
-		isOrderPending: G === "pending",
-		isOrderExecuting: G === "executing",
-		isOrderExecuted: G === "confirmed",
-		isPending: W.isLoading || W.isRefetching || G === "pending" || G === "executing",
-		isError: W.isError || G === "failed",
-		isSuccess: G === "confirmed",
-		error: W.error
-	}, q = K.lastOrderState || K.sentOrder, J = v({
-		order: q,
-		chainId: O,
-		account: I,
-		client: L,
-		logger: D,
-		mutationOptions: { onMutate: () => (E(q, "No order to cancel"), q) }
-	}), Ce = {
-		receipt: J.receipt,
-		txHash: J.txHash,
-		response: J.cancelOrderResponse,
-		isCancelingOrder: J.isPending,
-		isOrderCancellable: J.isOrderCancellable,
-		isOrderCanceled: J.isSuccess,
-		isPending: J.isPending,
-		isError: J.isError,
-		isSuccess: J.isSuccess,
-		error: J.error,
-		result: J.result,
-		step: J.step
-	}, we = _(), Y = ie(null), X = ie(null), Te = () => {
-		Y.current?.abort(new y()), Y.current = null, X.current = null;
-	}, Ee = a(), { markNonceAsUsed: De, clearNonce: Oe } = b({ chainId: O }), { partner: ke, partnerAddress: Ae, partnerFeeBps: je, partnerTakesSurplus: Me } = h(), { referrerAddress: Ne } = C(), Pe = n(), { onTwapOrder: Z } = u(), Fe = l(), Ie = c(), Le = async ({ onTxSent: e, lastPrice: n } = {}) => {
-		N.reset(), P.reset(), R.reset(), J.reset(), V(), xe(), E(A, "Twap price is not available");
-		let i = new AbortController();
-		Y.current = i;
-		let a = i.signal, { orderDeadline: o, orderInterval: c } = ee({
-			durationMin: Ie,
-			numSlices: k
-		}), l = Math.floor(Fe * 100), u, d, f, p = j.allowanceToSet, m = M.amountToPermit, h = A;
-		if (h.hmac === n?.hmac) {
+	}), W = U.data ? d(U.data) : null, G = {
+		sentOrder: H.order,
+		lastOrderState: U.data,
+		isOrderPending: W === "pending",
+		isOrderExecuting: W === "executing",
+		isOrderExecuted: W === "confirmed",
+		isPending: U.isLoading || U.isRefetching || W === "pending" || W === "executing",
+		isError: U.isError || W === "failed",
+		isSuccess: W === "confirmed",
+		error: U.error
+	}, K = G.lastOrderState || G.sentOrder, q = te({
+		order: K,
+		chainId: E,
+		account: P,
+		client: F,
+		logger: T,
+		mutationOptions: { onMutate: () => (C(K, "No order to cancel"), K) }
+	}), Se = {
+		receipt: q.receipt,
+		txHash: q.txHash,
+		response: q.cancelOrderResponse,
+		isCancelingOrder: q.isPending,
+		isOrderCancellable: q.isOrderCancellable,
+		isOrderCanceled: q.isSuccess,
+		isPending: q.isPending,
+		isError: q.isError,
+		isSuccess: q.isSuccess,
+		error: q.error,
+		result: q.result,
+		step: q.step
+	}, Ce = _(), J = ae(null), Y = ae(null), we = () => {
+		J.current?.abort(new v()), J.current = null, Y.current = null;
+	}, Te = i(), { markNonceAsUsed: Ee, clearNonce: De } = y({ chainId: E }), { partner: Oe, partnerAddress: ke, partnerFeeBps: Ae, partnerTakesSurplus: je } = h(), { referrerAddress: Me } = x(), Ne = t(), { onTwapOrder: X } = u(), Pe = l(), Fe = c(), Ie = async ({ onTxSent: e, lastPrice: t } = {}) => {
+		j.reset(), M.reset(), I.reset(), q.reset(), z(), V(), C(O, "Twap price is not available");
+		let r = new AbortController();
+		J.current = r;
+		let i = r.signal, { orderDeadline: a, orderInterval: c } = s({
+			durationMin: Fe,
+			numSlices: D
+		}), l = Math.floor(Pe * 100), u, d, f, p = k.allowanceToSet, m = A.amountToPermit, h = O;
+		if (h.id === t?.id) {
 			let e = await fe({ cancelRefetch: !1 });
-			a.throwIfAborted(), e.data && (h = e.data);
+			i.throwIfAborted(), e.data && (h = e.data);
 		}
 		let g;
-		X.current = h;
-		let _ = r(h.srcToken), { shouldDoApprovalTxOrPermit: v, tryPermit: y, shouldPreSignBatch: b } = S({
-			approval: j,
-			signPermit: M,
+		Y.current = h;
+		let _ = n(h.inputToken.address), { shouldDoApprovalTxOrPermit: te, tryPermit: v, shouldPreSignBatch: y } = b({
+			approval: k,
+			signPermit: A,
 			canBatchTxs: ve,
 			isConnectedToSafe: ye
 		});
 		try {
-			if (v && p) {
+			if (te && p) {
 				let t = ue;
 				if (t) {
 					let e = p;
-					g = Pe({
+					g = Ne({
 						queryKey: t,
 						onData: (t) => {
 							let n = t;
-							if (a.aborted) {
+							if (i.aborted) {
 								g?.(), g = void 0;
 								return;
 							}
-							let { srcAmount: r } = s({
+							let { srcAmount: r } = o({
 								price: n,
-								numSlices: k
+								numSlices: D
 							});
-							e >= BigInt(r) && (D.log("~ fresh price ~", n), h = n, X.current = h);
+							e >= BigInt(r) && (T.log("~ fresh price ~", n), h = n, Y.current = h);
 						}
 					});
 				}
 				try {
-					if (y) F.onSignPermit.request({ allowanceToSet: m }), u = await P.signPermitAsync({
-						deadline: BigInt(o),
+					if (v) N.onSignPermit.request({ allowanceToSet: m }), u = await M.signPermitAsync({
+						deadline: BigInt(a),
 						value: m
-					}), F.onSignPermit.confirmed({
+					}), N.onSignPermit.confirmed({
 						allowanceToSet: m,
 						permit: u?.permitEncodedArgs
 					});
 					else {
-						F.onApproveTx.request({ allowanceToSet: p }), d = await N.approveAsync({ allowanceData: { allowanceToSet: p } }), F.onApproveTx.sent({
+						N.onApproveTx.request({ allowanceToSet: p }), d = await j.approveAsync({ allowanceData: { allowanceToSet: p } }), N.onApproveTx.sent({
 							allowanceToSet: p,
 							txHash: d
-						}), a.throwIfAborted();
-						let t = we({
+						}), i.throwIfAborted();
+						let t = Ce({
 							hash: d,
-							chainId: O,
+							chainId: E,
 							onReplaced: (e) => {
-								D.log("onReplaced:approveTx", d, e);
+								T.log("onReplaced:approveTx", d, e);
 							}
 						});
 						e && e({
-							chainId: O,
+							chainId: E,
 							action: "approve",
 							transactionHash: d,
 							receiptPromise: t,
 							transactionSpecificData: {
 								action: "approve",
 								approvedAmount: p,
-								tokenAddress: j.token,
-								spenderAddress: j.spender
+								tokenAddress: k.token,
+								spenderAddress: k.spender
 							}
-						}), f = await t, F.onApproveTx.confirmed({
+						}), f = await t, N.onApproveTx.confirmed({
 							allowanceToSet: p,
 							txHash: d,
 							txReceipt: f
-						}), D.log("~ approveTx ~ receipt:", f);
+						}), T.log("~ approveTx ~ receipt:", f);
 					}
 				} catch (e) {
-					throw y ? F.onSignPermit.failed({
+					throw v ? N.onSignPermit.failed({
 						allowanceToSet: m,
 						error: e
-					}) : F.onApproveTx.failed({
+					}) : N.onApproveTx.failed({
 						allowanceToSet: p,
 						error: e,
 						txHash: d
 					}), e;
 				}
 			}
-			a.throwIfAborted(), E(I, "Account is not connected");
-			let n = h;
-			X.current = n, g?.(), g = void 0, E(n, "Twap price is not available");
-			let r = te(n), { srcAmount: i, destAmount: ee } = s({
-				price: n,
-				numSlices: k
-			}), x = u?.permitEncodedArgs, S = t(n) ? n.bridge.destinationChainId : O;
-			Z?.({ event: {
+			i.throwIfAborted(), C(P, "Account is not connected");
+			let t = h;
+			Y.current = t, g?.(), g = void 0, C(t, "Twap price is not available");
+			let n = ee(t), { srcAmount: r, destAmount: s } = o({
+				price: t,
+				numSlices: D
+			}), ne = u?.permitEncodedArgs;
+			X?.({ event: {
 				name: "TwapOrder:request",
-				params: { price: n }
+				params: { price: t }
 			} });
-			let C, w;
-			w = r === "SELL" ? {
+			let b, x;
+			x = n === "SELL" ? {
 				onChainOrderType: "TWAPOrder",
-				totalSrcAmount: i
+				totalSrcAmount: r
 			} : {
 				onChainOrderType: "TWAPBuyOrder",
-				totalDestAmount: ee,
-				maxSrcAmount: i
+				totalDestAmount: s,
+				maxSrcAmount: r
 			};
-			let T = {
-				signal: a,
+			let S = {
+				signal: i,
 				type: "MARKET",
 				degenMode: he.degenMode,
-				referrerAddress: Ne,
+				referrerAddress: Me,
 				orderInput: {
-					owner: I,
-					beneficiary: Ee,
-					srcToken: n.srcToken,
-					destToken: n.destToken,
-					permit: x,
-					destChainId: S,
-					deltaPrice: {
-						...n,
-						bridge: {
-							...n.bridge,
-							protocolSelector: re.protocolSelector
-						},
-						partner: ke
-					},
-					partner: ke,
-					partnerAddress: Ae,
-					partnerFeeBps: je,
-					partnerTakesSurplus: Me,
-					deadline: o,
-					...w,
-					numSlices: k,
+					owner: P,
+					beneficiary: Te,
+					permit: ne,
+					route: t.route,
+					partner: Oe,
+					partnerAddress: ke,
+					partnerFeeBps: Ae,
+					partnerTakesSurplus: je,
+					deadline: a,
+					...x,
+					numSlices: D,
 					slippage: l,
 					interval: c
 				}
 			};
-			return C = _ ? await Se({
-				createOrderInput: T,
-				depositAmount: le(w, Fe),
+			return b = _ ? await xe({
+				createOrderInput: S,
+				depositAmount: le(x, Pe),
 				onTxSent: e
-			}) : b ? await be({
-				createOrderInput: T,
-				approval: j,
+			}) : y ? await be({
+				createOrderInput: S,
+				approval: k,
 				onTxSent: e
-			}) : await R.mutateAsync(T), u && De(u.signedPermitData), Z?.({ event: {
+			}) : await I.mutateAsync(S), u && Ee(u.signedPermitData), X?.({ event: {
 				name: "TwapOrder:sent",
 				params: {
-					price: n,
-					order: C
+					price: t,
+					order: b
 				}
 			} }), {
-				tradeFlowType: se,
+				tradeFlowType: w,
 				approve: {
 					txHash: d,
 					receipt: f
 				},
-				twapOrder: { sentOrder: C },
-				twapPrice: n,
-				account: I,
-				receiverAddress: Ee
+				twapOrder: { sentOrder: b },
+				twapPrice: t,
+				account: P,
+				receiverAddress: Te
 			};
 		} catch (e) {
-			throw u && Oe(u.signedPermitData), Z?.({ event: {
+			throw u && De(u.signedPermitData), X?.({ event: {
 				name: "TwapOrder:failed",
 				params: { error: e }
 			} }), e;
 		} finally {
 			g?.();
 		}
-	}, Re = async () => {
+	}, Le = async () => {
 		try {
-			return await J.cancelDeltaOrder();
+			return await q.cancelDeltaOrder();
 		} catch (e) {
-			D.error("Cancel Delta order error", e), J.reset();
+			T.error("Cancel Delta order error", e), q.reset();
 		}
-	}, Q = ae({
-		mutationFn: Le,
+	}, Z = oe({
+		mutationFn: Ie,
 		mutationKey: [ce],
 		onSuccess: (e) => {
-			D.log("Twap Order success", e);
+			T.log("Twap Order success", e);
 		},
 		onError: (e) => {
-			D.error("Twap Order error", e);
+			T.error("Twap Order error", e);
 		},
 		onSettled: () => {
-			D.log("Twap Order settled");
+			T.log("Twap Order settled");
 		}
-	}), ze = Q.mutateAsync, Be = () => {
-		X.current = null, N.reset(), P.reset(), R.reset(), Q.reset(), J.reset(), V(), xe();
-	}, Ve = (e) => {
-		let t = X.current;
-		return Be(), ze({
+	}), Re = Z.mutateAsync, Q = () => {
+		Y.current = null, j.reset(), M.reset(), I.reset(), Z.reset(), q.reset(), z(), V();
+	}, ze = (e) => {
+		let t = Y.current;
+		return Q(), Re({
 			...e,
 			lastPrice: t
 		});
-	}, He = X.current || A, $ = Q.data;
-	$ && K.lastOrderState && ($ = {
+	}, Be = Y.current || O, $ = Z.data;
+	$ && G.lastOrderState && ($ = {
 		...$,
 		twapOrder: {
 			sentOrder: $.twapOrder.sentOrder,
-			lastOrderState: K.lastOrderState
+			lastOrderState: G.lastOrderState
 		}
 	});
-	let Ue = $?.twapOrder.sentOrder || K.lastOrderState || K.sentOrder;
+	let Ve = $?.twapOrder.sentOrder || G.lastOrderState || G.sentOrder;
 	return {
-		tradeFlowType: se,
-		chainId: O,
-		runTwapOrderFlow: ze,
-		reset: Be,
-		cancelFlow: Te,
-		retryFlow: Ve,
-		cancelTwapOrder: Re,
-		approval: j,
-		signPermit: M,
-		twapOrderPreSign: B,
-		twapOrderDeposit: H,
-		twapOrderSubmission: U,
-		twapOrderExecution: K,
-		twapOrderCancelation: Ce,
-		isPending: Q.isPending,
-		isSuccess: U.isSuccess && K.isSuccess,
-		isError: Q.isError,
-		error: Q.error,
+		tradeFlowType: w,
+		chainId: E,
+		runTwapOrderFlow: Re,
+		reset: Q,
+		cancelFlow: we,
+		retryFlow: ze,
+		cancelTwapOrder: Le,
+		approval: k,
+		signPermit: A,
+		twapOrderPreSign: R,
+		twapOrderDeposit: B,
+		twapOrderSubmission: H,
+		twapOrderExecution: G,
+		twapOrderCancelation: Se,
+		isPending: Z.isPending,
+		isSuccess: H.isSuccess && G.isSuccess,
+		isError: Z.isError,
+		error: Z.error,
 		result: $,
-		usedPrice: He,
-		freshPrice: A,
-		submittedTwapOrder: Ue
+		usedPrice: Be,
+		freshPrice: O,
+		submittedTwapOrder: Ve
 	};
 }
 function le(e, t) {
 	return "totalSrcAmount" in e ? e.totalSrcAmount : p(e.maxSrcAmount, t, "BUY").toFixed(0);
 }
 //#endregion
-export { D as useTwapFlow };
+export { T as useTwapFlow };
 
 //# sourceMappingURL=useTwapFlow.js.map