@velora-dex/widget 0.6.0 → 0.6.1-dev.2

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

@@ -6,36 +6,35 @@ 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 { useWidgetEvents as u } from "../../../core/state/widgetEventsAtom.js";
-import { getOverallOrderStatus as d } from "../prices/delta/orders/utils.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 ee } from "../prices/delta/bridge/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 { 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 g } from "../prices/usePricesParams.js";
-import { getSwapSideFromDeltaPrice as _ } from "../prices/delta/queries/utils.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 v } from "../prices/delta/queries/useDeltaOrders.js";
-import { applySlippage as y } from "../../../lib/utils/price.js";
-import { useEnsureTxReceipt as b } from "../../txs/queries/useAwaitTx.js";
-import { useCancelOrWithdrawAndCancelDeltaOrder as x } from "../prices/delta/mutations/useCancelOrWithdrawAndCancelDeltaOrder.js";
-import { UserCancelledError as S, isTransactionCancelledError as C } from "./common/errors.js";
-import { useCreateAndSubmitDeltaOrder as ie } from "../prices/delta/mutations/useCreateDeltaOrder.js";
-import { encodePermit2TransferFromSigDataForDelta as ae } from "../../permit/utils/encodeArgs.js";
-import { produceDeltaOrderDeadline as oe } from "../../permit/utils/deadlines.js";
+import { deltaOrdersQueryKey as y } from "../prices/delta/queries/useDeltaOrders.js";
+import { applySlippage as b } 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";
 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 w } from "react";
-import { useMutation as fe, useQueryClient as pe } from "@tanstack/react-query";
-import { assert as T } from "ts-essentials";
-import { useAccount as me } from "wagmi";
+import { useRef as fe } from "react";
+import { useMutation as pe, useQueryClient as me } from "@tanstack/react-query";
+import { assert as w } from "ts-essentials";
+import { useAccount as he } from "wagmi";
 //#region src/hooks/swap/tradeFlow/useDeltaFlow.ts
-var he = "deltaOrder", ge = "runDeltaOrderFlow";
-function _e({ deltaPrice: _e }) {
-	let E = t("DeltaFlow"), { resolvedSlippage: ve } = m("swap"), { priceParams: ye, chainId: D, destChainId: be } = g("swap"), xe = ne(), { result: O, queryKey: Se } = r({
+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({
 		priceParams: {
 			...ye,
 			...xe
@@ -43,18 +42,18 @@ function _e({ deltaPrice: _e }) {
 		chainId: D,
 		destChainId: be,
 		query: { enabled: !1 }
-	}), k = re({ price: O.data }) || O.data || _e, Ce = o(), A = !!k && k.srcToken.toLowerCase() !== k.destToken.toLowerCase(), { approval: j, signPermit: M, approveTxMut: N, signPermitMut: P, events: F } = ce({
+	}), 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,
 		spenderContractType: "ParaswapDelta",
-		swapSide: k && _(k) || Ce,
+		swapSide: k && p(k) || Ce,
 		tradeMode: "swap",
 		chainId: D,
 		applySlippage: A
-	}), { address: I } = me(), { minClient: L } = h({
+	}), { address: I } = he(), { minClient: L } = _({
 		chainId: D,
 		account: I
-	}), we = pe(), R = ie({
+	}), we = me(), R = ae({
 		chainId: D,
 		account: I,
 		client: L,
@@ -94,7 +93,7 @@ function _e({ deltaPrice: _e }) {
 		isError: z.isError || B.isError || V.isError,
 		isSuccess: z.isSuccess || B.isSuccess || V.isSuccess,
 		error: z.error || B.error || V.error
-	}, U = p({
+	}, U = h({
 		orderId: H.order?.id,
 		onAuctionSuccess: (e) => {
 			E.log("Delta Order success", e);
@@ -104,28 +103,25 @@ function _e({ deltaPrice: _e }) {
 		},
 		onUpdatedAuction: (e) => {
 			E.log("Delta Order updated", e);
-		},
-		onTimeoutGettingOrder: (e) => {
-			E.log("Delta Order timeout", e);
 		}
-	}), W = U.data ? d(U.data) : null, je = U.data === null && U.isSuccess, G = {
+	}), 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" || je,
+		isError: U.isError || W === "failed",
 		isSuccess: W === "confirmed",
 		error: U.error
-	}, { onSwap: K } = u(), q = G.lastOrderState || G.sentOrder, J = x({
+	}, { onSwap: K } = d(), q = G.lastOrderState || G.sentOrder, J = S({
 		order: q,
 		chainId: D,
 		account: I,
 		client: L,
 		logger: E,
 		mutationOptions: {
-			onMutate: () => (T(q, "No order to cancel"), q),
+			onMutate: () => (w(q, "No order to cancel"), q),
 			onSuccess: (e, t, n) => {
 				K?.({ event: {
 					name: "Swap:cancelled",
@@ -136,7 +132,7 @@ function _e({ deltaPrice: _e }) {
 				} });
 			}
 		}
-	}), Me = {
+	}), je = {
 		receipt: J.receipt,
 		txHash: J.txHash,
 		response: J.cancelOrderResponse,
@@ -149,127 +145,127 @@ function _e({ deltaPrice: _e }) {
 		error: J.error,
 		result: J.result,
 		step: J.step
-	}, Ne = f({
+	}, Me = m({
 		onAuctionSuccess: (e) => {
 			we.invalidateQueries({
-				queryKey: v({ userAddress: e.user }),
+				queryKey: y({ userAddress: e.user }),
 				exact: !1
 			});
 		},
 		onAuctionFailure: (e) => {
 			we.invalidateQueries({
-				queryKey: v({ userAddress: e.user }),
+				queryKey: y({ userAddress: e.user }),
 				exact: !1
 			});
 		}
-	}), Pe = b(), Y = w(null), X = w(null), Fe = () => {
-		Y.current?.abort(new S()), Y.current = null, X.current = null;
-	}, Ie = s(), { markNonceAsUsed: Le, clearNonce: Re } = se({ chainId: D }), { partner: ze, partnerAddress: Be, partnerFeeBps: Ve, partnerTakesSurplus: He } = te(), 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(), T(k, "Delta price is not available");
-		let i = _(k), o = new AbortController();
+	}), 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 = oe(), l, u, d, f = j.allowanceToSet, p = M.amountToPermit, m = k;
-		if (m.hmac === r?.hmac) {
+		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 && (m = e.data, n(m) && (m = ee({
-				price: m,
-				protocolName: Ue,
-				bridgePreference: We
+			s.throwIfAborted(), e.data && (g = e.data, n(g) && (g = ee({
+				price: g,
+				protocolName: He,
+				bridgePreference: Ue
 			})));
 		}
-		let h;
-		X.current = m;
-		let te = a(m.srcToken), { shouldDoApprovalTxOrPermit: ne, tryPermit: g, shouldPreSignBatch: re } = le({
+		let _;
+		X.current = g;
+		let te = a(g.srcToken), { shouldDoApprovalTxOrPermit: ne, tryPermit: v, shouldPreSignBatch: re } = le({
 			approval: j,
 			signPermit: M,
 			canBatchTxs: Te,
 			isConnectedToSafe: Ee
 		});
 		try {
-			if (ne && f) {
+			if (ne && m) {
 				let t = Se;
 				if (t) {
-					let e = f;
-					h = Ge({
+					let e = m;
+					_ = We({
 						queryKey: t,
 						onData: (t) => {
 							let r = t;
 							if (n(t) && (r = ee({
 								price: t,
-								protocolName: Ue,
-								bridgePreference: We
+								protocolName: He,
+								bridgePreference: Ue
 							})), s.aborted) {
-								h?.(), h = void 0;
+								_?.(), _ = void 0;
 								return;
 							}
 							let a = {
 								srcAmount: r.srcAmount,
 								destAmount: r.destAmount
-							}, o = A ? y(a, ve, i) : a;
-							e >= BigInt(o.srcAmount) && (E.log("~ fresh price ~", r), m = r, X.current = m);
+							}, o = A ? b(a, ve, i) : a;
+							e >= BigInt(o.srcAmount) && (E.log("~ fresh price ~", r), g = r, X.current = g);
 						}
 					});
 				}
 				try {
-					if (g) F.onSignPermit.request({ allowanceToSet: p }), l = await P.signPermitAsync({
+					if (v) F.onSignPermit.request({ allowanceToSet: h }), l = await P.signPermitAsync({
 						deadline: c,
-						value: p
+						value: h
 					}), F.onSignPermit.confirmed({
-						allowanceToSet: p,
+						allowanceToSet: h,
 						permit: l?.permitEncodedArgs
 					});
 					else {
-						F.onApproveTx.request({ allowanceToSet: f }), u = await N.approveAsync({ allowanceData: { allowanceToSet: f } }), F.onApproveTx.sent({
-							allowanceToSet: f,
-							txHash: u
+						F.onApproveTx.request({ allowanceToSet: m }), d = await N.approveAsync({ allowanceData: { allowanceToSet: m } }), F.onApproveTx.sent({
+							allowanceToSet: m,
+							txHash: d
 						}), s.throwIfAborted();
-						let t = Pe({
-							hash: u,
+						let t = Ne({
+							hash: d,
 							chainId: D,
 							onReplaced: (e) => {
-								E.log("onReplaced:approveTx", u, e);
+								E.log("onReplaced:approveTx", d, e);
 							}
 						});
 						e && e({
 							chainId: D,
 							action: "approve",
-							transactionHash: u,
+							transactionHash: d,
 							receiptPromise: t,
 							transactionSpecificData: {
 								action: "approve",
-								approvedAmount: f,
+								approvedAmount: m,
 								tokenAddress: j.token,
 								spenderAddress: j.spender
 							}
-						}), d = await t, F.onApproveTx.confirmed({
-							allowanceToSet: f,
-							txHash: u,
-							txReceipt: d
-						}), E.log("~ approveTx ~ receipt:", d);
+						}), f = await t, F.onApproveTx.confirmed({
+							allowanceToSet: m,
+							txHash: d,
+							txReceipt: f
+						}), E.log("~ approveTx ~ receipt:", f);
 					}
 				} catch (e) {
-					throw g ? F.onSignPermit.failed({
-						allowanceToSet: p,
+					throw v ? F.onSignPermit.failed({
+						allowanceToSet: h,
 						error: e
 					}) : F.onApproveTx.failed({
-						allowanceToSet: f,
+						allowanceToSet: m,
 						error: e,
-						txHash: u
+						txHash: d
 					}), e;
 				}
 			}
-			s.throwIfAborted(), T(I, "Account is not connected");
-			let r = m;
-			X.current = r, h?.(), h = void 0, T(r, "Delta price is not available");
+			s.throwIfAborted(), w(I, "Account is not connected");
+			let r = g;
+			X.current = r, _?.(), _ = void 0, w(r, "Delta price is not available");
 			let a = {
 				srcAmount: r.srcAmount,
 				destAmount: r.destAmount
-			}, o = A ? y(a, ve, i) : a, _ = l?.permitEncodedArgs;
-			l?.signedPermitData.type === "permit2" && l.signedPermitData.variant === "transferFrom" && (_ = ae({
+			}, o = A ? b(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 v = n(r) ? r.bridge.destinationChainId : D;
+			let p = n(r) ? r.bridge.destinationChainId : D;
 			K?.({ event: {
 				name: "Swap:request",
 				params: {
@@ -277,46 +273,50 @@ function _e({ deltaPrice: _e }) {
 					price: r
 				}
 			} });
-			let b, x = {
+			let y, x = {
 				signal: s,
 				type: "MARKET",
 				degenMode: ye.degenMode,
 				orderInput: {
 					owner: I,
-					beneficiary: Ie,
+					beneficiary: Fe,
 					srcToken: r.srcToken,
 					destToken: r.destToken,
-					permit: _,
-					destChainId: v,
+					permit: u,
+					destChainId: p,
 					deltaPrice: r,
-					partner: ze,
-					partnerAddress: Be,
-					partnerFeeBps: Ve,
-					partnerTakesSurplus: He,
+					partner: Re,
+					partnerAddress: ze,
+					partnerFeeBps: Be,
+					partnerTakesSurplus: Ve,
 					...o,
 					deadline: Number(c),
 					side: i
 				}
 			};
-			b = te ? await Ae({
-				createDeltaOrderInput: x,
-				depositAmount: x.orderInput.srcAmount,
-				onTxSent: e
-			}) : re ? await De({
-				createDeltaOrderInput: x,
+			if (te) {
+				let t = x.orderInput.srcAmount;
+				y = await Ae({
+					createOrderInput: x,
+					depositAmount: t,
+					onTxSent: e
+				});
+			} else y = re ? await De({
+				createOrderInput: x,
 				approval: j,
 				onTxSent: e
-			}) : await R.mutateAsync(x), l && Le(l.signedPermitData), K?.({ event: {
+			}) : await R.mutateAsync(x);
+			l && Ie(l.signedPermitData), K?.({ event: {
 				name: "Swap:sent",
 				params: {
 					swapMode: "delta",
 					price: r,
-					order: b
+					order: y
 				}
 			} });
-			let S = Ne({ orderId: b.id });
+			let S = Me({ orderId: y.id });
 			t && t({
-				order: b,
+				order: y,
 				lastOrderState: S
 			});
 			let C = await S;
@@ -325,29 +325,24 @@ function _e({ deltaPrice: _e }) {
 				params: {
 					swapMode: "delta",
 					price: r,
-					order: C ? {
-						...C,
-						orderVersion: b.orderVersion,
-						deltaGasOverhead: b.deltaGasOverhead,
-						signature: b.signature
-					} : b
+					order: C ?? y
 				}
 			} }), {
-				tradeFlowType: he,
+				tradeFlowType: ge,
 				approve: {
-					txHash: u,
-					receipt: d
+					txHash: d,
+					receipt: f
 				},
 				deltaOrder: {
-					sentOrder: b,
+					sentOrder: y,
 					lastOrderState: C
 				},
 				deltaPrice: r,
 				account: I,
-				receiverAddress: Ie
+				receiverAddress: Fe
 			};
 		} catch (e) {
-			throw l && Re(l.signedPermitData), C(e) || K?.({ event: {
+			throw l && Le(l.signedPermitData), ie(e) || K?.({ event: {
 				name: "Swap:failed",
 				params: {
 					swapMode: "delta",
@@ -355,17 +350,17 @@ function _e({ deltaPrice: _e }) {
 				}
 			} }), e;
 		} finally {
-			h?.();
+			_?.();
 		}
-	}, qe = async () => {
+	}, Ke = async () => {
 		try {
 			return await J.cancelDeltaOrder();
 		} catch (e) {
 			E.error("Cancel Delta order error", e), J.reset();
 		}
-	}, Z = fe({
-		mutationFn: Ke,
-		mutationKey: [ge],
+	}, Z = pe({
+		mutationFn: Ge,
+		mutationKey: [_e],
 		onSuccess: (e) => {
 			E.log("Delta Order success", e);
 		},
@@ -375,41 +370,41 @@ function _e({ deltaPrice: _e }) {
 		onSettled: () => {
 			E.log("Delta Order settled");
 		}
-	}), Je = Z.mutateAsync, Q = () => {
+	}), qe = Z.mutateAsync, Q = () => {
 		X.current = null, N.reset(), P.reset(), R.reset(), Z.reset(), J.reset(), Oe(), ke();
-	}, Ye = (e) => {
+	}, Je = (e) => {
 		let t = X.current;
-		return Q(), Je({
+		return Q(), qe({
 			...e,
 			lastPrice: t
 		});
-	}, Xe = X.current || k, $ = Z.data, Ze = $?.deltaOrder.lastOrderState || $?.deltaOrder.sentOrder || G.lastOrderState || G.sentOrder;
+	}, Ye = X.current || k, $ = Z.data, Xe = $?.deltaOrder.lastOrderState || $?.deltaOrder.sentOrder || G.lastOrderState || G.sentOrder;
 	return {
-		tradeFlowType: he,
+		tradeFlowType: ge,
 		chainId: D,
-		runDeltaOrderFlow: Je,
+		runDeltaOrderFlow: qe,
 		reset: Q,
-		cancelFlow: Fe,
-		retryFlow: Ye,
-		cancelDeltaOrder: qe,
+		cancelFlow: Pe,
+		retryFlow: Je,
+		cancelDeltaOrder: Ke,
 		approval: j,
 		signPermit: M,
 		deltaOrderPreSign: B,
 		deltaOrderDeposit: V,
 		deltaOrderSubmission: H,
 		deltaOrderExecution: G,
-		deltaOrderCancelation: Me,
+		deltaOrderCancelation: je,
 		isPending: Z.isPending,
 		isSuccess: H.isSuccess && G.isSuccess,
 		isError: Z.isError,
 		error: Z.error,
 		result: $,
-		usedPrice: Xe,
+		usedPrice: Ye,
 		freshPrice: k,
-		submittedDeltaOrder: Ze
+		submittedDeltaOrder: Xe
 	};
 }
 //#endregion
-export { _e as useDeltaFlow };
+export { T as useDeltaFlow };
 
 //# sourceMappingURL=useDeltaFlow.js.map