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

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

@@ -2,304 +2,307 @@ 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";
+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 _ = "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,
+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: x
-	}), { address: T } = ae(), { minClient: E } = s({
-		chainId: x,
-		account: T
-	}), D = ee({
-		chainId: x,
-		account: T,
-		client: E,
+		chainId: C
+	}), { address: D } = y(), { minClient: O } = c({
+		chainId: C,
+		account: D
+	}), k = p({
+		chainId: C,
+		account: D,
+		client: O,
 		mutationOptions: {
 			onSuccess: (e) => {
-				b.log("Create Limit Order success", e);
+				S.log("Create Limit Order success", e);
 			},
 			onError: (e) => {
-				b.error("Create Limit Order error", e);
+				S.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,
+	}), 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) => {
-			b.log("Limit Order success", e);
+			S.log("Limit Order success", e);
 		},
 		onAuctionFailure: (e) => {
-			b.log("Limit Order failure", e);
+			S.log("Limit Order failure", e);
 		},
 		onUpdatedAuction: (e) => {
-			b.log("Limit Order updated", e);
-		},
-		onTimeoutGettingOrder: (e) => {
-			b.log("Limit Order timeout", e);
+			S.log("Limit Order updated", 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");
+	}), 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();
-		U.current = n;
-		let r = n.signal, i, a, o = S.allowanceToSet, s = t(y.srcTokenAddress), { shouldDoApprovalTxOrPermit: c, shouldPreSignBatch: l } = te({
-			approval: S,
+		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: A,
-			isConnectedToSafe: j
+			canBatchTxs: M,
+			isConnectedToSafe: N
 		});
 		try {
 			if (c && o) try {
-				w.onApproveTx.request({ allowanceToSet: o }), i = await C.approveAsync({ allowanceData: { allowanceToSet: o } }), w.onApproveTx.sent({
+				E.onApproveTx.request({ allowanceToSet: o }), i = await T.approveAsync({ allowanceData: { allowanceToSet: o } }), E.onApproveTx.sent({
 					allowanceToSet: o,
 					txHash: i
 				}), r.throwIfAborted();
-				let t = H({
+				let t = U({
 					hash: i,
-					chainId: x,
+					chainId: C,
 					onReplaced: (e) => {
-						b.log("onReplaced:approveTx", i, e);
+						S.log("onReplaced:approveTx", i, e);
 					}
 				});
 				e && e({
-					chainId: x,
+					chainId: C,
 					action: "approve",
 					transactionHash: i,
 					receiptPromise: t,
 					transactionSpecificData: {
 						action: "approve",
 						approvedAmount: o,
-						tokenAddress: S.token,
-						spenderAddress: S.spender
+						tokenAddress: w.token,
+						spenderAddress: w.spender
 					}
-				}), a = await t, w.onApproveTx.confirmed({
+				}), a = await t, E.onApproveTx.confirmed({
 					allowanceToSet: o,
 					txHash: i,
 					txReceipt: a
-				}), b.log("~ approveTx ~ receipt:", a);
+				}), S.log("~ approveTx ~ receipt:", a);
 			} catch (e) {
-				throw w.onApproveTx.failed({
+				throw E.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: {
+			r.throwIfAborted(), v(D, "Account is not connected"), v(x, "limitPrice is not available"), Y?.({ event: {
 				name: "LimitOrder:request",
-				params: { price: y }
+				params: { price: x }
 			} });
-			let t = y.bridgePrice, n = t?.bridge.destinationChainId, u;
+			let t = x.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,
+					owner: D,
+					beneficiary: q,
+					srcToken: x.srcTokenAddress,
+					destToken: x.destTokenAddress,
+					srcAmount: x.srcAmount,
+					destAmount: x.destAmount,
 					destChainId: n,
 					deltaPrice: {
 						...t,
 						bridge: {
 							...t.bridge,
-							protocolSelector: p.protocolSelector,
-							protocolData: p.protocolData
+							protocolSelector: h.protocolSelector,
+							protocolData: h.protocolData
 						},
-						partner: G,
+						partner: K,
 						partnerFee: 0
 					},
-					partner: G,
-					deadline: q
+					partner: K,
+					deadline: J
 				}
 			} : {
 				signal: r,
 				type: "LIMIT",
 				orderInput: {
-					owner: T,
-					beneficiary: K,
-					srcToken: y.srcTokenAddress,
-					srcAmount: y.srcAmount,
-					destToken: y.destTokenAddress,
-					destAmount: y.destAmount,
+					owner: D,
+					beneficiary: q,
+					srcToken: x.srcTokenAddress,
+					srcAmount: x.srcAmount,
+					destToken: x.destTokenAddress,
+					destAmount: x.destAmount,
 					destChainId: n,
 					deltaPrice: {
-						destToken: y.destTokenAddress,
-						destAmount: y.destAmount,
-						srcAmount: y.srcAmount,
-						bridge: p,
-						partner: G,
+						destToken: x.destTokenAddress,
+						destAmount: x.destAmount,
+						srcAmount: x.srcAmount,
+						bridge: h,
+						partner: K,
 						partnerFee: 0
 					},
-					partner: G,
-					deadline: q
+					partner: K,
+					deadline: J
 				}
 			};
 			let d;
-			return d = s ? await se({
-				createDeltaOrderInput: u,
-				depositAmount: u.orderInput.srcAmount,
-				onTxSent: e
-			}) : l ? await oe({
-				createDeltaOrderInput: u,
-				approval: S,
+			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 D.mutateAsync(u), J?.({ event: {
+			}) : await k.mutateAsync(u);
+			return Y?.({ event: {
 				name: "LimitOrder:sent",
 				params: {
-					price: y,
+					price: x,
 					order: d
 				}
 			} }), {
-				tradeFlowType: _,
+				tradeFlowType: b,
 				approve: {
 					txHash: i,
 					receipt: a
 				},
 				limitOrder: { sentOrder: d },
-				limitPrice: y,
-				account: T,
-				receiverAddress: K
+				limitPrice: x,
+				account: D,
+				receiverAddress: q
 			};
 		} catch (e) {
-			throw b.error("Order submission error", e), J?.({ event: {
+			throw S.error("Order submission error", e), Y?.({ event: {
 				name: "LimitOrder:failed",
 				params: {
-					price: y,
+					price: x,
 					error: e
 				}
 			} }), e;
 		}
 	}, ce = async () => {
 		try {
-			return await B.cancelDeltaOrder();
+			return await V.cancelDeltaOrder();
 		} catch (e) {
-			b.error("Cancel Limit order error", e), B.reset();
+			S.error("Cancel Limit order error", e), V.reset();
 		}
-	}, X = ie({
-		mutationFn: Y,
-		mutationKey: [v],
+	}, X = _({
+		mutationFn: se,
+		mutationKey: [ie],
 		onSuccess: (e) => {
-			b.log("Order submission success", e);
+			S.log("Order submission success", e);
 		},
 		onError: (e) => {
-			b.error("Order submission error", e);
+			S.error("Order submission error", e);
 		},
 		onSettled: () => {
-			b.log("Order submission settled");
+			S.log("Order submission settled");
 		}
 	}), Z = X.mutateAsync, Q = () => {
-		C.reset(), D.reset(), X.reset(), B.reset(), M(), P();
+		T.reset(), k.reset(), X.reset(), V.reset(), P(), I();
 	}, le = (e) => (Q(), Z(e)), $ = X.data;
-	return $ && z.lastOrderState && ($ = {
+	return $ && B.lastOrderState && ($ = {
 		...$,
 		limitOrder: {
 			sentOrder: $.limitOrder.sentOrder,
-			lastOrderState: z.lastOrderState
+			lastOrderState: B.lastOrderState
 		}
 	}), {
-		tradeFlowType: _,
-		chainId: x,
+		tradeFlowType: b,
+		chainId: C,
 		runLimitOrderFlow: Z,
 		reset: Q,
-		cancelFlow: W,
+		cancelFlow: G,
 		retryFlow: le,
 		cancelLimitOrder: ce,
-		approval: S,
-		limitOrderSubmission: F,
-		limitOrderExecution: z,
-		limitOrderCancelation: V,
+		approval: w,
+		limitOrderSubmission: L,
+		limitOrderExecution: B,
+		limitOrderCancelation: H,
 		isPending: X.isPending,
-		isSuccess: F.isSuccess,
+		isSuccess: L.isSuccess,
 		isError: X.isError,
 		error: X.error,
 		result: $,
-		limitPrice: y
+		limitPrice: x
 	};
 }
 //#endregion
-export { y as useLimitOrderFlow };
+export { x as useLimitOrderFlow };
 
 //# sourceMappingURL=useLimitOrderFlow.js.map