@velora-dex/widget 0.7.1 → 0.7.2

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

@@ -9,15 +9,15 @@ import { bridgePreferenceAtom as l } from "../../../components/widget/TradeParam
 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 ee } from "../prices/delta/bridge/utils.js";
-import { useEnsureDeltaOrderExecuted as m, useWatchDeltaAuction as h } from "../prices/delta/queries/useWatchDeltaOrder.js";
-import { useSlippage as g } from "../../useSlippage.js";
-import { useMinViemClient as _ } from "../../useMinViemClient.js";
-import { usePartner as te } from "../../usePartner.js";
-import { useExtraDeltaPriceParams as ne, usePricesParams as v } from "../prices/usePricesParams.js";
-import { useSelectedBridgePrice as re } from "../prices/delta/bridge/useSelectedBridgePrice.js";
-import { deltaOrdersQueryKey as y } from "../prices/delta/queries/useDeltaOrders.js";
-import { applySlippage as b } from "../../../lib/utils/price.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";
@@ -27,103 +27,104 @@ import { useMarkPermit1Or2NonceAsUsed as se } from "./common/useSignPermit1Or2.j
 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 { useRef as fe } from "react";
-import { useMutation as pe, useQueryClient as me } from "@tanstack/react-query";
+import { useReferrer as fe } from "../../useReferrer.js";
+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 T({ deltaPrice: T }) {
-	let E = t("DeltaFlow"), { resolvedSlippage: ve } = g("swap"), { priceParams: ye, chainId: D, destChainId: be } = v("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 = re({ price: O.data }) || O.data || T, Ce = o(), A = !!k && k.srcToken.toLowerCase() !== k.destToken.toLowerCase(), { approval: j, signPermit: M, approveTxMut: N, signPermitMut: P, events: F } = ce({
-		srcToken: k?.srcToken,
-		srcAmount: k?.srcAmount,
+	}), 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 && p(k) || Ce,
+		swapSide: A && p(A) || Ce,
 		tradeMode: "swap",
-		chainId: D,
-		applySlippage: A
-	}), { address: I } = he(), { minClient: L } = _({
-		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) => {
-				E.log("Create Delta Order success", e);
+				D.log("Create Delta Order success", e);
 			},
 			onError: (e) => {
-				E.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: E,
-		viemClient: L
-	}), { deltaOrderDeposit: V, reset: ke, depositAndSubmitDeltaOrder: Ae } = de({
-		chainId: D,
-		account: I,
-		logger: E,
-		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 = h({
-		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) => {
-			E.log("Delta Order success", e);
+			D.log("Delta Order success", e);
 		},
 		onAuctionFailure: (e) => {
-			E.log("Delta Order failure", e);
+			D.log("Delta Order failure", e);
 		},
 		onUpdatedAuction: (e) => {
-			E.log("Delta Order updated", e);
+			D.log("Delta 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
-	}, { onSwap: K } = d(), q = G.lastOrderState || G.sentOrder, J = S({
-		order: q,
-		chainId: D,
-		account: I,
-		client: L,
-		logger: E,
+	}), 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",
@@ -133,152 +134,153 @@ function T({ deltaPrice: T }) {
 			}
 		}
 	}), 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 = m({
+		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: y({ userAddress: e.user }),
+				queryKey: b({ userAddress: e.user }),
 				exact: !1
 			});
 		},
 		onAuctionFailure: (e) => {
 			we.invalidateQueries({
-				queryKey: y({ userAddress: e.user }),
+				queryKey: b({ userAddress: e.user }),
 				exact: !1
 			});
 		}
-	}), Ne = x(), Y = fe(null), X = fe(null), Pe = () => {
-		Y.current?.abort(new C()), Y.current = null, X.current = null;
-	}, Fe = s(), { markNonceAsUsed: Ie, clearNonce: Le } = se({ chainId: D }), { partner: Re, partnerAddress: ze, partnerFeeBps: Be, partnerTakesSurplus: Ve } = te(), He = e(c), Ue = e(l), We = i(), Ge = 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 = p(k), o = new AbortController();
-		Y.current = o;
-		let s = o.signal, c = u(), l, d, f, m = j.allowanceToSet, h = M.amountToPermit, g = k;
-		if (g.hmac === r?.hmac) {
-			let e = await O.refetch({ cancelRefetch: !1 });
-			s.throwIfAborted(), e.data && (g = e.data, n(g) && (g = ee({
-				price: g,
-				protocolName: He,
-				bridgePreference: Ue
+	}), 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 _;
-		X.current = g;
-		let te = a(g.srcToken), { shouldDoApprovalTxOrPermit: ne, tryPermit: v, shouldPreSignBatch: re } = 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 && m) {
+			if (te && h) {
 				let t = Se;
 				if (t) {
-					let e = m;
-					_ = We({
+					let e = h;
+					v = Ge({
 						queryKey: t,
 						onData: (t) => {
 							let r = t;
-							if (n(t) && (r = ee({
+							if (n(t) && (r = m({
 								price: t,
-								protocolName: He,
-								bridgePreference: Ue
+								protocolName: Ue,
+								bridgePreference: We
 							})), s.aborted) {
-								_?.(), _ = void 0;
+								v?.(), v = void 0;
 								return;
 							}
 							let a = {
 								srcAmount: r.srcAmount,
 								destAmount: r.destAmount
-							}, o = A ? b(a, ve, i) : a;
-							e >= BigInt(o.srcAmount) && (E.log("~ fresh price ~", r), g = r, X.current = g);
+							}, o = j ? re(a, ve, i) : a;
+							e >= BigInt(o.srcAmount) && (D.log("~ fresh price ~", r), _ = r, Z.current = _);
 						}
 					});
 				}
 				try {
-					if (v) F.onSignPermit.request({ allowanceToSet: h }), l = await P.signPermitAsync({
+					if (y) I.onSignPermit.request({ allowanceToSet: g }), l = await F.signPermitAsync({
 						deadline: c,
-						value: h
-					}), F.onSignPermit.confirmed({
-						allowanceToSet: h,
+						value: g
+					}), I.onSignPermit.confirmed({
+						allowanceToSet: g,
 						permit: l?.permitEncodedArgs
 					});
 					else {
-						F.onApproveTx.request({ allowanceToSet: m }), d = await N.approveAsync({ allowanceData: { allowanceToSet: m } }), F.onApproveTx.sent({
-							allowanceToSet: m,
+						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: d,
-							chainId: D,
+							chainId: O,
 							onReplaced: (e) => {
-								E.log("onReplaced:approveTx", d, e);
+								D.log("onReplaced:approveTx", d, e);
 							}
 						});
 						e && e({
-							chainId: D,
+							chainId: O,
 							action: "approve",
 							transactionHash: d,
 							receiptPromise: t,
 							transactionSpecificData: {
 								action: "approve",
-								approvedAmount: m,
-								tokenAddress: j.token,
-								spenderAddress: j.spender
+								approvedAmount: h,
+								tokenAddress: M.token,
+								spenderAddress: M.spender
 							}
-						}), f = await t, F.onApproveTx.confirmed({
-							allowanceToSet: m,
+						}), f = await t, I.onApproveTx.confirmed({
+							allowanceToSet: h,
 							txHash: d,
 							txReceipt: f
-						}), E.log("~ approveTx ~ receipt:", f);
+						}), D.log("~ approveTx ~ receipt:", f);
 					}
 				} catch (e) {
-					throw v ? F.onSignPermit.failed({
-						allowanceToSet: h,
+					throw y ? I.onSignPermit.failed({
+						allowanceToSet: g,
 						error: e
-					}) : F.onApproveTx.failed({
-						allowanceToSet: m,
+					}) : I.onApproveTx.failed({
+						allowanceToSet: h,
 						error: e,
 						txHash: d
 					}), e;
 				}
 			}
-			s.throwIfAborted(), w(I, "Account is not connected");
-			let r = g;
-			X.current = r, _?.(), _ = 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.srcAmount,
 				destAmount: r.destAmount
-			}, o = A ? b(a, ve, i) : a, u = l?.permitEncodedArgs;
+			}, 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
 			}));
-			let p = n(r) ? r.bridge.destinationChainId : D;
-			K?.({ event: {
+			let p = n(r) ? r.bridge.destinationChainId : O;
+			q?.({ event: {
 				name: "Swap:request",
 				params: {
 					swapMode: "delta",
 					price: r
 				}
 			} });
-			let y, x = {
+			let b, x = {
 				signal: s,
 				type: "MARKET",
 				degenMode: ye.degenMode,
+				referrerAddress: He,
 				orderInput: {
-					owner: I,
+					owner: L,
 					beneficiary: Fe,
 					srcToken: r.srcToken,
 					destToken: r.destToken,
@@ -294,55 +296,55 @@ function T({ deltaPrice: T }) {
 					side: i
 				}
 			};
-			if (te) {
+			if (ee) {
 				let t = x.orderInput.srcAmount;
-				y = await Ae({
+				b = await Ae({
 					createOrderInput: x,
 					depositAmount: t,
 					onTxSent: e
 				});
-			} else y = re ? await De({
+			} else b = ne ? await De({
 				createOrderInput: x,
-				approval: j,
+				approval: M,
 				onTxSent: e
-			}) : await R.mutateAsync(x);
-			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 S = Me({ orderId: y.id });
+			let S = Me({ orderId: b.id });
 			t && t({
-				order: y,
+				order: b,
 				lastOrderState: S
 			});
 			let C = await S;
-			return K?.({ event: {
+			return q?.({ event: {
 				name: "Swap:confirmed",
 				params: {
 					swapMode: "delta",
 					price: r,
-					order: C ?? y
+					order: C ?? b
 				}
 			} }), {
-				tradeFlowType: ge,
+				tradeFlowType: T,
 				approve: {
 					txHash: d,
 					receipt: f
 				},
 				deltaOrder: {
-					sentOrder: y,
+					sentOrder: b,
 					lastOrderState: C
 				},
 				deltaPrice: r,
-				account: I,
+				account: L,
 				receiverAddress: Fe
 			};
 		} catch (e) {
-			throw l && Le(l.signedPermitData), ie(e) || K?.({ event: {
+			throw l && Le(l.signedPermitData), ie(e) || q?.({ event: {
 				name: "Swap:failed",
 				params: {
 					swapMode: "delta",
@@ -350,61 +352,61 @@ function T({ deltaPrice: T }) {
 				}
 			} }), e;
 		} finally {
-			_?.();
+			v?.();
 		}
-	}, Ke = async () => {
+	}, qe = async () => {
 		try {
-			return await J.cancelDeltaOrder();
+			return await Y.cancelDeltaOrder();
 		} catch (e) {
-			E.error("Cancel Delta order error", e), J.reset();
+			D.error("Cancel Delta order error", e), Y.reset();
 		}
-	}, Z = pe({
-		mutationFn: Ge,
+	}, Q = me({
+		mutationFn: Ke,
 		mutationKey: [_e],
 		onSuccess: (e) => {
-			E.log("Delta Order success", e);
+			D.log("Delta Order success", e);
 		},
 		onError: (e) => {
-			E.error("Delta Order error", e);
+			D.error("Delta Order error", e);
 		},
 		onSettled: () => {
-			E.log("Delta Order settled");
+			D.log("Delta Order settled");
 		}
-	}), qe = Z.mutateAsync, Q = () => {
-		X.current = null, N.reset(), P.reset(), R.reset(), Z.reset(), J.reset(), Oe(), ke();
-	}, Je = (e) => {
-		let t = X.current;
-		return Q(), qe({
+	}), 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
 		});
-	}, Ye = X.current || k, $ = Z.data, Xe = $?.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,
-		runDeltaOrderFlow: qe,
-		reset: Q,
+		tradeFlowType: T,
+		chainId: O,
+		runDeltaOrderFlow: Je,
+		reset: Ye,
 		cancelFlow: Pe,
-		retryFlow: Je,
-		cancelDeltaOrder: Ke,
-		approval: j,
-		signPermit: M,
-		deltaOrderPreSign: B,
-		deltaOrderDeposit: V,
-		deltaOrderSubmission: H,
-		deltaOrderExecution: G,
+		retryFlow: Xe,
+		cancelDeltaOrder: qe,
+		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: Ye,
-		freshPrice: k,
-		submittedDeltaOrder: Xe
+		usedPrice: Ze,
+		freshPrice: A,
+		submittedDeltaOrder: Qe
 	};
 }
 //#endregion
-export { T as useDeltaFlow };
+export { E as useDeltaFlow };
 
 //# sourceMappingURL=useDeltaFlow.js.map