@velora-dex/widget 0.1.0-rc.2 → 0.1.1

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

@@ -8,15 +8,21 @@ import { useSlippage } from '../../useSlippage.js';
 import { useMutation } from '@tanstack/react-query';
 import { useRef } from 'react';
 import { UserCancelledError } from './common/errors.js';
-import { useReceiverAddressValue } from '../../../components/widget/ReceiverAddress/state/receiverAddressAtom.js';
+import { useSwapReceiverAddressValue } from '../../../components/widget/ReceiverAddress/state/receiverAddressAtom.js';
 import { useSwapSide } from '../../../components/widget/SwapModeSwitcher/state/swapSideAtom.js';
 import { useApproveOrPermit } from './common/useApproveOrPermit.js';
 import { useMarkPermit1Or2NonceAsUsed } from './common/useSignPermit1Or2.js';
-import { useWidgetConfig } from '../../../core/state/configAtom.js';
 import { useLogger } from '../../../core/logger.js';
 import { useConstructGasParams } from './common/useConstructGasParams.js';
 import { useMarketPriceQueryForPrice, useSubscribeToMarketPrice } from '../prices/market/queries/useMarketPriceQuery.js';
+import { usePartner } from '../../usePartner.js';
+import { useSendBatchTx } from '../../batch/useSendBatchTx.js';
+import { useCanBatchTxs } from '../../batch/useCanBatchTxs.js';
+import { useAwaitCalls, useEnsureCallsStatus } from '../../batch/useAwaitCalls.js';
+import { useBatchWithApproveTxs } from '../../batch/useBatchWithApproveTxs.js';
+import { useWidgetEvents } from '../../../core/state/widgetEventsAtom.js';
 
+const marketSwapFlowType = "marketSwap";
 const MARKET_SWAP_MUTATION_KEY = "runMarketSwapFlow";
 function useMarketFlow({
   marketPrice
@@ -25,20 +31,22 @@ function useMarketFlow({
   const chainId = useChainId();
   const {
     resolvedSlippage
-  } = useSlippage();
+  } = useSlippage("swap");
   const swapSide = useSwapSide();
   const {
     approval,
     signPermit,
     approveTxMut,
-    signPermitMut
+    signPermitMut,
+    events: approveOrPermitEvents
   } = useApproveOrPermit({
     srcToken: marketPrice?.srcToken,
     // if we already approved some amount, save it in approval and signPermit objects
     srcAmount: marketPrice?.srcAmount,
     spenderContractType: "AugustusSwapper",
     // marketPrice is the preferred source of truth
-    swapSide: marketPrice?.side ?? swapSide
+    swapSide: marketPrice?.side ?? swapSide,
+    tradeMode: "swap"
   });
   const buildTxMut = useBuildTx({
     chainId,
@@ -65,10 +73,27 @@ function useMarketFlow({
       logger.error("Swap tx error", error_0);
     }
   });
+  const {
+    forCurrentChain: canBatchTxs
+  } = useCanBatchTxs();
+  const {
+    addTxWithApprovals
+  } = useBatchWithApproveTxs();
+  const batchTxMut = useSendBatchTx({
+    onSuccess: () => {
+      logger.log("Batch tx success");
+    },
+    onError: (error_1) => {
+      logger.error("Batch tx error", error_1);
+    }
+  });
   const swapTxMined = useAwaitTx({
     hash: sendSwapTxMut.txHash,
     chainId
   });
+  const batchTxMined = useAwaitCalls({
+    id: batchTxMut.data?.id
+  });
   const swap = {
     txHash: sendSwapTxMut.txHash,
     receipt: swapTxMined.data,
@@ -87,10 +112,31 @@ function useMarketFlow({
     isError: sendSwapTxMut.isError || swapTxMined.isError,
     error: sendSwapTxMut.error || swapTxMined.error
   };
+  const lastCallsReceipt = batchTxMined.data?.receipts?.[batchTxMined.data.receipts.length - 1];
+  const swapBatch = {
+    canBatchTxs,
+    callsId: batchTxMut.data?.id,
+    txHash: lastCallsReceipt?.transactionHash,
+    receipt: lastCallsReceipt,
+    /* calls sending */
+    isConfirmingCalls: batchTxMut.isPending,
+    isConfirmingCallsError: batchTxMut.isError,
+    isCallsSent: batchTxMut.isSuccess,
+    /* calls awaiting */
+    isCallsPending: batchTxMined.isLoading,
+    isCallsMined: batchTxMined.isSuccess,
+    isCallsAwaitingError: batchTxMined.isError,
+    /* combined */
+    isPending: batchTxMut.isPending || batchTxMined.isLoading,
+    isSuccess: batchTxMined.isSuccess,
+    isError: batchTxMut.isError || batchTxMined.isError,
+    error: batchTxMut.error || batchTxMined.error
+  };
   const {
     address: account
   } = useAccount();
   const ensureTxReceipt = useEnsureTxReceipt();
+  const ensureCallsStatus = useEnsureCallsStatus();
   const currentAbortControllerRef = useRef(null);
   const usingPriceRef = useRef(null);
   const cancelFlow = () => {
@@ -98,7 +144,7 @@ function useMarketFlow({
     currentAbortControllerRef.current = null;
     usingPriceRef.current = null;
   };
-  const receiverAddress = useReceiverAddressValue();
+  const receiverAddress = useSwapReceiverAddressValue();
   const {
     markNonceAsUsed,
     clearNonce
@@ -108,9 +154,12 @@ function useMarketFlow({
   const {
     constructGasParams
   } = useConstructGasParams();
-  const partner = useWidgetConfig().partner;
+  const partner = usePartner();
   const getQueryForPrice = useMarketPriceQueryForPrice();
   const subscribeToPrice = useSubscribeToMarketPrice();
+  const {
+    onSwap
+  } = useWidgetEvents();
   const submitSwapTx = async ({
     onTxSent
   } = {}) => {
@@ -118,6 +167,7 @@ function useMarketFlow({
     signPermitMut.reset();
     buildTxMut.reset();
     sendSwapTxMut.reset();
+    batchTxMut.reset();
     assert(marketPrice, "Market price is not available");
     const abortController = new AbortController();
     currentAbortControllerRef.current = abortController;
@@ -129,8 +179,9 @@ function useMarketFlow({
     let freshPrice = marketPrice;
     let unsubscribeFromPrice;
     usingPriceRef.current = freshPrice;
+    const shouldBatchTxs = canBatchTxs && approval.needsApproval && !!allowanceToSet;
     try {
-      if (approval.needsApproval && allowanceToSet) {
+      if (!shouldBatchTxs && approval.needsApproval && allowanceToSet) {
         const queryKey = getQueryForPrice({
           chainId,
           price: freshPrice
@@ -157,34 +208,77 @@ function useMarketFlow({
             }
           });
         }
-        if (!signPermit.isPermitSupported || !signPermit.isPermitReadyToSign) {
-          approveTxHash = await approveTxMut.approveAsync({
-            allowanceData: {
+        const tryPermit = signPermit.isPermitSupported && signPermit.isPermitReadyToSign;
+        try {
+          if (!tryPermit) {
+            approveOrPermitEvents.onApproveTx.request({
               allowanceToSet
-            }
-          });
-          signal.throwIfAborted();
-          const approveTxReceiptPromise = ensureTxReceipt({
-            hash: approveTxHash,
-            chainId,
-            onReplaced: (data) => {
-              logger.log("onReplaced:approveTx", approveTxHash, data);
-            }
-          });
-          if (onTxSent) {
-            onTxSent({
+            });
+            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,
-              actionType: "approve",
-              receiptPromise: approveTxReceiptPromise
+              txReceipt: approveTxReceipt
+            });
+            logger.log("~ approveTx ~ receipt:", approveTxReceipt);
+          } else {
+            approveOrPermitEvents.onSignPermit.request({
+              allowanceToSet
+            });
+            signedPermitResult = await signPermitMut.signPermitAsync({
+              value: allowanceToSet
+            });
+            approveOrPermitEvents.onSignPermit.confirmed({
+              allowanceToSet,
+              permit: signedPermitResult?.permitEncodedArgs
             });
           }
-          approveTxReceipt = await approveTxReceiptPromise;
-          logger.log("~ approveTx ~ receipt:", approveTxReceipt);
-        } else {
-          signedPermitResult = await signPermitMut.signPermitAsync({
-            value: allowanceToSet
-          });
+        } catch (error_3) {
+          if (!tryPermit) {
+            approveOrPermitEvents.onApproveTx.failed({
+              allowanceToSet,
+              error: error_3,
+              txHash: approveTxHash
+              // won't necessarily be available
+            });
+          } else {
+            approveOrPermitEvents.onSignPermit.failed({
+              allowanceToSet,
+              error: error_3
+            });
+          }
+          throw error_3;
         }
       }
       signal.throwIfAborted();
@@ -218,57 +312,192 @@ function useMarketFlow({
           priceRoute: marketPriceToUse,
           ...amountsAfterSlippage_0
         },
-        swapTxOptions: (
+        swapTxOptions: {
           // ignoreChecks: true,
-          // ignoreGasEstimate: true,
-          // ignoreAllowance: true,
+          // gas estimate will break if only swapn tx is estimated, but approve ts is not considerewd in a batch
+          ignoreGasEstimate: shouldBatchTxs,
+          // for Batch-capable wallets batch Approve+Swap tx have to ignore all checks
+          ignoreAllowance: shouldBatchTxs,
           // onlyParams: true,
-          // @TODO turn on ignore options when necessary (for Safe),
-          gasParams
-        )
+          ...gasParams
+        }
       });
       signal.throwIfAborted();
-      const swapTxHash = await sendSwapTxMut.sendTransactionAsync(txParams);
+      let swapTxHash;
+      let swapCallsId;
+      onSwap?.({
+        event: {
+          name: "Swap:request",
+          params: {
+            swapMode: "market",
+            price: marketPriceToUse
+          }
+        }
+      });
+      if (shouldBatchTxs) {
+        const {
+          calls
+        } = await addTxWithApprovals({
+          txsParams: [{
+            to: txParams.to,
+            account: txParams.from,
+            data: txParams.data,
+            value: BigInt(txParams.value),
+            chainId: txParams.chainId
+          }],
+          approveProps: [{
+            spender: approval.spender,
+            allowanceToSet: approval.allowanceToSet,
+            token: approval.token,
+            chainId: approval.chainId
+          }]
+        });
+        const sendCallsResult = await batchTxMut.sendCalls({
+          txsParams: calls
+        });
+        swapCallsId = sendCallsResult.id;
+        onSwap?.({
+          event: {
+            name: "Swap:sent",
+            params: {
+              swapMode: "market",
+              price: marketPriceToUse,
+              callsId: swapCallsId
+            }
+          }
+        });
+      } else {
+        swapTxHash = await sendSwapTxMut.sendTransactionAsync(txParams);
+        onSwap?.({
+          event: {
+            name: "Swap:sent",
+            params: {
+              swapMode: "market",
+              price: marketPriceToUse,
+              txHash: swapTxHash
+            }
+          }
+        });
+      }
       if (signedPermitResult) {
         markNonceAsUsed(signedPermitResult.signedPermitData);
       }
-      const swapTxReceiptPromise = ensureTxReceipt({
-        hash: swapTxHash,
-        chainId,
-        onReplaced: (data_0) => {
-          logger.log("onReplaced:swapTx", swapTxHash, data_0);
+      let swapCallsReceipt;
+      let swapTxReceipt;
+      if (swapCallsId) {
+        const sendCallsReceiptPromise = ensureCallsStatus({
+          id: swapCallsId
+        }).then((status) => status.receipts?.[status.receipts.length - 1]);
+        logger.log("~ swapTx ~ awaiting calls id :", swapCallsId);
+        if (onTxSent) {
+          onTxSent({
+            chainId,
+            action: "swap",
+            callsId: swapCallsId,
+            receiptPromise: sendCallsReceiptPromise,
+            transactionSpecificData: {
+              action: "swap",
+              source: "local",
+              srcTokenAddress: marketPriceToUse.srcToken,
+              destTokenAddress: marketPriceToUse.destToken,
+              srcAmount: amountsAfterSlippage_0.srcAmount,
+              destAmount: amountsAfterSlippage_0.destAmount,
+              srcAmountUSD: marketPriceToUse.srcUSD,
+              destAmountUSD: marketPriceToUse.destUSD,
+              gasCost: marketPriceToUse.gasCost
+            }
+          });
         }
-      });
-      if (onTxSent) {
-        onTxSent({
+        swapCallsReceipt = await sendCallsReceiptPromise;
+        if (swapCallsReceipt) {
+          onSwap?.({
+            event: {
+              name: "Swap:confirmed",
+              params: {
+                swapMode: "market",
+                price: marketPriceToUse,
+                callsReceipt: swapCallsReceipt,
+                callsId: swapCallsId
+              }
+            }
+          });
+        }
+      } else if (swapTxHash) {
+        const swapTxReceiptPromise = ensureTxReceipt({
+          hash: swapTxHash,
           chainId,
-          txHash: swapTxHash,
-          actionType: "swap",
-          receiptPromise: swapTxReceiptPromise
+          onReplaced: (data_0) => {
+            logger.log("onReplaced:swapTx", swapTxHash, data_0);
+          }
         });
+        logger.log("~ swapTx ~ awaiting tx hash :", swapTxHash);
+        if (onTxSent) {
+          onTxSent({
+            chainId,
+            action: "swap",
+            transactionHash: swapTxHash,
+            receiptPromise: swapTxReceiptPromise,
+            transactionSpecificData: {
+              action: "swap",
+              source: "local",
+              srcTokenAddress: marketPriceToUse.srcToken,
+              destTokenAddress: marketPriceToUse.destToken,
+              srcAmount: amountsAfterSlippage_0.srcAmount,
+              destAmount: amountsAfterSlippage_0.destAmount,
+              srcAmountUSD: marketPriceToUse.srcUSD,
+              destAmountUSD: marketPriceToUse.destUSD,
+              gasCost: marketPriceToUse.gasCost,
+              gasCostUSD: marketPriceToUse.gasCostUSD
+            }
+          });
+        }
+        swapTxReceipt = await swapTxReceiptPromise;
+        if (swapTxReceipt) {
+          onSwap?.({
+            event: {
+              name: "Swap:confirmed",
+              params: {
+                swapMode: "market",
+                price: marketPriceToUse,
+                txReceipt: swapTxReceipt,
+                txHash: swapTxHash
+              }
+            }
+          });
+        }
       }
-      const swapTxReceipt = await swapTxReceiptPromise;
-      logger.log("~ swapTx ~ receipt:", swapTxReceipt);
+      logger.log("~ swapTx ~ receipt:", swapCallsReceipt || swapTxReceipt);
       return {
-        tradeFlowType: "marketSwap",
+        tradeFlowType: marketSwapFlowType,
         approve: {
           txHash: approveTxHash,
           receipt: approveTxReceipt
         },
         swap: {
+          callsId: swapCallsId,
           txHash: swapTxHash,
-          receipt: swapTxReceipt
+          receipt: swapTxReceipt,
+          callsReceipt: swapCallsReceipt
         },
         marketPrice: marketPriceToUse,
         // @TODO add whatever else may be relevant
         account,
         receiverAddress
       };
-    } catch (error_1) {
+    } catch (error_2) {
       if (signedPermitResult) {
         clearNonce(signedPermitResult.signedPermitData);
       }
-      throw error_1;
+      onSwap?.({
+        event: {
+          name: "Swap:failed",
+          params: {
+            swapMode: "market",
+            error: error_2
+          }
+        }
+      });
+      throw error_2;
     } finally {
       unsubscribeFromPrice?.();
     }
@@ -279,8 +508,8 @@ function useMarketFlow({
     onSuccess: (data_1) => {
       logger.log("Swap tx success", data_1);
     },
-    onError: (error_2) => {
-      logger.error("Swap tx error", error_2);
+    onError: (error_4) => {
+      logger.error("Swap tx error", error_4);
     },
     onSettled: () => {
       logger.log("Swap tx settled");
@@ -293,6 +522,7 @@ function useMarketFlow({
     signPermitMut.reset();
     buildTxMut.reset();
     sendSwapTxMut.reset();
+    batchTxMut.reset();
     marketSwapMut.reset();
   };
   const retryFlow = (options) => {
@@ -301,6 +531,7 @@ function useMarketFlow({
   };
   const usedPrice = usingPriceRef.current || marketPrice;
   return {
+    tradeFlowType: marketSwapFlowType,
     chainId,
     runMarketSwapFlow,
     reset,
@@ -310,6 +541,7 @@ function useMarketFlow({
     signPermit,
     buildTxParams,
     swap,
+    swapBatch,
     // marketSwapMut includes all steps' queries and mutations and returns more precise errors (including cancellation)
     isPending: marketSwapMut.isPending,
     isSuccess: marketSwapMut.isSuccess,