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

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

@@ -1,595 +0,0 @@
-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);
-    },
-    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 = 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 = 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
-  };
-}
-function getDepositAmount(params, slippage) {
-  if ("totalSrcAmount" in params) {
-    return params.totalSrcAmount;
-  }
-  return amountAfterSlippage(params.maxSrcAmount, slippage, "BUY").toFixed(0);
-}
-
-export { useTwapFlow };
-//# sourceMappingURL=useTwapFlow.js.map