@ensofinance/checkout-widget 0.0.16 → 0.0.18

package/src/enso-api/model/walletControllerCreateApproveTransactionRoutingStrategy.ts

@@ -5,7 +5,7 @@
 - Find detailed documentation on [docs.enso.finance](https://docs.enso.finance).
 - To use the API, **you must include your API Key in the Authorization header** (Bearer format).
 - For testing, Swagger pre-authorizes you using the key: `1e02632d-6feb-4a75-a157-documentation` (1rps).
-- Get your own API Key at [enso.finance/developers](https://enso.finance/developers).
+- Get your own API Key at [enso.finance/developers](https://developers.enso.build/).
  * OpenAPI spec version: 1.0
  */
 
@@ -15,7 +15,7 @@ export type WalletControllerCreateApproveTransactionRoutingStrategy =
 
 // eslint-disable-next-line @typescript-eslint/no-redeclare
 export const WalletControllerCreateApproveTransactionRoutingStrategy = {
-    ensowallet: "ensowallet",
+    "ensowallet-v2": "ensowallet-v2",
     router: "router",
     delegate: "delegate",
     "router-legacy": "router-legacy",

package/src/enso-api/model/walletControllerWalletBalancesParams.ts

@@ -5,7 +5,7 @@
 - Find detailed documentation on [docs.enso.finance](https://docs.enso.finance).
 - To use the API, **you must include your API Key in the Authorization header** (Bearer format).
 - For testing, Swagger pre-authorizes you using the key: `1e02632d-6feb-4a75-a157-documentation` (1rps).
-- Get your own API Key at [enso.finance/developers](https://enso.finance/developers).
+- Get your own API Key at [enso.finance/developers](https://developers.enso.build/).
  * OpenAPI spec version: 1.0
  */
 
@@ -15,11 +15,11 @@ export type WalletControllerWalletBalancesParams = {
      */
     chainId: number;
     /**
-     * Address of the eoa with which to associate the ensoWallet for balances
+     * Address of the eoa with which to associate the ensoWallet-v2 for balances
      */
     eoaAddress?: string;
     /**
-     * If true returns balances for the provided address, instead of the associated ensoWallet
+     * If true returns balances for the provided address, instead of the associated ensoWallet-v2
      */
-    useEoa?: boolean;
+    useEoa: boolean;
 };

package/src/index.ts

@@ -18,3 +18,6 @@ export {
 // Export theme type for TypeScript users
 export type { WidgetTheme } from "./types";
 export { SupportedExchanges } from "./types";
+
+// Export default CEX bridge chain mapping for users to extend
+export { DEFAULT_CEX_BRIDGE_CHAIN_MAPPING } from "./util/constants";

package/src/types/index.ts

@@ -14,6 +14,8 @@ export type CheckoutConfig = {
     apiKey: string;
     theme?: WidgetTheme;
     enableExchange?: SupportedExchanges[];
+    /** Override the default CEX bridge chain mapping (maps target chains to intermediate chains for withdrawal + bridge) */
+    cexBridgeChainMapping?: Record<number, number>;
 };
 
 export type CheckoutModalProps = {

package/src/util/constants.tsx

@@ -191,6 +191,25 @@ export const CHAINS_NATIVE_TOKENS: Record<SupportedChainId, Token> = {
     [SupportedChainId.KATANA]: ETH_TOKEN,
 };
 
+// CEX Bridge Chain Mapping
+// Maps target chains not directly supported by CEXs to intermediate chains for withdrawal + bridge
+export const DEFAULT_CEX_BRIDGE_CHAIN_MAPPING: Record<number, number> = {
+    [SupportedChainId.HYPERLIQUID]: SupportedChainId.ARBITRUM_ONE, // 999 → 42161
+};
+
+/** @deprecated Use the context-aware version with custom mapping parameter */
+export const CEX_BRIDGE_CHAIN_MAPPING = DEFAULT_CEX_BRIDGE_CHAIN_MAPPING;
+
+export const isCexBridgeRequired = (
+    chainId: number,
+    mapping: Record<number, number> = DEFAULT_CEX_BRIDGE_CHAIN_MAPPING,
+): boolean => chainId in mapping;
+
+export const getCexIntermediateChain = (
+    chainId: number,
+    mapping: Record<number, number> = DEFAULT_CEX_BRIDGE_CHAIN_MAPPING,
+): number | null => mapping[chainId] ?? null;
+
 export const CHAINS_ETHERSCAN: Record<SupportedChainId, string> = {
     [SupportedChainId.OPTIMISM]: "https://optimistic.etherscan.io",
     [SupportedChainId.MAINNET]: "https://etherscan.io",

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);