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

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

@@ -1,437 +1,660 @@
-import { useLogger as e } from "../../../core/logger.js";
-import { useSwapSide as t } from "../../../components/widget/SwapModeSwitcher/state/swapSideAtom.js";
-import { useSwapReceiverAddressValue as n } from "../../../components/widget/ReceiverAddress/state/receiverAddressAtom.js";
-import { useWidgetEvents as r } from "../../../core/state/widgetEventsAtom.js";
-import { useMarketPriceQuery as i, useSubscribeToMarketPrice as a } from "../prices/market/queries/useMarketPriceQuery.js";
-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 { useSendMarketSwapTx as re } from "../prices/market/mutations/useSendMarketSwapTx.js";
-import { useBuildTx as ie } from "../prices/market/mutations/useBuildTx.js";
-import { useRef as x } from "react";
-import { useMutation as ae } from "@tanstack/react-query";
-import { assert as S } from "ts-essentials";
-import "viem";
-import { useAccount as oe } 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,
-		query: { enabled: !1 }
-	}), j = A.data || T, { approval: M, signPermit: N, approveTxMut: P, signPermitMut: F, events: I } = ee({
-		srcToken: j?.srcToken,
-		srcAmount: j?.srcAmount,
-		spenderContractType: "AugustusSwapper",
-		swapSide: j?.side ?? se,
-		tradeMode: "swap",
-		chainId: k
-	}), L = ie({
-		chainId: k,
-		mutationOptions: {
-			onSuccess: () => {
-				E.log("Build tx success");
-			},
-			onError: (e) => {
-				E.error("Build tx error", e);
-			}
-		}
-	}), le = {
-		isPending: L.isPending,
-		isError: L.isError,
-		isSuccess: L.isSuccess,
-		error: L.error
-	}, R = re({
-		onSuccess: () => {
-			E.log("Swap tx success");
-		},
-		onError: (e) => {
-			E.error("Swap tx error", e);
-		}
-	}), { forCurrentChain: z } = s(), { addTxWithApprovals: ue } = te(), B = ne({
-		onSuccess: () => {
-			E.log("Batch tx success");
-		},
-		onError: (e) => {
-			E.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,
-		cancelTxType: "SWAP",
-		onSuccess: (e) => {
-			X?.({ event: {
-				name: "Swap:cancelled",
-				params: {
-					swapMode: "market",
-					cancelTxDetails: e
-				}
-			} });
-		}
-	}), 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,
-		cancelSwapTx: async () => {
-			try {
-				S(R.txHash, "Swap tx hash is not available");
-				let e = await U.replaceTx({
-					action: "cancel",
-					hash: R.txHash
-				});
-				return e.replacementTxReceipt.status === "success" && W.current?.abort(new _("Swap tx cancelled", e)), e;
-			} catch (e) {
-				E.error("Cancel swap tx error", e), U.reset();
-			}
-		},
-		cancellingState: {
-			isPending: U.isPending,
-			isError: U.isError,
-			isSuccess: U.isSuccess,
-			error: U.error,
-			result: U.result,
-			step: U.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({
-		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");
-			let n = new AbortController();
-			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 A.refetch({ cancelRefetch: !1 });
-				r.throwIfAborted(), e.data && (l = e.data);
-			}
-			let d;
-			J.current = l;
-			let f = z && M.needsApproval && !!s;
-			try {
-				if (!f && M.needsApproval && s) {
-					let t = ce;
-					if (t) {
-						let e = s;
-						d = Se({
-							queryKey: t,
-							onData: (t) => {
-								if (r.aborted) {
-									d?.(), d = void 0;
-									return;
-								}
-								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);
-							}
-						});
-					}
-					let n = N.isPermitSupported && N.isPermitReadyToSign;
-					try {
-						if (n) I.onSignPermit.request({ allowanceToSet: c }), i = await F.signPermitAsync({ value: c }), I.onSignPermit.confirmed({
-							allowanceToSet: c,
-							permit: i?.permitEncodedArgs
-						});
-						else {
-							I.onApproveTx.request({ allowanceToSet: s }), a = await P.approveAsync({ allowanceData: { allowanceToSet: s } }), I.onApproveTx.sent({
-								allowanceToSet: s,
-								txHash: a
-							}), r.throwIfAborted();
-							let t = q({
-								hash: a,
-								chainId: k,
-								onReplaced: (e) => {
-									E.log("onReplaced:approveTx", a, e);
-								}
-							});
-							e && e({
-								chainId: k,
-								action: "approve",
-								transactionHash: a,
-								receiptPromise: t,
-								transactionSpecificData: {
-									action: "approve",
-									approvedAmount: s,
-									tokenAddress: M.token,
-									spenderAddress: M.spender
-								}
-							}), o = await t, I.onApproveTx.confirmed({
-								allowanceToSet: s,
-								txHash: a,
-								txReceipt: o
-							}), E.log("~ approveTx ~ receipt:", o);
-						}
-					} catch (e) {
-						throw n ? I.onSignPermit.failed({
-							allowanceToSet: c,
-							error: e
-						}) : I.onApproveTx.failed({
-							allowanceToSet: s,
-							error: e,
-							txHash: a
-						}), e;
-					}
-				}
-				r.throwIfAborted(), S(K, "Account is not connected");
-				let t = l;
-				J.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 = {
-					swapTxInput: {
-						userAddress: K,
-						receiver: Y,
-						srcToken: t.srcToken,
-						destToken: t.destToken,
-						srcDecimals: t.srcDecimals,
-						destDecimals: t.destDecimals,
-						partner: ve,
-						partnerAddress: ye,
-						partnerFeeBps: be,
-						takeSurplus: xe,
-						permit: i?.permitEncodedArgs,
-						priceRoute: t,
-						...n
-					},
-					swapTxOptions: {
-						ignoreGasEstimate: f,
-						ignoreAllowance: f,
-						degenMode: O.degenMode,
-						...p
-					}
-				}, h = await L.mutateAsync(m);
-				r.throwIfAborted();
-				let g, _;
-				if (X?.({ event: {
-					name: "Swap:request",
-					params: {
-						swapMode: "market",
-						price: t
-					}
-				} }), f) {
-					let { calls: e } = await ue({
-						txsParams: [{
-							to: h.to,
-							account: h.from,
-							data: h.data,
-							value: BigInt(h.value),
-							chainId: h.chainId
-						}],
-						approveProps: [{
-							spender: M.spender,
-							allowanceToSet: M.allowanceToSet,
-							token: M.token,
-							chainId: M.chainId
-						}]
-					});
-					_ = (await B.sendCalls({ txsParams: e })).id, X?.({ event: {
-						name: "Swap:sent",
-						params: {
-							swapMode: "market",
-							price: t,
-							callsId: _
-						}
-					} });
-				} else g = await R.sendTransactionAsync({
-					...h,
-					chainId: k
-				}), X?.({ event: {
-					name: "Swap:sent",
-					params: {
-						swapMode: "market",
-						price: t,
-						txHash: g
-					}
-				} });
-				i && he(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,
-						action: "swap",
-						callsId: _,
-						receiptPromise: r,
-						transactionSpecificData: {
-							action: "swap",
-							source: "local",
-							srcTokenAddress: t.srcToken,
-							destTokenAddress: t.destToken,
-							srcAmount: n.srcAmount,
-							destAmount: n.destAmount,
-							srcAmountUSD: t.srcUSD,
-							destAmountUSD: t.destUSD,
-							gasCost: t.gasCost,
-							swapSide: t.side
-						}
-					}), v = await r, v && X?.({ event: {
-						name: "Swap:confirmed",
-						params: {
-							swapMode: "market",
-							price: t,
-							callsReceipt: v,
-							callsId: _
-						}
-					} });
-				} else if (g) {
-					let i = q({
-						hash: g,
-						chainId: k,
-						onReplaced: (e) => {
-							E.log("onReplaced:swapTx", g, e);
-						}
-					});
-					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);
-							}
-						};
-					}), o = Promise.race([i, a]);
-					e && e({
-						chainId: k,
-						action: "swap",
-						transactionHash: g,
-						receiptPromise: o,
-						transactionSpecificData: {
-							action: "swap",
-							source: "local",
-							srcTokenAddress: t.srcToken,
-							destTokenAddress: t.destToken,
-							srcAmount: n.srcAmount,
-							destAmount: n.destAmount,
-							srcAmountUSD: t.srcUSD,
-							destAmountUSD: t.destUSD,
-							gasCost: t.gasCost,
-							gasCostUSD: t.gasCostUSD,
-							swapSide: t.side
-						}
-					}), b = await o, b && X?.({ event: {
-						name: "Swap:confirmed",
-						params: {
-							swapMode: "market",
-							price: t,
-							txReceipt: b,
-							txHash: g
-						}
-					} });
-				}
-				return E.log("~ swapTx ~ receipt:", v || b), {
-					tradeFlowType: C,
-					approve: {
-						txHash: a,
-						receipt: o
-					},
-					swap: {
-						swapRequest: m,
-						callsId: _,
-						txHash: g,
-						receipt: b,
-						callsReceipt: v
-					},
-					marketPrice: t,
-					account: K,
-					receiverAddress: Y
-				};
-			} catch (e) {
-				throw i && ge(i.signedPermitData), y(e) || X?.({ event: {
-					name: "Swap:failed",
-					params: {
-						swapMode: "market",
-						error: e
-					}
-				} }), e;
-			} finally {
-				d?.();
-			}
-		},
-		mutationKey: [w],
-		onSuccess: (e) => {
-			E.log("Swap tx success", e);
-		},
-		onError: (e) => {
-			E.error("Swap tx error", e);
-		},
-		onSettled: () => {
-			E.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;
-		return $(), Q({
-			...e,
-			lastPrice: t
-		});
-	}, we = J.current || j, Te = Z.data?.swap.swapRequest;
-	return {
-		tradeFlowType: C,
-		chainId: k,
-		runMarketSwapFlow: Q,
-		reset: $,
-		cancelFlow: me,
-		retryFlow: Ce,
-		approval: M,
-		signPermit: N,
-		buildTxParams: le,
-		swap: de,
-		swapBatch: fe,
-		isPending: Z.isPending,
-		isSuccess: Z.isSuccess,
-		isError: Z.isError,
-		error: Z.error,
-		result: Z.data,
-		usedPrice: we,
-		freshPrice: j,
-		submittedSwapRequest: Te
-	};
+import { useAwaitTx, useEnsureTxReceipt } from '../../txs/queries/useAwaitTx.js';
+import { useAccount } from 'wagmi';
+import { useSendMarketSwapTx } from '../prices/market/mutations/useSendMarketSwapTx.js';
+import { useBuildTx } from '../prices/market/mutations/useBuildTx.js';
+import { assert } from 'ts-essentials';
+import 'viem';
+import { applySlippage } from '../../../lib/utils/price.js';
+import { useSlippage } from '../../useSlippage.js';
+import { useMutation } from '@tanstack/react-query';
+import { useRef } from 'react';
+import { isTransactionCancelledError, TransactionCancelledError, UserCancelledError } from './common/errors.js';
+import { useSwapReceiverAddressValue } from '../../../components/widget/ReceiverAddress/state/receiverAddressAtom.js';
+import { useSwapSide } from '../../../components/widget/SwapModeSwitcher/state/swapSideAtom.js';
+import { useApproveOrPermit } from './common/useApproveOrPermit.js';
+import { useMarkPermit1Or2NonceAsUsed } from './common/useSignPermit1Or2.js';
+import { useLogger } from '../../../core/logger.js';
+import { useConstructGasParams } from './common/useConstructGasParams.js';
+import { useMarketPriceQuery, useSubscribeToMarketPrice } from '../prices/market/queries/useMarketPriceQuery.js';
+import { usePartner } from '../../usePartner.js';
+import { useSendBatchTx } from '../../batch/useSendBatchTx.js';
+import { useCanBatchTxs } from '../../batch/useCanBatchTxs.js';
+import { useAwaitCalls, useEnsureCallsStatus } from '../../batch/useAwaitCalls.js';
+import { useBatchWithApproveTxs } from '../../batch/useBatchWithApproveTxs.js';
+import { useWidgetEvents } from '../../../core/state/widgetEventsAtom.js';
+import { usePricesParams } from '../prices/usePricesParams.js';
+import { useReplaceTx } from '../../txs/mutations/useReplaceTx.js';
+
+const marketSwapFlowType = "marketSwap";
+const MARKET_SWAP_MUTATION_KEY = "runMarketSwapFlow";
+function useMarketFlow({
+  marketPrice: _marketPrice
+}) {
+  const logger = useLogger("MarketFlow");
+  const {
+    resolvedSlippage
+  } = useSlippage("swap");
+  const swapSideFromInput = useSwapSide();
+  const {
+    priceParams,
+    chainId
+  } = usePricesParams("swap");
+  const {
+    result: marketPriceQuery,
+    queryKey: marketPriceQueryKey
+  } = useMarketPriceQuery({
+    priceParams,
+    chainId,
+    query: {
+      enabled: false
+    }
+  });
+  const marketPrice = marketPriceQuery.data || _marketPrice;
+  const {
+    approval,
+    signPermit,
+    approveTxMut,
+    signPermitMut,
+    events: approveOrPermitEvents
+  } = useApproveOrPermit({
+    srcToken: marketPrice?.srcToken,
+    // if we already approved some amount, save it in approval and signPermit objects
+    srcAmount: marketPrice?.srcAmount,
+    spenderContractType: "AugustusSwapper",
+    // marketPrice is the preferred source of truth
+    swapSide: marketPrice?.side ?? swapSideFromInput,
+    tradeMode: "swap",
+    chainId
+  });
+  const buildTxMut = useBuildTx({
+    chainId,
+    mutationOptions: {
+      onSuccess: () => {
+        logger.log("Build tx success");
+      },
+      onError: (error) => {
+        logger.error("Build tx error", error);
+      }
+    }
+  });
+  const buildTxParams = {
+    isPending: buildTxMut.isPending,
+    isError: buildTxMut.isError,
+    isSuccess: buildTxMut.isSuccess,
+    error: buildTxMut.error
+  };
+  const sendSwapTxMut = useSendMarketSwapTx({
+    onSuccess: () => {
+      logger.log("Swap tx success");
+    },
+    onError: (error_0) => {
+      logger.error("Swap tx error", error_0);
+    }
+  });
+  const {
+    forCurrentChain: canBatchTxs
+  } = useCanBatchTxs();
+  const {
+    addTxWithApprovals
+  } = useBatchWithApproveTxs();
+  const batchTxMut = useSendBatchTx({
+    onSuccess: () => {
+      logger.log("Batch tx success");
+    },
+    onError: (error_1) => {
+      logger.error("Batch tx error", error_1);
+    }
+  });
+  const swapTxMined = useAwaitTx({
+    hash: sendSwapTxMut.txHash,
+    chainId
+  });
+  const batchTxMined = useAwaitCalls({
+    id: batchTxMut.data?.id
+  });
+  const cancelSwapTxMut = useReplaceTx({
+    chainId,
+    txHash: sendSwapTxMut.txHash,
+    cancelTxType: "SWAP",
+    onSuccess: (details) => {
+      onSwap?.({
+        event: {
+          name: "Swap:cancelled",
+          params: {
+            swapMode: "market",
+            cancelTxDetails: details
+          }
+        }
+      });
+    }
+  });
+  const currentAbortControllerRef = useRef(null);
+  const cancelSwapTx = async () => {
+    try {
+      assert(sendSwapTxMut.txHash, "Swap tx hash is not available");
+      const result = await cancelSwapTxMut.replaceTx({
+        action: "cancel",
+        hash: sendSwapTxMut.txHash
+      });
+      if (result.replacementTxReceipt.status === "success") {
+        currentAbortControllerRef.current?.abort(new TransactionCancelledError("Swap tx cancelled", result));
+      }
+      return result;
+    } catch (error_2) {
+      logger.error("Cancel swap tx error", error_2);
+      cancelSwapTxMut.reset();
+    }
+  };
+  const swap = {
+    txHash: sendSwapTxMut.txHash,
+    receipt: swapTxMined.data,
+    /* tx sending */
+    isConfirmingTX: sendSwapTxMut.isPending,
+    isConfirmingTxError: sendSwapTxMut.isError,
+    isTxSent: sendSwapTxMut.isSuccess,
+    /* tx awaiting */
+    isTxPending: swapTxMined.isLoading,
+    isTxMined: swapTxMined.isSuccess,
+    isTxAwaitingError: swapTxMined.isError,
+    /* combined */
+    isPending: sendSwapTxMut.isPending || swapTxMined.isLoading,
+    isSuccess: swapTxMined.isSuccess,
+    // final success
+    isError: sendSwapTxMut.isError || swapTxMined.isError,
+    error: sendSwapTxMut.error || swapTxMined.error,
+    isTxCancellable: cancelSwapTxMut.isWalletSupported && // allow to retry cancel (no !cancelSwapTxMut.isPending check) if the Cancel tx is slow
+    !!sendSwapTxMut.txHash && !swapTxMined.data && !cancelSwapTxMut.isSuccess,
+    cancelSwapTx,
+    cancellingState: {
+      isPending: cancelSwapTxMut.isPending,
+      isError: cancelSwapTxMut.isError,
+      isSuccess: cancelSwapTxMut.isSuccess,
+      error: cancelSwapTxMut.error,
+      result: cancelSwapTxMut.result,
+      step: cancelSwapTxMut.step
+    }
+  };
+  const lastCallsReceipt = batchTxMined.data?.receipts?.[batchTxMined.data.receipts.length - 1];
+  const swapBatch = {
+    canBatchTxs,
+    callsId: batchTxMut.data?.id,
+    txHash: lastCallsReceipt?.transactionHash,
+    receipt: lastCallsReceipt,
+    /* calls sending */
+    isConfirmingCalls: batchTxMut.isPending,
+    isConfirmingCallsError: batchTxMut.isError,
+    isCallsSent: batchTxMut.isSuccess,
+    /* calls awaiting */
+    isCallsPending: batchTxMined.isLoading,
+    isCallsMined: batchTxMined.isSuccess,
+    isCallsAwaitingError: batchTxMined.isError,
+    /* combined */
+    isPending: batchTxMut.isPending || batchTxMined.isLoading,
+    isSuccess: batchTxMined.isSuccess,
+    isError: batchTxMut.isError || batchTxMined.isError,
+    error: batchTxMut.error || batchTxMined.error
+  };
+  const {
+    address: account
+  } = useAccount();
+  const ensureTxReceipt = useEnsureTxReceipt();
+  const ensureCallsStatus = useEnsureCallsStatus();
+  const usingPriceRef = useRef(null);
+  const cancelFlow = () => {
+    currentAbortControllerRef.current?.abort(new UserCancelledError());
+    currentAbortControllerRef.current = null;
+    usingPriceRef.current = null;
+  };
+  const receiverAddress = useSwapReceiverAddressValue();
+  const {
+    markNonceAsUsed,
+    clearNonce
+  } = useMarkPermit1Or2NonceAsUsed({
+    chainId
+  });
+  const {
+    constructGasParams
+  } = useConstructGasParams();
+  const {
+    partner,
+    partnerAddress,
+    partnerFeeBps,
+    partnerTakesSurplus
+  } = usePartner();
+  const subscribeToPrice = useSubscribeToMarketPrice();
+  const {
+    onSwap
+  } = useWidgetEvents();
+  const submitSwapTx = async ({
+    onTxSent,
+    lastPrice
+  } = {}) => {
+    approveTxMut.reset();
+    signPermitMut.reset();
+    buildTxMut.reset();
+    sendSwapTxMut.reset();
+    batchTxMut.reset();
+    cancelSwapTxMut.reset();
+    assert(marketPrice, "Market price is not available");
+    const abortController = new AbortController();
+    currentAbortControllerRef.current = abortController;
+    const signal = abortController.signal;
+    let signedPermitResult;
+    let approveTxHash;
+    let approveTxReceipt;
+    const allowanceToSet = approval.allowanceToSet;
+    const allowanceToPermit = signPermit.amountToPermit;
+    let freshPrice = marketPrice;
+    if (freshPrice.hmac === lastPrice?.hmac) {
+      const newPriceResult = await marketPriceQuery.refetch({
+        cancelRefetch: false
+      });
+      signal.throwIfAborted();
+      if (newPriceResult.data) {
+        freshPrice = newPriceResult.data;
+      }
+    }
+    let unsubscribeFromPrice;
+    usingPriceRef.current = freshPrice;
+    const shouldBatchTxs = canBatchTxs && approval.needsApproval && !!allowanceToSet;
+    try {
+      if (!shouldBatchTxs && approval.needsApproval && allowanceToSet) {
+        const queryKey = marketPriceQueryKey;
+        if (queryKey) {
+          const approvedAmount = allowanceToSet;
+          unsubscribeFromPrice = subscribeToPrice({
+            queryKey,
+            onData: (newPrice) => {
+              if (signal.aborted) {
+                unsubscribeFromPrice?.();
+                unsubscribeFromPrice = void 0;
+                return;
+              }
+              const amountsAfterSlippage = applySlippage({
+                srcAmount: newPrice.srcAmount,
+                destAmount: newPrice.destAmount
+              }, resolvedSlippage, newPrice.side);
+              if (approvedAmount >= BigInt(amountsAfterSlippage.srcAmount)) {
+                logger.log("~ fresh price ~", newPrice);
+                freshPrice = newPrice;
+                usingPriceRef.current = freshPrice;
+              }
+            }
+          });
+        }
+        const tryPermit = signPermit.isPermitSupported && signPermit.isPermitReadyToSign;
+        try {
+          if (!tryPermit) {
+            approveOrPermitEvents.onApproveTx.request({
+              allowanceToSet
+            });
+            approveTxHash = await approveTxMut.approveAsync({
+              allowanceData: {
+                allowanceToSet
+              }
+            });
+            approveOrPermitEvents.onApproveTx.sent({
+              allowanceToSet,
+              txHash: approveTxHash
+            });
+            signal.throwIfAborted();
+            const approveTxReceiptPromise = ensureTxReceipt({
+              hash: approveTxHash,
+              chainId,
+              onReplaced: (data) => {
+                logger.log("onReplaced:approveTx", approveTxHash, data);
+              }
+            });
+            if (onTxSent) {
+              onTxSent({
+                chainId,
+                action: "approve",
+                transactionHash: approveTxHash,
+                receiptPromise: approveTxReceiptPromise,
+                transactionSpecificData: {
+                  action: "approve",
+                  approvedAmount: allowanceToSet,
+                  tokenAddress: approval.token,
+                  spenderAddress: approval.spender
+                }
+              });
+            }
+            approveTxReceipt = await approveTxReceiptPromise;
+            approveOrPermitEvents.onApproveTx.confirmed({
+              allowanceToSet,
+              txHash: approveTxHash,
+              txReceipt: approveTxReceipt
+            });
+            logger.log("~ approveTx ~ receipt:", approveTxReceipt);
+          } else {
+            approveOrPermitEvents.onSignPermit.request({
+              allowanceToSet: allowanceToPermit
+            });
+            signedPermitResult = await signPermitMut.signPermitAsync({
+              value: allowanceToPermit
+            });
+            approveOrPermitEvents.onSignPermit.confirmed({
+              allowanceToSet: allowanceToPermit,
+              permit: signedPermitResult?.permitEncodedArgs
+            });
+          }
+        } catch (error_4) {
+          if (!tryPermit) {
+            approveOrPermitEvents.onApproveTx.failed({
+              allowanceToSet,
+              error: error_4,
+              txHash: approveTxHash
+              // won't necessarily be available
+            });
+          } else {
+            approveOrPermitEvents.onSignPermit.failed({
+              allowanceToSet: allowanceToPermit,
+              error: error_4
+            });
+          }
+          throw error_4;
+        }
+      }
+      signal.throwIfAborted();
+      assert(account, "Account is not connected");
+      const marketPriceToUse = freshPrice;
+      usingPriceRef.current = marketPriceToUse;
+      unsubscribeFromPrice?.();
+      unsubscribeFromPrice = void 0;
+      assert(marketPriceToUse, "Market price is not available");
+      const amountsAfterSlippage_0 = applySlippage({
+        srcAmount: marketPriceToUse.srcAmount,
+        destAmount: marketPriceToUse.destAmount
+      }, resolvedSlippage, marketPriceToUse.side);
+      const gasParams = constructGasParams();
+      const swapRequest = {
+        swapTxInput: {
+          userAddress: account,
+          receiver: receiverAddress,
+          srcToken: marketPriceToUse.srcToken,
+          destToken: marketPriceToUse.destToken,
+          srcDecimals: marketPriceToUse.srcDecimals,
+          destDecimals: marketPriceToUse.destDecimals,
+          partner,
+          partnerAddress,
+          partnerFeeBps,
+          takeSurplus: partnerTakesSurplus,
+          permit: signedPermitResult?.permitEncodedArgs,
+          // just signed Permit signature
+          priceRoute: marketPriceToUse,
+          ...amountsAfterSlippage_0
+        },
+        swapTxOptions: {
+          // ignoreChecks: true,
+          // gas estimate will break if only swap tx is estimated, but approve tx is not considered in a batch
+          ignoreGasEstimate: shouldBatchTxs,
+          // for Batch-capable wallets batch Approve+Swap tx have to ignore all checks
+          ignoreAllowance: shouldBatchTxs,
+          // onlyParams: true,
+          degenMode: priceParams.degenMode,
+          ...gasParams
+        }
+      };
+      const txParams = await buildTxMut.mutateAsync(swapRequest);
+      signal.throwIfAborted();
+      let swapTxHash;
+      let swapCallsId;
+      onSwap?.({
+        event: {
+          name: "Swap:request",
+          params: {
+            swapMode: "market",
+            price: marketPriceToUse
+          }
+        }
+      });
+      if (shouldBatchTxs) {
+        const {
+          calls
+        } = await addTxWithApprovals({
+          txsParams: [{
+            to: txParams.to,
+            account: txParams.from,
+            data: txParams.data,
+            value: BigInt(txParams.value),
+            chainId: txParams.chainId
+          }],
+          approveProps: [{
+            spender: approval.spender,
+            allowanceToSet: approval.allowanceToSet,
+            token: approval.token,
+            chainId: approval.chainId
+          }]
+        });
+        const sendCallsResult = await batchTxMut.sendCalls({
+          txsParams: calls
+        });
+        swapCallsId = sendCallsResult.id;
+        onSwap?.({
+          event: {
+            name: "Swap:sent",
+            params: {
+              swapMode: "market",
+              price: marketPriceToUse,
+              callsId: swapCallsId
+            }
+          }
+        });
+      } else {
+        swapTxHash = await sendSwapTxMut.sendTransactionAsync({
+          ...txParams,
+          chainId
+        });
+        onSwap?.({
+          event: {
+            name: "Swap:sent",
+            params: {
+              swapMode: "market",
+              price: marketPriceToUse,
+              txHash: swapTxHash
+            }
+          }
+        });
+      }
+      if (signedPermitResult) {
+        markNonceAsUsed(signedPermitResult.signedPermitData);
+      }
+      let swapCallsReceipt;
+      let swapTxReceipt;
+      if (swapCallsId) {
+        const sendCallsReceiptPromise = ensureCallsStatus({
+          id: swapCallsId
+        }).then((status) => status.receipts?.[status.receipts.length - 1]);
+        logger.log("~ swapTx ~ awaiting calls id :", swapCallsId);
+        if (onTxSent) {
+          onTxSent({
+            chainId,
+            action: "swap",
+            callsId: swapCallsId,
+            receiptPromise: sendCallsReceiptPromise,
+            transactionSpecificData: {
+              action: "swap",
+              source: "local",
+              srcTokenAddress: marketPriceToUse.srcToken,
+              destTokenAddress: marketPriceToUse.destToken,
+              srcAmount: amountsAfterSlippage_0.srcAmount,
+              destAmount: amountsAfterSlippage_0.destAmount,
+              srcAmountUSD: marketPriceToUse.srcUSD,
+              destAmountUSD: marketPriceToUse.destUSD,
+              gasCost: marketPriceToUse.gasCost,
+              swapSide: marketPriceToUse.side
+            }
+          });
+        }
+        swapCallsReceipt = await sendCallsReceiptPromise;
+        if (swapCallsReceipt) {
+          onSwap?.({
+            event: {
+              name: "Swap:confirmed",
+              params: {
+                swapMode: "market",
+                price: marketPriceToUse,
+                callsReceipt: swapCallsReceipt,
+                callsId: swapCallsId
+              }
+            }
+          });
+        }
+      } else if (swapTxHash) {
+        const swapTxReceiptPromise = ensureTxReceipt({
+          hash: swapTxHash,
+          chainId,
+          onReplaced: (data_0) => {
+            logger.log("onReplaced:swapTx", swapTxHash, data_0);
+          }
+        });
+        logger.log("~ swapTx ~ awaiting tx hash :", swapTxHash);
+        signal.throwIfAborted();
+        const txCancelledPromise = new Promise((_, reject) => {
+          signal.onabort = () => {
+            try {
+              signal.throwIfAborted();
+            } catch (error_5) {
+              if (isTransactionCancelledError(error_5)) {
+                reject(error_5);
+              }
+            }
+          };
+        });
+        const txReceiptOrCancelledPromise = Promise.race([swapTxReceiptPromise, txCancelledPromise]);
+        if (onTxSent) {
+          onTxSent({
+            chainId,
+            action: "swap",
+            transactionHash: swapTxHash,
+            receiptPromise: txReceiptOrCancelledPromise,
+            transactionSpecificData: {
+              action: "swap",
+              source: "local",
+              srcTokenAddress: marketPriceToUse.srcToken,
+              destTokenAddress: marketPriceToUse.destToken,
+              srcAmount: amountsAfterSlippage_0.srcAmount,
+              destAmount: amountsAfterSlippage_0.destAmount,
+              srcAmountUSD: marketPriceToUse.srcUSD,
+              destAmountUSD: marketPriceToUse.destUSD,
+              gasCost: marketPriceToUse.gasCost,
+              gasCostUSD: marketPriceToUse.gasCostUSD,
+              swapSide: marketPriceToUse.side
+            }
+          });
+        }
+        swapTxReceipt = await txReceiptOrCancelledPromise;
+        if (swapTxReceipt) {
+          onSwap?.({
+            event: {
+              name: "Swap:confirmed",
+              params: {
+                swapMode: "market",
+                price: marketPriceToUse,
+                txReceipt: swapTxReceipt,
+                txHash: swapTxHash
+              }
+            }
+          });
+        }
+      }
+      logger.log("~ swapTx ~ receipt:", swapCallsReceipt || swapTxReceipt);
+      return {
+        tradeFlowType: marketSwapFlowType,
+        approve: {
+          txHash: approveTxHash,
+          receipt: approveTxReceipt
+        },
+        swap: {
+          swapRequest,
+          callsId: swapCallsId,
+          txHash: swapTxHash,
+          receipt: swapTxReceipt,
+          callsReceipt: swapCallsReceipt
+        },
+        marketPrice: marketPriceToUse,
+        // @TODO add whatever else may be relevant
+        account,
+        receiverAddress
+      };
+    } catch (error_3) {
+      if (signedPermitResult) {
+        clearNonce(signedPermitResult.signedPermitData);
+      }
+      if (!isTransactionCancelledError(error_3)) {
+        onSwap?.({
+          event: {
+            name: "Swap:failed",
+            params: {
+              swapMode: "market",
+              error: error_3
+            }
+          }
+        });
+      }
+      throw error_3;
+    } finally {
+      unsubscribeFromPrice?.();
+    }
+  };
+  const marketSwapMut = useMutation({
+    mutationFn: submitSwapTx,
+    mutationKey: [MARKET_SWAP_MUTATION_KEY],
+    onSuccess: (data_1) => {
+      logger.log("Swap tx success", data_1);
+    },
+    onError: (error_6) => {
+      logger.error("Swap tx error", error_6);
+    },
+    onSettled: () => {
+      logger.log("Swap tx settled");
+    }
+  });
+  const runMarketSwapFlow = marketSwapMut.mutateAsync;
+  const reset = () => {
+    usingPriceRef.current = null;
+    approveTxMut.reset();
+    signPermitMut.reset();
+    buildTxMut.reset();
+    sendSwapTxMut.reset();
+    batchTxMut.reset();
+    marketSwapMut.reset();
+    cancelSwapTxMut.reset();
+  };
+  const retryFlow = (options) => {
+    const lastPrice_0 = usingPriceRef.current;
+    reset();
+    return runMarketSwapFlow({
+      ...options,
+      lastPrice: lastPrice_0
+    });
+  };
+  const usedPrice = usingPriceRef.current || marketPrice;
+  const result_0 = marketSwapMut.data;
+  const submittedSwapRequest = result_0?.swap.swapRequest;
+  return {
+    tradeFlowType: marketSwapFlowType,
+    chainId,
+    runMarketSwapFlow,
+    reset,
+    cancelFlow,
+    retryFlow,
+    approval,
+    signPermit,
+    buildTxParams,
+    swap,
+    swapBatch,
+    // marketSwapMut includes all steps' queries and mutations and returns more precise errors (including cancellation)
+    isPending: marketSwapMut.isPending,
+    isSuccess: marketSwapMut.isSuccess,
+    isError: marketSwapMut.isError,
+    error: marketSwapMut.error,
+    result: marketSwapMut.data,
+    usedPrice,
+    freshPrice: marketPrice,
+    submittedSwapRequest
+  };
 }
-//#endregion
-export { T as useMarketFlow };
 
-//# sourceMappingURL=useMarketFlow.js.map
+export { useMarketFlow };
+//# sourceMappingURL=useMarketFlow.js.map