@velora-dex/widget 0.7.0 → 0.7.2

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

@@ -17,62 +17,63 @@ 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 { useSendMarketSwapTx as re } from "../prices/market/mutations/useSendMarketSwapTx.js";
-import { useBuildTx as ie } from "../prices/market/mutations/useBuildTx.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 { useRef as x } from "react";
-import { useMutation as ae } from "@tanstack/react-query";
+import { useMutation as oe } from "@tanstack/react-query";
 import { assert as S } from "ts-essentials";
 import "viem";
-import { useAccount as oe } from "wagmi";
+import { useAccount as se } from "wagmi";
 //#region src/hooks/swap/tradeFlow/useMarketFlow.ts
-var C = "marketSwap", w = "runMarketSwapFlow";
-function T({ marketPrice: T }) {
-	let E = e("MarketFlow"), { resolvedSlippage: D } = o("swap"), se = t(), { priceParams: O, chainId: k } = l("swap"), { result: A, queryKey: ce } = i({
-		priceParams: O,
-		chainId: k,
+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,
 		query: { enabled: !1 }
-	}), j = A.data || T, { approval: M, signPermit: N, approveTxMut: P, signPermitMut: F, events: I } = ee({
-		srcToken: j?.srcToken,
-		srcAmount: j?.srcAmount,
+	}), A = k.data || w, { approval: j, signPermit: M, approveTxMut: N, signPermitMut: P, events: F } = ee({
+		srcToken: A?.srcToken,
+		srcAmount: A?.srcAmount,
 		spenderContractType: "AugustusSwapper",
-		swapSide: j?.side ?? se,
+		swapSide: A?.side ?? le,
 		tradeMode: "swap",
-		chainId: k
-	}), L = ie({
-		chainId: k,
+		chainId: O
+	}), I = ae({
+		chainId: O,
 		mutationOptions: {
 			onSuccess: () => {
-				E.log("Build tx success");
+				T.log("Build tx success");
 			},
 			onError: (e) => {
-				E.error("Build tx error", e);
+				T.error("Build tx error", e);
 			}
 		}
-	}), le = {
-		isPending: L.isPending,
-		isError: L.isError,
-		isSuccess: L.isSuccess,
-		error: L.error
-	}, R = re({
+	}), de = {
+		isPending: I.isPending,
+		isError: I.isError,
+		isSuccess: I.isSuccess,
+		error: I.error
+	}, L = ie({
 		onSuccess: () => {
-			E.log("Swap tx success");
+			T.log("Swap tx success");
 		},
 		onError: (e) => {
-			E.error("Swap tx error", e);
+			T.error("Swap tx error", e);
 		}
-	}), { forCurrentChain: z } = s(), { addTxWithApprovals: ue } = te(), B = ne({
+	}), { forCurrentChain: R } = s(), { addTxWithApprovals: fe } = te(), z = ne({
 		onSuccess: () => {
-			E.log("Batch tx success");
+			T.log("Batch tx success");
 		},
 		onError: (e) => {
-			E.error("Batch tx error", e);
+			T.error("Batch tx error", e);
 		}
-	}), V = m({
-		hash: R.txHash,
-		chainId: k
-	}), H = f({ id: B.data?.id }), U = g({
-		chainId: k,
-		txHash: R.txHash,
+	}), B = m({
+		hash: L.txHash,
+		chainId: O
+	}), V = f({ id: z.data?.id }), H = g({
+		chainId: O,
+		txHash: L.txHash,
 		cancelTxType: "SWAP",
 		onSuccess: (e) => {
 			X?.({ event: {
@@ -83,76 +84,76 @@ function T({ marketPrice: T }) {
 				}
 			} });
 		}
-	}), W = x(null), de = {
-		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,
+	}), 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,
 		cancelSwapTx: async () => {
 			try {
-				S(R.txHash, "Swap tx hash is not available");
-				let e = await U.replaceTx({
+				S(L.txHash, "Swap tx hash is not available");
+				let e = await H.replaceTx({
 					action: "cancel",
-					hash: R.txHash
+					hash: L.txHash
 				});
-				return e.replacementTxReceipt.status === "success" && W.current?.abort(new _("Swap tx cancelled", e)), e;
+				return e.replacementTxReceipt.status === "success" && U.current?.abort(new _("Swap tx cancelled", e)), e;
 			} catch (e) {
-				E.error("Cancel swap tx error", e), U.reset();
+				T.error("Cancel swap tx error", e), H.reset();
 			}
 		},
 		cancellingState: {
-			isPending: U.isPending,
-			isError: U.isError,
-			isSuccess: U.isSuccess,
-			error: U.error,
-			result: U.result,
-			step: U.step
+			isPending: H.isPending,
+			isError: H.isError,
+			isSuccess: H.isSuccess,
+			error: H.error,
+			result: H.result,
+			step: H.step
 		}
-	}, G = H.data?.receipts?.[H.data.receipts.length - 1], fe = {
-		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 } = oe(), q = h(), pe = p(), J = x(null), me = () => {
-		W.current?.abort(new v()), W.current = null, J.current = null;
-	}, Y = n(), { markNonceAsUsed: he, clearNonce: ge } = b({ chainId: k }), { constructGasParams: _e } = d(), { partner: ve, partnerAddress: ye, partnerFeeBps: be, partnerTakesSurplus: xe } = c(), Se = a(), { onSwap: X } = r(), Z = ae({
+	}, 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({
 		mutationFn: async ({ onTxSent: e, lastPrice: t } = {}) => {
-			P.reset(), F.reset(), L.reset(), R.reset(), B.reset(), U.reset(), S(j, "Market price is not available");
+			N.reset(), P.reset(), I.reset(), L.reset(), z.reset(), H.reset(), S(A, "Market price is not available");
 			let n = new AbortController();
-			W.current = n;
-			let r = n.signal, i, a, o, s = M.allowanceToSet, c = N.amountToPermit, l = j;
+			U.current = n;
+			let r = n.signal, i, a, o, s = j.allowanceToSet, c = M.amountToPermit, l = A;
 			if (l.hmac === t?.hmac) {
-				let e = await A.refetch({ cancelRefetch: !1 });
+				let e = await k.refetch({ cancelRefetch: !1 });
 				r.throwIfAborted(), e.data && (l = e.data);
 			}
 			let d;
-			J.current = l;
-			let f = z && M.needsApproval && !!s;
+			q.current = l;
+			let f = R && j.needsApproval && !!s;
 			try {
-				if (!f && M.needsApproval && s) {
-					let t = ce;
+				if (!f && j.needsApproval && s) {
+					let t = ue;
 					if (t) {
 						let e = s;
-						d = Se({
+						d = we({
 							queryKey: t,
 							onData: (t) => {
 								if (r.aborted) {
@@ -162,75 +163,76 @@ function T({ marketPrice: T }) {
 								let n = u({
 									srcAmount: t.srcAmount,
 									destAmount: t.destAmount
-								}, D, t.side);
-								e >= BigInt(n.srcAmount) && (E.log("~ fresh price ~", t), l = t, J.current = l);
+								}, E, t.side);
+								e >= BigInt(n.srcAmount) && (T.log("~ fresh price ~", t), l = t, q.current = l);
 							}
 						});
 					}
-					let n = N.isPermitSupported && N.isPermitReadyToSign;
+					let n = M.isPermitSupported && M.isPermitReadyToSign;
 					try {
-						if (n) I.onSignPermit.request({ allowanceToSet: c }), i = await F.signPermitAsync({ value: c }), I.onSignPermit.confirmed({
+						if (n) F.onSignPermit.request({ allowanceToSet: c }), i = await P.signPermitAsync({ value: c }), F.onSignPermit.confirmed({
 							allowanceToSet: c,
 							permit: i?.permitEncodedArgs
 						});
 						else {
-							I.onApproveTx.request({ allowanceToSet: s }), a = await P.approveAsync({ allowanceData: { allowanceToSet: s } }), I.onApproveTx.sent({
+							F.onApproveTx.request({ allowanceToSet: s }), a = await N.approveAsync({ allowanceData: { allowanceToSet: s } }), F.onApproveTx.sent({
 								allowanceToSet: s,
 								txHash: a
 							}), r.throwIfAborted();
-							let t = q({
+							let t = K({
 								hash: a,
-								chainId: k,
+								chainId: O,
 								onReplaced: (e) => {
-									E.log("onReplaced:approveTx", a, e);
+									T.log("onReplaced:approveTx", a, e);
 								}
 							});
 							e && e({
-								chainId: k,
+								chainId: O,
 								action: "approve",
 								transactionHash: a,
 								receiptPromise: t,
 								transactionSpecificData: {
 									action: "approve",
 									approvedAmount: s,
-									tokenAddress: M.token,
-									spenderAddress: M.spender
+									tokenAddress: j.token,
+									spenderAddress: j.spender
 								}
-							}), o = await t, I.onApproveTx.confirmed({
+							}), o = await t, F.onApproveTx.confirmed({
 								allowanceToSet: s,
 								txHash: a,
 								txReceipt: o
-							}), E.log("~ approveTx ~ receipt:", o);
+							}), T.log("~ approveTx ~ receipt:", o);
 						}
 					} catch (e) {
-						throw n ? I.onSignPermit.failed({
+						throw n ? F.onSignPermit.failed({
 							allowanceToSet: c,
 							error: e
-						}) : I.onApproveTx.failed({
+						}) : F.onApproveTx.failed({
 							allowanceToSet: s,
 							error: e,
 							txHash: a
 						}), e;
 					}
 				}
-				r.throwIfAborted(), S(K, "Account is not connected");
+				r.throwIfAborted(), S(G, "Account is not connected");
 				let t = l;
-				J.current = t, d?.(), d = void 0, S(t, "Market price is not available");
+				q.current = t, d?.(), d = void 0, S(t, "Market price is not available");
 				let n = u({
 					srcAmount: t.srcAmount,
 					destAmount: t.destAmount
-				}, D, t.side), p = _e(), m = {
+				}, E, t.side), p = ye(), m = {
 					swapTxInput: {
-						userAddress: K,
-						receiver: Y,
+						userAddress: G,
+						receiver: J,
 						srcToken: t.srcToken,
 						destToken: t.destToken,
 						srcDecimals: t.srcDecimals,
 						destDecimals: t.destDecimals,
-						partner: ve,
-						partnerAddress: ye,
-						partnerFeeBps: be,
-						takeSurplus: xe,
+						partner: be,
+						partnerAddress: Y,
+						partnerFeeBps: xe,
+						takeSurplus: Se,
+						referrer: Ce,
 						permit: i?.permitEncodedArgs,
 						priceRoute: t,
 						...n
@@ -238,10 +240,10 @@ function T({ marketPrice: T }) {
 					swapTxOptions: {
 						ignoreGasEstimate: f,
 						ignoreAllowance: f,
-						degenMode: O.degenMode,
+						degenMode: D.degenMode,
 						...p
 					}
-				}, h = await L.mutateAsync(m);
+				}, h = await I.mutateAsync(m);
 				r.throwIfAborted();
 				let g, _;
 				if (X?.({ event: {
@@ -251,7 +253,7 @@ function T({ marketPrice: T }) {
 						price: t
 					}
 				} }), f) {
-					let { calls: e } = await ue({
+					let { calls: e } = await fe({
 						txsParams: [{
 							to: h.to,
 							account: h.from,
@@ -260,13 +262,13 @@ function T({ marketPrice: T }) {
 							chainId: h.chainId
 						}],
 						approveProps: [{
-							spender: M.spender,
-							allowanceToSet: M.allowanceToSet,
-							token: M.token,
-							chainId: M.chainId
+							spender: j.spender,
+							allowanceToSet: j.allowanceToSet,
+							token: j.token,
+							chainId: j.chainId
 						}]
 					});
-					_ = (await B.sendCalls({ txsParams: e })).id, X?.({ event: {
+					_ = (await z.sendCalls({ txsParams: e })).id, X?.({ event: {
 						name: "Swap:sent",
 						params: {
 							swapMode: "market",
@@ -274,9 +276,9 @@ function T({ marketPrice: T }) {
 							callsId: _
 						}
 					} });
-				} else g = await R.sendTransactionAsync({
+				} else g = await L.sendTransactionAsync({
 					...h,
-					chainId: k
+					chainId: O
 				}), X?.({ event: {
 					name: "Swap:sent",
 					params: {
@@ -285,12 +287,12 @@ function T({ marketPrice: T }) {
 						txHash: g
 					}
 				} });
-				i && he(i.signedPermitData);
+				i && _e(i.signedPermitData);
 				let v, b;
 				if (_) {
-					let r = pe({ id: _ }).then((e) => e.receipts?.[e.receipts.length - 1]);
-					E.log("~ swapTx ~ awaiting calls id :", _), e && e({
-						chainId: k,
+					let r = he({ id: _ }).then((e) => e.receipts?.[e.receipts.length - 1]);
+					T.log("~ swapTx ~ awaiting calls id :", _), e && e({
+						chainId: O,
 						action: "swap",
 						callsId: _,
 						receiptPromise: r,
@@ -316,14 +318,14 @@ function T({ marketPrice: T }) {
 						}
 					} });
 				} else if (g) {
-					let i = q({
+					let i = K({
 						hash: g,
-						chainId: k,
+						chainId: O,
 						onReplaced: (e) => {
-							E.log("onReplaced:swapTx", g, e);
+							T.log("onReplaced:swapTx", g, e);
 						}
 					});
-					E.log("~ swapTx ~ awaiting tx hash :", g), r.throwIfAborted();
+					T.log("~ swapTx ~ awaiting tx hash :", g), r.throwIfAborted();
 					let a = new Promise((e, t) => {
 						r.onabort = () => {
 							try {
@@ -334,7 +336,7 @@ function T({ marketPrice: T }) {
 						};
 					}), o = Promise.race([i, a]);
 					e && e({
-						chainId: k,
+						chainId: O,
 						action: "swap",
 						transactionHash: g,
 						receiptPromise: o,
@@ -361,7 +363,7 @@ function T({ marketPrice: T }) {
 						}
 					} });
 				}
-				return E.log("~ swapTx ~ receipt:", v || b), {
+				return T.log("~ swapTx ~ receipt:", v || b), {
 					tradeFlowType: C,
 					approve: {
 						txHash: a,
@@ -375,11 +377,11 @@ function T({ marketPrice: T }) {
 						callsReceipt: v
 					},
 					marketPrice: t,
-					account: K,
-					receiverAddress: Y
+					account: G,
+					receiverAddress: J
 				};
 			} catch (e) {
-				throw i && ge(i.signedPermitData), y(e) || X?.({ event: {
+				throw i && ve(i.signedPermitData), y(e) || X?.({ event: {
 					name: "Swap:failed",
 					params: {
 						swapMode: "market",
@@ -390,48 +392,48 @@ function T({ marketPrice: T }) {
 				d?.();
 			}
 		},
-		mutationKey: [w],
+		mutationKey: [ce],
 		onSuccess: (e) => {
-			E.log("Swap tx success", e);
+			T.log("Swap tx success", e);
 		},
 		onError: (e) => {
-			E.error("Swap tx error", e);
+			T.error("Swap tx error", e);
 		},
 		onSettled: () => {
-			E.log("Swap tx settled");
+			T.log("Swap tx settled");
 		}
 	}), Q = Z.mutateAsync, $ = () => {
-		J.current = null, P.reset(), F.reset(), L.reset(), R.reset(), B.reset(), Z.reset(), U.reset();
-	}, Ce = (e) => {
-		let t = J.current;
+		q.current = null, N.reset(), P.reset(), I.reset(), L.reset(), z.reset(), Z.reset(), H.reset();
+	}, Te = (e) => {
+		let t = q.current;
 		return $(), Q({
 			...e,
 			lastPrice: t
 		});
-	}, we = J.current || j, Te = Z.data?.swap.swapRequest;
+	}, Ee = q.current || A, De = Z.data?.swap.swapRequest;
 	return {
 		tradeFlowType: C,
-		chainId: k,
+		chainId: O,
 		runMarketSwapFlow: Q,
 		reset: $,
-		cancelFlow: me,
-		retryFlow: Ce,
-		approval: M,
-		signPermit: N,
-		buildTxParams: le,
-		swap: de,
-		swapBatch: fe,
+		cancelFlow: ge,
+		retryFlow: Te,
+		approval: j,
+		signPermit: M,
+		buildTxParams: de,
+		swap: pe,
+		swapBatch: me,
 		isPending: Z.isPending,
 		isSuccess: Z.isSuccess,
 		isError: Z.isError,
 		error: Z.error,
 		result: Z.data,
-		usedPrice: we,
-		freshPrice: j,
-		submittedSwapRequest: Te
+		usedPrice: Ee,
+		freshPrice: A,
+		submittedSwapRequest: De
 	};
 }
 //#endregion
-export { T as useMarketFlow };
+export { w as useMarketFlow };
 
 //# sourceMappingURL=useMarketFlow.js.map