@velora-dex/widget 0.4.13 → 0.4.14-dev.1

package/dist/hooks/swap/tradeFlow/useTwapFlow.d.ts

@@ -0,0 +1,88 @@
+import { BridgePrice, DeltaPrice } from '@velora-dex/sdk';
+import { Address, TransactionReceipt } from 'viem';
+import { ApprovalFlowResult, SignPermitFlowResult, SubmitTxResult } from './common/types';
+import { SupportedChainId } from '../../../lib/web3/wagmi/types';
+import { CallsSentObject, TxSentObject } from '../../../lib/utils/transactionHandlers';
+import { OrderSentObject } from '../../../lib/utils/toasts';
+import { CancelDeltaOrdersReturn } from '../prices/delta/mutations/useCancelDeltaOrders';
+import { DeltaAuctionWithTwapOrder, NullableDeltaAuctionWithTwapOrder } from '../prices/delta/orders/types';
+import { TwapOrderPreSignResult } from '../prices/delta/mutations/twap/usePreSignAndSubmitTwapOrder';
+import { TwapOrderDepositResult } from '../prices/delta/mutations/twap/useDepositAndSubmitTwapOrder';
+declare const twapOrderFlowType = "twapOrder";
+export type UseTwapFlowInput = {
+    twapPrice?: DeltaPrice | BridgePrice;
+};
+export type SubmitTwapOrderResult = {
+    tradeFlowType: typeof twapOrderFlowType;
+    approve: SubmitTxResult;
+    twapOrder: {
+        sentOrder: DeltaAuctionWithTwapOrder;
+    };
+    twapPrice: DeltaPrice | BridgePrice;
+    account: Address;
+    receiverAddress?: Address;
+};
+type OnTxSent = (txSent: TxSentObject | CallsSentObject) => void;
+type OnOrderSent = (orderSent: OrderSentObject) => void;
+type RunTwapOrderOptions = {
+    onTxSent?: OnTxSent;
+    onOrderSent?: OnOrderSent;
+};
+type TwapOrderSubmissionResult = {
+    order?: DeltaAuctionWithTwapOrder;
+    isCreatingOrder: boolean;
+    isPostingOrder: boolean;
+    isOrderSent: boolean;
+    isPending: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+};
+type TwapOrderExecutionResult = {
+    sentOrder?: DeltaAuctionWithTwapOrder;
+    lastOrderState?: NullableDeltaAuctionWithTwapOrder;
+    isOrderPending: boolean;
+    isOrderExecuting: boolean;
+    isOrderExecuted: boolean;
+    isPending: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+};
+type TwapOrderCancelationResult = {
+    receipt?: TransactionReceipt;
+    isCancelingOrder: boolean;
+    isOrderCancellable: boolean;
+    isOrderCanceled: boolean;
+    isPending: boolean;
+    isError: boolean;
+    isSuccess: boolean;
+    error: Error | null;
+};
+export type UseTwapFlowResult = {
+    tradeFlowType: typeof twapOrderFlowType;
+    chainId: SupportedChainId;
+    runTwapOrderFlow: (options?: RunTwapOrderOptions) => Promise<SubmitTwapOrderResult>;
+    reset: () => void;
+    cancelFlow: () => void;
+    retryFlow: (options?: RunTwapOrderOptions) => Promise<SubmitTwapOrderResult>;
+    cancelTwapOrder: () => Promise<TransactionReceipt | CancelDeltaOrdersReturn>;
+    approval: ApprovalFlowResult;
+    signPermit: SignPermitFlowResult;
+    twapOrderPreSign: TwapOrderPreSignResult;
+    twapOrderDeposit: TwapOrderDepositResult;
+    twapOrderSubmission: TwapOrderSubmissionResult;
+    twapOrderExecution: TwapOrderExecutionResult;
+    twapOrderCancelation: TwapOrderCancelationResult;
+    isPending: boolean;
+    isSuccess: boolean;
+    isError: boolean;
+    error: Error | null;
+    result?: SubmitTwapOrderResult;
+    usedPrice?: DeltaPrice | BridgePrice;
+    freshPrice?: DeltaPrice | BridgePrice;
+    submittedTwapOrder?: DeltaAuctionWithTwapOrder;
+};
+export declare function useTwapFlow({ twapPrice: _twapPrice, }: UseTwapFlowInput): UseTwapFlowResult;
+export {};
+//# sourceMappingURL=useTwapFlow.d.ts.map

package/dist/hooks/swap/tradeFlow/useTwapFlow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTwapFlow.d.ts","sourceRoot":"","sources":["../../../../src/hooks/swap/tradeFlow/useTwapFlow.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,591 @@
+import '@velora-dex/sdk';
+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 { useMinViemClient } from '../../useMinViemClient.js';
+import { useWatchDeltaAuction, useEnsureDeltaOrderExecuted } from '../prices/delta/queries/useWatchDeltaOrder.js';
+import { getOverallOrderStatus } from '../prices/delta/orders/utils.js';
+import { useQueryClient, useMutation } from '@tanstack/react-query';
+import { useRef } from 'react';
+import { 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 '../../permit/utils/deadlines.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 { getSwapSideFromDeltaPrice } from '../prices/delta/queries/utils.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 { getTwapAmountsFromPrice } from '../../../lib/utils/twap.js';
+import { TEN_MINUTES_MS } from '../../../lib/constants/time.js';
+import { millisecondsToSeconds, minutesToMilliseconds } from '../../../lib/utils/time.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);
+    },
+    onTimeoutGettingOrder: (order_3) => {
+      logger.log("Twap Order timeout", order_3);
+    }
+  });
+  const orderStatus = watchOrderExecution.data ? getOverallOrderStatus(watchOrderExecution.data) : null;
+  const neverFetchedFinishedOrder = watchOrderExecution.data === null && watchOrderExecution.isSuccess;
+  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" || neverFetchedFinishedOrder,
+    isSuccess: orderStatus === "confirmed",
+    error: watchOrderExecution.error
+  };
+  const cancelOrderMut = useCancelOrWithdrawAndCancelDeltaOrder({
+    // supply the must up-to-date order for cancellation
+    order: twapOrderExecution.lastOrderState || twapOrderExecution.sentOrder,
+    chainId,
+    account,
+    client: minClient,
+    logger
+  });
+  const twapOrderCancelation = {
+    receipt: cancelOrderMut.receipt,
+    isCancelingOrder: cancelOrderMut.isPending,
+    isOrderCancellable: cancelOrderMut.isOrderCancellable,
+    isOrderCanceled: cancelOrderMut.isSuccess,
+    isPending: cancelOrderMut.isPending,
+    isError: cancelOrderMut.isError,
+    isSuccess: cancelOrderMut.isSuccess,
+    error: cancelOrderMut.error
+  };
+  const ensureOrderExecuted = useEnsureDeltaOrderExecuted({
+    onAuctionSuccess: (order_4) => {
+      queryClient.invalidateQueries({
+        queryKey: deltaOrdersQueryKey({
+          userAddress: order_4.user
+        }),
+        exact: false
+      });
+    },
+    onAuctionFailure: (order_5) => {
+      queryClient.invalidateQueries({
+        queryKey: deltaOrdersQueryKey({
+          userAddress: order_5.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 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 orderDurationMs = minutesToMilliseconds(twapDurationMin);
+    const orderDeadline = produceDeltaOrderDeadline(
+      // 10 min buffer for possible delays in order creation or slice executions
+      orderDurationMs + TEN_MINUTES_MS
+    );
+    const orderInterval = Math.floor(millisecondsToSeconds(orderDurationMs) / 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: 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: Number(orderDeadline),
+          // twap specific params
+          ...sellOrBuyParams,
+          numSlices,
+          slippage: orderSlippageBps,
+          interval: orderInterval
+        }
+      };
+      if (shouldDepositAndPreSign) {
+        const depositAmount = "totalSrcAmount" in sellOrBuyParams ? sellOrBuyParams.totalSrcAmount : amountAfterSlippage(sellOrBuyParams.maxSrcAmount, twapSlippage, "BUY").toFixed(0);
+        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 = cancelOrderMut.cancelDeltaOrder;
+  const twapOrderMut = useMutation({
+    mutationFn: submitTwapOrder,
+    mutationKey: [TWAP_ORDER_MUTATION_KEY],
+    onSuccess: (data_0) => {
+      logger.log("Twap Order success", data_0);
+    },
+    onError: (error_2) => {
+      logger.error("Twap Order error", error_2);
+    },
+    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;
+  const result = twapOrderMut.data;
+  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
+  };
+}
+
+export { useTwapFlow };
+//# sourceMappingURL=useTwapFlow.js.map