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

package/dist/hooks/otc/tradeFlow/useOtcOrderFlow.js

@@ -1,391 +1,253 @@
-import { useChainId, useAccount } from 'wagmi';
-import { assert } from 'ts-essentials';
-import { useEnsureTxReceipt } from '../../txs/queries/useAwaitTx.js';
-import { useCreateLimitOrder } from '../mutations/useCreateLimitOrder.js';
-import { useCancelOtcOrderEventCallbacks, useCancelOtcOrderAndWait } from '../mutations/useCancelLimitOrder.js';
-import { useMinViemClient } from '../../useMinViemClient.js';
-import { useMutation } from '@tanstack/react-query';
-import { useRef } from 'react';
-import { UserCancelledError } from '../../swap/tradeFlow/common/errors.js';
-import { handleTxSent } from '../../../lib/utils/transactionHandlers.js';
-import { useApproveOrPermit } from '../../swap/tradeFlow/common/useApproveOrPermit.js';
-import { useLogger } from '../../../core/logger.js';
-import { useOtcDeadline } from '../../../core/otc/state/deadlineAtom.js';
-import { useOtcReceiverAddressValue } from '../../../core/otc/state/receiverAddressAtom.js';
-import { useLimitOrderByHashQuery } from '../queries/useLimitOrders.js';
-import { useWidgetEvents } from '../../../core/state/widgetEventsAtom.js';
-import { useBatchWrapAndApprove, shouldApproveOrBatchWrapAndApprove } from '../../swap/tradeFlow/common/useBatchWrapAndApprove.js';
-import { useChainMatches } from '../../useChainMatches.js';
-import { useSwitchChainWithGuard } from '../../useSwitchChainWithGuard.js';
-
-const otcOrderFlowType = "otcOrder";
-const OTC_ORDER_MUTATION_KEY = "runOtcOrderFlow";
-function useOtcOrderFlow({
-  otcPrice,
-  preWrapETH
-}) {
-  const logger = useLogger("OtcOrderFlow");
-  const chainId = useChainId();
-  const {
-    approval,
-    approveTxMut,
-    events: approveOrPermitEvents
-  } = useApproveOrPermit({
-    srcToken: otcPrice?.srcTokenAddress,
-    srcAmount: otcPrice?.srcAmount,
-    spenderContractType: "AugustusRFQ",
-    swapSide: "SELL",
-    tradeMode: "otc",
-    chainId
-  });
-  const {
-    address: account
-  } = useAccount();
-  const {
-    minClient
-  } = useMinViemClient({
-    chainId,
-    account
-  });
-  const {
-    batchWrapAndApprove,
-    reset: resetBatchWrapAndApprove,
-    canBatchTxs,
-    wrapAndApproveBatchResult: wrapAndApprovalBatch
-  } = useBatchWrapAndApprove({
-    chainId,
-    account,
-    logger,
-    tradeMode: "otc"
-  });
-  const createOrderMut = useCreateLimitOrder({
-    chainId,
-    account,
-    client: minClient,
-    mutationOptions: {
-      onSuccess: (order) => {
-        logger.log("Create OTC Order success", order);
-      },
-      onError: (error) => {
-        logger.error("Create OTC Order error", error);
-      }
-    }
-  });
-  const otcOrderSubmission = {
-    order: createOrderMut.data,
-    isCreatingOrder: createOrderMut.isPending,
-    isOrderSent: createOrderMut.isSuccess,
-    isPending: createOrderMut.isPending,
-    isError: createOrderMut.isError,
-    isSuccess: createOrderMut.isSuccess,
-    error: createOrderMut.error
-  };
-  const limitOrderQuery = useLimitOrderByHashQuery({
-    orderParams: otcOrderSubmission.order?.orderHash
-  });
-  const cancelOrderEvents = useCancelOtcOrderEventCallbacks(otcOrderSubmission.order);
-  const orderChainId = otcOrderSubmission.order?.chainId;
-  const {
-    forcedChainMatchesWalletChain
-  } = useChainMatches(orderChainId);
-  const {
-    mutateAsync: switchChain
-  } = useSwitchChainWithGuard();
-  const cancelOrderMut = useCancelOtcOrderAndWait({
-    chainId,
-    account,
-    client: minClient,
-    mutationOptions: {
-      onMutate: async (variables) => {
-        assert(orderChainId, "orderChainId is undefined");
-        if (!forcedChainMatchesWalletChain) {
-          await switchChain({
-            chainId: orderChainId
-          });
-        }
-        cancelOrderEvents.onMutate?.(variables);
-      },
-      onSuccess: (txReceipt, vars) => {
-        logger.log("Cancel Order success", txReceipt);
-        cancelOrderEvents.onSuccess?.(txReceipt, vars);
-      },
-      onError: (error_0, vars_0) => {
-        logger.error("Cancel Order error", error_0);
-        cancelOrderEvents.onError?.(error_0, vars_0);
-      }
-    }
-  });
-  const isCancelTxSucceeded = cancelOrderMut.result?.status === "success";
-  const isCancelTxReverted = cancelOrderMut.result?.status === "reverted";
-  const lastOrderState = limitOrderQuery.data && isCancelTxSucceeded && cancelOrderMut.result ? {
-    // optimistically update order state to CANCELLED
-    // because API won't return the updated order state immediately
-    // as it depends on the subgraph indexing
-    ...limitOrderQuery.data,
-    state: "CANCELLED",
-    transactionHash: cancelOrderMut.result.transactionHash
-  } : limitOrderQuery.data;
-  const otcOrderCancelation = {
-    txHash: cancelOrderMut.txHash,
-    receipt: cancelOrderMut.receipt,
-    isCancelingOrder: cancelOrderMut.isPending,
-    isOrderCanceled: isCancelTxSucceeded,
-    lastOrderState,
-    isPending: cancelOrderMut.isPending,
-    isError: cancelOrderMut.isError || isCancelTxReverted,
-    isSuccess: cancelOrderMut.isSuccess && isCancelTxSucceeded,
-    error: cancelOrderMut.error,
-    step: cancelOrderMut.step
-  };
-  const ensureTxReceipt = useEnsureTxReceipt();
-  const currentAbortControllerRef = useRef(null);
-  const cancelFlow = () => {
-    currentAbortControllerRef.current?.abort(new UserCancelledError());
-    currentAbortControllerRef.current = null;
-  };
-  const receiverAddress = useOtcReceiverAddressValue();
-  const deadline = useOtcDeadline();
-  const {
-    onOTCOrder
-  } = useWidgetEvents();
-  const submitOtcOrder = async ({
-    onTxSent
-  } = {}) => {
-    approveTxMut.reset();
-    createOrderMut.reset();
-    cancelOrderMut.reset();
-    resetBatchWrapAndApprove();
-    assert(otcPrice, "Otc price data is not available");
-    const abortController = new AbortController();
-    currentAbortControllerRef.current = abortController;
-    const signal = abortController.signal;
-    let approveTxHash;
-    let approveTxReceipt;
-    let wrapAndApproveBatch = {};
-    const allowanceToSet = approval.allowanceToSet;
-    const {
-      shouldDoApprovalTx,
-      shouldWrapAndApproveBatch
-    } = shouldApproveOrBatchWrapAndApprove({
-      approval,
-      preWrapETH,
-      canBatchTxs
-    });
-    try {
-      if (shouldWrapAndApproveBatch) {
-        const sendCallsResult = await batchWrapAndApprove({
-          approval,
-          preWrapETH: {
-            wrapAmount: BigInt(otcPrice.srcAmount)
-          },
-          onTxSent,
-          signal
-        });
-        const lastCallsReceipt = sendCallsResult?.receipts?.[sendCallsResult.receipts.length - 1];
-        wrapAndApproveBatch = {
-          callsId: sendCallsResult?.id,
-          callsReceipt: lastCallsReceipt
-        };
-        logger.log("~ wrap and approve batch tx ~ receipt:", lastCallsReceipt);
-      } else if (shouldDoApprovalTx && allowanceToSet) {
-        try {
-          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);
-        } catch (error_2) {
-          logger.error("Approve tx error", error_2);
-          approveOrPermitEvents.onApproveTx.failed({
-            allowanceToSet,
-            error: error_2,
-            txHash: approveTxHash
-            // won't necessarily be available
-          });
-          throw error_2;
-        }
-      }
-      signal.throwIfAborted();
-      assert(account, "Account is not connected");
-      assert(otcPrice, "otcPrice is not available");
-      assert(receiverAddress, "Receiver address is not set");
-      onOTCOrder?.({
-        event: {
-          name: "OTCOrder:request",
-          params: {
-            price: otcPrice
-          }
-        }
-      });
-      const orderFromAPI = await createOrderMut.mutateAsync({
-        signal,
-        orderInput: {
-          expiry: deadline,
-          makerAsset: otcPrice.srcTokenAddress,
-          takerAsset: otcPrice.destTokenAddress,
-          makerAmount: otcPrice.srcAmount,
-          takerAmount: otcPrice.destAmount,
-          maker: account,
-          taker: receiverAddress
-        }
-      });
-      onOTCOrder?.({
-        event: {
-          name: "OTCOrder:sent",
-          params: {
-            price: otcPrice,
-            order: orderFromAPI
-          }
-        }
-      });
-      return {
-        tradeFlowType: otcOrderFlowType,
-        approve: {
-          txHash: approveTxHash,
-          receipt: approveTxReceipt
-        },
-        wrapAndApproveBatch,
-        otcOrder: {
-          sentOrder: orderFromAPI
-        },
-        otcPrice,
-        account,
-        receiverAddress
-      };
-    } catch (error_1) {
-      logger.error("Order submission error", error_1);
-      onOTCOrder?.({
-        event: {
-          name: "OTCOrder:failed",
-          params: {
-            price: otcPrice,
-            error: error_1
-          }
-        }
-      });
-      throw error_1;
-    }
-  };
-  const otcOrderMut = useMutation({
-    mutationFn: submitOtcOrder,
-    mutationKey: [OTC_ORDER_MUTATION_KEY],
-    onSuccess: (data_0) => {
-      logger.log("Order submission success", data_0);
-    },
-    onError: (error_3) => {
-      logger.error("Order submission error", error_3);
-    },
-    onSettled: () => {
-      logger.log("Order submission settled");
-    }
-  });
-  const runOtcOrderFlow = otcOrderMut.mutateAsync;
-  const cancelOtcOrder = async () => {
-    const orderToCancel = otcOrderSubmission.order;
-    assert(orderToCancel, "No order to cancel");
-    return cancelOrderMut.cancelOtcOrder({
-      orderHash: orderToCancel.orderHash,
-      onTxSent: ({
-        chainId: chainId_0,
-        transactionHash,
-        receiptPromise
-      }) => {
-        handleTxSent({
-          chainId: chainId_0,
-          transactionHash,
-          action: "cancelOtcOrder",
-          transactionSpecificData: {
-            action: "cancelOtcOrder",
-            cancelledOrder: orderToCancel
-          },
-          receiptPromise
-        });
-        cancelOrderEvents.onTxSent?.({
-          chainId: chainId_0,
-          txHash: transactionHash
-        });
-      }
-    });
-  };
-  const reset = () => {
-    approveTxMut.reset();
-    createOrderMut.reset();
-    otcOrderMut.reset();
-    cancelOrderMut.reset();
-    resetBatchWrapAndApprove();
-  };
-  const retryFlow = (options) => {
-    reset();
-    return runOtcOrderFlow(options);
-  };
-  let result = otcOrderMut.data;
-  if (result && otcOrderCancelation.lastOrderState) {
-    result = {
-      ...result,
-      otcOrder: {
-        sentOrder: result.otcOrder.sentOrder,
-        lastOrderState: otcOrderCancelation.lastOrderState
-      }
-    };
-  }
-  return {
-    tradeFlowType: otcOrderFlowType,
-    chainId,
-    runOtcOrderFlow,
-    reset,
-    cancelFlow,
-    retryFlow,
-    cancelOtcOrder,
-    approval,
-    wrapAndApprovalBatch,
-    otcOrderSubmission,
-    otcOrderCancelation,
-    // otcOrderMut includes all steps' queries and mutations and returns more precise errors (including cancellation)
-    isPending: otcOrderMut.isPending,
-    isSuccess: otcOrderSubmission.isSuccess,
-    // approval is an optional step
-    isError: otcOrderMut.isError,
-    error: otcOrderMut.error,
-    result,
-    otcPrice
-  };
+import { useLogger as e } from "../../../core/logger.js";
+import { useOtcDeadline as t } from "../../../core/otc/state/deadlineAtom.js";
+import { useOtcReceiverAddressValue as n } from "../../../core/otc/state/receiverAddressAtom.js";
+import { useWidgetEvents as r } from "../../../core/state/widgetEventsAtom.js";
+import { useMinViemClient as i } from "../../useMinViemClient.js";
+import { useLimitOrderByHashQuery as a } from "../queries/useLimitOrders.js";
+import { useChainMatches as o } from "../../useChainMatches.js";
+import { useEnsureTxReceipt as s } from "../../txs/queries/useAwaitTx.js";
+import { handleTxSent as c } from "../../../lib/utils/transactionHandlers.js";
+import { useSwitchChainWithGuard as l } from "../../useSwitchChainWithGuard.js";
+import { useCancelOtcOrderAndWait as u, useCancelOtcOrderEventCallbacks as d } from "../mutations/useCancelLimitOrder.js";
+import { UserCancelledError as ee } from "../../swap/tradeFlow/common/errors.js";
+import { useApproveOrPermit as f } from "../../swap/tradeFlow/common/useApproveOrPermit.js";
+import { useCreateLimitOrder as p } from "../mutations/useCreateLimitOrder.js";
+import { shouldApproveOrBatchWrapAndApprove as te, useBatchWrapAndApprove as m } from "../../swap/tradeFlow/common/useBatchWrapAndApprove.js";
+import { useRef as h } from "react";
+import { useMutation as g } from "@tanstack/react-query";
+import { assert as _ } from "ts-essentials";
+import { useAccount as v, useChainId as y } from "wagmi";
+//#region src/hooks/otc/tradeFlow/useOtcOrderFlow.ts
+var b = "otcOrder", ne = "runOtcOrderFlow";
+function x({ otcPrice: x, preWrapETH: S }) {
+	let C = e("OtcOrderFlow"), w = y(), { approval: T, approveTxMut: E, events: D } = f({
+		srcToken: x?.srcTokenAddress,
+		srcAmount: x?.srcAmount,
+		spenderContractType: "AugustusRFQ",
+		swapSide: "SELL",
+		tradeMode: "otc",
+		chainId: w
+	}), { address: O } = v(), { minClient: k } = i({
+		chainId: w,
+		account: O
+	}), { batchWrapAndApprove: re, reset: A, canBatchTxs: ie, wrapAndApproveBatchResult: j } = m({
+		chainId: w,
+		account: O,
+		logger: C,
+		tradeMode: "otc"
+	}), M = p({
+		chainId: w,
+		account: O,
+		client: k,
+		mutationOptions: {
+			onSuccess: (e) => {
+				C.log("Create OTC Order success", e);
+			},
+			onError: (e) => {
+				C.error("Create OTC Order error", e);
+			}
+		}
+	}), N = {
+		order: M.data,
+		isCreatingOrder: M.isPending,
+		isOrderSent: M.isSuccess,
+		isPending: M.isPending,
+		isError: M.isError,
+		isSuccess: M.isSuccess,
+		error: M.error
+	}, P = a({ orderParams: N.order?.orderHash }), F = d(N.order), I = N.order?.chainId, { forcedChainMatchesWalletChain: L } = o(I), { mutateAsync: R } = l(), z = u({
+		chainId: w,
+		account: O,
+		client: k,
+		mutationOptions: {
+			onMutate: async (e) => {
+				_(I, "orderChainId is undefined"), L || await R({ chainId: I }), F.onMutate?.(e);
+			},
+			onSuccess: (e, t) => {
+				C.log("Cancel Order success", e), F.onSuccess?.(e, t);
+			},
+			onError: (e, t) => {
+				C.error("Cancel Order error", e), F.onError?.(e, t);
+			}
+		}
+	}), B = z.result?.status === "success", V = z.result?.status === "reverted", H = P.data && B && z.result ? {
+		...P.data,
+		state: "CANCELLED",
+		transactionHash: z.result.transactionHash
+	} : P.data, U = {
+		txHash: z.txHash,
+		receipt: z.receipt,
+		isCancelingOrder: z.isPending,
+		isOrderCanceled: B,
+		lastOrderState: H,
+		isPending: z.isPending,
+		isError: z.isError || V,
+		isSuccess: z.isSuccess && B,
+		error: z.error,
+		step: z.step
+	}, W = s(), G = h(null), K = () => {
+		G.current?.abort(new ee()), G.current = null;
+	}, q = n(), J = t(), { onOTCOrder: Y } = r(), X = g({
+		mutationFn: async ({ onTxSent: e } = {}) => {
+			E.reset(), M.reset(), z.reset(), A(), _(x, "Otc price data is not available");
+			let t = new AbortController();
+			G.current = t;
+			let n = t.signal, r, i, a = {}, o = T.allowanceToSet, { shouldDoApprovalTx: s, shouldWrapAndApproveBatch: c } = te({
+				approval: T,
+				preWrapETH: S,
+				canBatchTxs: ie
+			});
+			try {
+				if (c) {
+					let t = await re({
+						approval: T,
+						preWrapETH: { wrapAmount: BigInt(x.srcAmount) },
+						onTxSent: e,
+						signal: n
+					}), r = t?.receipts?.[t.receipts.length - 1];
+					a = {
+						callsId: t?.id,
+						callsReceipt: r
+					}, C.log("~ wrap and approve batch tx ~ receipt:", r);
+				} else if (s && o) try {
+					D.onApproveTx.request({ allowanceToSet: o }), r = await E.approveAsync({ allowanceData: { allowanceToSet: o } }), D.onApproveTx.sent({
+						allowanceToSet: o,
+						txHash: r
+					}), n.throwIfAborted();
+					let t = W({
+						hash: r,
+						chainId: w,
+						onReplaced: (e) => {
+							C.log("onReplaced:approveTx", r, e);
+						}
+					});
+					e && e({
+						chainId: w,
+						action: "approve",
+						transactionHash: r,
+						receiptPromise: t,
+						transactionSpecificData: {
+							action: "approve",
+							approvedAmount: o,
+							tokenAddress: T.token,
+							spenderAddress: T.spender
+						}
+					}), i = await t, D.onApproveTx.confirmed({
+						allowanceToSet: o,
+						txHash: r,
+						txReceipt: i
+					}), C.log("~ approveTx ~ receipt:", i);
+				} catch (e) {
+					throw C.error("Approve tx error", e), D.onApproveTx.failed({
+						allowanceToSet: o,
+						error: e,
+						txHash: r
+					}), e;
+				}
+				n.throwIfAborted(), _(O, "Account is not connected"), _(x, "otcPrice is not available"), _(q, "Receiver address is not set"), Y?.({ event: {
+					name: "OTCOrder:request",
+					params: { price: x }
+				} });
+				let t = await M.mutateAsync({
+					signal: n,
+					orderInput: {
+						expiry: J,
+						makerAsset: x.srcTokenAddress,
+						takerAsset: x.destTokenAddress,
+						makerAmount: x.srcAmount,
+						takerAmount: x.destAmount,
+						maker: O,
+						taker: q
+					}
+				});
+				return Y?.({ event: {
+					name: "OTCOrder:sent",
+					params: {
+						price: x,
+						order: t
+					}
+				} }), {
+					tradeFlowType: b,
+					approve: {
+						txHash: r,
+						receipt: i
+					},
+					wrapAndApproveBatch: a,
+					otcOrder: { sentOrder: t },
+					otcPrice: x,
+					account: O,
+					receiverAddress: q
+				};
+			} catch (e) {
+				throw C.error("Order submission error", e), Y?.({ event: {
+					name: "OTCOrder:failed",
+					params: {
+						price: x,
+						error: e
+					}
+				} }), e;
+			}
+		},
+		mutationKey: [ne],
+		onSuccess: (e) => {
+			C.log("Order submission success", e);
+		},
+		onError: (e) => {
+			C.error("Order submission error", e);
+		},
+		onSettled: () => {
+			C.log("Order submission settled");
+		}
+	}), Z = X.mutateAsync, ae = async () => {
+		let e = N.order;
+		return _(e, "No order to cancel"), z.cancelOtcOrder({
+			orderHash: e.orderHash,
+			onTxSent: ({ chainId: t, transactionHash: n, receiptPromise: r }) => {
+				c({
+					chainId: t,
+					transactionHash: n,
+					action: "cancelOtcOrder",
+					transactionSpecificData: {
+						action: "cancelOtcOrder",
+						cancelledOrder: e
+					},
+					receiptPromise: r
+				}), F.onTxSent?.({
+					chainId: t,
+					txHash: n
+				});
+			}
+		});
+	}, Q = () => {
+		E.reset(), M.reset(), X.reset(), z.reset(), A();
+	}, oe = (e) => (Q(), Z(e)), $ = X.data;
+	return $ && U.lastOrderState && ($ = {
+		...$,
+		otcOrder: {
+			sentOrder: $.otcOrder.sentOrder,
+			lastOrderState: U.lastOrderState
+		}
+	}), {
+		tradeFlowType: b,
+		chainId: w,
+		runOtcOrderFlow: Z,
+		reset: Q,
+		cancelFlow: K,
+		retryFlow: oe,
+		cancelOtcOrder: ae,
+		approval: T,
+		wrapAndApprovalBatch: j,
+		otcOrderSubmission: N,
+		otcOrderCancelation: U,
+		isPending: X.isPending,
+		isSuccess: N.isSuccess,
+		isError: X.isError,
+		error: X.error,
+		result: $,
+		otcPrice: x
+	};
 }
+//#endregion
+export { x as useOtcOrderFlow };
 
-export { useOtcOrderFlow };
-//# sourceMappingURL=useOtcOrderFlow.js.map
+//# sourceMappingURL=useOtcOrderFlow.js.map