@velora-dex/widget 0.8.3-dev.1 → 0.8.4-dev.0

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

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