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

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

@@ -1,619 +1,368 @@
-import '@velora-dex/sdk';
-import { useAccount } from 'wagmi';
-import { assert } from 'ts-essentials';
-import { useEnsureTxReceipt } from '../../txs/queries/useAwaitTx.js';
-import 'viem';
-import { deltaOrdersQueryKey } from '../prices/delta/queries/useDeltaOrders.js';
-import { useMinViemClient } from '../../useMinViemClient.js';
-import { useWatchDeltaAuction, useEnsureDeltaOrderExecuted } from '../prices/delta/queries/useWatchDeltaOrder.js';
-import { getOverallOrderStatus, getSwapSideFromDeltaPrice } from '../prices/delta/orders/utils.js';
-import { useQueryClient, useMutation } from '@tanstack/react-query';
-import { useRef } from 'react';
-import { UserCancelledError } from './common/errors.js';
-import { useTwapReceiverAddressValue } from '../../../core/twap/state/twapReceiverAddressAtom.js';
-import { useApproveOrPermit } from './common/useApproveOrPermit.js';
-import { useMarkPermit1Or2NonceAsUsed } from './common/useSignPermit1Or2.js';
-import { useLogger } from '../../../core/logger.js';
-import { useSubscribeToDeltaPrice, isBridgePrice } from '../prices/delta/queries/useDeltaPriceQuery.js';
-import { usePartner } from '../../usePartner.js';
-import { useWidgetEvents } from '../../../core/state/widgetEventsAtom.js';
-import { shouldApproveOrBatch } from './common/usePreSignAndSubmitDeltaOrder.js';
-import { isETHaddress } from '../../../tokens/utils/eth.js';
-import { useCancelOrWithdrawAndCancelDeltaOrder } from '../prices/delta/mutations/useCancelOrWithdrawAndCancelDeltaOrder.js';
-import { useTwapPrices } from '../prices/useTwapPrices.js';
-import { useDegenMode } from '../../../components/widget/TradeParameters/state/degenModeParamAtom.js';
-import { useTwapSide } from '../../../core/twap/state/twapSideAtom.js';
-import { useTwapSlippage, useTwapDuration } from '../../../core/twap/state/twapParamsAtom.js';
-import { useCreateAndSubmitTwapOrder } from '../prices/delta/mutations/twap/useCreateTwapOrder.js';
-import { produceTwapDeadlines, getTwapAmountsFromPrice } from '../../../lib/utils/twap.js';
-import { usePreSignAndSubmitTwapOrder } from '../prices/delta/mutations/twap/usePreSignAndSubmitTwapOrder.js';
-import { useDepositAndSubmitTwapOrder } from '../prices/delta/mutations/twap/useDepositAndSubmitTwapOrder.js';
-import { amountAfterSlippage } from '../../../lib/utils/slippage.js';
-import { DEFAULT_DELTA_BRIDGE } from '../prices/delta/bridge/const.js';
-
-const twapOrderFlowType = "twapOrder";
-const TWAP_ORDER_MUTATION_KEY = "runTwapOrderFlow";
-function useTwapFlow({
-  twapPrice: _twapPrice
-}) {
-  const logger = useLogger("TwapFlow");
-  const {
-    queryKey,
-    price,
-    chainId,
-    refetch,
-    totalSrcAmount,
-    side: sideFromPrices,
-    numSlices
-  } = useTwapPrices({
-    enabled: false
-  });
-  const twapPrice = price || _twapPrice;
-  const twapSideFromInput = useTwapSide();
-  const twapSide = sideFromPrices || twapSideFromInput;
-  const {
-    approval,
-    signPermit,
-    approveTxMut,
-    signPermitMut,
-    events: approveOrPermitEvents
-  } = useApproveOrPermit({
-    srcToken: twapPrice?.srcToken,
-    srcAmount: totalSrcAmount,
-    spenderContractType: "ParaswapDelta",
-    swapSide: twapSide,
-    tradeMode: "twap",
-    chainId,
-    tryPermit2: false
-  });
-  const {
-    address: account
-  } = useAccount();
-  const {
-    minClient
-  } = useMinViemClient({
-    chainId,
-    account
-  });
-  const queryClient = useQueryClient();
-  const createAndSubmitOrderMut = useCreateAndSubmitTwapOrder({
-    chainId,
-    account,
-    client: minClient,
-    mutationOptions: {
-      onSuccess: (order) => {
-        logger.log("Create Twap Order success", order);
-      },
-      onError: (error) => {
-        logger.error("Create Twap Order error", error);
-      }
-    }
-  });
-  const twapOrderCreateAndSubmit = {
-    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 {
-    twapOrderPreSign,
-    canBatchTxs,
-    isConnectedToSafe,
-    preSignAndSubmitTwapOrder,
-    reset: resetPreSignAndSubmitTwapOrder
-  } = usePreSignAndSubmitTwapOrder({
-    chainId,
-    account,
-    logger,
-    viemClient: minClient
-  });
-  const {
-    twapOrderDeposit,
-    reset: resetDepositAndSubmitTwapOrder,
-    depositAndSubmitTwapOrder
-  } = useDepositAndSubmitTwapOrder({
-    chainId,
-    account,
-    logger,
-    viemClient: minClient
-  });
-  const twapOrderSubmission = {
-    order: twapOrderCreateAndSubmit.order || twapOrderPreSign.order || twapOrderDeposit.order,
-    isPostingOrder: twapOrderCreateAndSubmit.isPostingOrder || twapOrderPreSign.postingOrder.isPostingOrder || twapOrderDeposit.postingOrder.isPostingOrder,
-    isCreatingOrder: twapOrderCreateAndSubmit.isCreatingOrder || twapOrderPreSign.isCreatingOrder || twapOrderDeposit.isCreatingOrder,
-    isOrderSent: twapOrderCreateAndSubmit.isOrderSent || twapOrderPreSign.isOrderSent || twapOrderDeposit.isOrderSent,
-    isPending: twapOrderCreateAndSubmit.isPending || twapOrderPreSign.isPending || twapOrderDeposit.isPending,
-    isError: twapOrderCreateAndSubmit.isError || twapOrderPreSign.isError || twapOrderDeposit.isError,
-    isSuccess: twapOrderCreateAndSubmit.isSuccess || twapOrderPreSign.isSuccess || twapOrderDeposit.isSuccess,
-    error: twapOrderCreateAndSubmit.error || twapOrderPreSign.error || twapOrderDeposit.error
-  };
-  const watchOrderExecution = useWatchDeltaAuction({
-    orderId: twapOrderSubmission.order?.id,
-    onAuctionSuccess: (order_0) => {
-      logger.log("Twap Order success", order_0);
-    },
-    onAuctionFailure: (order_1) => {
-      logger.log("Twap Order failure", order_1);
-    },
-    onUpdatedAuction: (order_2) => {
-      logger.log("Twap Order updated", order_2);
-    }
-  });
-  const orderStatus = watchOrderExecution.data ? getOverallOrderStatus(watchOrderExecution.data) : null;
-  const twapOrderExecution = {
-    sentOrder: twapOrderSubmission.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 orderToCancel = twapOrderExecution.lastOrderState || twapOrderExecution.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;
-      }
-    }
-  });
-  const twapOrderCancelation = {
-    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 = useTwapReceiverAddressValue();
-  const {
-    markNonceAsUsed,
-    clearNonce
-  } = useMarkPermit1Or2NonceAsUsed({
-    chainId
-  });
-  const {
-    partner,
-    partnerAddress,
-    partnerFeeBps,
-    partnerTakesSurplus
-  } = usePartner();
-  const subscribeToPrice = useSubscribeToDeltaPrice();
-  const {
-    onTwapOrder
-  } = useWidgetEvents();
-  const degenMode = useDegenMode();
-  const twapSlippage = useTwapSlippage();
-  const twapDurationMin = useTwapDuration();
-  const submitTwapOrder = async ({
-    onTxSent,
-    onOrderSent,
-    lastPrice
-  } = {}) => {
-    approveTxMut.reset();
-    signPermitMut.reset();
-    createAndSubmitOrderMut.reset();
-    cancelOrderMut.reset();
-    resetPreSignAndSubmitTwapOrder();
-    resetDepositAndSubmitTwapOrder();
-    assert(twapPrice, "Twap price is not available");
-    const abortController = new AbortController();
-    currentAbortControllerRef.current = abortController;
-    const signal = abortController.signal;
-    const {
-      orderDeadline,
-      orderInterval
-    } = produceTwapDeadlines({
-      durationMin: twapDurationMin,
-      numSlices
-    });
-    const orderSlippageBps = Math.floor(twapSlippage * 100);
-    let signedPermitResult;
-    let approveTxHash;
-    let approveTxReceipt;
-    const allowanceToSet = approval.allowanceToSet;
-    const allowanceToPermit = signPermit.amountToPermit;
-    let freshPrice = twapPrice;
-    if (freshPrice.hmac === lastPrice?.hmac) {
-      const newPriceResult = await refetch({
-        cancelRefetch: false
-      });
-      signal.throwIfAborted();
-      if (newPriceResult.data) {
-        freshPrice = newPriceResult.data;
-      }
-    }
-    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 = queryKey;
-        if (_queryKey) {
-          const approvedAmount = allowanceToSet;
-          unsubscribeFromPrice = subscribeToPrice({
-            queryKey: _queryKey,
-            onData: (price_0) => {
-              const newPrice = price_0;
-              if (signal.aborted) {
-                unsubscribeFromPrice?.();
-                unsubscribeFromPrice = void 0;
-                return;
-              }
-              const {
-                srcAmount: totalSrcAmount_0
-              } = getTwapAmountsFromPrice({
-                price: newPrice,
-                numSlices
-              });
-              if (approvedAmount >= BigInt(totalSrcAmount_0)) {
-                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: BigInt(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 twapPriceToUse = freshPrice;
-      usingPriceRef.current = twapPriceToUse;
-      unsubscribeFromPrice?.();
-      unsubscribeFromPrice = void 0;
-      assert(twapPriceToUse, "Twap price is not available");
-      const twapSide_0 = getSwapSideFromDeltaPrice(twapPriceToUse);
-      const {
-        srcAmount: totalSrcAmount_1,
-        destAmount: totalDestAmount
-      } = getTwapAmountsFromPrice({
-        price: twapPriceToUse,
-        numSlices
-      });
-      const permit = signedPermitResult?.permitEncodedArgs;
-      const destChainId = isBridgePrice(twapPriceToUse) ? twapPriceToUse.bridge.destinationChainId : chainId;
-      onTwapOrder?.({
-        event: {
-          name: "TwapOrder:request",
-          params: {
-            price: twapPriceToUse
-          }
-        }
-      });
-      let orderFromAPI;
-      let sellOrBuyParams;
-      if (twapSide_0 === "SELL") {
-        sellOrBuyParams = {
-          onChainOrderType: "TWAPOrder",
-          totalSrcAmount: totalSrcAmount_1
-          // SDK adds destAmountPerSlice internally with slippage applied
-        };
-      } else {
-        sellOrBuyParams = {
-          onChainOrderType: "TWAPBuyOrder",
-          totalDestAmount,
-          // SDK applies slippage to maxSrcAmount internally
-          maxSrcAmount: totalSrcAmount_1
-        };
-      }
-      const createOrderInput = {
-        signal,
-        type: "MARKET",
-        degenMode,
-        orderInput: {
-          owner: account,
-          beneficiary: receiverAddress,
-          srcToken: twapPriceToUse.srcToken,
-          destToken: twapPriceToUse.destToken,
-          permit,
-          destChainId,
-          deltaPrice: {
-            ...twapPriceToUse,
-            bridge: {
-              ...twapPriceToUse.bridge,
-              // TWAP: pass nullified protocolSelector
-              protocolSelector: DEFAULT_DELTA_BRIDGE.protocolSelector
-              // SDK nullifies protocolData internally
-            },
-            partner
-          },
-          partner,
-          partnerAddress,
-          partnerFeeBps,
-          partnerTakesSurplus,
-          deadline: orderDeadline,
-          // twap specific params
-          ...sellOrBuyParams,
-          numSlices,
-          slippage: orderSlippageBps,
-          interval: orderInterval
-        }
-      };
-      if (shouldDepositAndPreSign) {
-        const depositAmount = getDepositAmount(sellOrBuyParams, twapSlippage);
-        orderFromAPI = await depositAndSubmitTwapOrder({
-          createOrderInput,
-          depositAmount,
-          onTxSent
-        });
-      } else if (shouldPreSignBatch) {
-        orderFromAPI = await preSignAndSubmitTwapOrder({
-          createOrderInput,
-          approval,
-          onTxSent
-        });
-      } else {
-        orderFromAPI = await createAndSubmitOrderMut.mutateAsync(createOrderInput);
-      }
-      if (signedPermitResult) {
-        markNonceAsUsed(signedPermitResult.signedPermitData);
-      }
-      onTwapOrder?.({
-        event: {
-          name: "TwapOrder:sent",
-          params: {
-            price: twapPriceToUse,
-            order: orderFromAPI
-          }
-        }
-      });
-      const lastOrderStatePromise = ensureOrderExecuted({
-        orderId: orderFromAPI.id
-        // signal, // fails the toast if aborted, don't use
-      });
-      if (onOrderSent) {
-        onOrderSent({
-          order: orderFromAPI,
-          lastOrderState: lastOrderStatePromise
-        });
-      }
-      return {
-        tradeFlowType: twapOrderFlowType,
-        approve: {
-          txHash: approveTxHash,
-          receipt: approveTxReceipt
-        },
-        twapOrder: {
-          sentOrder: orderFromAPI
-        },
-        twapPrice: twapPriceToUse,
-        account,
-        receiverAddress
-      };
-    } catch (error_0) {
-      if (signedPermitResult) {
-        clearNonce(signedPermitResult.signedPermitData);
-      }
-      onTwapOrder?.({
-        event: {
-          name: "TwapOrder:failed",
-          params: {
-            error: error_0
-          }
-        }
-      });
-      throw error_0;
-    } finally {
-      unsubscribeFromPrice?.();
-    }
-  };
-  const cancelTwapOrder = async () => {
-    try {
-      return await cancelOrderMut.cancelDeltaOrder();
-    } catch (error_2) {
-      logger.error("Cancel Delta order error", error_2);
-      cancelOrderMut.reset();
-    }
-  };
-  const twapOrderMut = useMutation({
-    mutationFn: submitTwapOrder,
-    mutationKey: [TWAP_ORDER_MUTATION_KEY],
-    onSuccess: (data_0) => {
-      logger.log("Twap Order success", data_0);
-    },
-    onError: (error_3) => {
-      logger.error("Twap Order error", error_3);
-    },
-    onSettled: () => {
-      logger.log("Twap Order settled");
-    }
-  });
-  const runTwapOrderFlow = twapOrderMut.mutateAsync;
-  const reset = () => {
-    usingPriceRef.current = null;
-    approveTxMut.reset();
-    signPermitMut.reset();
-    createAndSubmitOrderMut.reset();
-    twapOrderMut.reset();
-    cancelOrderMut.reset();
-    resetPreSignAndSubmitTwapOrder();
-    resetDepositAndSubmitTwapOrder();
-  };
-  const retryFlow = (options) => {
-    const lastPrice_0 = usingPriceRef.current;
-    reset();
-    return runTwapOrderFlow({
-      ...options,
-      lastPrice: lastPrice_0
-    });
-  };
-  const usedPrice = usingPriceRef.current || twapPrice;
-  let result = twapOrderMut.data;
-  if (result && twapOrderExecution.lastOrderState) {
-    result = {
-      ...result,
-      twapOrder: {
-        sentOrder: result.twapOrder.sentOrder,
-        // lastOrderState may be CANCELLED here
-        lastOrderState: twapOrderExecution.lastOrderState
-      }
-    };
-  }
-  const submittedTwapOrder = result?.twapOrder.sentOrder || twapOrderExecution.lastOrderState || twapOrderExecution.sentOrder;
-  return {
-    tradeFlowType: twapOrderFlowType,
-    chainId,
-    runTwapOrderFlow,
-    reset,
-    cancelFlow,
-    retryFlow,
-    cancelTwapOrder,
-    approval,
-    signPermit,
-    twapOrderPreSign,
-    twapOrderDeposit,
-    twapOrderSubmission,
-    twapOrderExecution,
-    twapOrderCancelation,
-    // twapOrderMut includes all steps' queries and mutations and returns more precise errors (including cancellation)
-    isPending: twapOrderMut.isPending,
-    isSuccess: twapOrderSubmission.isSuccess && twapOrderExecution.isSuccess,
-    // approval is an optional step
-    isError: twapOrderMut.isError,
-    error: twapOrderMut.error,
-    result,
-    usedPrice,
-    freshPrice: twapPrice,
-    submittedTwapOrder
-  };
+import { useLogger as e } from "../../../core/logger.js";
+import { isBridgePrice as t, useSubscribeToDeltaPrice as n } from "../prices/delta/queries/useDeltaPriceQuery.js";
+import { isETHaddress as r } from "../../../tokens/utils/eth.js";
+import { useTwapSide as i } from "../../../core/twap/state/twapSideAtom.js";
+import { useTwapReceiverAddressValue as a } from "../../../core/twap/state/twapReceiverAddressAtom.js";
+import { HALF_MINUTE_MS as o } from "../../../lib/constants/time.js";
+import { getTwapAmountsFromPrice as s, produceTwapDeadlines as c } from "../../../lib/utils/twap.js";
+import { useTwapDuration as l, useTwapSlippage as u } from "../../../core/twap/state/twapParamsAtom.js";
+import { useWidgetEvents as d } from "../../../core/state/widgetEventsAtom.js";
+import { getOverallOrderStatus as f, getSwapSideFromDeltaPrice as ee } from "../prices/delta/orders/utils.js";
+import { useWatchDeltaAuction as p } from "../prices/delta/queries/useWatchDeltaOrder.js";
+import { amountAfterSlippage as m } from "../../../lib/utils/slippage.js";
+import { useMinViemClient as h } from "../../useMinViemClient.js";
+import { usePartner as g } from "../../usePartner.js";
+import { useTwapPrices as _ } from "../prices/useTwapPrices.js";
+import { useEnsureTxReceipt as te } from "../../txs/queries/useAwaitTx.js";
+import { useCancelOrWithdrawAndCancelDeltaOrder as ne } from "../prices/delta/mutations/useCancelOrWithdrawAndCancelDeltaOrder.js";
+import { UserCancelledError as v } from "./common/errors.js";
+import { useMarkPermit1Or2NonceAsUsed as re } from "./common/useSignPermit1Or2.js";
+import { useApproveOrPermit as ie } from "./common/useApproveOrPermit.js";
+import { shouldApproveOrBatch as ae } from "./common/usePreSignAndSubmitDeltaOrder.js";
+import { useCreateAndSubmitTwapOrder as y } from "../prices/delta/mutations/twap/useCreateTwapOrder.js";
+import { usePreSignAndSubmitTwapOrder as b } from "../prices/delta/mutations/twap/usePreSignAndSubmitTwapOrder.js";
+import { useDepositAndSubmitTwapOrder as x } from "../prices/delta/mutations/twap/useDepositAndSubmitTwapOrder.js";
+import { DEFAULT_DELTA_BRIDGE as oe } from "../prices/delta/bridge/const.js";
+import { useRef as S } from "react";
+import { useMutation as se } from "@tanstack/react-query";
+import { assert as C } from "ts-essentials";
+import "@velora-dex/sdk";
+import "viem";
+import { useAccount as ce } from "wagmi";
+//#region src/hooks/swap/tradeFlow/useTwapFlow.ts
+var w = "twapOrder", le = "runTwapOrderFlow";
+function T({ twapPrice: m }) {
+	let T = e("TwapFlow"), { queryKey: de, price: fe, chainId: E, refetch: pe, totalSrcAmount: me, side: he, numSlices: D, priceParams: ge } = _({ enabled: !1 }), O = fe || m, _e = i(), ve = he || _e, { approval: k, signPermit: A, approveTxMut: j, signPermitMut: M, events: N } = ie({
+		srcToken: O?.srcToken,
+		srcAmount: me,
+		spenderContractType: "ParaswapDelta",
+		swapSide: ve,
+		tradeMode: "twap",
+		chainId: E,
+		tryPermit2: !1
+	}), { address: P } = ce(), { minClient: F } = h({
+		chainId: E,
+		account: P
+	}), I = y({
+		chainId: E,
+		account: P,
+		client: F,
+		mutationOptions: {
+			onSuccess: (e) => {
+				T.log("Create Twap Order success", e);
+			},
+			onError: (e) => {
+				T.error("Create Twap Order error", e);
+			}
+		}
+	}), L = {
+		order: I.order,
+		isCreatingOrder: I.isCreatingOrder,
+		isPostingOrder: I.isPostingOrder,
+		isOrderSent: I.isOrderSent,
+		isPending: I.isPending,
+		isError: I.isError,
+		isSuccess: I.isSuccess,
+		error: I.error
+	}, { twapOrderPreSign: R, canBatchTxs: ye, isConnectedToSafe: be, preSignAndSubmitTwapOrder: xe, reset: z } = b({
+		chainId: E,
+		account: P,
+		logger: T,
+		viemClient: F
+	}), { twapOrderDeposit: B, reset: V, depositAndSubmitTwapOrder: Se } = x({
+		chainId: E,
+		account: P,
+		logger: T,
+		viemClient: F
+	}), H = {
+		order: L.order || R.order || B.order,
+		isPostingOrder: L.isPostingOrder || R.postingOrder.isPostingOrder || B.postingOrder.isPostingOrder,
+		isCreatingOrder: L.isCreatingOrder || R.isCreatingOrder || B.isCreatingOrder,
+		isOrderSent: L.isOrderSent || R.isOrderSent || B.isOrderSent,
+		isPending: L.isPending || R.isPending || B.isPending,
+		isError: L.isError || R.isError || B.isError,
+		isSuccess: L.isSuccess || R.isSuccess || B.isSuccess,
+		error: L.error || R.error || B.error
+	}, U = p({
+		orderId: H.order?.id,
+		refetchInterval: o,
+		onAuctionSuccess: (e) => {
+			T.log("Twap Order success", e);
+		},
+		onAuctionFailure: (e) => {
+			T.log("Twap Order failure", e);
+		},
+		onUpdatedAuction: (e) => {
+			T.log("Twap 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
+	}, K = G.lastOrderState || G.sentOrder, q = ne({
+		order: K,
+		chainId: E,
+		account: P,
+		client: F,
+		logger: T,
+		mutationOptions: { onMutate: () => (C(K, "No order to cancel"), K) }
+	}), Ce = {
+		receipt: q.receipt,
+		txHash: q.txHash,
+		response: q.cancelOrderResponse,
+		isCancelingOrder: q.isPending,
+		isOrderCancellable: q.isOrderCancellable,
+		isOrderCanceled: q.isSuccess,
+		isPending: q.isPending,
+		isError: q.isError,
+		isSuccess: q.isSuccess,
+		error: q.error,
+		result: q.result,
+		step: q.step
+	}, we = te(), J = S(null), Y = S(null), Te = () => {
+		J.current?.abort(new v()), J.current = null, Y.current = null;
+	}, Ee = a(), { markNonceAsUsed: De, clearNonce: Oe } = re({ chainId: E }), { partner: ke, partnerAddress: Ae, partnerFeeBps: je, partnerTakesSurplus: Me } = g(), Ne = n(), { onTwapOrder: X } = d(), Pe = u(), Fe = l(), Ie = async ({ onTxSent: e, lastPrice: n } = {}) => {
+		j.reset(), M.reset(), I.reset(), q.reset(), z(), V(), C(O, "Twap price is not available");
+		let i = new AbortController();
+		J.current = i;
+		let a = i.signal, { orderDeadline: o, orderInterval: l } = c({
+			durationMin: Fe,
+			numSlices: D
+		}), u = Math.floor(Pe * 100), d, f, p, m = k.allowanceToSet, h = A.amountToPermit, g = O;
+		if (g.hmac === n?.hmac) {
+			let e = await pe({ cancelRefetch: !1 });
+			a.throwIfAborted(), e.data && (g = e.data);
+		}
+		let _;
+		Y.current = g;
+		let te = r(g.srcToken), { shouldDoApprovalTxOrPermit: ne, tryPermit: v, shouldPreSignBatch: re } = ae({
+			approval: k,
+			signPermit: A,
+			canBatchTxs: ye,
+			isConnectedToSafe: be
+		});
+		try {
+			if (ne && m) {
+				let t = de;
+				if (t) {
+					let e = m;
+					_ = Ne({
+						queryKey: t,
+						onData: (t) => {
+							let n = t;
+							if (a.aborted) {
+								_?.(), _ = void 0;
+								return;
+							}
+							let { srcAmount: r } = s({
+								price: n,
+								numSlices: D
+							});
+							e >= BigInt(r) && (T.log("~ fresh price ~", n), g = n, Y.current = g);
+						}
+					});
+				}
+				try {
+					if (v) N.onSignPermit.request({ allowanceToSet: h }), d = await M.signPermitAsync({
+						deadline: BigInt(o),
+						value: h
+					}), N.onSignPermit.confirmed({
+						allowanceToSet: h,
+						permit: d?.permitEncodedArgs
+					});
+					else {
+						N.onApproveTx.request({ allowanceToSet: m }), f = await j.approveAsync({ allowanceData: { allowanceToSet: m } }), N.onApproveTx.sent({
+							allowanceToSet: m,
+							txHash: f
+						}), a.throwIfAborted();
+						let t = we({
+							hash: f,
+							chainId: E,
+							onReplaced: (e) => {
+								T.log("onReplaced:approveTx", f, e);
+							}
+						});
+						e && e({
+							chainId: E,
+							action: "approve",
+							transactionHash: f,
+							receiptPromise: t,
+							transactionSpecificData: {
+								action: "approve",
+								approvedAmount: m,
+								tokenAddress: k.token,
+								spenderAddress: k.spender
+							}
+						}), p = await t, N.onApproveTx.confirmed({
+							allowanceToSet: m,
+							txHash: f,
+							txReceipt: p
+						}), T.log("~ approveTx ~ receipt:", p);
+					}
+				} catch (e) {
+					throw v ? N.onSignPermit.failed({
+						allowanceToSet: h,
+						error: e
+					}) : N.onApproveTx.failed({
+						allowanceToSet: m,
+						error: e,
+						txHash: f
+					}), e;
+				}
+			}
+			a.throwIfAborted(), C(P, "Account is not connected");
+			let n = g;
+			Y.current = n, _?.(), _ = void 0, C(n, "Twap price is not available");
+			let r = ee(n), { srcAmount: i, destAmount: c } = s({
+				price: n,
+				numSlices: D
+			}), ie = d?.permitEncodedArgs, ae = t(n) ? n.bridge.destinationChainId : E;
+			X?.({ event: {
+				name: "TwapOrder:request",
+				params: { price: n }
+			} });
+			let y, b;
+			b = r === "SELL" ? {
+				onChainOrderType: "TWAPOrder",
+				totalSrcAmount: i
+			} : {
+				onChainOrderType: "TWAPBuyOrder",
+				totalDestAmount: c,
+				maxSrcAmount: i
+			};
+			let x = {
+				signal: a,
+				type: "MARKET",
+				degenMode: ge.degenMode,
+				orderInput: {
+					owner: P,
+					beneficiary: Ee,
+					srcToken: n.srcToken,
+					destToken: n.destToken,
+					permit: ie,
+					destChainId: ae,
+					deltaPrice: {
+						...n,
+						bridge: {
+							...n.bridge,
+							protocolSelector: oe.protocolSelector
+						},
+						partner: ke
+					},
+					partner: ke,
+					partnerAddress: Ae,
+					partnerFeeBps: je,
+					partnerTakesSurplus: Me,
+					deadline: o,
+					...b,
+					numSlices: D,
+					slippage: u,
+					interval: l
+				}
+			};
+			return y = te ? await Se({
+				createOrderInput: x,
+				depositAmount: ue(b, Pe),
+				onTxSent: e
+			}) : re ? await xe({
+				createOrderInput: x,
+				approval: k,
+				onTxSent: e
+			}) : await I.mutateAsync(x), d && De(d.signedPermitData), X?.({ event: {
+				name: "TwapOrder:sent",
+				params: {
+					price: n,
+					order: y
+				}
+			} }), {
+				tradeFlowType: w,
+				approve: {
+					txHash: f,
+					receipt: p
+				},
+				twapOrder: { sentOrder: y },
+				twapPrice: n,
+				account: P,
+				receiverAddress: Ee
+			};
+		} catch (e) {
+			throw d && Oe(d.signedPermitData), X?.({ event: {
+				name: "TwapOrder:failed",
+				params: { error: e }
+			} }), e;
+		} finally {
+			_?.();
+		}
+	}, Le = async () => {
+		try {
+			return await q.cancelDeltaOrder();
+		} catch (e) {
+			T.error("Cancel Delta order error", e), q.reset();
+		}
+	}, Z = se({
+		mutationFn: Ie,
+		mutationKey: [le],
+		onSuccess: (e) => {
+			T.log("Twap Order success", e);
+		},
+		onError: (e) => {
+			T.error("Twap Order error", e);
+		},
+		onSettled: () => {
+			T.log("Twap Order settled");
+		}
+	}), Re = Z.mutateAsync, Q = () => {
+		Y.current = null, j.reset(), M.reset(), I.reset(), Z.reset(), q.reset(), z(), V();
+	}, ze = (e) => {
+		let t = Y.current;
+		return Q(), Re({
+			...e,
+			lastPrice: t
+		});
+	}, Be = Y.current || O, $ = Z.data;
+	$ && G.lastOrderState && ($ = {
+		...$,
+		twapOrder: {
+			sentOrder: $.twapOrder.sentOrder,
+			lastOrderState: G.lastOrderState
+		}
+	});
+	let Ve = $?.twapOrder.sentOrder || G.lastOrderState || G.sentOrder;
+	return {
+		tradeFlowType: w,
+		chainId: E,
+		runTwapOrderFlow: Re,
+		reset: Q,
+		cancelFlow: Te,
+		retryFlow: ze,
+		cancelTwapOrder: Le,
+		approval: k,
+		signPermit: A,
+		twapOrderPreSign: R,
+		twapOrderDeposit: B,
+		twapOrderSubmission: H,
+		twapOrderExecution: G,
+		twapOrderCancelation: Ce,
+		isPending: Z.isPending,
+		isSuccess: H.isSuccess && G.isSuccess,
+		isError: Z.isError,
+		error: Z.error,
+		result: $,
+		usedPrice: Be,
+		freshPrice: O,
+		submittedTwapOrder: Ve
+	};
 }
-function getDepositAmount(params, slippage) {
-  if ("totalSrcAmount" in params) {
-    return params.totalSrcAmount;
-  }
-  return amountAfterSlippage(params.maxSrcAmount, slippage, "BUY").toFixed(0);
+function ue(e, t) {
+	return "totalSrcAmount" in e ? e.totalSrcAmount : m(e.maxSrcAmount, t, "BUY").toFixed(0);
 }
+//#endregion
+export { T as useTwapFlow };
 
-export { useTwapFlow };
-//# sourceMappingURL=useTwapFlow.js.map
+//# sourceMappingURL=useTwapFlow.js.map