@ensofinance/checkout-widget 0.0.17 → 0.0.18

package/src/util/tx-tracker.tsx

@@ -52,7 +52,7 @@ export const useTrackTx = () => {
     return { track };
 };
 
-enum LayerZeroStatus {
+export enum LayerZeroStatus {
     Pending = "PENDING",
     Success = "SUCCEEDED",
     Failed = "FAILED",
@@ -61,6 +61,167 @@ enum LayerZeroStatus {
     Delivered = "DELIVERED",
 }
 
+// Types for Enso bridge check API response
+export interface BridgeCheckResponse {
+    sourceChainId: number;
+    sourceTxHash: string;
+    status: "pending" | "success" | "failed";
+    layerZeroMessage?: {
+        srcEid: number;
+        dstEid: number;
+        srcChainId: number;
+        dstChainId: number;
+        status: LayerZeroStatus;
+        srcTxHash: string;
+        dstTxHash: string;
+        srcBlockNumber: string;
+        dstBlockNumber: number;
+        sender: string;
+        receiver: string;
+    };
+    destinationChainId?: number;
+    destinationTxHash?: string;
+    ensoSourceEvent?: {
+        accountId: string;
+        requestId: string;
+        blockNumber: number;
+        transactionHash: string;
+        chainId: number;
+        success: boolean;
+    };
+    ensoDestinationEvent?: {
+        blockNumber: number;
+        transactionHash: string;
+        chainId: number;
+        success: boolean;
+        error?: string;
+        refundDetails?: {
+            token: string;
+            amount: string;
+            recipient: string;
+            isNative: boolean;
+        };
+    };
+}
+
+// Hook for bridge status using Enso API (includes destination execution verification)
+export const useBridgeStatus = (
+    hash?: `0x${string}`,
+    chainId?: number,
+    enabled = true,
+) => {
+    const { data, isLoading } = useQuery({
+        queryKey: ["bridgeStatus", hash || "none", chainId],
+        queryFn: async (): Promise<BridgeCheckResponse | null> => {
+            if (!hash || !chainId) return null;
+            const res = await fetch(
+                `https://api.enso.finance/api/v1/layerzero/bridge/check?chainId=${chainId}&txHash=${hash}`,
+            );
+            if (!res.ok) return null;
+            return res.json();
+        },
+        refetchInterval: 3000,
+        enabled: enabled && !!hash && !!chainId,
+    });
+
+    const lzStatus = data?.layerZeroMessage?.status;
+    const overallStatus = data?.status;
+    const destinationSuccess = data?.ensoDestinationEvent?.success;
+    const refundDetails = data?.ensoDestinationEvent?.refundDetails;
+
+    let step = 0;
+    let message = "Waiting for bridge transaction...";
+
+    if (!data) {
+        step = 0;
+        message = "Waiting for bridge transaction...";
+    } else if (lzStatus === LayerZeroStatus.Inflight) {
+        step = 1;
+        message = "Funds in transit to destination...";
+    } else if (lzStatus === LayerZeroStatus.Confirming) {
+        step = 2;
+        message = "Confirming on destination chain...";
+    } else if (lzStatus === LayerZeroStatus.Delivered) {
+        if (overallStatus === "success" || destinationSuccess === true) {
+            step = 4;
+            message = "Bridge completed successfully!";
+        } else if (overallStatus === "failed" || destinationSuccess === false) {
+            step = 4;
+            message = refundDetails
+                ? "Destination execution failed. Funds refunded."
+                : "Destination execution failed.";
+        } else {
+            step = 3;
+            message = "Verifying destination execution...";
+        }
+    } else if (lzStatus === LayerZeroStatus.Failed) {
+        step = 4;
+        message = "Bridge transaction failed.";
+    }
+
+    return {
+        data,
+        isLoading,
+        lzStatus,
+        overallStatus,
+        destinationSuccess,
+        refundDetails,
+        step,
+        message,
+        isComplete: overallStatus === "success",
+        isFailed: overallStatus === "failed" || lzStatus === LayerZeroStatus.Failed,
+        destinationTxHash: data?.destinationTxHash,
+    };
+};
+
+// Legacy hook for LayerZero status polling (kept for backward compatibility)
+export const useLayerZeroStatus = (hash?: `0x${string}`, enabled = true) => {
+    const { data, isLoading } = useQuery({
+        queryKey: ["layerZeroStatus", hash || "none"],
+        queryFn: async () => {
+            if (!hash) return null;
+            return fetch(
+                `https://scan.layerzero-api.com/v1/messages/tx/${hash}`,
+            )
+                .then((res) => res.json())
+                .then((res) => res.data?.[0] ?? null);
+        },
+        refetchInterval: 2000,
+        enabled: enabled && !!hash,
+    });
+
+    const statusName = data?.status?.name as LayerZeroStatus | undefined;
+    const sourceStatus = data?.source?.status as LayerZeroStatus | undefined;
+
+    let step = 0;
+    let message = "Waiting for bridge transaction...";
+
+    if (sourceStatus && sourceStatus !== LayerZeroStatus.Success) {
+        step = 1;
+        message = "Waiting for funds to be sent on destination";
+    } else if (statusName === LayerZeroStatus.Inflight) {
+        step = 2;
+        message = "Waiting for funds to be delivered on destination";
+    } else if (statusName === LayerZeroStatus.Confirming) {
+        step = 3;
+        message = "Waiting for destination execution";
+    } else if (statusName === LayerZeroStatus.Delivered) {
+        step = 4;
+        message = "Bridging is complete";
+    }
+
+    return {
+        data,
+        isLoading,
+        status: statusName,
+        sourceStatus,
+        step,
+        message,
+        isComplete: statusName === LayerZeroStatus.Delivered,
+        isFailed: statusName === LayerZeroStatus.Failed,
+    };
+}
+
 const useLayerZeroUrl = (hash?: `0x${string}`, reset?: () => void) => {
     // const [loadingToastId, setLoadingToastId] = useState<string>();
     const updateTx = useTrackingStore((state) => state.updateTx);