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

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

@@ -6,21 +6,21 @@ import { useSwapSide as o } from "../../../components/widget/SwapModeSwitcher/st
 import { useSwapReceiverAddressValue as s } from "../../../components/widget/ReceiverAddress/state/receiverAddressAtom.js";
 import { protocolNameAtom as c } from "../../../components/widget/TradeParameters/state/bridgePreferences/protocolNameAtom.js";
 import { bridgePreferenceAtom as l } from "../../../components/widget/TradeParameters/state/bridgePreferences/bridgePreferenceAtom.js";
-import { produceDeltaOrderDeadline as ee } from "../../../lib/utils/delta.js";
-import { useWidgetEvents as u } from "../../../core/state/widgetEventsAtom.js";
-import { getOverallOrderStatus as d } from "../prices/delta/orders/utils.js";
-import { useEnsureDeltaOrderExecuted as f, useWatchDeltaAuction as p } from "../prices/delta/queries/useWatchDeltaOrder.js";
-import { useSlippage as m } from "../../useSlippage.js";
-import { useMinViemClient as h } from "../../useMinViemClient.js";
-import { usePartner as te } from "../../usePartner.js";
-import { useExtraDeltaPriceParams as ne, usePricesParams as g } from "../prices/usePricesParams.js";
-import { extractSelectedBridgePrice as re } from "../prices/delta/bridge/utils.js";
-import { useSelectedBridgePrice as ie } from "../prices/delta/bridge/useSelectedBridgePrice.js";
-import { deltaOrdersQueryKey as _ } from "../prices/delta/queries/useDeltaOrders.js";
-import { applySlippage as v } from "../../../lib/utils/price.js";
-import { useEnsureTxReceipt as y } from "../../txs/queries/useAwaitTx.js";
-import { useCancelOrWithdrawAndCancelDeltaOrder as b } from "../prices/delta/mutations/useCancelOrWithdrawAndCancelDeltaOrder.js";
-import { UserCancelledError as x, isTransactionCancelledError as S } from "./common/errors.js";
+import { produceDeltaOrderDeadline as u } from "../../../lib/utils/delta.js";
+import { useWidgetEvents as d } from "../../../core/state/widgetEventsAtom.js";
+import { getOverallOrderStatus as f, getSwapSideFromDeltaPrice as p } from "../prices/delta/orders/utils.js";
+import { extractSelectedBridgePrice as m } from "../prices/delta/bridge/utils.js";
+import { useEnsureDeltaOrderExecuted as h, useWatchDeltaAuction as g } from "../prices/delta/queries/useWatchDeltaOrder.js";
+import { useSlippage as _ } from "../../useSlippage.js";
+import { useMinViemClient as v } from "../../useMinViemClient.js";
+import { usePartner as ee } from "../../usePartner.js";
+import { useExtraDeltaPriceParams as te, usePricesParams as y } from "../prices/usePricesParams.js";
+import { useSelectedBridgePrice as ne } from "../prices/delta/bridge/useSelectedBridgePrice.js";
+import { deltaOrdersQueryKey as b } from "../prices/delta/queries/useDeltaOrders.js";
+import { applySlippage as re } from "../../../lib/utils/price.js";
+import { useEnsureTxReceipt as x } from "../../txs/queries/useAwaitTx.js";
+import { useCancelOrWithdrawAndCancelDeltaOrder as S } from "../prices/delta/mutations/useCancelOrWithdrawAndCancelDeltaOrder.js";
+import { UserCancelledError as C, isTransactionCancelledError as ie } from "./common/errors.js";
 import { useCreateAndSubmitDeltaOrder as ae } from "../prices/delta/mutations/useCreateDeltaOrder.js";
 import { encodePermit2TransferFromSigDataForDelta as oe } from "../../permit/utils/encodeArgs.js";
 import { useMarkPermit1Or2NonceAsUsed as se } from "./common/useSignPermit1Or2.js";
@@ -28,103 +28,103 @@ import { useApproveOrPermit as ce } from "./common/useApproveOrPermit.js";
 import { shouldApproveOrBatch as le, usePreSignAndSubmitDeltaOrder as ue } from "./common/usePreSignAndSubmitDeltaOrder.js";
 import { useDepositAndSubmitDeltaOrder as de } from "./common/useDepositAndSubmitDeltaOrder.js";
 import { useReferrer as fe } from "../../useReferrer.js";
-import { useRef as C } from "react";
-import { useMutation as pe, useQueryClient as me } from "@tanstack/react-query";
+import { useRef as pe } from "react";
+import { useMutation as me, useQueryClient as he } from "@tanstack/react-query";
 import { assert as w } from "ts-essentials";
-import { useAccount as he } from "wagmi";
+import { useAccount as ge } from "wagmi";
 //#region src/hooks/swap/tradeFlow/useDeltaFlow.ts
-var ge = "deltaOrder", _e = "runDeltaOrderFlow";
-function ve({ deltaPrice: ve }) {
-	let T = t("DeltaFlow"), { resolvedSlippage: E } = m("swap"), { priceParams: ye, chainId: D, destChainId: be } = g("swap"), xe = ne(), { result: O, queryKey: Se } = r({
+var T = "deltaOrder", _e = "runDeltaOrderFlow";
+function E({ deltaPrice: E }) {
+	let D = t("DeltaFlow"), { resolvedSlippage: ve } = _("swap"), { priceParams: ye, chainId: O, destChainId: be } = y("swap"), xe = te(), { result: k, queryKey: Se } = r({
 		priceParams: {
 			...ye,
 			...xe
 		},
-		chainId: D,
+		chainId: O,
 		destChainId: be,
 		query: { enabled: !1 }
-	}), k = ie({ price: O.data }) || O.data || ve, Ce = o(), A = !!k && k.inputToken.address.toLowerCase() !== k.outputToken.address.toLowerCase(), { approval: j, signPermit: M, approveTxMut: N, signPermitMut: P, events: F } = ce({
-		srcToken: k?.inputToken.address,
-		srcAmount: k?.route.origin.input.amount,
+	}), A = ne({ price: k.data }) || k.data || E, Ce = o(), j = !!A && A.srcToken.toLowerCase() !== A.destToken.toLowerCase(), { approval: M, signPermit: N, approveTxMut: P, signPermitMut: F, events: I } = ce({
+		srcToken: A?.srcToken,
+		srcAmount: A?.srcAmount,
 		spenderContractType: "ParaswapDelta",
-		swapSide: k?.side || Ce,
+		swapSide: A && p(A) || Ce,
 		tradeMode: "swap",
-		chainId: D,
-		applySlippage: A
-	}), { address: I } = he(), { minClient: L } = h({
-		chainId: D,
-		account: I
-	}), we = me(), R = ae({
-		chainId: D,
-		account: I,
-		client: L,
+		chainId: O,
+		applySlippage: j
+	}), { address: L } = ge(), { minClient: R } = v({
+		chainId: O,
+		account: L
+	}), we = he(), z = ae({
+		chainId: O,
+		account: L,
+		client: R,
 		mutationOptions: {
 			onSuccess: (e) => {
-				T.log("Create Delta Order success", e);
+				D.log("Create Delta Order success", e);
 			},
 			onError: (e) => {
-				T.error("Create Delta Order error", e);
+				D.error("Create Delta 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
-	}, { deltaOrderPreSign: B, canBatchTxs: Te, isConnectedToSafe: Ee, preSignAndSubmitDeltaOrder: De, reset: Oe } = ue({
-		chainId: D,
-		account: I,
-		logger: T,
-		viemClient: L
-	}), { deltaOrderDeposit: V, reset: ke, depositAndSubmitDeltaOrder: Ae } = de({
-		chainId: D,
-		account: I,
-		logger: T,
-		viemClient: L
-	}), H = {
-		order: z.order || B.order || V.order,
-		isPostingOrder: z.isPostingOrder || B.postingOrder.isPostingOrder || V.postingOrder.isPostingOrder,
-		isCreatingOrder: z.isCreatingOrder || B.isCreatingOrder || V.isCreatingOrder,
-		isOrderSent: z.isOrderSent || B.isOrderSent || V.isOrderSent,
-		isPending: z.isPending || B.isPending || V.isPending,
-		isError: z.isError || B.isError || V.isError,
-		isSuccess: z.isSuccess || B.isSuccess || V.isSuccess,
-		error: z.error || B.error || V.error
-	}, U = p({
-		orderId: H.order?.id,
+	}), B = {
+		order: z.order,
+		isCreatingOrder: z.isCreatingOrder,
+		isPostingOrder: z.isPostingOrder,
+		isOrderSent: z.isOrderSent,
+		isPending: z.isPending,
+		isError: z.isError,
+		isSuccess: z.isSuccess,
+		error: z.error
+	}, { deltaOrderPreSign: V, canBatchTxs: Te, isConnectedToSafe: Ee, preSignAndSubmitDeltaOrder: De, reset: Oe } = ue({
+		chainId: O,
+		account: L,
+		logger: D,
+		viemClient: R
+	}), { deltaOrderDeposit: H, reset: ke, depositAndSubmitDeltaOrder: Ae } = de({
+		chainId: O,
+		account: L,
+		logger: D,
+		viemClient: R
+	}), U = {
+		order: B.order || V.order || H.order,
+		isPostingOrder: B.isPostingOrder || V.postingOrder.isPostingOrder || H.postingOrder.isPostingOrder,
+		isCreatingOrder: B.isCreatingOrder || V.isCreatingOrder || H.isCreatingOrder,
+		isOrderSent: B.isOrderSent || V.isOrderSent || H.isOrderSent,
+		isPending: B.isPending || V.isPending || H.isPending,
+		isError: B.isError || V.isError || H.isError,
+		isSuccess: B.isSuccess || V.isSuccess || H.isSuccess,
+		error: B.error || V.error || H.error
+	}, W = g({
+		orderId: U.order?.id,
 		onAuctionSuccess: (e) => {
-			T.log("Delta Order success", e);
+			D.log("Delta Order success", e);
 		},
 		onAuctionFailure: (e) => {
-			T.log("Delta Order failure", e);
+			D.log("Delta Order failure", e);
 		},
 		onUpdatedAuction: (e) => {
-			T.log("Delta Order updated", e);
+			D.log("Delta 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
-	}, { onSwap: K } = u(), q = G.lastOrderState || G.sentOrder, J = b({
-		order: q,
-		chainId: D,
-		account: I,
-		client: L,
-		logger: T,
+	}), G = W.data ? f(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
+	}, { onSwap: q } = d(), J = K.lastOrderState || K.sentOrder, Y = S({
+		order: J,
+		chainId: O,
+		account: L,
+		client: R,
+		logger: D,
 		mutationOptions: {
-			onMutate: () => (w(q, "No order to cancel"), q),
+			onMutate: () => (w(J, "No order to cancel"), J),
 			onSuccess: (e, t, n) => {
-				K?.({ event: {
+				q?.({ event: {
 					name: "Swap:cancelled",
 					params: {
 						swapMode: "delta",
@@ -134,212 +134,217 @@ function ve({ deltaPrice: ve }) {
 			}
 		}
 	}), je = {
-		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
-	}, Me = f({
+		receipt: Y.receipt,
+		txHash: Y.txHash,
+		response: Y.cancelOrderResponse,
+		isCancelingOrder: Y.isPending,
+		isOrderCancellable: Y.isOrderCancellable,
+		isOrderCanceled: Y.isSuccess,
+		isPending: Y.isPending,
+		isError: Y.isError,
+		isSuccess: Y.isSuccess,
+		error: Y.error,
+		result: Y.result,
+		step: Y.step
+	}, Me = h({
 		onAuctionSuccess: (e) => {
 			we.invalidateQueries({
-				queryKey: _({ userAddress: e.owner }),
+				queryKey: b({ userAddress: e.user }),
 				exact: !1
 			});
 		},
 		onAuctionFailure: (e) => {
 			we.invalidateQueries({
-				queryKey: _({ userAddress: e.owner }),
+				queryKey: b({ userAddress: e.user }),
 				exact: !1
 			});
 		}
-	}), Ne = y(), Y = C(null), X = C(null), Pe = () => {
-		Y.current?.abort(new x()), Y.current = null, X.current = null;
-	}, Fe = s(), { markNonceAsUsed: Ie, clearNonce: Le } = se({ chainId: D }), { partner: Re, partnerAddress: ze, partnerFeeBps: Be, partnerTakesSurplus: Ve } = te(), { referrerAddress: He } = fe(), Ue = e(c), We = e(l), Ge = i(), Ke = async ({ onTxSent: e, onOrderSent: t, lastPrice: r } = {}) => {
-		N.reset(), P.reset(), R.reset(), J.reset(), Oe(), ke(), w(k, "Delta price is not available");
-		let i = k.side, o = new AbortController();
-		Y.current = o;
-		let s = o.signal, c = ee(), l, u, d, f = j.allowanceToSet, p = M.amountToPermit, m = k;
-		if (m.id === r?.id) {
-			let e = await O.refetch({ cancelRefetch: !1 });
-			s.throwIfAborted(), e.data && (m = e.data, n(m) && (m = re({
-				price: m,
+	}), Ne = x(), X = pe(null), Z = pe(null), Pe = () => {
+		X.current?.abort(new C()), X.current = null, Z.current = null;
+	}, Fe = s(), { markNonceAsUsed: Ie, clearNonce: Le } = se({ chainId: O }), { partner: Re, partnerAddress: ze, partnerFeeBps: Be, partnerTakesSurplus: Ve } = ee(), { referrerAddress: He } = fe(), Ue = e(c), We = e(l), Ge = i(), Ke = async ({ onTxSent: e, onOrderSent: t, lastPrice: r } = {}) => {
+		P.reset(), F.reset(), z.reset(), Y.reset(), Oe(), ke(), w(A, "Delta price is not available");
+		let i = p(A), o = new AbortController();
+		X.current = o;
+		let s = o.signal, c = u(), l, d, f, h = M.allowanceToSet, g = N.amountToPermit, _ = A;
+		if (_.hmac === r?.hmac) {
+			let e = await k.refetch({ cancelRefetch: !1 });
+			s.throwIfAborted(), e.data && (_ = e.data, n(_) && (_ = m({
+				price: _,
 				protocolName: Ue,
 				bridgePreference: We
 			})));
 		}
-		let h;
-		X.current = m;
-		let te = a(m.inputToken.address), { shouldDoApprovalTxOrPermit: ne, tryPermit: g, shouldPreSignBatch: ie } = le({
-			approval: j,
-			signPermit: M,
+		let v;
+		Z.current = _;
+		let ee = a(_.srcToken), { shouldDoApprovalTxOrPermit: te, tryPermit: y, shouldPreSignBatch: ne } = le({
+			approval: M,
+			signPermit: N,
 			canBatchTxs: Te,
 			isConnectedToSafe: Ee
 		});
 		try {
-			if (ne && f) {
+			if (te && h) {
 				let t = Se;
 				if (t) {
-					let e = f;
-					h = Ge({
+					let e = h;
+					v = Ge({
 						queryKey: t,
 						onData: (t) => {
 							let r = t;
-							if (n(t) && (r = re({
+							if (n(t) && (r = m({
 								price: t,
 								protocolName: Ue,
 								bridgePreference: We
 							})), s.aborted) {
-								h?.(), h = void 0;
+								v?.(), v = void 0;
 								return;
 							}
 							let a = {
-								srcAmount: r.route.origin.input.amount,
-								destAmount: r.route.destination.output.amount
-							}, o = A ? v(a, E, i) : a;
-							e >= BigInt(o.srcAmount) && (T.log("~ fresh price ~", r), m = r, X.current = m);
+								srcAmount: r.srcAmount,
+								destAmount: r.destAmount
+							}, o = j ? re(a, ve, i) : a;
+							e >= BigInt(o.srcAmount) && (D.log("~ fresh price ~", r), _ = r, Z.current = _);
 						}
 					});
 				}
 				try {
-					if (g) F.onSignPermit.request({ allowanceToSet: p }), l = await P.signPermitAsync({
+					if (y) I.onSignPermit.request({ allowanceToSet: g }), l = await F.signPermitAsync({
 						deadline: c,
-						value: p
-					}), F.onSignPermit.confirmed({
-						allowanceToSet: p,
+						value: g
+					}), I.onSignPermit.confirmed({
+						allowanceToSet: g,
 						permit: l?.permitEncodedArgs
 					});
 					else {
-						F.onApproveTx.request({ allowanceToSet: f }), u = await N.approveAsync({ allowanceData: { allowanceToSet: f } }), F.onApproveTx.sent({
-							allowanceToSet: f,
-							txHash: u
+						I.onApproveTx.request({ allowanceToSet: h }), d = await P.approveAsync({ allowanceData: { allowanceToSet: h } }), I.onApproveTx.sent({
+							allowanceToSet: h,
+							txHash: d
 						}), s.throwIfAborted();
 						let t = Ne({
-							hash: u,
-							chainId: D,
+							hash: d,
+							chainId: O,
 							onReplaced: (e) => {
-								T.log("onReplaced:approveTx", u, e);
+								D.log("onReplaced:approveTx", d, e);
 							}
 						});
 						e && e({
-							chainId: D,
+							chainId: O,
 							action: "approve",
-							transactionHash: u,
+							transactionHash: d,
 							receiptPromise: t,
 							transactionSpecificData: {
 								action: "approve",
-								approvedAmount: f,
-								tokenAddress: j.token,
-								spenderAddress: j.spender
+								approvedAmount: h,
+								tokenAddress: M.token,
+								spenderAddress: M.spender
 							}
-						}), d = await t, F.onApproveTx.confirmed({
-							allowanceToSet: f,
-							txHash: u,
-							txReceipt: d
-						}), T.log("~ approveTx ~ receipt:", d);
+						}), f = await t, I.onApproveTx.confirmed({
+							allowanceToSet: h,
+							txHash: d,
+							txReceipt: f
+						}), D.log("~ approveTx ~ receipt:", f);
 					}
 				} catch (e) {
-					throw g ? F.onSignPermit.failed({
-						allowanceToSet: p,
+					throw y ? I.onSignPermit.failed({
+						allowanceToSet: g,
 						error: e
-					}) : F.onApproveTx.failed({
-						allowanceToSet: f,
+					}) : I.onApproveTx.failed({
+						allowanceToSet: h,
 						error: e,
-						txHash: u
+						txHash: d
 					}), e;
 				}
 			}
-			s.throwIfAborted(), w(I, "Account is not connected");
-			let r = m;
-			X.current = r, h?.(), h = void 0, w(r, "Delta price is not available");
+			s.throwIfAborted(), w(L, "Account is not connected");
+			let r = _;
+			Z.current = r, v?.(), v = void 0, w(r, "Delta price is not available");
 			let a = {
-				srcAmount: r.route.origin.input.amount,
-				destAmount: r.route.destination.output.amount
-			}, o = A ? v(a, E, i) : a, ee = A ? Math.round(E * 100) : 0, _ = l?.permitEncodedArgs;
-			l?.signedPermitData.type === "permit2" && l.signedPermitData.variant === "transferFrom" && (_ = oe({
+				srcAmount: r.srcAmount,
+				destAmount: r.destAmount
+			}, o = j ? re(a, ve, i) : a, u = l?.permitEncodedArgs;
+			l?.signedPermitData.type === "permit2" && l.signedPermitData.variant === "transferFrom" && (u = oe({
 				nonce: l.signedPermitData.nonce,
 				signature: l.signature
-			})), K?.({ event: {
+			}));
+			let p = n(r) ? r.bridge.destinationChainId : O;
+			q?.({ event: {
 				name: "Swap:request",
 				params: {
 					swapMode: "delta",
 					price: r
 				}
 			} });
-			let y, b = {
+			let b, x = {
 				signal: s,
 				type: "MARKET",
 				degenMode: ye.degenMode,
 				referrerAddress: He,
 				orderInput: {
-					owner: I,
+					owner: L,
 					beneficiary: Fe,
-					permit: _,
-					route: r.route,
-					side: i,
-					slippage: ee,
+					srcToken: r.srcToken,
+					destToken: r.destToken,
+					permit: u,
+					destChainId: p,
+					deltaPrice: r,
 					partner: Re,
 					partnerAddress: ze,
 					partnerFeeBps: Be,
 					partnerTakesSurplus: Ve,
-					deadline: Number(c)
+					...o,
+					deadline: Number(c),
+					side: i
 				}
 			};
-			if (te) {
-				let t = o.srcAmount;
-				y = await Ae({
-					createOrderInput: b,
+			if (ee) {
+				let t = x.orderInput.srcAmount;
+				b = await Ae({
+					createOrderInput: x,
 					depositAmount: t,
 					onTxSent: e
 				});
-			} else y = ie ? await De({
-				createOrderInput: b,
-				approval: j,
+			} else b = ne ? await De({
+				createOrderInput: x,
+				approval: M,
 				onTxSent: e
-			}) : await R.mutateAsync(b);
-			l && Ie(l.signedPermitData), K?.({ event: {
+			}) : await z.mutateAsync(x);
+			l && Ie(l.signedPermitData), q?.({ event: {
 				name: "Swap:sent",
 				params: {
 					swapMode: "delta",
 					price: r,
-					order: y
+					order: b
 				}
 			} });
-			let x = Me({ orderId: y.id });
+			let S = Me({ orderId: b.id });
 			t && t({
-				order: y,
-				lastOrderState: x
+				order: b,
+				lastOrderState: S
 			});
-			let S = await x;
-			return K?.({ event: {
+			let C = await S;
+			return q?.({ event: {
 				name: "Swap:confirmed",
 				params: {
 					swapMode: "delta",
 					price: r,
-					order: S ?? y
+					order: C ?? b
 				}
 			} }), {
-				tradeFlowType: ge,
+				tradeFlowType: T,
 				approve: {
-					txHash: u,
-					receipt: d
+					txHash: d,
+					receipt: f
 				},
 				deltaOrder: {
-					sentOrder: y,
-					lastOrderState: S
+					sentOrder: b,
+					lastOrderState: C
 				},
 				deltaPrice: r,
-				account: I,
+				account: L,
 				receiverAddress: Fe
 			};
 		} catch (e) {
-			throw l && Le(l.signedPermitData), S(e) || K?.({ event: {
+			throw l && Le(l.signedPermitData), ie(e) || q?.({ event: {
 				name: "Swap:failed",
 				params: {
 					swapMode: "delta",
@@ -347,61 +352,61 @@ function ve({ deltaPrice: ve }) {
 				}
 			} }), e;
 		} finally {
-			h?.();
+			v?.();
 		}
 	}, qe = async () => {
 		try {
-			return await J.cancelDeltaOrder();
+			return await Y.cancelDeltaOrder();
 		} catch (e) {
-			T.error("Cancel Delta order error", e), J.reset();
+			D.error("Cancel Delta order error", e), Y.reset();
 		}
-	}, Z = pe({
+	}, Q = me({
 		mutationFn: Ke,
 		mutationKey: [_e],
 		onSuccess: (e) => {
-			T.log("Delta Order success", e);
+			D.log("Delta Order success", e);
 		},
 		onError: (e) => {
-			T.error("Delta Order error", e);
+			D.error("Delta Order error", e);
 		},
 		onSettled: () => {
-			T.log("Delta Order settled");
+			D.log("Delta Order settled");
 		}
-	}), Je = Z.mutateAsync, Q = () => {
-		X.current = null, N.reset(), P.reset(), R.reset(), Z.reset(), J.reset(), Oe(), ke();
-	}, Ye = (e) => {
-		let t = X.current;
-		return Q(), Je({
+	}), Je = Q.mutateAsync, Ye = () => {
+		Z.current = null, P.reset(), F.reset(), z.reset(), Q.reset(), Y.reset(), Oe(), ke();
+	}, Xe = (e) => {
+		let t = Z.current;
+		return Ye(), Je({
 			...e,
 			lastPrice: t
 		});
-	}, Xe = X.current || k, $ = Z.data, Ze = $?.deltaOrder.lastOrderState || $?.deltaOrder.sentOrder || G.lastOrderState || G.sentOrder;
+	}, Ze = Z.current || A, $ = Q.data, Qe = $?.deltaOrder.lastOrderState || $?.deltaOrder.sentOrder || K.lastOrderState || K.sentOrder;
 	return {
-		tradeFlowType: ge,
-		chainId: D,
+		tradeFlowType: T,
+		chainId: O,
 		runDeltaOrderFlow: Je,
-		reset: Q,
+		reset: Ye,
 		cancelFlow: Pe,
-		retryFlow: Ye,
+		retryFlow: Xe,
 		cancelDeltaOrder: qe,
-		approval: j,
-		signPermit: M,
-		deltaOrderPreSign: B,
-		deltaOrderDeposit: V,
-		deltaOrderSubmission: H,
-		deltaOrderExecution: G,
+		approval: M,
+		signPermit: N,
+		deltaOrderPreSign: V,
+		deltaOrderDeposit: H,
+		deltaOrderSubmission: U,
+		deltaOrderExecution: K,
 		deltaOrderCancelation: je,
-		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: Xe,
-		freshPrice: k,
-		submittedDeltaOrder: Ze
+		usedPrice: Ze,
+		freshPrice: A,
+		submittedDeltaOrder: Qe
 	};
 }
 //#endregion
-export { ve as useDeltaFlow };
+export { E as useDeltaFlow };
 
 //# sourceMappingURL=useDeltaFlow.js.map