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

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

@@ -1,466 +1,299 @@
-import { useChainId, useAccount } from 'wagmi';
-import { assert } from 'ts-essentials';
-import { useAwaitTx, useEnsureTxReceipt } from '../../txs/queries/useAwaitTx.js';
-import { zeroAddress } from 'viem';
-import { useMinViemClient } from '../../useMinViemClient.js';
-import { useMutation } from '@tanstack/react-query';
-import { useRef } from 'react';
-import { UserCancelledError } from '../../swap/tradeFlow/common/errors.js';
-import 'react/jsx-runtime';
-import '../../../_virtual/index.js';
-import 'lucide-react';
-import 'sonner';
-import 'clsx';
-import 'tailwind-merge';
-import '../../../assets/spinner.svg.js';
-import '../../../assets/circle-check.svg.js';
-import '../../../assets/circle-exclamation.svg.js';
-import '@radix-ui/react-progress';
-import '../../../lib/web3/wagmi/constants.js';
-import '../../../core/store.js';
-import { useApproveOrPermit } from '../../swap/tradeFlow/common/useApproveOrPermit.js';
-import { useLogger } from '../../../core/logger.js';
-import { useFillOrder } from '../mutations/useFillOrder.js';
-import { useMarkPermit1Or2NonceAsUsed } from '../../swap/tradeFlow/common/useSignPermit1Or2.js';
-import { useWidgetEvents } from '../../../core/state/widgetEventsAtom.js';
-import { useCanBatchTxs } from '../../batch/useCanBatchTxs.js';
-import { useBatchWithApproveTxs } from '../../batch/useBatchWithApproveTxs.js';
-import { useSendBatchTx } from '../../batch/useSendBatchTx.js';
-import { useAwaitCalls, useEnsureCallsStatus } from '../../batch/useAwaitCalls.js';
-import { useCalldataSDK } from '../../useSDK.js';
-
-const fillOtcOrderFlowType = "fillOtcOrder";
-const OTC_ORDER_MUTATION_KEY = "runFillOtcOrderFlow";
-function useFillOtcOrderFlow({
-  order
-}) {
-  const logger = useLogger("FillOtcOrderFlow");
-  const chainId = useChainId();
-  const {
-    approval,
-    signPermit,
-    approveTxMut,
-    signPermitMut,
-    events: approveOrPermitEvents
-  } = useApproveOrPermit({
-    srcToken: order?.takerAsset,
-    srcAmount: order?.takerAmount,
-    spenderContractType: "AugustusRFQ",
-    swapSide: "SELL",
-    tradeMode: "otc",
-    chainId
-  });
-  const {
-    address: account
-  } = useAccount();
-  const {
-    minClient
-  } = useMinViemClient({
-    chainId,
-    account
-  });
-  const {
-    sdk: callDataSDK
-  } = useCalldataSDK({
-    chainId,
-    client: minClient
-  });
-  const fillOrderMut = useFillOrder({
-    chainId,
-    account,
-    client: minClient,
-    mutationOptions: {
-      onSuccess: (order_0) => {
-        logger.log("Fill OTC Order success", order_0);
-      },
-      onError: (error) => {
-        logger.error("Fill OTC Order error", error);
-      }
-    }
-  });
-  const {
-    forCurrentChain: canBatchTxs
-  } = useCanBatchTxs();
-  const {
-    addTxWithApprovals
-  } = useBatchWithApproveTxs();
-  const batchTxMut = useSendBatchTx({
-    onSuccess: () => {
-      logger.log("Batch tx success");
-    },
-    onError: (error_0) => {
-      logger.error("Batch tx error", error_0);
-    }
-  });
-  const fillTxMined = useAwaitTx({
-    chainId,
-    hash: fillOrderMut.data
-  });
-  const batchTxMined = useAwaitCalls({
-    id: batchTxMut.data?.id
-  });
-  const fillOrder = {
-    txHash: fillOrderMut.data,
-    receipt: fillTxMined.data,
-    /* tx sending */
-    isConfirmingTX: fillOrderMut.isPending,
-    isConfirmingTxError: fillOrderMut.isError,
-    isTxSent: fillOrderMut.isSuccess,
-    /* tx awaiting */
-    isTxPending: fillTxMined.isPending,
-    isTxMined: fillTxMined.isSuccess,
-    isTxAwaitingError: fillTxMined.isError,
-    /* combined */
-    isPending: fillOrderMut.isPending || fillTxMined.isLoading,
-    isSuccess: fillTxMined.isSuccess,
-    // success only when tx is mined
-    isError: fillOrderMut.isError || fillTxMined.isError,
-    error: fillOrderMut.error || fillTxMined.error
-  };
-  const lastCallsReceipt = batchTxMined.data?.receipts?.[batchTxMined.data.receipts.length - 1];
-  const fillOrderBatch = {
-    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 ensureTxReceipt = useEnsureTxReceipt();
-  const ensureCallsStatus = useEnsureCallsStatus();
-  const currentAbortControllerRef = useRef(null);
-  const cancelFlow = () => {
-    currentAbortControllerRef.current?.abort(new UserCancelledError());
-    currentAbortControllerRef.current = null;
-  };
-  const {
-    markNonceAsUsed,
-    clearNonce
-  } = useMarkPermit1Or2NonceAsUsed({
-    chainId
-  });
-  const events = useWidgetEvents();
-  const submitFillTx = async ({
-    onTxSent
-  } = {}) => {
-    approveTxMut.reset();
-    signPermitMut.reset();
-    fillOrderMut.reset();
-    batchTxMut.reset();
-    assert(order, "no order to fill");
-    assert(order.taker !== zeroAddress, "taker must not be zero address");
-    const abortController = new AbortController();
-    currentAbortControllerRef.current = abortController;
-    const signal = abortController.signal;
-    let signedPermitResult;
-    let approveTxHash;
-    let approveTxReceipt;
-    const allowanceToSet = approval.allowanceToSet;
-    const allowanceToPermit = signPermit.amountToPermit;
-    const baseEventParams = {
-      orderHash: order.orderHash,
-      orderType: "OTC",
-      orderSubType: order.type
-    };
-    events.onFillOTCOrder?.({
-      event: {
-        name: "FillOTCOrder:request",
-        params: baseEventParams
-      }
-    });
-    const shouldBatchTxs = canBatchTxs && approval.needsApproval && !!allowanceToSet;
-    try {
-      if (!shouldBatchTxs && approval.needsApproval && allowanceToSet) {
-        const tryPermit = signPermit.isPermitSupported && signPermit.isPermitReadyToSign;
-        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({
-              value: allowanceToPermit
-            });
-            approveOrPermitEvents.onSignPermit.confirmed({
-              allowanceToSet: allowanceToPermit,
-              permit: signedPermitResult?.permitEncodedArgs
-            });
-          }
-        } catch (error_2) {
-          if (!tryPermit) {
-            approveOrPermitEvents.onApproveTx.failed({
-              allowanceToSet,
-              error: error_2,
-              txHash: approveTxHash
-              // won't necessarily be available
-            });
-          } else {
-            approveOrPermitEvents.onSignPermit.failed({
-              allowanceToSet: allowanceToPermit,
-              error: error_2
-            });
-          }
-          throw error_2;
-        }
-      }
-      signal.throwIfAborted();
-      assert(account, "Account is not connected");
-      const orderFillData = {
-        order,
-        signature: order.signature
-      };
-      if (signedPermitResult) {
-        orderFillData.takerPermit = {
-          encodedPermitParams: signedPermitResult.permitEncodedArgs
-        };
-      }
-      let fillTxHash;
-      let fillCallsId;
-      if (shouldBatchTxs) {
-        assert(callDataSDK, "callDataSDK is not initialized");
-        const calldata = await callDataSDK.fillOrderDirectly({
-          order,
-          signature: order.signature
-        });
-        const {
-          calls
-        } = await addTxWithApprovals({
-          txsParams: [{
-            to: approval.spender,
-            account,
-            data: calldata,
-            value: 0n,
-            chainId
-          }],
-          approveProps: [{
-            spender: approval.spender,
-            allowanceToSet: approval.allowanceToSet,
-            token: approval.token,
-            chainId: approval.chainId
-          }]
-        });
-        const sendCallsResult = await batchTxMut.sendCalls({
-          txsParams: calls
-        });
-        fillCallsId = sendCallsResult.id;
-        events.onFillOTCOrder?.({
-          event: {
-            name: "FillOTCOrder:sent",
-            params: {
-              callsId: fillCallsId,
-              ...baseEventParams
-            }
-          }
-        });
-      } else {
-        fillTxHash = await fillOrderMut.mutateAsync({
-          orderFillData,
-          signal
-        });
-        events.onFillOTCOrder?.({
-          event: {
-            name: "FillOTCOrder:sent",
-            params: {
-              txHash: fillTxHash,
-              ...baseEventParams
-            }
-          }
-        });
-      }
-      if (signedPermitResult) {
-        markNonceAsUsed(signedPermitResult.signedPermitData);
-      }
-      let fillCallsReceipt;
-      let fillTxReceipt;
-      if (fillCallsId) {
-        const sendCallsReceiptPromise = ensureCallsStatus({
-          id: fillCallsId
-        }).then((status) => status.receipts?.[status.receipts.length - 1]);
-        logger.log("~ fillTx ~ awaiting calls id :", fillCallsId);
-        if (onTxSent) {
-          onTxSent({
-            chainId,
-            callsId: fillCallsId,
-            action: "fillOtcOrder",
-            receiptPromise: sendCallsReceiptPromise,
-            transactionSpecificData: {
-              action: "fillOtcOrder",
-              filledOrder: order
-            }
-          });
-        }
-        fillCallsReceipt = await sendCallsReceiptPromise;
-        if (fillCallsReceipt) {
-          events.onFillOTCOrder?.({
-            event: {
-              name: "FillOTCOrder:confirmed",
-              params: {
-                callsId: fillCallsId,
-                callsReceipt: fillCallsReceipt,
-                ...baseEventParams
-              }
-            }
-          });
-        }
-      } else if (fillTxHash) {
-        const fillTxReceiptPromise = ensureTxReceipt({
-          hash: fillTxHash,
-          chainId,
-          onReplaced: (data_0) => {
-            logger.log("onReplaced:fillTx", fillTxHash, data_0);
-          }
-        });
-        logger.log("~ fillTx ~ awaiting tx hash :", fillTxHash);
-        if (onTxSent) {
-          onTxSent({
-            chainId,
-            transactionHash: fillTxHash,
-            action: "fillOtcOrder",
-            receiptPromise: fillTxReceiptPromise,
-            transactionSpecificData: {
-              action: "fillOtcOrder",
-              filledOrder: order
-            }
-          });
-        }
-        fillTxReceipt = await fillTxReceiptPromise;
-        events.onFillOTCOrder?.({
-          event: {
-            name: "FillOTCOrder:confirmed",
-            params: {
-              txHash: fillTxHash,
-              txReceipt: fillTxReceipt,
-              ...baseEventParams
-            }
-          }
-        });
-      }
-      logger.log("~ fillTx ~ receipt:", fillCallsReceipt || fillTxReceipt);
-      return {
-        tradeFlowType: fillOtcOrderFlowType,
-        approve: {
-          txHash: approveTxHash,
-          receipt: approveTxReceipt
-        },
-        fill: {
-          txHash: fillTxHash,
-          txReceipt: fillTxReceipt,
-          order
-        },
-        account,
-        receiverAddress: order.taker
-      };
-    } catch (error_1) {
-      events.onFillOTCOrder?.({
-        event: {
-          name: "FillOTCOrder:failed",
-          params: {
-            ...baseEventParams,
-            error: error_1
-          }
-        }
-      });
-      if (signedPermitResult) {
-        clearNonce(signedPermitResult.signedPermitData);
-      }
-      throw error_1;
-    }
-  };
-  const runFillOrderMut = useMutation({
-    mutationFn: submitFillTx,
-    mutationKey: [OTC_ORDER_MUTATION_KEY],
-    onSuccess: (data_1) => {
-      logger.log("Fill order flow success", data_1);
-    },
-    onError: (error_3) => {
-      logger.error("Fill order flow error", error_3);
-    },
-    onSettled: () => {
-      logger.log("Fill order flow settled");
-    }
-  });
-  const runFillOtcOrderFlow = runFillOrderMut.mutateAsync;
-  const reset = () => {
-    approveTxMut.reset();
-    signPermitMut.reset();
-    fillOrderMut.reset();
-    batchTxMut.reset();
-    runFillOrderMut.reset();
-  };
-  const retryFlow = (options) => {
-    reset();
-    return runFillOtcOrderFlow(options);
-  };
-  return {
-    tradeFlowType: fillOtcOrderFlowType,
-    chainId,
-    runFillOtcOrderFlow,
-    reset,
-    cancelFlow,
-    retryFlow,
-    approval,
-    signPermit,
-    fillOrder,
-    fillOrderBatch,
-    isPending: runFillOrderMut.isPending,
-    isSuccess: runFillOrderMut.isSuccess,
-    isError: runFillOrderMut.isError,
-    error: runFillOrderMut.error,
-    result: runFillOrderMut.data
-  };
+import { useLogger as e } from "../../../core/logger.js";
+import { useCalldataSDK as t } from "../../useSDK.js";
+import { useWidgetEvents as n } from "../../../core/state/widgetEventsAtom.js";
+import { useMinViemClient as r } from "../../useMinViemClient.js";
+import { useCanBatchTxs as i } from "../../batch/useCanBatchTxs.js";
+import { useAwaitCalls as a, useEnsureCallsStatus as o } from "../../batch/useAwaitCalls.js";
+import { useAwaitTx as s, useEnsureTxReceipt as c } from "../../txs/queries/useAwaitTx.js";
+import { UserCancelledError as l } from "../../swap/tradeFlow/common/errors.js";
+import { useMarkPermit1Or2NonceAsUsed as u } from "../../swap/tradeFlow/common/useSignPermit1Or2.js";
+import { useApproveOrPermit as d } from "../../swap/tradeFlow/common/useApproveOrPermit.js";
+import { useBatchWithApproveTxs as f } from "../../batch/useBatchWithApproveTxs.js";
+import { useSendBatchTx as p } from "../../batch/useSendBatchTx.js";
+import { useFillOrder as m } from "../mutations/useFillOrder.js";
+import { useRef as h } from "react";
+import { useMutation as g } from "@tanstack/react-query";
+import { assert as _ } from "ts-essentials";
+import { zeroAddress as v } from "viem";
+import { useAccount as y, useChainId as b } from "wagmi";
+//#region src/hooks/otc/tradeFlow/useFillOtcOrderFlow.ts
+var x = "fillOtcOrder", S = "runFillOtcOrderFlow";
+function C({ order: C }) {
+	let w = e("FillOtcOrderFlow"), T = b(), { approval: E, signPermit: D, approveTxMut: O, signPermitMut: k, events: A } = d({
+		srcToken: C?.takerAsset,
+		srcAmount: C?.takerAmount,
+		spenderContractType: "AugustusRFQ",
+		swapSide: "SELL",
+		tradeMode: "otc",
+		chainId: T
+	}), { address: j } = y(), { minClient: M } = r({
+		chainId: T,
+		account: j
+	}), { sdk: N } = t({
+		chainId: T,
+		client: M
+	}), P = m({
+		chainId: T,
+		account: j,
+		client: M,
+		mutationOptions: {
+			onSuccess: (e) => {
+				w.log("Fill OTC Order success", e);
+			},
+			onError: (e) => {
+				w.error("Fill OTC Order error", e);
+			}
+		}
+	}), { forCurrentChain: F } = i(), { addTxWithApprovals: I } = f(), L = p({
+		onSuccess: () => {
+			w.log("Batch tx success");
+		},
+		onError: (e) => {
+			w.error("Batch tx error", e);
+		}
+	}), R = s({
+		chainId: T,
+		hash: P.data
+	}), z = a({ id: L.data?.id }), B = {
+		txHash: P.data,
+		receipt: R.data,
+		isConfirmingTX: P.isPending,
+		isConfirmingTxError: P.isError,
+		isTxSent: P.isSuccess,
+		isTxPending: R.isPending,
+		isTxMined: R.isSuccess,
+		isTxAwaitingError: R.isError,
+		isPending: P.isPending || R.isLoading,
+		isSuccess: R.isSuccess,
+		isError: P.isError || R.isError,
+		error: P.error || R.error
+	}, V = z.data?.receipts?.[z.data.receipts.length - 1], H = {
+		canBatchTxs: F,
+		callsId: L.data?.id,
+		txHash: V?.transactionHash,
+		receipt: V,
+		isConfirmingCalls: L.isPending,
+		isConfirmingCallsError: L.isError,
+		isCallsSent: L.isSuccess,
+		isCallsPending: z.isLoading,
+		isCallsMined: z.isSuccess,
+		isCallsAwaitingError: z.isError,
+		isPending: L.isPending || z.isLoading,
+		isSuccess: z.isSuccess,
+		isError: L.isError || z.isError,
+		error: L.error || z.error
+	}, U = c(), W = o(), G = h(null), K = () => {
+		G.current?.abort(new l()), G.current = null;
+	}, { markNonceAsUsed: q, clearNonce: J } = u({ chainId: T }), Y = n(), X = g({
+		mutationFn: async ({ onTxSent: e } = {}) => {
+			O.reset(), k.reset(), P.reset(), L.reset(), _(C, "no order to fill"), _(C.taker !== v, "taker must not be zero address");
+			let t = new AbortController();
+			G.current = t;
+			let n = t.signal, r, i, a, o = E.allowanceToSet, s = D.amountToPermit, c = {
+				orderHash: C.orderHash,
+				orderType: "OTC",
+				orderSubType: C.type
+			};
+			Y.onFillOTCOrder?.({ event: {
+				name: "FillOTCOrder:request",
+				params: c
+			} });
+			let l = F && E.needsApproval && !!o;
+			try {
+				if (!l && E.needsApproval && o) {
+					let t = D.isPermitSupported && D.isPermitReadyToSign;
+					try {
+						if (t) A.onSignPermit.request({ allowanceToSet: s }), r = await k.signPermitAsync({ value: s }), A.onSignPermit.confirmed({
+							allowanceToSet: s,
+							permit: r?.permitEncodedArgs
+						});
+						else {
+							A.onApproveTx.request({ allowanceToSet: o }), i = await O.approveAsync({ allowanceData: { allowanceToSet: o } }), A.onApproveTx.sent({
+								allowanceToSet: o,
+								txHash: i
+							}), n.throwIfAborted();
+							let t = U({
+								hash: i,
+								chainId: T,
+								onReplaced: (e) => {
+									w.log("onReplaced:approveTx", i, e);
+								}
+							});
+							e && e({
+								chainId: T,
+								action: "approve",
+								transactionHash: i,
+								receiptPromise: t,
+								transactionSpecificData: {
+									action: "approve",
+									approvedAmount: o,
+									tokenAddress: E.token,
+									spenderAddress: E.spender
+								}
+							}), a = await t, A.onApproveTx.confirmed({
+								allowanceToSet: o,
+								txHash: i,
+								txReceipt: a
+							}), w.log("~ approveTx ~ receipt:", a);
+						}
+					} catch (e) {
+						throw t ? A.onSignPermit.failed({
+							allowanceToSet: s,
+							error: e
+						}) : A.onApproveTx.failed({
+							allowanceToSet: o,
+							error: e,
+							txHash: i
+						}), e;
+					}
+				}
+				n.throwIfAborted(), _(j, "Account is not connected");
+				let t = {
+					order: C,
+					signature: C.signature
+				};
+				r && (t.takerPermit = { encodedPermitParams: r.permitEncodedArgs });
+				let u, d;
+				if (l) {
+					_(N, "callDataSDK is not initialized");
+					let e = await N.fillOrderDirectly({
+						order: C,
+						signature: C.signature
+					}), { calls: t } = await I({
+						txsParams: [{
+							to: E.spender,
+							account: j,
+							data: e,
+							value: 0n,
+							chainId: T
+						}],
+						approveProps: [{
+							spender: E.spender,
+							allowanceToSet: E.allowanceToSet,
+							token: E.token,
+							chainId: E.chainId
+						}]
+					});
+					d = (await L.sendCalls({ txsParams: t })).id, Y.onFillOTCOrder?.({ event: {
+						name: "FillOTCOrder:sent",
+						params: {
+							callsId: d,
+							...c
+						}
+					} });
+				} else u = await P.mutateAsync({
+					orderFillData: t,
+					signal: n
+				}), Y.onFillOTCOrder?.({ event: {
+					name: "FillOTCOrder:sent",
+					params: {
+						txHash: u,
+						...c
+					}
+				} });
+				r && q(r.signedPermitData);
+				let f, p;
+				if (d) {
+					let t = W({ id: d }).then((e) => e.receipts?.[e.receipts.length - 1]);
+					w.log("~ fillTx ~ awaiting calls id :", d), e && e({
+						chainId: T,
+						callsId: d,
+						action: "fillOtcOrder",
+						receiptPromise: t,
+						transactionSpecificData: {
+							action: "fillOtcOrder",
+							filledOrder: C
+						}
+					}), f = await t, f && Y.onFillOTCOrder?.({ event: {
+						name: "FillOTCOrder:confirmed",
+						params: {
+							callsId: d,
+							callsReceipt: f,
+							...c
+						}
+					} });
+				} else if (u) {
+					let t = U({
+						hash: u,
+						chainId: T,
+						onReplaced: (e) => {
+							w.log("onReplaced:fillTx", u, e);
+						}
+					});
+					w.log("~ fillTx ~ awaiting tx hash :", u), e && e({
+						chainId: T,
+						transactionHash: u,
+						action: "fillOtcOrder",
+						receiptPromise: t,
+						transactionSpecificData: {
+							action: "fillOtcOrder",
+							filledOrder: C
+						}
+					}), p = await t, Y.onFillOTCOrder?.({ event: {
+						name: "FillOTCOrder:confirmed",
+						params: {
+							txHash: u,
+							txReceipt: p,
+							...c
+						}
+					} });
+				}
+				return w.log("~ fillTx ~ receipt:", f || p), {
+					tradeFlowType: x,
+					approve: {
+						txHash: i,
+						receipt: a
+					},
+					fill: {
+						txHash: u,
+						txReceipt: p,
+						order: C
+					},
+					account: j,
+					receiverAddress: C.taker
+				};
+			} catch (e) {
+				throw Y.onFillOTCOrder?.({ event: {
+					name: "FillOTCOrder:failed",
+					params: {
+						...c,
+						error: e
+					}
+				} }), r && J(r.signedPermitData), e;
+			}
+		},
+		mutationKey: [S],
+		onSuccess: (e) => {
+			w.log("Fill order flow success", e);
+		},
+		onError: (e) => {
+			w.error("Fill order flow error", e);
+		},
+		onSettled: () => {
+			w.log("Fill order flow settled");
+		}
+	}), Z = X.mutateAsync, Q = () => {
+		O.reset(), k.reset(), P.reset(), L.reset(), X.reset();
+	};
+	return {
+		tradeFlowType: x,
+		chainId: T,
+		runFillOtcOrderFlow: Z,
+		reset: Q,
+		cancelFlow: K,
+		retryFlow: (e) => (Q(), Z(e)),
+		approval: E,
+		signPermit: D,
+		fillOrder: B,
+		fillOrderBatch: H,
+		isPending: X.isPending,
+		isSuccess: X.isSuccess,
+		isError: X.isError,
+		error: X.error,
+		result: X.data
+	};
 }
+//#endregion
+export { C as useFillOtcOrderFlow };
 
-export { useFillOtcOrderFlow };
-//# sourceMappingURL=useFillOtcOrderFlow.js.map
+//# sourceMappingURL=useFillOtcOrderFlow.js.map