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

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

@@ -1,660 +1,437 @@
-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
-  };
+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
+	};
 }
+//#endregion
+export { T as useMarketFlow };
 
-export { useMarketFlow };
-//# sourceMappingURL=useMarketFlow.js.map
+//# sourceMappingURL=useMarketFlow.js.map