@velora-dex/widget 0.7.4-dev.0 → 0.8.0

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

@@ -6,74 +6,77 @@ import { useMarketPriceQuery as i, useSubscribeToMarketPrice as a } from "../pri
 import { useSlippage as o } from "../../useSlippage.js";
 import { useCanBatchTxs as s } from "../../batch/useCanBatchTxs.js";
 import { usePartner as c } from "../../usePartner.js";
-import { usePricesParams as l } from "../prices/usePricesParams.js";
-import { applySlippage as u } from "../../../lib/utils/price.js";
-import { useConstructGasParams as d } from "./common/useConstructGasParams.js";
-import { useAwaitCalls as f, useEnsureCallsStatus as p } from "../../batch/useAwaitCalls.js";
-import { useAwaitTx as m, useEnsureTxReceipt as h } from "../../txs/queries/useAwaitTx.js";
-import { useReplaceTx as g } from "../../txs/mutations/useReplaceTx.js";
-import { TransactionCancelledError as _, UserCancelledError as v, isTransactionCancelledError as y } from "./common/errors.js";
-import { useMarkPermit1Or2NonceAsUsed as b } from "./common/useSignPermit1Or2.js";
-import { useApproveOrPermit as ee } from "./common/useApproveOrPermit.js";
-import { useBatchWithApproveTxs as te } from "../../batch/useBatchWithApproveTxs.js";
-import { useSendBatchTx as ne } from "../../batch/useSendBatchTx.js";
-import { useReferrer as re } from "../../useReferrer.js";
-import { useSendMarketSwapTx as ie } from "../prices/market/mutations/useSendMarketSwapTx.js";
-import { useBuildTx as ae } from "../prices/market/mutations/useBuildTx.js";
+import { useExtraMarketPriceParams as l, usePricesParams as u } from "../prices/usePricesParams.js";
+import { applySlippage as d } from "../../../lib/utils/price.js";
+import { useConstructGasParams as f } from "./common/useConstructGasParams.js";
+import { useAwaitCalls as p, useEnsureCallsStatus as m } from "../../batch/useAwaitCalls.js";
+import { useAwaitTx as h, useEnsureTxReceipt as g } from "../../txs/queries/useAwaitTx.js";
+import { useReplaceTx as _ } from "../../txs/mutations/useReplaceTx.js";
+import { TransactionCancelledError as v, UserCancelledError as y, isTransactionCancelledError as b } from "./common/errors.js";
+import { useMarkPermit1Or2NonceAsUsed as ee } from "./common/useSignPermit1Or2.js";
+import { useApproveOrPermit as te } from "./common/useApproveOrPermit.js";
+import { useBatchWithApproveTxs as ne } from "../../batch/useBatchWithApproveTxs.js";
+import { useSendBatchTx as re } from "../../batch/useSendBatchTx.js";
+import { useReferrer as ie } from "../../useReferrer.js";
+import { useSendMarketSwapTx as ae } from "../prices/market/mutations/useSendMarketSwapTx.js";
+import { useBuildTx as oe } from "../prices/market/mutations/useBuildTx.js";
 import { useRef as x } from "react";
-import { useMutation as oe } from "@tanstack/react-query";
+import { useMutation as se } from "@tanstack/react-query";
 import { assert as S } from "ts-essentials";
 import "viem";
-import { useAccount as se } from "wagmi";
+import { useAccount as ce } from "wagmi";
 //#region src/hooks/swap/tradeFlow/useMarketFlow.ts
-var C = "marketSwap", ce = "runMarketSwapFlow";
-function w({ marketPrice: w }) {
-	let T = e("MarketFlow"), { resolvedSlippage: E } = o("swap"), le = t(), { priceParams: D, chainId: O } = l("swap"), { result: k, queryKey: ue } = i({
-		priceParams: D,
-		chainId: O,
+var C = "marketSwap", w = "runMarketSwapFlow";
+function T({ marketPrice: T }) {
+	let E = e("MarketFlow"), { resolvedSlippage: D } = o("swap"), le = t(), { priceParams: O, chainId: k } = u("swap"), ue = l(), { result: A, queryKey: de } = i({
+		priceParams: {
+			...O,
+			...ue
+		},
+		chainId: k,
 		query: { enabled: !1 }
-	}), A = k.data || w, { approval: j, signPermit: M, approveTxMut: N, signPermitMut: P, events: F } = ee({
-		srcToken: A?.srcToken,
-		srcAmount: A?.srcAmount,
+	}), j = A.data || T, { approval: M, signPermit: N, approveTxMut: P, signPermitMut: F, events: I } = te({
+		srcToken: j?.srcToken,
+		srcAmount: j?.srcAmount,
 		spenderContractType: "AugustusSwapper",
-		swapSide: A?.side ?? le,
+		swapSide: j?.side ?? le,
 		tradeMode: "swap",
-		chainId: O
-	}), I = ae({
-		chainId: O,
+		chainId: k
+	}), L = oe({
+		chainId: k,
 		mutationOptions: {
 			onSuccess: () => {
-				T.log("Build tx success");
+				E.log("Build tx success");
 			},
 			onError: (e) => {
-				T.error("Build tx error", e);
+				E.error("Build tx error", e);
 			}
 		}
-	}), de = {
-		isPending: I.isPending,
-		isError: I.isError,
-		isSuccess: I.isSuccess,
-		error: I.error
-	}, L = ie({
+	}), fe = {
+		isPending: L.isPending,
+		isError: L.isError,
+		isSuccess: L.isSuccess,
+		error: L.error
+	}, R = ae({
 		onSuccess: () => {
-			T.log("Swap tx success");
+			E.log("Swap tx success");
 		},
 		onError: (e) => {
-			T.error("Swap tx error", e);
+			E.error("Swap tx error", e);
 		}
-	}), { forCurrentChain: R } = s(), { addTxWithApprovals: fe } = te(), z = ne({
+	}), { forCurrentChain: z } = s(), { addTxWithApprovals: pe } = ne(), B = re({
 		onSuccess: () => {
-			T.log("Batch tx success");
+			E.log("Batch tx success");
 		},
 		onError: (e) => {
-			T.error("Batch tx error", e);
+			E.error("Batch tx error", e);
 		}
-	}), B = m({
-		hash: L.txHash,
-		chainId: O
-	}), V = f({ id: z.data?.id }), H = g({
-		chainId: O,
-		txHash: L.txHash,
+	}), V = h({
+		hash: R.txHash,
+		chainId: k
+	}), H = p({ id: B.data?.id }), U = _({
+		chainId: k,
+		txHash: R.txHash,
 		cancelTxType: "SWAP",
 		onSuccess: (e) => {
 			X?.({ event: {
@@ -84,155 +87,155 @@ function w({ marketPrice: w }) {
 				}
 			} });
 		}
-	}), U = x(null), pe = {
-		txHash: L.txHash,
-		receipt: B.data,
-		isConfirmingTX: L.isPending,
-		isConfirmingTxError: L.isError,
-		isTxSent: L.isSuccess,
-		isTxPending: B.isLoading,
-		isTxMined: B.isSuccess,
-		isTxAwaitingError: B.isError,
-		isPending: L.isPending || B.isLoading,
-		isSuccess: B.isSuccess,
-		isError: L.isError || B.isError,
-		error: L.error || B.error,
-		isTxCancellable: H.isWalletSupported && !!L.txHash && !B.data && !H.isSuccess,
+	}), W = x(null), me = {
+		txHash: R.txHash,
+		receipt: V.data,
+		isConfirmingTX: R.isPending,
+		isConfirmingTxError: R.isError,
+		isTxSent: R.isSuccess,
+		isTxPending: V.isLoading,
+		isTxMined: V.isSuccess,
+		isTxAwaitingError: V.isError,
+		isPending: R.isPending || V.isLoading,
+		isSuccess: V.isSuccess,
+		isError: R.isError || V.isError,
+		error: R.error || V.error,
+		isTxCancellable: U.isWalletSupported && !!R.txHash && !V.data && !U.isSuccess,
 		cancelSwapTx: async () => {
 			try {
-				S(L.txHash, "Swap tx hash is not available");
-				let e = await H.replaceTx({
+				S(R.txHash, "Swap tx hash is not available");
+				let e = await U.replaceTx({
 					action: "cancel",
-					hash: L.txHash
+					hash: R.txHash
 				});
-				return e.replacementTxReceipt.status === "success" && U.current?.abort(new _("Swap tx cancelled", e)), e;
+				return e.replacementTxReceipt.status === "success" && W.current?.abort(new v("Swap tx cancelled", e)), e;
 			} catch (e) {
-				T.error("Cancel swap tx error", e), H.reset();
+				E.error("Cancel swap tx error", e), U.reset();
 			}
 		},
 		cancellingState: {
-			isPending: H.isPending,
-			isError: H.isError,
-			isSuccess: H.isSuccess,
-			error: H.error,
-			result: H.result,
-			step: H.step
+			isPending: U.isPending,
+			isError: U.isError,
+			isSuccess: U.isSuccess,
+			error: U.error,
+			result: U.result,
+			step: U.step
 		}
-	}, W = V.data?.receipts?.[V.data.receipts.length - 1], me = {
-		canBatchTxs: R,
-		callsId: z.data?.id,
-		txHash: W?.transactionHash,
-		receipt: W,
-		isConfirmingCalls: z.isPending,
-		isConfirmingCallsError: z.isError,
-		isCallsSent: z.isSuccess,
-		isCallsPending: V.isLoading,
-		isCallsMined: V.isSuccess,
-		isCallsAwaitingError: V.isError,
-		isPending: z.isPending || V.isLoading,
-		isSuccess: V.isSuccess,
-		isError: z.isError || V.isError,
-		error: z.error || V.error
-	}, { address: G } = se(), K = h(), he = p(), q = x(null), ge = () => {
-		U.current?.abort(new v()), U.current = null, q.current = null;
-	}, J = n(), { markNonceAsUsed: _e, clearNonce: ve } = b({ chainId: O }), { constructGasParams: ye } = d(), { partner: be, partnerAddress: Y, partnerFeeBps: xe, partnerTakesSurplus: Se } = c(), { referrerAddress: Ce } = re(), we = a(), { onSwap: X } = r(), Z = oe({
+	}, G = H.data?.receipts?.[H.data.receipts.length - 1], he = {
+		canBatchTxs: z,
+		callsId: B.data?.id,
+		txHash: G?.transactionHash,
+		receipt: G,
+		isConfirmingCalls: B.isPending,
+		isConfirmingCallsError: B.isError,
+		isCallsSent: B.isSuccess,
+		isCallsPending: H.isLoading,
+		isCallsMined: H.isSuccess,
+		isCallsAwaitingError: H.isError,
+		isPending: B.isPending || H.isLoading,
+		isSuccess: H.isSuccess,
+		isError: B.isError || H.isError,
+		error: B.error || H.error
+	}, { address: K } = ce(), q = g(), ge = m(), J = x(null), _e = () => {
+		W.current?.abort(new y()), W.current = null, J.current = null;
+	}, Y = n(), { markNonceAsUsed: ve, clearNonce: ye } = ee({ chainId: k }), { constructGasParams: be } = f(), { partner: xe, partnerAddress: Se, partnerFeeBps: Ce, partnerTakesSurplus: we } = c(), { referrerAddress: Te } = ie(), Ee = a(), { onSwap: X } = r(), Z = se({
 		mutationFn: async ({ onTxSent: e, lastPrice: t } = {}) => {
-			N.reset(), P.reset(), I.reset(), L.reset(), z.reset(), H.reset(), S(A, "Market price is not available");
+			P.reset(), F.reset(), L.reset(), R.reset(), B.reset(), U.reset(), S(j, "Market price is not available");
 			let n = new AbortController();
-			U.current = n;
-			let r = n.signal, i, a, o, s = j.allowanceToSet, c = M.amountToPermit, l = A;
+			W.current = n;
+			let r = n.signal, i, a, o, s = M.allowanceToSet, c = N.amountToPermit, l = j;
 			if (l.hmac === t?.hmac) {
-				let e = await k.refetch({ cancelRefetch: !1 });
+				let e = await A.refetch({ cancelRefetch: !1 });
 				r.throwIfAborted(), e.data && (l = e.data);
 			}
-			let d;
-			q.current = l;
-			let f = R && j.needsApproval && !!s;
+			let u;
+			J.current = l;
+			let f = z && M.needsApproval && !!s;
 			try {
-				if (!f && j.needsApproval && s) {
-					let t = ue;
+				if (!f && M.needsApproval && s) {
+					let t = de;
 					if (t) {
 						let e = s;
-						d = we({
+						u = Ee({
 							queryKey: t,
 							onData: (t) => {
 								if (r.aborted) {
-									d?.(), d = void 0;
+									u?.(), u = void 0;
 									return;
 								}
-								let n = u({
+								let n = d({
 									srcAmount: t.srcAmount,
 									destAmount: t.destAmount
-								}, E, t.side);
-								e >= BigInt(n.srcAmount) && (T.log("~ fresh price ~", t), l = t, q.current = l);
+								}, D, t.side);
+								e >= BigInt(n.srcAmount) && (E.log("~ fresh price ~", t), l = t, J.current = l);
 							}
 						});
 					}
-					let n = M.isPermitSupported && M.isPermitReadyToSign;
+					let n = N.isPermitSupported && N.isPermitReadyToSign;
 					try {
-						if (n) F.onSignPermit.request({ allowanceToSet: c }), i = await P.signPermitAsync({ value: c }), F.onSignPermit.confirmed({
+						if (n) I.onSignPermit.request({ allowanceToSet: c }), i = await F.signPermitAsync({ value: c }), I.onSignPermit.confirmed({
 							allowanceToSet: c,
 							permit: i?.permitEncodedArgs
 						});
 						else {
-							F.onApproveTx.request({ allowanceToSet: s }), a = await N.approveAsync({ allowanceData: { allowanceToSet: s } }), F.onApproveTx.sent({
+							I.onApproveTx.request({ allowanceToSet: s }), a = await P.approveAsync({ allowanceData: { allowanceToSet: s } }), I.onApproveTx.sent({
 								allowanceToSet: s,
 								txHash: a
 							}), r.throwIfAborted();
-							let t = K({
+							let t = q({
 								hash: a,
-								chainId: O,
+								chainId: k,
 								onReplaced: (e) => {
-									T.log("onReplaced:approveTx", a, e);
+									E.log("onReplaced:approveTx", a, e);
 								}
 							});
 							e && e({
-								chainId: O,
+								chainId: k,
 								action: "approve",
 								transactionHash: a,
 								receiptPromise: t,
 								transactionSpecificData: {
 									action: "approve",
 									approvedAmount: s,
-									tokenAddress: j.token,
-									spenderAddress: j.spender
+									tokenAddress: M.token,
+									spenderAddress: M.spender
 								}
-							}), o = await t, F.onApproveTx.confirmed({
+							}), o = await t, I.onApproveTx.confirmed({
 								allowanceToSet: s,
 								txHash: a,
 								txReceipt: o
-							}), T.log("~ approveTx ~ receipt:", o);
+							}), E.log("~ approveTx ~ receipt:", o);
 						}
 					} catch (e) {
-						throw n ? F.onSignPermit.failed({
+						throw n ? I.onSignPermit.failed({
 							allowanceToSet: c,
 							error: e
-						}) : F.onApproveTx.failed({
+						}) : I.onApproveTx.failed({
 							allowanceToSet: s,
 							error: e,
 							txHash: a
 						}), e;
 					}
 				}
-				r.throwIfAborted(), S(G, "Account is not connected");
+				r.throwIfAborted(), S(K, "Account is not connected");
 				let t = l;
-				q.current = t, d?.(), d = void 0, S(t, "Market price is not available");
-				let n = u({
+				J.current = t, u?.(), u = void 0, S(t, "Market price is not available");
+				let n = d({
 					srcAmount: t.srcAmount,
 					destAmount: t.destAmount
-				}, E, t.side), p = ye(), m = {
+				}, D, t.side), p = be(), m = {
 					swapTxInput: {
-						userAddress: G,
-						receiver: J,
+						userAddress: K,
+						receiver: Y,
 						srcToken: t.srcToken,
 						destToken: t.destToken,
 						srcDecimals: t.srcDecimals,
 						destDecimals: t.destDecimals,
-						partner: be,
-						partnerAddress: Y,
-						partnerFeeBps: xe,
-						takeSurplus: Se,
-						referrer: Ce,
+						partner: xe,
+						partnerAddress: Se,
+						partnerFeeBps: Ce,
+						takeSurplus: we,
+						referrer: Te,
 						permit: i?.permitEncodedArgs,
 						priceRoute: t,
 						...n
@@ -240,10 +243,10 @@ function w({ marketPrice: w }) {
 					swapTxOptions: {
 						ignoreGasEstimate: f,
 						ignoreAllowance: f,
-						degenMode: D.degenMode,
+						degenMode: O.degenMode,
 						...p
 					}
-				}, h = await I.mutateAsync(m);
+				}, h = await L.mutateAsync(m);
 				r.throwIfAborted();
 				let g, _;
 				if (X?.({ event: {
@@ -253,7 +256,7 @@ function w({ marketPrice: w }) {
 						price: t
 					}
 				} }), f) {
-					let { calls: e } = await fe({
+					let { calls: e } = await pe({
 						txsParams: [{
 							to: h.to,
 							account: h.from,
@@ -262,13 +265,13 @@ function w({ marketPrice: w }) {
 							chainId: h.chainId
 						}],
 						approveProps: [{
-							spender: j.spender,
-							allowanceToSet: j.allowanceToSet,
-							token: j.token,
-							chainId: j.chainId
+							spender: M.spender,
+							allowanceToSet: M.allowanceToSet,
+							token: M.token,
+							chainId: M.chainId
 						}]
 					});
-					_ = (await z.sendCalls({ txsParams: e })).id, X?.({ event: {
+					_ = (await B.sendCalls({ txsParams: e })).id, X?.({ event: {
 						name: "Swap:sent",
 						params: {
 							swapMode: "market",
@@ -276,9 +279,9 @@ function w({ marketPrice: w }) {
 							callsId: _
 						}
 					} });
-				} else g = await L.sendTransactionAsync({
+				} else g = await R.sendTransactionAsync({
 					...h,
-					chainId: O
+					chainId: k
 				}), X?.({ event: {
 					name: "Swap:sent",
 					params: {
@@ -287,12 +290,12 @@ function w({ marketPrice: w }) {
 						txHash: g
 					}
 				} });
-				i && _e(i.signedPermitData);
-				let v, b;
+				i && ve(i.signedPermitData);
+				let v, y;
 				if (_) {
-					let r = he({ id: _ }).then((e) => e.receipts?.[e.receipts.length - 1]);
-					T.log("~ swapTx ~ awaiting calls id :", _), e && e({
-						chainId: O,
+					let r = ge({ id: _ }).then((e) => e.receipts?.[e.receipts.length - 1]);
+					E.log("~ swapTx ~ awaiting calls id :", _), e && e({
+						chainId: k,
 						action: "swap",
 						callsId: _,
 						receiptPromise: r,
@@ -318,25 +321,25 @@ function w({ marketPrice: w }) {
 						}
 					} });
 				} else if (g) {
-					let i = K({
+					let i = q({
 						hash: g,
-						chainId: O,
+						chainId: k,
 						onReplaced: (e) => {
-							T.log("onReplaced:swapTx", g, e);
+							E.log("onReplaced:swapTx", g, e);
 						}
 					});
-					T.log("~ swapTx ~ awaiting tx hash :", g), r.throwIfAborted();
+					E.log("~ swapTx ~ awaiting tx hash :", g), r.throwIfAborted();
 					let a = new Promise((e, t) => {
 						r.onabort = () => {
 							try {
 								r.throwIfAborted();
 							} catch (e) {
-								y(e) && t(e);
+								b(e) && t(e);
 							}
 						};
 					}), o = Promise.race([i, a]);
 					e && e({
-						chainId: O,
+						chainId: k,
 						action: "swap",
 						transactionHash: g,
 						receiptPromise: o,
@@ -353,17 +356,17 @@ function w({ marketPrice: w }) {
 							gasCostUSD: t.gasCostUSD,
 							swapSide: t.side
 						}
-					}), b = await o, b && X?.({ event: {
+					}), y = await o, y && X?.({ event: {
 						name: "Swap:confirmed",
 						params: {
 							swapMode: "market",
 							price: t,
-							txReceipt: b,
+							txReceipt: y,
 							txHash: g
 						}
 					} });
 				}
-				return T.log("~ swapTx ~ receipt:", v || b), {
+				return E.log("~ swapTx ~ receipt:", v || y), {
 					tradeFlowType: C,
 					approve: {
 						txHash: a,
@@ -373,15 +376,15 @@ function w({ marketPrice: w }) {
 						swapRequest: m,
 						callsId: _,
 						txHash: g,
-						receipt: b,
+						receipt: y,
 						callsReceipt: v
 					},
 					marketPrice: t,
-					account: G,
-					receiverAddress: J
+					account: K,
+					receiverAddress: Y
 				};
 			} catch (e) {
-				throw i && ve(i.signedPermitData), y(e) || X?.({ event: {
+				throw i && ye(i.signedPermitData), b(e) || X?.({ event: {
 					name: "Swap:failed",
 					params: {
 						swapMode: "market",
@@ -389,51 +392,51 @@ function w({ marketPrice: w }) {
 					}
 				} }), e;
 			} finally {
-				d?.();
+				u?.();
 			}
 		},
-		mutationKey: [ce],
+		mutationKey: [w],
 		onSuccess: (e) => {
-			T.log("Swap tx success", e);
+			E.log("Swap tx success", e);
 		},
 		onError: (e) => {
-			T.error("Swap tx error", e);
+			E.error("Swap tx error", e);
 		},
 		onSettled: () => {
-			T.log("Swap tx settled");
+			E.log("Swap tx settled");
 		}
 	}), Q = Z.mutateAsync, $ = () => {
-		q.current = null, N.reset(), P.reset(), I.reset(), L.reset(), z.reset(), Z.reset(), H.reset();
-	}, Te = (e) => {
-		let t = q.current;
+		J.current = null, P.reset(), F.reset(), L.reset(), R.reset(), B.reset(), Z.reset(), U.reset();
+	}, De = (e) => {
+		let t = J.current;
 		return $(), Q({
 			...e,
 			lastPrice: t
 		});
-	}, Ee = q.current || A, De = Z.data?.swap.swapRequest;
+	}, Oe = J.current || j, ke = Z.data?.swap.swapRequest;
 	return {
 		tradeFlowType: C,
-		chainId: O,
+		chainId: k,
 		runMarketSwapFlow: Q,
 		reset: $,
-		cancelFlow: ge,
-		retryFlow: Te,
-		approval: j,
-		signPermit: M,
-		buildTxParams: de,
-		swap: pe,
-		swapBatch: me,
+		cancelFlow: _e,
+		retryFlow: De,
+		approval: M,
+		signPermit: N,
+		buildTxParams: fe,
+		swap: me,
+		swapBatch: he,
 		isPending: Z.isPending,
 		isSuccess: Z.isSuccess,
 		isError: Z.isError,
 		error: Z.error,
 		result: Z.data,
-		usedPrice: Ee,
-		freshPrice: A,
-		submittedSwapRequest: De
+		usedPrice: Oe,
+		freshPrice: j,
+		submittedSwapRequest: ke
 	};
 }
 //#endregion
-export { w as useMarketFlow };
+export { T as useMarketFlow };
 
 //# sourceMappingURL=useMarketFlow.js.map