@velora-dex/widget 0.7.1 → 0.7.2

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

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