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

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

@@ -0,0 +1,619 @@
+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
+  };
+}
+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