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

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

@@ -9,33 +9,33 @@ 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 ie } 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 ae } from "./common/errors.js";
-import { useCreateAndSubmitDeltaOrder as oe } from "../prices/delta/mutations/useCreateDeltaOrder.js";
-import { encodePermit2TransferFromSigDataForDelta as se } from "../../permit/utils/encodeArgs.js";
-import { useMarkPermit1Or2NonceAsUsed as ce } from "./common/useSignPermit1Or2.js";
-import { useApproveOrPermit as le } from "./common/useApproveOrPermit.js";
-import { shouldApproveOrBatch as ue, usePreSignAndSubmitDeltaOrder as de } from "./common/usePreSignAndSubmitDeltaOrder.js";
-import { useDepositAndSubmitDeltaOrder as fe } from "./common/useDepositAndSubmitDeltaOrder.js";
-import { useReferrer as pe } from "../../useReferrer.js";
-import { useRef as me } from "react";
-import { useMutation as he, useQueryClient as ge } from "@tanstack/react-query";
-import { assert as C } from "ts-essentials";
-import { useAccount as _e } from "wagmi";
+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";
+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 pe } from "react";
+import { useMutation as me, useQueryClient as he } from "@tanstack/react-query";
+import { assert as w } from "ts-essentials";
+import { useAccount as ge } from "wagmi";
 //#region src/hooks/swap/tradeFlow/useDeltaFlow.ts
-var w = "deltaOrder", ve = "runDeltaOrderFlow";
-function T({ deltaPrice: T }) {
-	let E = t("DeltaFlow"), { resolvedSlippage: D } = g("swap"), { priceParams: ye, chainId: O, destChainId: be } = v("swap"), xe = ne(), { result: k, 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
@@ -43,27 +43,27 @@ function T({ deltaPrice: T }) {
 		chainId: O,
 		destChainId: be,
 		query: { enabled: !1 }
-	}), A = re({ price: k.data }) || k.data || T, Ce = o(), j = !!A && A.inputToken.address.toLowerCase() !== A.outputToken.address.toLowerCase(), { approval: M, signPermit: N, approveTxMut: P, signPermitMut: F, events: I } = le({
-		srcToken: A?.inputToken.address,
-		srcAmount: A?.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: A && p(A) || Ce,
 		tradeMode: "swap",
 		chainId: O,
 		applySlippage: j
-	}), { address: L } = _e(), { minClient: R } = _({
+	}), { address: L } = ge(), { minClient: R } = v({
 		chainId: O,
 		account: L
-	}), we = ge(), z = oe({
+	}), 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);
 			}
 		}
 	}), B = {
@@ -75,15 +75,15 @@ function T({ deltaPrice: T }) {
 		isError: z.isError,
 		isSuccess: z.isSuccess,
 		error: z.error
-	}, { deltaOrderPreSign: V, canBatchTxs: Te, isConnectedToSafe: Ee, preSignAndSubmitDeltaOrder: De, reset: Oe } = de({
+	}, { deltaOrderPreSign: V, canBatchTxs: Te, isConnectedToSafe: Ee, preSignAndSubmitDeltaOrder: De, reset: Oe } = ue({
 		chainId: O,
 		account: L,
-		logger: E,
+		logger: D,
 		viemClient: R
-	}), { deltaOrderDeposit: H, reset: ke, depositAndSubmitDeltaOrder: Ae } = fe({
+	}), { deltaOrderDeposit: H, reset: ke, depositAndSubmitDeltaOrder: Ae } = de({
 		chainId: O,
 		account: L,
-		logger: E,
+		logger: D,
 		viemClient: R
 	}), U = {
 		order: B.order || V.order || H.order,
@@ -94,16 +94,16 @@ function T({ deltaPrice: T }) {
 		isError: B.isError || V.isError || H.isError,
 		isSuccess: B.isSuccess || V.isSuccess || H.isSuccess,
 		error: B.error || V.error || H.error
-	}, W = h({
+	}, 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);
 		}
 	}), G = W.data ? f(W.data) : null, K = {
 		sentOrder: U.order,
@@ -115,14 +115,14 @@ function T({ deltaPrice: T }) {
 		isError: W.isError || G === "failed",
 		isSuccess: G === "confirmed",
 		error: W.error
-	}, { onSwap: q } = d(), J = K.lastOrderState || K.sentOrder, Y = x({
+	}, { onSwap: q } = d(), J = K.lastOrderState || K.sentOrder, Y = S({
 		order: J,
 		chainId: O,
 		account: L,
 		client: R,
-		logger: E,
+		logger: D,
 		mutationOptions: {
-			onMutate: () => (C(J, "No order to cancel"), J),
+			onMutate: () => (w(J, "No order to cancel"), J),
 			onSuccess: (e, t, n) => {
 				q?.({ event: {
 					name: "Swap:cancelled",
@@ -146,85 +146,85 @@ function T({ deltaPrice: T }) {
 		error: Y.error,
 		result: Y.result,
 		step: Y.step
-	}, Me = m({
+	}, 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 = b(), X = me(null), Z = me(null), Pe = () => {
-		X.current?.abort(new S()), X.current = null, Z.current = null;
-	}, Fe = s(), { markNonceAsUsed: Ie, clearNonce: Le } = ce({ chainId: O }), { partner: Re, partnerAddress: ze, partnerFeeBps: Be, partnerTakesSurplus: Ve } = te(), { referrerAddress: He } = pe(), 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(), C(A, "Delta price is not available");
+	}), 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, m = M.allowanceToSet, h = N.amountToPermit, g = A;
-		if (g.id === r?.id) {
+		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 && (g = e.data, n(g) && (g = ee({
-				price: g,
+			s.throwIfAborted(), e.data && (_ = e.data, n(_) && (_ = m({
+				price: _,
 				protocolName: Ue,
 				bridgePreference: We
 			})));
 		}
-		let _;
-		Z.current = g;
-		let te = a(g.inputToken.address), { shouldDoApprovalTxOrPermit: ne, tryPermit: v, shouldPreSignBatch: re } = ue({
+		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;
-					_ = Ge({
+					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: Ue,
 								bridgePreference: We
 							})), s.aborted) {
-								_?.(), _ = void 0;
+								v?.(), v = void 0;
 								return;
 							}
 							let a = {
-								srcAmount: r.route.origin.input.amount,
-								destAmount: r.route.destination.output.amount
-							}, o = j ? ie(a, D, i) : a;
-							e >= BigInt(o.srcAmount) && (E.log("~ fresh price ~", r), g = r, Z.current = g);
+								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 (v) I.onSignPermit.request({ allowanceToSet: h }), l = await F.signPermitAsync({
+					if (y) I.onSignPermit.request({ allowanceToSet: g }), l = await F.signPermitAsync({
 						deadline: c,
-						value: h
+						value: g
 					}), I.onSignPermit.confirmed({
-						allowanceToSet: h,
+						allowanceToSet: g,
 						permit: l?.permitEncodedArgs
 					});
 					else {
-						I.onApproveTx.request({ allowanceToSet: m }), d = await P.approveAsync({ allowanceData: { allowanceToSet: m } }), I.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: O,
 							onReplaced: (e) => {
-								E.log("onReplaced:approveTx", d, e);
+								D.log("onReplaced:approveTx", d, e);
 							}
 						});
 						e && e({
@@ -234,45 +234,47 @@ function T({ deltaPrice: T }) {
 							receiptPromise: t,
 							transactionSpecificData: {
 								action: "approve",
-								approvedAmount: m,
+								approvedAmount: h,
 								tokenAddress: M.token,
 								spenderAddress: M.spender
 							}
 						}), f = await t, I.onApproveTx.confirmed({
-							allowanceToSet: m,
+							allowanceToSet: h,
 							txHash: d,
 							txReceipt: f
-						}), E.log("~ approveTx ~ receipt:", f);
+						}), D.log("~ approveTx ~ receipt:", f);
 					}
 				} catch (e) {
-					throw v ? I.onSignPermit.failed({
-						allowanceToSet: h,
+					throw y ? I.onSignPermit.failed({
+						allowanceToSet: g,
 						error: e
 					}) : I.onApproveTx.failed({
-						allowanceToSet: m,
+						allowanceToSet: h,
 						error: e,
 						txHash: d
 					}), e;
 				}
 			}
-			s.throwIfAborted(), C(L, "Account is not connected");
-			let r = g;
-			Z.current = r, _?.(), _ = void 0, C(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 = j ? ie(a, D, i) : a, u = j ? Math.round(D * 100) : 0, p = l?.permitEncodedArgs;
-			l?.signedPermitData.type === "permit2" && l.signedPermitData.variant === "transferFrom" && (p = se({
+				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
-			})), q?.({ 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,
@@ -280,66 +282,69 @@ function T({ deltaPrice: T }) {
 				orderInput: {
 					owner: L,
 					beneficiary: Fe,
-					permit: p,
-					route: r.route,
-					side: i,
-					slippage: u,
+					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 = re ? await De({
-				createOrderInput: b,
+			} else b = ne ? await De({
+				createOrderInput: x,
 				approval: M,
 				onTxSent: e
-			}) : await z.mutateAsync(b);
+			}) : 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;
+			let C = await S;
 			return q?.({ event: {
 				name: "Swap:confirmed",
 				params: {
 					swapMode: "delta",
 					price: r,
-					order: S ?? y
+					order: C ?? b
 				}
 			} }), {
-				tradeFlowType: w,
+				tradeFlowType: T,
 				approve: {
 					txHash: d,
 					receipt: f
 				},
 				deltaOrder: {
-					sentOrder: y,
-					lastOrderState: S
+					sentOrder: b,
+					lastOrderState: C
 				},
 				deltaPrice: r,
 				account: L,
 				receiverAddress: Fe
 			};
 		} catch (e) {
-			throw l && Le(l.signedPermitData), ae(e) || q?.({ event: {
+			throw l && Le(l.signedPermitData), ie(e) || q?.({ event: {
 				name: "Swap:failed",
 				params: {
 					swapMode: "delta",
@@ -347,25 +352,25 @@ function T({ deltaPrice: T }) {
 				}
 			} }), e;
 		} finally {
-			_?.();
+			v?.();
 		}
 	}, qe = async () => {
 		try {
 			return await Y.cancelDeltaOrder();
 		} catch (e) {
-			E.error("Cancel Delta order error", e), Y.reset();
+			D.error("Cancel Delta order error", e), Y.reset();
 		}
-	}, Q = he({
+	}, Q = me({
 		mutationFn: Ke,
-		mutationKey: [ve],
+		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");
 		}
 	}), Je = Q.mutateAsync, Ye = () => {
 		Z.current = null, P.reset(), F.reset(), z.reset(), Q.reset(), Y.reset(), Oe(), ke();
@@ -377,7 +382,7 @@ function T({ deltaPrice: T }) {
 		});
 	}, Ze = Z.current || A, $ = Q.data, Qe = $?.deltaOrder.lastOrderState || $?.deltaOrder.sentOrder || K.lastOrderState || K.sentOrder;
 	return {
-		tradeFlowType: w,
+		tradeFlowType: T,
 		chainId: O,
 		runDeltaOrderFlow: Je,
 		reset: Ye,
@@ -402,6 +407,6 @@ function T({ deltaPrice: T }) {
 	};
 }
 //#endregion
-export { T as useDeltaFlow };
+export { E as useDeltaFlow };
 
 //# sourceMappingURL=useDeltaFlow.js.map