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

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

@@ -1,638 +1,410 @@
-import { useAccount } from 'wagmi';
-import { assert } from 'ts-essentials';
-import { useEnsureTxReceipt } from '../../txs/queries/useAwaitTx.js';
-import { deltaOrdersQueryKey } from '../prices/delta/queries/useDeltaOrders.js';
-import { useCreateAndSubmitDeltaOrder } from '../prices/delta/mutations/useCreateDeltaOrder.js';
-import { useMinViemClient } from '../../useMinViemClient.js';
-import { useWatchDeltaAuction, useEnsureDeltaOrderExecuted } from '../prices/delta/queries/useWatchDeltaOrder.js';
-import { getSwapSideFromDeltaPrice, getOverallOrderStatus } from '../prices/delta/orders/utils.js';
-import { applySlippage } from '../../../lib/utils/price.js';
-import { useSlippage } from '../../useSlippage.js';
-import { useQueryClient, useMutation } from '@tanstack/react-query';
-import { useRef } from 'react';
-import { isTransactionCancelledError, UserCancelledError } from './common/errors.js';
-import { useSwapReceiverAddressValue } from '../../../components/widget/ReceiverAddress/state/receiverAddressAtom.js';
-import { useApproveOrPermit } from './common/useApproveOrPermit.js';
-import { useMarkPermit1Or2NonceAsUsed } from './common/useSignPermit1Or2.js';
-import { produceDeltaOrderDeadline } from '../../../lib/utils/delta.js';
-import { encodePermit2TransferFromSigDataForDelta } from '../../permit/utils/encodeArgs.js';
-import { useLogger } from '../../../core/logger.js';
-import { useDeltaPriceQuery, useSubscribeToDeltaPrice, isBridgePrice } from '../prices/delta/queries/useDeltaPriceQuery.js';
-import { usePartner } from '../../usePartner.js';
-import { useWidgetEvents } from '../../../core/state/widgetEventsAtom.js';
-import { usePreSignAndSubmitDeltaOrder, shouldApproveOrBatch } from './common/usePreSignAndSubmitDeltaOrder.js';
-import { useSwapSide } from '../../../components/widget/SwapModeSwitcher/state/swapSideAtom.js';
-import { extractSelectedBridgePrice } from '../prices/delta/bridge/utils.js';
-import { useAtomValue } from '../../../core/store.js';
-import { bridgePreferenceAtom } from '../../../components/widget/TradeParameters/state/bridgePreferences/bridgePreferenceAtom.js';
-import { protocolNameAtom } from '../../../components/widget/TradeParameters/state/bridgePreferences/protocolNameAtom.js';
-import { useDepositAndSubmitDeltaOrder } from './common/useDepositAndSubmitDeltaOrder.js';
-import { isETHaddress } from '../../../tokens/utils/eth.js';
-import { useCancelOrWithdrawAndCancelDeltaOrder } from '../prices/delta/mutations/useCancelOrWithdrawAndCancelDeltaOrder.js';
-import { usePricesParams, useExtraDeltaPriceParams } from '../prices/usePricesParams.js';
-import { useSelectedBridgePrice } from '../prices/delta/bridge/useSelectedBridgePrice.js';
-
-const deltaOrderFlowType = "deltaOrder";
-const DELTA_ORDER_MUTATION_KEY = "runDeltaOrderFlow";
-function useDeltaFlow({
-  deltaPrice: _deltaPrice
-}) {
-  const logger = useLogger("DeltaFlow");
-  const {
-    resolvedSlippage
-  } = useSlippage("swap");
-  const {
-    priceParams,
-    chainId,
-    destChainId
-  } = usePricesParams("swap");
-  const extraDeltaPriceParams = useExtraDeltaPriceParams();
-  const {
-    result: deltaPriceQuery,
-    queryKey: deltaPriceQueryKey
-  } = useDeltaPriceQuery({
-    priceParams: {
-      ...priceParams,
-      ...extraDeltaPriceParams
-    },
-    chainId,
-    destChainId,
-    query: {
-      enabled: false
-    }
-  });
-  const selectedBridgePrice = useSelectedBridgePrice({
-    price: deltaPriceQuery.data
-  });
-  const deltaPrice = selectedBridgePrice || deltaPriceQuery.data || _deltaPrice;
-  const swapSideFromInput = useSwapSide();
-  const shouldApplySlippage = !!deltaPrice && deltaPrice.srcToken.toLowerCase() !== deltaPrice.destToken.toLowerCase();
-  const {
-    approval,
-    signPermit,
-    approveTxMut,
-    signPermitMut,
-    events: approveOrPermitEvents
-  } = useApproveOrPermit({
-    srcToken: deltaPrice?.srcToken,
-    srcAmount: deltaPrice?.srcAmount,
-    spenderContractType: "ParaswapDelta",
-    swapSide: deltaPrice && getSwapSideFromDeltaPrice(deltaPrice) || swapSideFromInput,
-    tradeMode: "swap",
-    chainId,
-    applySlippage: shouldApplySlippage
-  });
-  const {
-    address: account
-  } = useAccount();
-  const {
-    minClient
-  } = useMinViemClient({
-    chainId,
-    account
-  });
-  const queryClient = useQueryClient();
-  const createAndSubmitOrderMut = useCreateAndSubmitDeltaOrder({
-    chainId,
-    account,
-    client: minClient,
-    mutationOptions: {
-      onSuccess: (order) => {
-        logger.log("Create Delta Order success", order);
-      },
-      onError: (error) => {
-        logger.error("Create Delta Order error", error);
-      }
-    }
-  });
-  const deltaOrderCreateAndSubmit = {
-    order: createAndSubmitOrderMut.order,
-    isCreatingOrder: createAndSubmitOrderMut.isCreatingOrder,
-    isPostingOrder: createAndSubmitOrderMut.isPostingOrder,
-    isOrderSent: createAndSubmitOrderMut.isOrderSent,
-    isPending: createAndSubmitOrderMut.isPending,
-    isError: createAndSubmitOrderMut.isError,
-    isSuccess: createAndSubmitOrderMut.isSuccess,
-    error: createAndSubmitOrderMut.error
-  };
-  const {
-    deltaOrderPreSign,
-    canBatchTxs,
-    isConnectedToSafe,
-    preSignAndSubmitDeltaOrder,
-    reset: resetPreSignAndSubmitDeltaOrder
-  } = usePreSignAndSubmitDeltaOrder({
-    chainId,
-    account,
-    logger,
-    viemClient: minClient
-  });
-  const {
-    deltaOrderDeposit,
-    reset: resetDepositAndSubmitDeltaOrder,
-    depositAndSubmitDeltaOrder
-  } = useDepositAndSubmitDeltaOrder({
-    chainId,
-    account,
-    logger,
-    viemClient: minClient
-  });
-  const deltaOrderSubmission = {
-    order: deltaOrderCreateAndSubmit.order || deltaOrderPreSign.order || deltaOrderDeposit.order,
-    isPostingOrder: deltaOrderCreateAndSubmit.isPostingOrder || deltaOrderPreSign.postingOrder.isPostingOrder || deltaOrderDeposit.postingOrder.isPostingOrder,
-    isCreatingOrder: deltaOrderCreateAndSubmit.isCreatingOrder || deltaOrderPreSign.isCreatingOrder || deltaOrderDeposit.isCreatingOrder,
-    isOrderSent: deltaOrderCreateAndSubmit.isOrderSent || deltaOrderPreSign.isOrderSent || deltaOrderDeposit.isOrderSent,
-    isPending: deltaOrderCreateAndSubmit.isPending || deltaOrderPreSign.isPending || deltaOrderDeposit.isPending,
-    isError: deltaOrderCreateAndSubmit.isError || deltaOrderPreSign.isError || deltaOrderDeposit.isError,
-    isSuccess: deltaOrderCreateAndSubmit.isSuccess || deltaOrderPreSign.isSuccess || deltaOrderDeposit.isSuccess,
-    error: deltaOrderCreateAndSubmit.error || deltaOrderPreSign.error || deltaOrderDeposit.error
-  };
-  const watchOrderExecution = useWatchDeltaAuction({
-    orderId: deltaOrderSubmission.order?.id,
-    onAuctionSuccess: (order_0) => {
-      logger.log("Delta Order success", order_0);
-    },
-    onAuctionFailure: (order_1) => {
-      logger.log("Delta Order failure", order_1);
-    },
-    onUpdatedAuction: (order_2) => {
-      logger.log("Delta Order updated", order_2);
-    }
-  });
-  const orderStatus = watchOrderExecution.data ? getOverallOrderStatus(watchOrderExecution.data) : null;
-  const deltaOrderExecution = {
-    sentOrder: deltaOrderSubmission.order,
-    lastOrderState: watchOrderExecution.data,
-    isOrderPending: orderStatus === "pending",
-    isOrderExecuting: orderStatus === "executing",
-    isOrderExecuted: orderStatus === "confirmed",
-    isPending: watchOrderExecution.isLoading || watchOrderExecution.isRefetching || orderStatus === "pending" || orderStatus === "executing",
-    isError: watchOrderExecution.isError || orderStatus === "failed",
-    isSuccess: orderStatus === "confirmed",
-    error: watchOrderExecution.error
-  };
-  const {
-    onSwap
-  } = useWidgetEvents();
-  const orderToCancel = deltaOrderExecution.lastOrderState || deltaOrderExecution.sentOrder;
-  const cancelOrderMut = useCancelOrWithdrawAndCancelDeltaOrder({
-    // supply the must up-to-date order for cancellation
-    order: orderToCancel,
-    chainId,
-    account,
-    client: minClient,
-    logger,
-    mutationOptions: {
-      onMutate: () => {
-        assert(orderToCancel, "No order to cancel");
-        return orderToCancel;
-      },
-      onSuccess: (_details, _variables, onMutateResult) => {
-        onSwap?.({
-          event: {
-            name: "Swap:cancelled",
-            params: {
-              swapMode: "delta",
-              order: onMutateResult
-            }
-          }
-        });
-      }
-    }
-  });
-  const deltaOrderCancelation = {
-    receipt: cancelOrderMut.receipt,
-    txHash: cancelOrderMut.txHash,
-    response: cancelOrderMut.cancelOrderResponse,
-    isCancelingOrder: cancelOrderMut.isPending,
-    isOrderCancellable: cancelOrderMut.isOrderCancellable,
-    isOrderCanceled: cancelOrderMut.isSuccess,
-    isPending: cancelOrderMut.isPending,
-    isError: cancelOrderMut.isError,
-    isSuccess: cancelOrderMut.isSuccess,
-    error: cancelOrderMut.error,
-    result: cancelOrderMut.result,
-    step: cancelOrderMut.step
-  };
-  const ensureOrderExecuted = useEnsureDeltaOrderExecuted({
-    onAuctionSuccess: (order_3) => {
-      queryClient.invalidateQueries({
-        queryKey: deltaOrdersQueryKey({
-          userAddress: order_3.user
-        }),
-        exact: false
-      });
-    },
-    onAuctionFailure: (order_4) => {
-      queryClient.invalidateQueries({
-        queryKey: deltaOrdersQueryKey({
-          userAddress: order_4.user
-        }),
-        exact: false
-      });
-    }
-  });
-  const ensureTxReceipt = useEnsureTxReceipt();
-  const currentAbortControllerRef = useRef(null);
-  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 {
-    partner,
-    partnerAddress,
-    partnerFeeBps,
-    partnerTakesSurplus
-  } = usePartner();
-  const protocolName = useAtomValue(protocolNameAtom);
-  const bridgePreference = useAtomValue(bridgePreferenceAtom);
-  const subscribeToPrice = useSubscribeToDeltaPrice();
-  const submitDeltaOrder = async ({
-    onTxSent,
-    onOrderSent,
-    lastPrice
-  } = {}) => {
-    approveTxMut.reset();
-    signPermitMut.reset();
-    createAndSubmitOrderMut.reset();
-    cancelOrderMut.reset();
-    resetPreSignAndSubmitDeltaOrder();
-    resetDepositAndSubmitDeltaOrder();
-    assert(deltaPrice, "Delta price is not available");
-    const swapSide = getSwapSideFromDeltaPrice(deltaPrice);
-    const abortController = new AbortController();
-    currentAbortControllerRef.current = abortController;
-    const signal = abortController.signal;
-    const orderDeadline = produceDeltaOrderDeadline();
-    let signedPermitResult;
-    let approveTxHash;
-    let approveTxReceipt;
-    const allowanceToSet = approval.allowanceToSet;
-    const allowanceToPermit = signPermit.amountToPermit;
-    let freshPrice = deltaPrice;
-    if (freshPrice.hmac === lastPrice?.hmac) {
-      const newPriceResult = await deltaPriceQuery.refetch({
-        cancelRefetch: false
-      });
-      signal.throwIfAborted();
-      if (newPriceResult.data) {
-        freshPrice = newPriceResult.data;
-        if (isBridgePrice(freshPrice)) {
-          freshPrice = extractSelectedBridgePrice({
-            price: freshPrice,
-            protocolName,
-            bridgePreference
-          });
-        }
-      }
-    }
-    let unsubscribeFromPrice;
-    usingPriceRef.current = freshPrice;
-    const shouldDepositAndPreSign = (
-      // @TODO [depositNativeAndPreSign] ensureDeltaEthBalance and compare with price.srcAmount to skip the deposit,
-      // or deposit the difference between user dETH balance and price.srcAmount to avoid unnecessary deposits
-      isETHaddress(freshPrice.srcToken)
-    );
-    const {
-      shouldDoApprovalTxOrPermit,
-      tryPermit,
-      shouldPreSignBatch
-    } = shouldApproveOrBatch({
-      approval,
-      signPermit,
-      canBatchTxs,
-      isConnectedToSafe
-    });
-    try {
-      if (shouldDoApprovalTxOrPermit && allowanceToSet) {
-        const queryKey = deltaPriceQueryKey;
-        if (queryKey) {
-          const approvedAmount = allowanceToSet;
-          unsubscribeFromPrice = subscribeToPrice({
-            queryKey,
-            onData: (price) => {
-              let newPrice = price;
-              if (isBridgePrice(price)) {
-                newPrice = extractSelectedBridgePrice({
-                  price,
-                  protocolName,
-                  bridgePreference
-                });
-              }
-              if (signal.aborted) {
-                unsubscribeFromPrice?.();
-                unsubscribeFromPrice = void 0;
-                return;
-              }
-              const amounts = {
-                srcAmount: newPrice.srcAmount,
-                destAmount: newPrice.destAmount
-              };
-              const amountsAfterSlippage = shouldApplySlippage ? (
-                // slightly higher srcAmount if BUY with slippage,
-                // slightly lower destAmount if SELL with slippage
-                applySlippage(amounts, resolvedSlippage, swapSide)
-              ) : amounts;
-              if (approvedAmount >= BigInt(amountsAfterSlippage.srcAmount)) {
-                logger.log("~ fresh price ~", newPrice);
-                freshPrice = newPrice;
-                usingPriceRef.current = freshPrice;
-              }
-            }
-          });
-        }
-        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({
-              deadline: orderDeadline,
-              value: allowanceToPermit
-            });
-            approveOrPermitEvents.onSignPermit.confirmed({
-              allowanceToSet: allowanceToPermit,
-              permit: signedPermitResult?.permitEncodedArgs
-            });
-          }
-        } catch (error_1) {
-          if (!tryPermit) {
-            approveOrPermitEvents.onApproveTx.failed({
-              allowanceToSet,
-              error: error_1,
-              txHash: approveTxHash
-              // won't necessarily be available
-            });
-          } else {
-            approveOrPermitEvents.onSignPermit.failed({
-              allowanceToSet: allowanceToPermit,
-              error: error_1
-            });
-          }
-          throw error_1;
-        }
-      }
-      signal.throwIfAborted();
-      assert(account, "Account is not connected");
-      const deltaPriceToUse = freshPrice;
-      usingPriceRef.current = deltaPriceToUse;
-      unsubscribeFromPrice?.();
-      unsubscribeFromPrice = void 0;
-      assert(deltaPriceToUse, "Delta price is not available");
-      const amounts_0 = {
-        srcAmount: deltaPriceToUse.srcAmount,
-        destAmount: deltaPriceToUse.destAmount
-      };
-      const amountsAfterSlippage_0 = shouldApplySlippage ? (
-        // slightly higher srcAmount if BUY with slippage,
-        // slightly lower destAmount if SELL with slippage
-        applySlippage(amounts_0, resolvedSlippage, swapSide)
-      ) : amounts_0;
-      let permit = signedPermitResult?.permitEncodedArgs;
-      if (signedPermitResult?.signedPermitData.type === "permit2" && signedPermitResult.signedPermitData.variant === "transferFrom") {
-        permit = encodePermit2TransferFromSigDataForDelta({
-          nonce: signedPermitResult.signedPermitData.nonce,
-          signature: signedPermitResult.signature
-        });
-      }
-      const destChainId_0 = isBridgePrice(deltaPriceToUse) ? deltaPriceToUse.bridge.destinationChainId : chainId;
-      onSwap?.({
-        event: {
-          name: "Swap:request",
-          params: {
-            swapMode: "delta",
-            price: deltaPriceToUse
-          }
-        }
-      });
-      let orderFromAPI;
-      const createOrderInput = {
-        signal,
-        type: "MARKET",
-        degenMode: priceParams.degenMode,
-        orderInput: {
-          owner: account,
-          beneficiary: receiverAddress,
-          srcToken: deltaPriceToUse.srcToken,
-          destToken: deltaPriceToUse.destToken,
-          permit,
-          destChainId: destChainId_0,
-          deltaPrice: deltaPriceToUse,
-          partner,
-          partnerAddress,
-          partnerFeeBps,
-          partnerTakesSurplus,
-          ...amountsAfterSlippage_0,
-          deadline: Number(orderDeadline),
-          side: swapSide
-        }
-      };
-      if (shouldDepositAndPreSign) {
-        const depositAmount = createOrderInput.orderInput.srcAmount;
-        orderFromAPI = await depositAndSubmitDeltaOrder({
-          createOrderInput,
-          depositAmount,
-          onTxSent
-        });
-      } else if (shouldPreSignBatch) {
-        orderFromAPI = await preSignAndSubmitDeltaOrder({
-          createOrderInput,
-          approval,
-          onTxSent
-        });
-      } else {
-        orderFromAPI = await createAndSubmitOrderMut.mutateAsync(createOrderInput);
-      }
-      if (signedPermitResult) {
-        markNonceAsUsed(signedPermitResult.signedPermitData);
-      }
-      onSwap?.({
-        event: {
-          name: "Swap:sent",
-          params: {
-            swapMode: "delta",
-            price: deltaPriceToUse,
-            order: orderFromAPI
-          }
-        }
-      });
-      const lastOrderStatePromise = ensureOrderExecuted({
-        orderId: orderFromAPI.id
-        // signal, // fails the toast if aborted, don't use
-      });
-      if (onOrderSent) {
-        onOrderSent({
-          order: orderFromAPI,
-          lastOrderState: lastOrderStatePromise
-        });
-      }
-      const lastOrderState = await lastOrderStatePromise;
-      onSwap?.({
-        event: {
-          name: "Swap:confirmed",
-          params: {
-            swapMode: "delta",
-            price: deltaPriceToUse,
-            order: lastOrderState ?? orderFromAPI
-          }
-        }
-      });
-      return {
-        tradeFlowType: deltaOrderFlowType,
-        approve: {
-          txHash: approveTxHash,
-          receipt: approveTxReceipt
-        },
-        deltaOrder: {
-          sentOrder: orderFromAPI,
-          lastOrderState
-        },
-        deltaPrice: deltaPriceToUse,
-        // @TODO add whatever else may be relevant
-        account,
-        receiverAddress
-      };
-    } catch (error_0) {
-      if (signedPermitResult) {
-        clearNonce(signedPermitResult.signedPermitData);
-      }
-      if (!isTransactionCancelledError(error_0)) {
-        onSwap?.({
-          event: {
-            name: "Swap:failed",
-            params: {
-              swapMode: "delta",
-              error: error_0
-            }
-          }
-        });
-      }
-      throw error_0;
-    } finally {
-      unsubscribeFromPrice?.();
-    }
-  };
-  const cancelDeltaOrder = async () => {
-    try {
-      return await cancelOrderMut.cancelDeltaOrder();
-    } catch (error_2) {
-      logger.error("Cancel Delta order error", error_2);
-      cancelOrderMut.reset();
-    }
-  };
-  const deltaOrderMut = useMutation({
-    mutationFn: submitDeltaOrder,
-    mutationKey: [DELTA_ORDER_MUTATION_KEY],
-    onSuccess: (data_0) => {
-      logger.log("Delta Order success", data_0);
-    },
-    onError: (error_3) => {
-      logger.error("Delta Order error", error_3);
-    },
-    onSettled: () => {
-      logger.log("Delta Order settled");
-    }
-  });
-  const runDeltaOrderFlow = deltaOrderMut.mutateAsync;
-  const reset = () => {
-    usingPriceRef.current = null;
-    approveTxMut.reset();
-    signPermitMut.reset();
-    createAndSubmitOrderMut.reset();
-    deltaOrderMut.reset();
-    cancelOrderMut.reset();
-    resetPreSignAndSubmitDeltaOrder();
-    resetDepositAndSubmitDeltaOrder();
-  };
-  const retryFlow = (options) => {
-    const lastPrice_0 = usingPriceRef.current;
-    reset();
-    return runDeltaOrderFlow({
-      ...options,
-      lastPrice: lastPrice_0
-    });
-  };
-  const usedPrice = usingPriceRef.current || deltaPrice;
-  const result = deltaOrderMut.data;
-  const submittedDeltaOrder = result?.deltaOrder.lastOrderState || result?.deltaOrder.sentOrder || deltaOrderExecution.lastOrderState || deltaOrderExecution.sentOrder;
-  return {
-    tradeFlowType: deltaOrderFlowType,
-    chainId,
-    runDeltaOrderFlow,
-    reset,
-    cancelFlow,
-    retryFlow,
-    cancelDeltaOrder,
-    approval,
-    signPermit,
-    deltaOrderPreSign,
-    deltaOrderDeposit,
-    deltaOrderSubmission,
-    deltaOrderExecution,
-    deltaOrderCancelation,
-    // deltaOrderMut includes all steps' queries and mutations and returns more precise errors (including cancellation)
-    isPending: deltaOrderMut.isPending,
-    isSuccess: deltaOrderSubmission.isSuccess && deltaOrderExecution.isSuccess,
-    // approval is an optional step
-    isError: deltaOrderMut.isError,
-    error: deltaOrderMut.error,
-    result,
-    usedPrice,
-    freshPrice: deltaPrice,
-    submittedDeltaOrder
-  };
+import { useAtomValue as e } from "../../../core/store.js";
+import { useLogger as t } from "../../../core/logger.js";
+import { isBridgePrice as n, useDeltaPriceQuery as r, useSubscribeToDeltaPrice as i } from "../prices/delta/queries/useDeltaPriceQuery.js";
+import { isETHaddress as a } from "../../../tokens/utils/eth.js";
+import { useSwapSide as o } from "../../../components/widget/SwapModeSwitcher/state/swapSideAtom.js";
+import { useSwapReceiverAddressValue as s } from "../../../components/widget/ReceiverAddress/state/receiverAddressAtom.js";
+import { protocolNameAtom as c } from "../../../components/widget/TradeParameters/state/bridgePreferences/protocolNameAtom.js";
+import { bridgePreferenceAtom as l } from "../../../components/widget/TradeParameters/state/bridgePreferences/bridgePreferenceAtom.js";
+import { produceDeltaOrderDeadline as u } from "../../../lib/utils/delta.js";
+import { useWidgetEvents as d } from "../../../core/state/widgetEventsAtom.js";
+import { getOverallOrderStatus as f, getSwapSideFromDeltaPrice as p } from "../prices/delta/orders/utils.js";
+import { extractSelectedBridgePrice as ee } from "../prices/delta/bridge/utils.js";
+import { useEnsureDeltaOrderExecuted as m, useWatchDeltaAuction as h } from "../prices/delta/queries/useWatchDeltaOrder.js";
+import { useSlippage as g } from "../../useSlippage.js";
+import { useMinViemClient as _ } from "../../useMinViemClient.js";
+import { usePartner as te } from "../../usePartner.js";
+import { useExtraDeltaPriceParams as ne, usePricesParams as v } from "../prices/usePricesParams.js";
+import { useSelectedBridgePrice as re } from "../prices/delta/bridge/useSelectedBridgePrice.js";
+import { deltaOrdersQueryKey as y } from "../prices/delta/queries/useDeltaOrders.js";
+import { applySlippage as b } from "../../../lib/utils/price.js";
+import { useEnsureTxReceipt as x } from "../../txs/queries/useAwaitTx.js";
+import { useCancelOrWithdrawAndCancelDeltaOrder as S } from "../prices/delta/mutations/useCancelOrWithdrawAndCancelDeltaOrder.js";
+import { UserCancelledError as C, isTransactionCancelledError as ie } from "./common/errors.js";
+import { useCreateAndSubmitDeltaOrder as ae } from "../prices/delta/mutations/useCreateDeltaOrder.js";
+import { encodePermit2TransferFromSigDataForDelta as oe } from "../../permit/utils/encodeArgs.js";
+import { useMarkPermit1Or2NonceAsUsed as se } from "./common/useSignPermit1Or2.js";
+import { useApproveOrPermit as ce } from "./common/useApproveOrPermit.js";
+import { shouldApproveOrBatch as le, usePreSignAndSubmitDeltaOrder as ue } from "./common/usePreSignAndSubmitDeltaOrder.js";
+import { useDepositAndSubmitDeltaOrder as de } from "./common/useDepositAndSubmitDeltaOrder.js";
+import { useRef as fe } from "react";
+import { useMutation as pe, useQueryClient as me } from "@tanstack/react-query";
+import { assert as w } from "ts-essentials";
+import { useAccount as he } from "wagmi";
+//#region src/hooks/swap/tradeFlow/useDeltaFlow.ts
+var ge = "deltaOrder", _e = "runDeltaOrderFlow";
+function T({ deltaPrice: T }) {
+	let E = t("DeltaFlow"), { resolvedSlippage: ve } = g("swap"), { priceParams: ye, chainId: D, destChainId: be } = v("swap"), xe = ne(), { result: O, queryKey: Se } = r({
+		priceParams: {
+			...ye,
+			...xe
+		},
+		chainId: D,
+		destChainId: be,
+		query: { enabled: !1 }
+	}), k = re({ price: O.data }) || O.data || T, Ce = o(), A = !!k && k.srcToken.toLowerCase() !== k.destToken.toLowerCase(), { approval: j, signPermit: M, approveTxMut: N, signPermitMut: P, events: F } = ce({
+		srcToken: k?.srcToken,
+		srcAmount: k?.srcAmount,
+		spenderContractType: "ParaswapDelta",
+		swapSide: k && p(k) || Ce,
+		tradeMode: "swap",
+		chainId: D,
+		applySlippage: A
+	}), { address: I } = he(), { minClient: L } = _({
+		chainId: D,
+		account: I
+	}), we = me(), R = ae({
+		chainId: D,
+		account: I,
+		client: L,
+		mutationOptions: {
+			onSuccess: (e) => {
+				E.log("Create Delta Order success", e);
+			},
+			onError: (e) => {
+				E.error("Create Delta Order error", e);
+			}
+		}
+	}), z = {
+		order: R.order,
+		isCreatingOrder: R.isCreatingOrder,
+		isPostingOrder: R.isPostingOrder,
+		isOrderSent: R.isOrderSent,
+		isPending: R.isPending,
+		isError: R.isError,
+		isSuccess: R.isSuccess,
+		error: R.error
+	}, { deltaOrderPreSign: B, canBatchTxs: Te, isConnectedToSafe: Ee, preSignAndSubmitDeltaOrder: De, reset: Oe } = ue({
+		chainId: D,
+		account: I,
+		logger: E,
+		viemClient: L
+	}), { deltaOrderDeposit: V, reset: ke, depositAndSubmitDeltaOrder: Ae } = de({
+		chainId: D,
+		account: I,
+		logger: E,
+		viemClient: L
+	}), H = {
+		order: z.order || B.order || V.order,
+		isPostingOrder: z.isPostingOrder || B.postingOrder.isPostingOrder || V.postingOrder.isPostingOrder,
+		isCreatingOrder: z.isCreatingOrder || B.isCreatingOrder || V.isCreatingOrder,
+		isOrderSent: z.isOrderSent || B.isOrderSent || V.isOrderSent,
+		isPending: z.isPending || B.isPending || V.isPending,
+		isError: z.isError || B.isError || V.isError,
+		isSuccess: z.isSuccess || B.isSuccess || V.isSuccess,
+		error: z.error || B.error || V.error
+	}, U = h({
+		orderId: H.order?.id,
+		onAuctionSuccess: (e) => {
+			E.log("Delta Order success", e);
+		},
+		onAuctionFailure: (e) => {
+			E.log("Delta Order failure", e);
+		},
+		onUpdatedAuction: (e) => {
+			E.log("Delta Order updated", e);
+		}
+	}), W = U.data ? f(U.data) : null, G = {
+		sentOrder: H.order,
+		lastOrderState: U.data,
+		isOrderPending: W === "pending",
+		isOrderExecuting: W === "executing",
+		isOrderExecuted: W === "confirmed",
+		isPending: U.isLoading || U.isRefetching || W === "pending" || W === "executing",
+		isError: U.isError || W === "failed",
+		isSuccess: W === "confirmed",
+		error: U.error
+	}, { onSwap: K } = d(), q = G.lastOrderState || G.sentOrder, J = S({
+		order: q,
+		chainId: D,
+		account: I,
+		client: L,
+		logger: E,
+		mutationOptions: {
+			onMutate: () => (w(q, "No order to cancel"), q),
+			onSuccess: (e, t, n) => {
+				K?.({ event: {
+					name: "Swap:cancelled",
+					params: {
+						swapMode: "delta",
+						order: n
+					}
+				} });
+			}
+		}
+	}), je = {
+		receipt: J.receipt,
+		txHash: J.txHash,
+		response: J.cancelOrderResponse,
+		isCancelingOrder: J.isPending,
+		isOrderCancellable: J.isOrderCancellable,
+		isOrderCanceled: J.isSuccess,
+		isPending: J.isPending,
+		isError: J.isError,
+		isSuccess: J.isSuccess,
+		error: J.error,
+		result: J.result,
+		step: J.step
+	}, Me = m({
+		onAuctionSuccess: (e) => {
+			we.invalidateQueries({
+				queryKey: y({ userAddress: e.user }),
+				exact: !1
+			});
+		},
+		onAuctionFailure: (e) => {
+			we.invalidateQueries({
+				queryKey: y({ userAddress: e.user }),
+				exact: !1
+			});
+		}
+	}), Ne = x(), Y = fe(null), X = fe(null), Pe = () => {
+		Y.current?.abort(new C()), Y.current = null, X.current = null;
+	}, Fe = s(), { markNonceAsUsed: Ie, clearNonce: Le } = se({ chainId: D }), { partner: Re, partnerAddress: ze, partnerFeeBps: Be, partnerTakesSurplus: Ve } = te(), He = e(c), Ue = e(l), We = i(), Ge = async ({ onTxSent: e, onOrderSent: t, lastPrice: r } = {}) => {
+		N.reset(), P.reset(), R.reset(), J.reset(), Oe(), ke(), w(k, "Delta price is not available");
+		let i = p(k), o = new AbortController();
+		Y.current = o;
+		let s = o.signal, c = u(), l, d, f, m = j.allowanceToSet, h = M.amountToPermit, g = k;
+		if (g.hmac === r?.hmac) {
+			let e = await O.refetch({ cancelRefetch: !1 });
+			s.throwIfAborted(), e.data && (g = e.data, n(g) && (g = ee({
+				price: g,
+				protocolName: He,
+				bridgePreference: Ue
+			})));
+		}
+		let _;
+		X.current = g;
+		let te = a(g.srcToken), { shouldDoApprovalTxOrPermit: ne, tryPermit: v, shouldPreSignBatch: re } = le({
+			approval: j,
+			signPermit: M,
+			canBatchTxs: Te,
+			isConnectedToSafe: Ee
+		});
+		try {
+			if (ne && m) {
+				let t = Se;
+				if (t) {
+					let e = m;
+					_ = We({
+						queryKey: t,
+						onData: (t) => {
+							let r = t;
+							if (n(t) && (r = ee({
+								price: t,
+								protocolName: He,
+								bridgePreference: Ue
+							})), s.aborted) {
+								_?.(), _ = void 0;
+								return;
+							}
+							let a = {
+								srcAmount: r.srcAmount,
+								destAmount: r.destAmount
+							}, o = A ? b(a, ve, i) : a;
+							e >= BigInt(o.srcAmount) && (E.log("~ fresh price ~", r), g = r, X.current = g);
+						}
+					});
+				}
+				try {
+					if (v) F.onSignPermit.request({ allowanceToSet: h }), l = await P.signPermitAsync({
+						deadline: c,
+						value: h
+					}), F.onSignPermit.confirmed({
+						allowanceToSet: h,
+						permit: l?.permitEncodedArgs
+					});
+					else {
+						F.onApproveTx.request({ allowanceToSet: m }), d = await N.approveAsync({ allowanceData: { allowanceToSet: m } }), F.onApproveTx.sent({
+							allowanceToSet: m,
+							txHash: d
+						}), s.throwIfAborted();
+						let t = Ne({
+							hash: d,
+							chainId: D,
+							onReplaced: (e) => {
+								E.log("onReplaced:approveTx", d, e);
+							}
+						});
+						e && e({
+							chainId: D,
+							action: "approve",
+							transactionHash: d,
+							receiptPromise: t,
+							transactionSpecificData: {
+								action: "approve",
+								approvedAmount: m,
+								tokenAddress: j.token,
+								spenderAddress: j.spender
+							}
+						}), f = await t, F.onApproveTx.confirmed({
+							allowanceToSet: m,
+							txHash: d,
+							txReceipt: f
+						}), E.log("~ approveTx ~ receipt:", f);
+					}
+				} catch (e) {
+					throw v ? F.onSignPermit.failed({
+						allowanceToSet: h,
+						error: e
+					}) : F.onApproveTx.failed({
+						allowanceToSet: m,
+						error: e,
+						txHash: d
+					}), e;
+				}
+			}
+			s.throwIfAborted(), w(I, "Account is not connected");
+			let r = g;
+			X.current = r, _?.(), _ = void 0, w(r, "Delta price is not available");
+			let a = {
+				srcAmount: r.srcAmount,
+				destAmount: r.destAmount
+			}, o = A ? b(a, ve, i) : a, u = l?.permitEncodedArgs;
+			l?.signedPermitData.type === "permit2" && l.signedPermitData.variant === "transferFrom" && (u = oe({
+				nonce: l.signedPermitData.nonce,
+				signature: l.signature
+			}));
+			let p = n(r) ? r.bridge.destinationChainId : D;
+			K?.({ event: {
+				name: "Swap:request",
+				params: {
+					swapMode: "delta",
+					price: r
+				}
+			} });
+			let y, x = {
+				signal: s,
+				type: "MARKET",
+				degenMode: ye.degenMode,
+				orderInput: {
+					owner: I,
+					beneficiary: Fe,
+					srcToken: r.srcToken,
+					destToken: r.destToken,
+					permit: u,
+					destChainId: p,
+					deltaPrice: r,
+					partner: Re,
+					partnerAddress: ze,
+					partnerFeeBps: Be,
+					partnerTakesSurplus: Ve,
+					...o,
+					deadline: Number(c),
+					side: i
+				}
+			};
+			if (te) {
+				let t = x.orderInput.srcAmount;
+				y = await Ae({
+					createOrderInput: x,
+					depositAmount: t,
+					onTxSent: e
+				});
+			} else y = re ? await De({
+				createOrderInput: x,
+				approval: j,
+				onTxSent: e
+			}) : await R.mutateAsync(x);
+			l && Ie(l.signedPermitData), K?.({ event: {
+				name: "Swap:sent",
+				params: {
+					swapMode: "delta",
+					price: r,
+					order: y
+				}
+			} });
+			let S = Me({ orderId: y.id });
+			t && t({
+				order: y,
+				lastOrderState: S
+			});
+			let C = await S;
+			return K?.({ event: {
+				name: "Swap:confirmed",
+				params: {
+					swapMode: "delta",
+					price: r,
+					order: C ?? y
+				}
+			} }), {
+				tradeFlowType: ge,
+				approve: {
+					txHash: d,
+					receipt: f
+				},
+				deltaOrder: {
+					sentOrder: y,
+					lastOrderState: C
+				},
+				deltaPrice: r,
+				account: I,
+				receiverAddress: Fe
+			};
+		} catch (e) {
+			throw l && Le(l.signedPermitData), ie(e) || K?.({ event: {
+				name: "Swap:failed",
+				params: {
+					swapMode: "delta",
+					error: e
+				}
+			} }), e;
+		} finally {
+			_?.();
+		}
+	}, Ke = async () => {
+		try {
+			return await J.cancelDeltaOrder();
+		} catch (e) {
+			E.error("Cancel Delta order error", e), J.reset();
+		}
+	}, Z = pe({
+		mutationFn: Ge,
+		mutationKey: [_e],
+		onSuccess: (e) => {
+			E.log("Delta Order success", e);
+		},
+		onError: (e) => {
+			E.error("Delta Order error", e);
+		},
+		onSettled: () => {
+			E.log("Delta Order settled");
+		}
+	}), qe = Z.mutateAsync, Q = () => {
+		X.current = null, N.reset(), P.reset(), R.reset(), Z.reset(), J.reset(), Oe(), ke();
+	}, Je = (e) => {
+		let t = X.current;
+		return Q(), qe({
+			...e,
+			lastPrice: t
+		});
+	}, Ye = X.current || k, $ = Z.data, Xe = $?.deltaOrder.lastOrderState || $?.deltaOrder.sentOrder || G.lastOrderState || G.sentOrder;
+	return {
+		tradeFlowType: ge,
+		chainId: D,
+		runDeltaOrderFlow: qe,
+		reset: Q,
+		cancelFlow: Pe,
+		retryFlow: Je,
+		cancelDeltaOrder: Ke,
+		approval: j,
+		signPermit: M,
+		deltaOrderPreSign: B,
+		deltaOrderDeposit: V,
+		deltaOrderSubmission: H,
+		deltaOrderExecution: G,
+		deltaOrderCancelation: je,
+		isPending: Z.isPending,
+		isSuccess: H.isSuccess && G.isSuccess,
+		isError: Z.isError,
+		error: Z.error,
+		result: $,
+		usedPrice: Ye,
+		freshPrice: k,
+		submittedDeltaOrder: Xe
+	};
 }
+//#endregion
+export { T as useDeltaFlow };
 
-export { useDeltaFlow };
-//# sourceMappingURL=useDeltaFlow.js.map
+//# sourceMappingURL=useDeltaFlow.js.map