@velora-dex/widget 0.5.0 → 0.6.0

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

@@ -1,446 +1,305 @@
-import { useChainId, useAccount } from 'wagmi';
-import { assert } from 'ts-essentials';
-import { useEnsureTxReceipt } from '../../txs/queries/useAwaitTx.js';
-import '../../../_virtual/index.js';
-import '../../useSDK.js';
-import '../../../lib/queryClient.js';
-import 'clsx';
-import 'tailwind-merge';
-import { useMutation } from '@tanstack/react-query';
-import { useCreateAndSubmitDeltaOrder } from '../prices/delta/mutations/useCreateDeltaOrder.js';
-import { useMinViemClient } from '../../useMinViemClient.js';
-import { useRef } from 'react';
-import { UserCancelledError } from './common/errors.js';
-import { useApproveOrPermit } from './common/useApproveOrPermit.js';
-import { useLogger } from '../../../core/logger.js';
-import { usePartner } from '../../usePartner.js';
-import { useLimitDeadline } from '../../../core/limit/state/deadlineAtom.js';
-import { getOverallOrderStatus } from '../prices/delta/orders/utils.js';
-import { useWatchDeltaAuction } from '../prices/delta/queries/useWatchDeltaOrder.js';
-import { useWidgetEvents } from '../../../core/state/widgetEventsAtom.js';
-import { usePreSignAndSubmitDeltaOrder, shouldApproveOrBatch } from './common/usePreSignAndSubmitDeltaOrder.js';
-import { DEFAULT_DELTA_BRIDGE } from '../prices/delta/bridge/const.js';
-import { useLimitReceiverAddressValue } from '../../../core/limit/state/receiverAddressAtom.js';
-import { useDepositAndSubmitDeltaOrder } from './common/useDepositAndSubmitDeltaOrder.js';
-import { isETHaddress } from '../../../tokens/utils/eth.js';
-import { useCancelOrWithdrawAndCancelDeltaOrder } from '../prices/delta/mutations/useCancelOrWithdrawAndCancelDeltaOrder.js';
-
-const limitOrderFlowType = "limitOrder";
-const LIMIT_ORDER_MUTATION_KEY = "runLimitOrderFlow";
-function useLimitOrderFlow({
-  limitPrice
-}) {
-  const logger = useLogger("LimitOrderFlow");
-  const chainId = useChainId();
-  const {
-    approval,
-    approveTxMut,
-    events: approveOrPermitEvents
-  } = useApproveOrPermit({
-    srcToken: limitPrice?.srcTokenAddress,
-    srcAmount: limitPrice?.srcAmount,
-    spenderContractType: "ParaswapDelta",
-    swapSide: "SELL",
-    tradeMode: "limit",
-    chainId
-  });
-  const {
-    address: account
-  } = useAccount();
-  const {
-    minClient
-  } = useMinViemClient({
-    chainId,
-    account
-  });
-  const createAndSubmitOrderMut = useCreateAndSubmitDeltaOrder({
-    chainId,
-    account,
-    client: minClient,
-    mutationOptions: {
-      onSuccess: (order) => {
-        logger.log("Create Limit Order success", order);
-      },
-      onError: (error) => {
-        logger.error("Create Limit Order error", error);
-      }
-    }
-  });
-  const limitOrderCreateAndSubmit = {
-    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 {
-    deltaOrderPreSign,
-    canBatchTxs,
-    isConnectedToSafe,
-    preSignAndSubmitDeltaOrder,
-    reset: resetPreSignAndSubmitDeltaOrder
-  } = usePreSignAndSubmitDeltaOrder({
-    chainId,
-    account,
-    logger,
-    viemClient: minClient
-  });
-  const {
-    deltaOrderDeposit,
-    reset: resetDepositAndSubmitDeltaOrder,
-    depositAndSubmitDeltaOrder
-  } = useDepositAndSubmitDeltaOrder({
-    chainId,
-    account,
-    logger,
-    viemClient: minClient
-  });
-  const limitOrderSubmission = {
-    order: limitOrderCreateAndSubmit.order || deltaOrderPreSign.order || deltaOrderDeposit.order,
-    isPostingOrder: limitOrderCreateAndSubmit.isPostingOrder || deltaOrderPreSign.postingOrder.isPostingOrder || deltaOrderDeposit.postingOrder.isPostingOrder,
-    isCreatingOrder: limitOrderCreateAndSubmit.isCreatingOrder || deltaOrderPreSign.isCreatingOrder || deltaOrderDeposit.isCreatingOrder,
-    isOrderSent: limitOrderCreateAndSubmit.isOrderSent || deltaOrderPreSign.isOrderSent || deltaOrderDeposit.isOrderSent,
-    isPending: limitOrderCreateAndSubmit.isPending || deltaOrderPreSign.isPending || deltaOrderDeposit.isPending,
-    isError: limitOrderCreateAndSubmit.isError || deltaOrderPreSign.isError || deltaOrderDeposit.isError,
-    isSuccess: limitOrderCreateAndSubmit.isSuccess || deltaOrderPreSign.isSuccess || deltaOrderDeposit.isSuccess,
-    error: limitOrderCreateAndSubmit.error || deltaOrderPreSign.error || deltaOrderDeposit.error
-  };
-  const watchOrderExecution = useWatchDeltaAuction({
-    orderId: limitOrderSubmission.order?.id,
-    onAuctionSuccess: (order_0) => {
-      logger.log("Limit Order success", order_0);
-    },
-    onAuctionFailure: (order_1) => {
-      logger.log("Limit Order failure", order_1);
-    },
-    onUpdatedAuction: (order_2) => {
-      logger.log("Limit Order updated", order_2);
-    },
-    onTimeoutGettingOrder: (order_3) => {
-      logger.log("Limit Order timeout", order_3);
-    }
-  });
-  const orderStatus = watchOrderExecution.data ? getOverallOrderStatus(watchOrderExecution.data) : null;
-  const neverFetchedFinishedOrder = watchOrderExecution.data === null && watchOrderExecution.isSuccess;
-  const limitOrderExecution = {
-    sentOrder: limitOrderSubmission.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: limitOrderExecution.lastOrderState || limitOrderExecution.sentOrder,
-    chainId,
-    account,
-    client: minClient,
-    logger
-  });
-  const limitOrderCancelation = {
-    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,
-    step: cancelOrderMut.step
-  };
-  const ensureTxReceipt = useEnsureTxReceipt();
-  const currentAbortControllerRef = useRef(null);
-  const cancelFlow = () => {
-    currentAbortControllerRef.current?.abort(new UserCancelledError());
-    currentAbortControllerRef.current = null;
-  };
-  const {
-    partner
-  } = usePartner();
-  const receiverAddress = useLimitReceiverAddressValue();
-  const deadline = useLimitDeadline();
-  const {
-    onLimitOrder
-  } = useWidgetEvents();
-  const submitLimitOrder = async ({
-    onTxSent
-  } = {}) => {
-    approveTxMut.reset();
-    createAndSubmitOrderMut.reset();
-    cancelOrderMut.reset();
-    resetPreSignAndSubmitDeltaOrder();
-    resetDepositAndSubmitDeltaOrder();
-    assert(limitPrice, "Limit price data is not available");
-    const abortController = new AbortController();
-    currentAbortControllerRef.current = abortController;
-    const signal = abortController.signal;
-    let approveTxHash;
-    let approveTxReceipt;
-    const allowanceToSet = approval.allowanceToSet;
-    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(limitPrice.srcTokenAddress)
-    );
-    const {
-      shouldDoApprovalTxOrPermit: shouldDoApprovalTx,
-      shouldPreSignBatch
-    } = shouldApproveOrBatch({
-      approval,
-      signPermit: {
-        isPermitSupported: false,
-        isPermitReadyToSign: false
-      },
-      canBatchTxs,
-      isConnectedToSafe
-    });
-    try {
-      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_1) {
-          approveOrPermitEvents.onApproveTx.failed({
-            allowanceToSet,
-            error: error_1,
-            txHash: approveTxHash
-            // won't necessarily be available
-          });
-          throw error_1;
-        }
-      }
-      signal.throwIfAborted();
-      assert(account, "Account is not connected");
-      assert(limitPrice, "limitPrice is not available");
-      onLimitOrder?.({
-        event: {
-          name: "LimitOrder:request",
-          params: {
-            price: limitPrice
-          }
-        }
-      });
-      const bridgePrice = limitPrice.bridgePrice;
-      const destChainId = bridgePrice?.bridge.destinationChainId;
-      let createOrderInput;
-      if (bridgePrice) {
-        createOrderInput = {
-          signal,
-          type: "LIMIT",
-          orderInput: {
-            owner: account,
-            beneficiary: receiverAddress,
-            srcToken: limitPrice.srcTokenAddress,
-            destToken: limitPrice.destTokenAddress,
-            srcAmount: limitPrice.srcAmount,
-            destAmount: limitPrice.destAmount,
-            destChainId,
-            deltaPrice: {
-              ...bridgePrice,
-              bridge: {
-                ...bridgePrice.bridge,
-                protocolSelector: DEFAULT_DELTA_BRIDGE.protocolSelector,
-                protocolData: DEFAULT_DELTA_BRIDGE.protocolData
-              },
-              partner,
-              partnerFee: 0
-            },
-            partner,
-            deadline
-          }
-        };
-      } else {
-        createOrderInput = {
-          signal,
-          type: "LIMIT",
-          orderInput: {
-            owner: account,
-            beneficiary: receiverAddress,
-            srcToken: limitPrice.srcTokenAddress,
-            srcAmount: limitPrice.srcAmount,
-            destToken: limitPrice.destTokenAddress,
-            destAmount: limitPrice.destAmount,
-            destChainId,
-            deltaPrice: {
-              destToken: limitPrice.destTokenAddress,
-              destAmount: limitPrice.destAmount,
-              srcAmount: limitPrice.srcAmount,
-              bridge: DEFAULT_DELTA_BRIDGE,
-              partner,
-              partnerFee: 0
-            },
-            partner,
-            deadline
-          }
-        };
-      }
-      let orderFromAPI;
-      if (shouldDepositAndPreSign) {
-        orderFromAPI = await depositAndSubmitDeltaOrder({
-          createDeltaOrderInput: createOrderInput,
-          depositAmount: createOrderInput.orderInput.srcAmount,
-          onTxSent
-        });
-      } else if (shouldPreSignBatch) {
-        orderFromAPI = await preSignAndSubmitDeltaOrder({
-          createDeltaOrderInput: createOrderInput,
-          approval,
-          onTxSent
-        });
-      } else {
-        orderFromAPI = await createAndSubmitOrderMut.mutateAsync(createOrderInput);
-      }
-      onLimitOrder?.({
-        event: {
-          name: "LimitOrder:sent",
-          params: {
-            price: limitPrice,
-            order: orderFromAPI
-          }
-        }
-      });
-      return {
-        tradeFlowType: limitOrderFlowType,
-        approve: {
-          txHash: approveTxHash,
-          receipt: approveTxReceipt
-        },
-        limitOrder: {
-          sentOrder: orderFromAPI
-        },
-        limitPrice,
-        account,
-        receiverAddress
-      };
-    } catch (error_0) {
-      logger.error("Order submission error", error_0);
-      onLimitOrder?.({
-        event: {
-          name: "LimitOrder:failed",
-          params: {
-            price: limitPrice,
-            error: error_0
-          }
-        }
-      });
-      throw error_0;
-    }
-  };
-  const cancelLimitOrder = async () => {
-    try {
-      return await cancelOrderMut.cancelDeltaOrder();
-    } catch (error_2) {
-      logger.error("Cancel Limit order error", error_2);
-      cancelOrderMut.reset();
-    }
-  };
-  const limitOrderMut = useMutation({
-    mutationFn: submitLimitOrder,
-    mutationKey: [LIMIT_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 runLimitOrderFlow = limitOrderMut.mutateAsync;
-  const reset = () => {
-    approveTxMut.reset();
-    createAndSubmitOrderMut.reset();
-    limitOrderMut.reset();
-    cancelOrderMut.reset();
-    resetPreSignAndSubmitDeltaOrder();
-    resetDepositAndSubmitDeltaOrder();
-  };
-  const retryFlow = (options) => {
-    reset();
-    return runLimitOrderFlow(options);
-  };
-  let result = limitOrderMut.data;
-  if (result && limitOrderExecution.lastOrderState) {
-    result = {
-      ...result,
-      limitOrder: {
-        sentOrder: result.limitOrder.sentOrder,
-        // lastOrderState may be CANCELLED here
-        lastOrderState: limitOrderExecution.lastOrderState
-      }
-    };
-  }
-  return {
-    tradeFlowType: limitOrderFlowType,
-    chainId,
-    runLimitOrderFlow,
-    reset,
-    cancelFlow,
-    retryFlow,
-    cancelLimitOrder,
-    approval,
-    limitOrderSubmission,
-    limitOrderExecution,
-    limitOrderCancelation,
-    // deltaOrderMut includes all steps' queries and mutations and returns more precise errors (including cancellation)
-    isPending: limitOrderMut.isPending,
-    isSuccess: limitOrderSubmission.isSuccess,
-    // approval is an optional step
-    isError: limitOrderMut.isError,
-    error: limitOrderMut.error,
-    result,
-    limitPrice
-  };
+import { useLogger as e } from "../../../core/logger.js";
+import { isETHaddress as t } from "../../../tokens/utils/eth.js";
+import { useLimitDeadline as n } from "../../../core/limit/state/deadlineAtom.js";
+import { useLimitReceiverAddressValue as r } from "../../../core/limit/state/receiverAddressAtom.js";
+import { useWidgetEvents as i } from "../../../core/state/widgetEventsAtom.js";
+import { getOverallOrderStatus as a } from "../prices/delta/orders/utils.js";
+import { useWatchDeltaAuction as o } from "../prices/delta/queries/useWatchDeltaOrder.js";
+import { useMinViemClient as s } from "../../useMinViemClient.js";
+import { usePartner as c } from "../../usePartner.js";
+import { useEnsureTxReceipt as l } from "../../txs/queries/useAwaitTx.js";
+import { useCancelOrWithdrawAndCancelDeltaOrder as u } from "../prices/delta/mutations/useCancelOrWithdrawAndCancelDeltaOrder.js";
+import { UserCancelledError as d } from "./common/errors.js";
+import { useCreateAndSubmitDeltaOrder as ee } from "../prices/delta/mutations/useCreateDeltaOrder.js";
+import { useApproveOrPermit as f } from "./common/useApproveOrPermit.js";
+import { shouldApproveOrBatch as te, usePreSignAndSubmitDeltaOrder as ne } from "./common/usePreSignAndSubmitDeltaOrder.js";
+import { useDepositAndSubmitDeltaOrder as re } from "./common/useDepositAndSubmitDeltaOrder.js";
+import { DEFAULT_DELTA_BRIDGE as p } from "../prices/delta/bridge/const.js";
+import { useRef as m } from "react";
+import { useMutation as ie } from "@tanstack/react-query";
+import { assert as h } from "ts-essentials";
+import { useAccount as ae, useChainId as g } from "wagmi";
+//#region src/hooks/swap/tradeFlow/useLimitOrderFlow.ts
+var _ = "limitOrder", v = "runLimitOrderFlow";
+function y({ limitPrice: y }) {
+	let b = e("LimitOrderFlow"), x = g(), { approval: S, approveTxMut: C, events: w } = f({
+		srcToken: y?.srcTokenAddress,
+		srcAmount: y?.srcAmount,
+		spenderContractType: "ParaswapDelta",
+		swapSide: "SELL",
+		tradeMode: "limit",
+		chainId: x
+	}), { address: T } = ae(), { minClient: E } = s({
+		chainId: x,
+		account: T
+	}), D = ee({
+		chainId: x,
+		account: T,
+		client: E,
+		mutationOptions: {
+			onSuccess: (e) => {
+				b.log("Create Limit Order success", e);
+			},
+			onError: (e) => {
+				b.error("Create Limit Order error", e);
+			}
+		}
+	}), O = {
+		order: D.order,
+		isCreatingOrder: D.isCreatingOrder,
+		isPostingOrder: D.isPostingOrder,
+		isOrderSent: D.isOrderSent,
+		isPending: D.isPending,
+		isError: D.isError,
+		isSuccess: D.isSuccess,
+		error: D.error
+	}, { deltaOrderPreSign: k, canBatchTxs: A, isConnectedToSafe: j, preSignAndSubmitDeltaOrder: oe, reset: M } = ne({
+		chainId: x,
+		account: T,
+		logger: b,
+		viemClient: E
+	}), { deltaOrderDeposit: N, reset: P, depositAndSubmitDeltaOrder: se } = re({
+		chainId: x,
+		account: T,
+		logger: b,
+		viemClient: E
+	}), F = {
+		order: O.order || k.order || N.order,
+		isPostingOrder: O.isPostingOrder || k.postingOrder.isPostingOrder || N.postingOrder.isPostingOrder,
+		isCreatingOrder: O.isCreatingOrder || k.isCreatingOrder || N.isCreatingOrder,
+		isOrderSent: O.isOrderSent || k.isOrderSent || N.isOrderSent,
+		isPending: O.isPending || k.isPending || N.isPending,
+		isError: O.isError || k.isError || N.isError,
+		isSuccess: O.isSuccess || k.isSuccess || N.isSuccess,
+		error: O.error || k.error || N.error
+	}, I = o({
+		orderId: F.order?.id,
+		onAuctionSuccess: (e) => {
+			b.log("Limit Order success", e);
+		},
+		onAuctionFailure: (e) => {
+			b.log("Limit Order failure", e);
+		},
+		onUpdatedAuction: (e) => {
+			b.log("Limit Order updated", e);
+		},
+		onTimeoutGettingOrder: (e) => {
+			b.log("Limit Order timeout", e);
+		}
+	}), L = I.data ? a(I.data) : null, R = I.data === null && I.isSuccess, z = {
+		sentOrder: F.order,
+		lastOrderState: I.data,
+		isOrderPending: L === "pending",
+		isOrderExecuting: L === "executing",
+		isOrderExecuted: L === "confirmed",
+		isPending: I.isLoading || I.isRefetching || L === "pending" || L === "executing",
+		isError: I.isError || L === "failed" || R,
+		isSuccess: L === "confirmed",
+		error: I.error
+	}, B = u({
+		order: z.lastOrderState || z.sentOrder,
+		chainId: x,
+		account: T,
+		client: E,
+		logger: b
+	}), V = {
+		receipt: B.receipt,
+		txHash: B.txHash,
+		response: B.cancelOrderResponse,
+		isCancelingOrder: B.isPending,
+		isOrderCancellable: B.isOrderCancellable,
+		isOrderCanceled: B.isSuccess,
+		isPending: B.isPending,
+		isError: B.isError,
+		isSuccess: B.isSuccess,
+		error: B.error,
+		step: B.step
+	}, H = l(), U = m(null), W = () => {
+		U.current?.abort(new d()), U.current = null;
+	}, { partner: G } = c(), K = r(), q = n(), { onLimitOrder: J } = i(), Y = async ({ onTxSent: e } = {}) => {
+		C.reset(), D.reset(), B.reset(), M(), P(), h(y, "Limit price data is not available");
+		let n = new AbortController();
+		U.current = n;
+		let r = n.signal, i, a, o = S.allowanceToSet, s = t(y.srcTokenAddress), { shouldDoApprovalTxOrPermit: c, shouldPreSignBatch: l } = te({
+			approval: S,
+			signPermit: {
+				isPermitSupported: !1,
+				isPermitReadyToSign: !1
+			},
+			canBatchTxs: A,
+			isConnectedToSafe: j
+		});
+		try {
+			if (c && o) try {
+				w.onApproveTx.request({ allowanceToSet: o }), i = await C.approveAsync({ allowanceData: { allowanceToSet: o } }), w.onApproveTx.sent({
+					allowanceToSet: o,
+					txHash: i
+				}), r.throwIfAborted();
+				let t = H({
+					hash: i,
+					chainId: x,
+					onReplaced: (e) => {
+						b.log("onReplaced:approveTx", i, e);
+					}
+				});
+				e && e({
+					chainId: x,
+					action: "approve",
+					transactionHash: i,
+					receiptPromise: t,
+					transactionSpecificData: {
+						action: "approve",
+						approvedAmount: o,
+						tokenAddress: S.token,
+						spenderAddress: S.spender
+					}
+				}), a = await t, w.onApproveTx.confirmed({
+					allowanceToSet: o,
+					txHash: i,
+					txReceipt: a
+				}), b.log("~ approveTx ~ receipt:", a);
+			} catch (e) {
+				throw w.onApproveTx.failed({
+					allowanceToSet: o,
+					error: e,
+					txHash: i
+				}), e;
+			}
+			r.throwIfAborted(), h(T, "Account is not connected"), h(y, "limitPrice is not available"), J?.({ event: {
+				name: "LimitOrder:request",
+				params: { price: y }
+			} });
+			let t = y.bridgePrice, n = t?.bridge.destinationChainId, u;
+			u = t ? {
+				signal: r,
+				type: "LIMIT",
+				orderInput: {
+					owner: T,
+					beneficiary: K,
+					srcToken: y.srcTokenAddress,
+					destToken: y.destTokenAddress,
+					srcAmount: y.srcAmount,
+					destAmount: y.destAmount,
+					destChainId: n,
+					deltaPrice: {
+						...t,
+						bridge: {
+							...t.bridge,
+							protocolSelector: p.protocolSelector,
+							protocolData: p.protocolData
+						},
+						partner: G,
+						partnerFee: 0
+					},
+					partner: G,
+					deadline: q
+				}
+			} : {
+				signal: r,
+				type: "LIMIT",
+				orderInput: {
+					owner: T,
+					beneficiary: K,
+					srcToken: y.srcTokenAddress,
+					srcAmount: y.srcAmount,
+					destToken: y.destTokenAddress,
+					destAmount: y.destAmount,
+					destChainId: n,
+					deltaPrice: {
+						destToken: y.destTokenAddress,
+						destAmount: y.destAmount,
+						srcAmount: y.srcAmount,
+						bridge: p,
+						partner: G,
+						partnerFee: 0
+					},
+					partner: G,
+					deadline: q
+				}
+			};
+			let d;
+			return d = s ? await se({
+				createDeltaOrderInput: u,
+				depositAmount: u.orderInput.srcAmount,
+				onTxSent: e
+			}) : l ? await oe({
+				createDeltaOrderInput: u,
+				approval: S,
+				onTxSent: e
+			}) : await D.mutateAsync(u), J?.({ event: {
+				name: "LimitOrder:sent",
+				params: {
+					price: y,
+					order: d
+				}
+			} }), {
+				tradeFlowType: _,
+				approve: {
+					txHash: i,
+					receipt: a
+				},
+				limitOrder: { sentOrder: d },
+				limitPrice: y,
+				account: T,
+				receiverAddress: K
+			};
+		} catch (e) {
+			throw b.error("Order submission error", e), J?.({ event: {
+				name: "LimitOrder:failed",
+				params: {
+					price: y,
+					error: e
+				}
+			} }), e;
+		}
+	}, ce = async () => {
+		try {
+			return await B.cancelDeltaOrder();
+		} catch (e) {
+			b.error("Cancel Limit order error", e), B.reset();
+		}
+	}, X = ie({
+		mutationFn: Y,
+		mutationKey: [v],
+		onSuccess: (e) => {
+			b.log("Order submission success", e);
+		},
+		onError: (e) => {
+			b.error("Order submission error", e);
+		},
+		onSettled: () => {
+			b.log("Order submission settled");
+		}
+	}), Z = X.mutateAsync, Q = () => {
+		C.reset(), D.reset(), X.reset(), B.reset(), M(), P();
+	}, le = (e) => (Q(), Z(e)), $ = X.data;
+	return $ && z.lastOrderState && ($ = {
+		...$,
+		limitOrder: {
+			sentOrder: $.limitOrder.sentOrder,
+			lastOrderState: z.lastOrderState
+		}
+	}), {
+		tradeFlowType: _,
+		chainId: x,
+		runLimitOrderFlow: Z,
+		reset: Q,
+		cancelFlow: W,
+		retryFlow: le,
+		cancelLimitOrder: ce,
+		approval: S,
+		limitOrderSubmission: F,
+		limitOrderExecution: z,
+		limitOrderCancelation: V,
+		isPending: X.isPending,
+		isSuccess: F.isSuccess,
+		isError: X.isError,
+		error: X.error,
+		result: $,
+		limitPrice: y
+	};
 }
+//#endregion
+export { y as useLimitOrderFlow };
 
-export { useLimitOrderFlow };
-//# sourceMappingURL=useLimitOrderFlow.js.map
+//# sourceMappingURL=useLimitOrderFlow.js.map