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

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

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