@openocean.finance/widget 1.0.0

package/dist/esm/services/DebridgeService.js

@@ -0,0 +1,693 @@
+import { encodeAbiParameters, parseAbiParameters } from 'viem';
+// Define mapping between chain IDs and Debridge internal chain IDs
+const DEBRIDGE_CHAIN_IDS = {
+    1151111081099710: '7565164', // Solana
+    // Other EVM chain IDs use numeric strings directly
+};
+// Debridge internal uses native token addresses
+const DEBRIDGE_NATIVE_ADDRESS = {
+    evm: '0x0000000000000000000000000000000000000000',
+    solana: '11111111111111111111111111111111', // Debridge specific representation for SOL
+};
+// Actual native token addresses (for isNativeToken check)
+const NATIVE_TOKEN_ADDRESSES = [
+    '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee', // Common EVM Native Placeholder
+    '0x0000000000000000000000000000000000001010', // Polygon Native Placeholder
+    '0x0000000000000000000000000000000000000000', // EVM Zero Address (often used for native)
+    'So11111111111111111111111111111111111111112', // Solana Native Mint Address
+    '', // Empty string might be used in some cases
+].map((addr) => addr.toLowerCase());
+// Contract addresses and configurations
+const CONTRACT_CONFIG = {
+    56: {
+        // BSC
+        debridge: '0x...', // Supplement Debridge contract address
+        ooSwap: '0x22fefa40802E7aD7878FdE48700462e3f920E2C5',
+        bridgeId: { debridge: 22 /* Example ID */ },
+        messageBus: { debridge: '0x...' /* Example */ },
+        middlewareId: { ooSwap: 11 },
+    },
+    250: {
+        // Fantom
+        debridge: '0x...',
+        ooSwap: '0x521a8903B8D4C21b55768aE14f6cA31879B98d5e',
+        bridgeId: { debridge: 22 },
+        messageBus: { debridge: '0x...' },
+        middlewareId: { ooSwap: 5 },
+    },
+    137: {
+        // Polygon
+        debridge: '0x...',
+        ooSwap: '0x22fefa40802E7aD7878FdE48700462e3f920E2C5',
+        bridgeId: { debridge: 22 },
+        messageBus: { debridge: '0x...' },
+        middlewareId: { ooSwap: 7 },
+    },
+    43114: {
+        // Avalanche
+        debridge: '0x...',
+        ooSwap: '0x521a8903B8D4C21b55768aE14f6cA31879B98d5e',
+        bridgeId: { debridge: 22 },
+        messageBus: { debridge: '0x...' },
+        middlewareId: { ooSwap: 7 },
+    },
+    1: {
+        // Ethereum
+        debridge: '0x...',
+        ooSwap: '0xf951a9ea6b8400de7094d4b2b8d2ff2176d7ca81',
+        bridgeId: { debridge: 22 },
+        messageBus: { debridge: '0x...' },
+        middlewareId: { ooSwap: 11 },
+    },
+    42161: {
+        // Arbitrum
+        debridge: '0x65C757C04141a1602705F1F90260FEd66a86d0b8',
+        ooSwap: '0x900822ea09123b5583ef5ca8fd8ca542ea21699a',
+        bridgeId: { debridge: 22 },
+        messageBus: { debridge: '0x...' /* Needs supplement */ },
+        middlewareId: { ooSwap: 6 },
+    },
+    10: {
+        // Optimism
+        debridge: '0x...',
+        ooSwap: '0x521a8903B8D4C21b55768aE14f6cA31879B98d5e',
+        bridgeId: { debridge: 22 },
+        messageBus: { debridge: '0x...' },
+        middlewareId: { ooSwap: 2 },
+    },
+    324: {
+        // zkSync Era
+        debridge: '0x...',
+        ooSwap: '0xB6d35eE980Cde5e706C0866DF0122b076D26C44d',
+        bridgeId: { debridge: 22 },
+        messageBus: { debridge: '0x...' },
+        middlewareId: { ooSwap: 1 },
+    },
+    8453: {
+        // Base
+        debridge: '0x4045734fe21c7B7E0cE516BE009780Cc2BA39A8f',
+        // ooSwap: '...', // Base chain might not have ooSwap
+        bridgeId: { debridge: 3 },
+        messageBus: { debridge: '0x...' /* Needs supplement */ },
+        // middlewareId: {},
+    },
+    7565164: {
+        // Solana (Special handling)
+        debridge: '', // Solana might not need EVM address, but program ID
+        bridgeId: { debridge: -1 /* Placeholder */ },
+        messageBus: {},
+    },
+    // ... Add other chain Debridge configurations
+};
+// Native token information
+const NATIVE_TOKENS = {
+    1: {
+        chainId: 1,
+        symbol: 'ETH',
+        name: 'Ethereum',
+        decimals: 18,
+        address: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+        icon: '//s3.openocean.finance/images/1637894743832_8242841824007741.png',
+    },
+    56: {
+        chainId: 56,
+        address: '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee',
+        name: 'Binance Chain Native Token',
+        symbol: 'BNB',
+        decimals: 18,
+        icon: 'https://s3.openocean.finance/token_logos/logos/bsc/0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee.png',
+    },
+    137: {
+        chainId: 137,
+        address: '0x0000000000000000000000000000000000001010',
+        icon: 'https://s3.openocean.finance/images/1637561049975_1903381661429342.png',
+        name: 'Matic',
+        symbol: 'MATIC',
+        decimals: 18,
+    },
+    43114: {
+        chainId: 43114,
+        address: '0x0000000000000000000000000000000000000000',
+        name: 'Avalanche',
+        symbol: 'AVAX',
+        icon: 'https://ethapi.openocean.finance/logos/avax/0x0000000000000000000000000000000000000000.png',
+        decimals: 18,
+    },
+    250: {
+        chainId: 250,
+        address: '0x0000000000000000000000000000000000000000',
+        name: 'Fantom',
+        symbol: 'FTM',
+        decimals: 18,
+        icon: 'https://ethapi.openocean.finance/logos/fantom/0x0000000000000000000000000000000000000000.png',
+    },
+    42161: {
+        name: 'ETH',
+        address: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+        decimals: 18,
+        symbol: 'ETH',
+        icon: 'https://s3.openocean.finance/images/1660286550539_3465620840567112.png',
+        chainId: 42161,
+    },
+    10: {
+        name: 'Etherum',
+        address: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+        decimals: 18,
+        symbol: 'ETH',
+        icon: 'https://s3.openocean.finance/images/1661137422943_3757149396730206.png',
+        chainId: 10,
+    },
+    324: {
+        chainId: 324,
+        name: 'Ethereum',
+        address: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+        decimals: 18,
+        symbol: 'ETH',
+        icon: 'https://s3.openocean.finance/token_logos/logos/1678448299500_8777733284012612.png',
+    },
+    8453: {
+        chainId: 8453,
+        name: 'Ethereum',
+        address: '0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE',
+        decimals: 18,
+        symbol: 'ETH',
+        icon: 'https://s3.openocean.finance/token_logos/logos/1704872214606_042688653920736286.png',
+    },
+    7565164: {
+        chainId: 7565164,
+        name: 'SOL',
+        address: 'So11111111111111111111111111111111111111112',
+        decimals: 9,
+        symbol: 'SOL',
+        icon: 'https://s3.openocean.finance/token_logos/logos/solana/So11111111111111111111111111111111111111112.png',
+    },
+};
+export class DebridgeService {
+    /**
+     * Map Debridge status code to internal unified status code
+     * @param status Debridge return status string or number
+     * @returns Internal status code ('2': failure, '3': pending, '5': success) or '2' (unknown/failure)
+     */
+    static mapStatus(status) {
+        const mapped = DebridgeService.STATUS_MAP[status] ||
+            DebridgeService.STATUS_MAP[String(status).toLowerCase()];
+        console.log(`Mapping status: ${status} -> ${mapped || '2 (default)'}`);
+        return mapped || '2'; // Default to failure if unknown
+    }
+    /**
+     * Check if address is native token address
+     * @param tokenAddress Token address
+     * @returns Whether it's a native token
+     */
+    static isNativeToken(tokenAddress) {
+        return NATIVE_TOKEN_ADDRESSES.includes(tokenAddress.toLowerCase());
+    }
+    /**
+     * Get native token information for specified chain
+     * @param chainId Chain ID
+     * @returns Native token Asset object or undefined
+     */
+    static getNativeTokenInfo(chainId) {
+        return NATIVE_TOKENS[chainId];
+    }
+    /**
+     * Get contract configuration information for specified chain and contract type
+     * @param chainId Chain ID
+     * @param contractType Contract type ('debridge', 'ooSwap', 'bridgeId', 'messageBus', 'middlewareId')
+     * @param subType Optional, for getting specific values under 'bridgeId', 'messageBus', 'middlewareId'
+     * @returns Configuration value or undefined
+     */
+    static getContractConfig(chainId, contractType, subType) {
+        const chainConfig = CONTRACT_CONFIG[chainId];
+        if (!chainConfig) {
+            console.warn(`No contract config found for chainId: ${chainId}`);
+            return undefined;
+        }
+        const typeConfig = chainConfig[contractType];
+        if (subType) {
+            return typeConfig ? typeConfig[subType] : undefined;
+        }
+        return typeConfig;
+    }
+    /**
+     * Get Debridge internal chain ID
+     * @param chainId Original chain ID
+     * @returns Debridge chain ID string
+     */
+    static getDebridgeChainId(chainId) {
+        return DEBRIDGE_CHAIN_IDS[chainId] || chainId.toString();
+    }
+    /**
+     * Get Debridge token address for specified asset
+     * @param asset Token Asset object
+     * @returns Debridge token address string
+     */
+    static getDebridgeTokenAddress(asset) {
+        if (asset.chain === 'solana') {
+            return asset.address === NATIVE_TOKENS[7565164]?.address // 'So11111111111111111111111111111111111111112'
+                ? DEBRIDGE_NATIVE_ADDRESS.solana // '11111111111111111111111111111111'
+                : asset.address;
+        }
+        else {
+            // EVM
+            return DebridgeService.isNativeToken(asset.address)
+                ? DEBRIDGE_NATIVE_ADDRESS.evm // '0x0000000000000000000000000000000000000000'
+                : asset.address;
+        }
+    }
+    // Debridge directly get cross amount API not found, return original input value
+    static async getCrossAmount(params) {
+        console.log('Debridge getCrossAmount called with:', params);
+        // Debridge quote or order/create-tx API returns estimated output, but here needs independent API
+        // Temporary unable to directly get, return input value as placeholder
+        return { crossOutAmount: params.amt };
+    }
+    // Debridge get minSend direct API not found, return 0
+    static async minSend(params) {
+        console.log('Debridge minSend called with:', params);
+        // Debridge documentation seems not have separate minSend API
+        // Minimum value usually implicit in /quote or /order/create-tx response or error
+        return 0; // Return 0 as placeholder
+    }
+    /**
+     * Query Debridge cross-chain transaction status
+     * @param params Contains requestId
+     * @returns Transaction status and destination chain hash
+     */
+    static async getCrossStatus(params) {
+        const { requestId } = params;
+        const url = new URL(`${DebridgeService.DEBRIDGE_API_URL}/intents/status/v2`);
+        url.searchParams.append('requestId', requestId);
+        try {
+            const response = await fetch(url.toString());
+            const data = await response.json(); // Try parsing JSON even for errors
+            console.log('Debridge getCrossStatus response:', data);
+            if (!response.ok) {
+                const error = new Error(`HTTP error! status: ${response.status}`);
+                error.response = { status: response.status, data: data };
+                throw error;
+            }
+            const { status, txHashes, error: apiError } = data || {};
+            let internalStatus = '2'; // Default to failure
+            if (apiError) {
+                console.error('Debridge status API returned error:', apiError);
+                internalStatus = '2';
+            }
+            else if (status) {
+                internalStatus = DebridgeService.mapStatus(status);
+            }
+            const destHash = txHashes && txHashes.length > 0 ? txHashes[0] : undefined;
+            return {
+                code: 200, // response.status should be 200 here
+                data: { status: internalStatus, destHash: destHash },
+            };
+        }
+        catch (error) {
+            // Handles fetch network errors or errors thrown from !response.ok
+            console.error(`Error fetching Debridge status for ${requestId}:`, error.response?.data || error.message);
+            const errorStatus = error.response?.data?.status;
+            const internalStatus = errorStatus
+                ? DebridgeService.mapStatus(errorStatus)
+                : '2';
+            const code = error.response?.status || 500;
+            return {
+                code: code === 404 ? 404 : 500,
+                data: { status: internalStatus },
+            };
+        }
+    }
+    /**
+     * Get Debridge cross-chain quote (Swap U Then Cross)
+     * @param params Contains source/target information, amount, slippage, etc.
+     * @returns Contains object with fields needed to build Route or null (failure)
+     */
+    static async swapUThenCross(params) {
+        // Return type needs more specific definition
+        const { fromMsg, toMsg, inAmount, slippage_tolerance, account, receiver } = params;
+        const debridgeSrcChainId = DebridgeService.getDebridgeChainId(fromMsg.chainId);
+        const debridgeDstChainId = DebridgeService.getDebridgeChainId(toMsg.chainId);
+        const debridgeSrcToken = DebridgeService.getDebridgeTokenAddress(fromMsg);
+        const debridgeDstToken = DebridgeService.getDebridgeTokenAddress(toMsg);
+        const queryParams = account && receiver
+            ? {
+                srcChainId: debridgeSrcChainId,
+                srcChainTokenIn: debridgeSrcToken,
+                srcChainTokenInAmount: inAmount,
+                dstChainId: debridgeDstChainId,
+                dstChainTokenOut: debridgeDstToken,
+                dstChainTokenOutRecipient: receiver || account,
+                senderAddress: account,
+                referralCode: DebridgeService.REFERRAL_CODE.toString(), // Ensure referralCode is string
+                srcChainRefundAddress: account,
+                srcChainOrderAuthorityAddress: account,
+                dstChainOrderAuthorityAddress: receiver || account,
+                enableEstimate: false,
+                prependOperatingExpenses: true,
+                additionalTakerRewardBps: 0,
+                allowedTaker: debridgeDstChainId === '7565164'
+                    ? '2snHHreXbpJ7UwZxPe37gnUNf7Wx7wv6UKDSR2JckKuS'
+                    : '0x555CE236C0220695b68341bc48C68d52210cC35b',
+                deBridgeApp: 'DESWAP',
+                ptp: false,
+                tab: new Date().getTime(),
+            }
+            : {
+                srcChainId: debridgeSrcChainId,
+                srcChainTokenIn: debridgeSrcToken,
+                srcChainTokenInAmount: inAmount,
+                dstChainTokenOutAmount: 'auto',
+                dstChainId: debridgeDstChainId,
+                dstChainTokenOut: debridgeDstToken,
+                referralCode: DebridgeService.REFERRAL_CODE.toString(), // Ensure referralCode is string
+                prependOperatingExpenses: true,
+                additionalTakerRewardBps: 0,
+                tab: new Date().getTime(),
+            };
+        const url = new URL(`${DebridgeService.DEBRIDGE_QUOTE_URL}/dln/order/create-tx`);
+        Object.entries(queryParams).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                url.searchParams.append(key, value.toString());
+            }
+        });
+        try {
+            console.log('Calling Debridge create-tx with url:', url.toString());
+            const response = await fetch(url.toString());
+            const quoteData = await response.json();
+            console.log('Debridge create-tx response:', quoteData);
+            if (!response.ok) {
+                const error = new Error(`HTTP error! status: ${response.status}`);
+                error.response = { status: response.status, data: quoteData };
+                throw error;
+            }
+            if (!quoteData || !quoteData.estimation || !quoteData.tx) {
+                console.error('Invalid response from Debridge create-tx API', quoteData);
+                return null;
+            }
+            const { estimation, tx, orderId, fixFee, prependedOperatingExpenseCost } = quoteData;
+            const { srcChainTokenIn, dstChainTokenOut, approximateFulfillmentDelay } = estimation;
+            // Calculate minOutAmount based on slippage
+            const outAmount = dstChainTokenOut?.amount;
+            const slippagePercent = Number.parseFloat(slippage_tolerance.toString()) / 100;
+            const minOutAmount = outAmount
+                ? ((BigInt(outAmount) *
+                    BigInt(Math.floor((1 - slippagePercent) * 10000))) /
+                    BigInt(10000)).toString()
+                : '0';
+            // Determine fee token (native token of source chain)
+            const feeTokenInfo = DebridgeService.getNativeTokenInfo(fromMsg.chainId);
+            // Use fixFee if available, otherwise default to '0'
+            const feeAmount = fixFee || '0';
+            let finalFeeToken = feeTokenInfo;
+            if (finalFeeToken) {
+                // Apply address transformation rules
+                let address = finalFeeToken.address.toLowerCase();
+                const chainId = finalFeeToken.chainId;
+                if (chainId === 1151111081099710 &&
+                    address === 'so11111111111111111111111111111111111111112') {
+                    address = '11111111111111111111111111111111'; // Debridge Solana native representation
+                }
+                else if (address === '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee') {
+                    address = '0x0000000000000000000000000000000000000000'; // Zero address representation
+                }
+                // Create a new object with the potentially modified address
+                finalFeeToken = { ...finalFeeToken, address: address };
+            }
+            // Specific address for Solana, Debridge contract address for other chains
+            const to = fromMsg.chainId === 1151111081099710
+                ? 'src5qyZHqTqecJV4aY6Cb6zDZLMDzrDKKezs22MPHr4'
+                : tx.to;
+            return {
+                prependedOperatingExpenseCost,
+                isDebridgeRoute: true, // Flag to identify the route source
+                orderId: orderId,
+                fromTokenUSD: srcChainTokenIn?.approximateUsdValue?.toString() || '0',
+                toTokenUSD: dstChainTokenOut?.approximateUsdValue?.toString() || '0',
+                outAmount: outAmount || '0',
+                minOutAmount: minOutAmount,
+                // Transaction details directly from tx object
+                transaction: tx.data,
+                to,
+                value: tx.value || feeAmount || '0', // Value (often native token fee for Debridge)
+                // Chain info
+                chainId: fromMsg.chainId, // Source chain for the transaction
+                from: account, // User's account initiates the transaction
+                // Estimate details
+                approveContract: to, // Approval needed for the Debridge contract
+                // executionDuration: approximateFulfillmentDelay ? approximateFulfillmentDelay * 1000 : 300000, // Convert seconds to ms? Needs verification. Defaulting to 5min.
+                executionDuration: 300000, // Hardcoding 5min for now, Debridge delay unit unclear.
+                // Fee details
+                feeCosts: finalFeeToken
+                    ? [
+                        {
+                            name: 'Debridge Fee',
+                            description: 'Protocol fee charged by Debridge',
+                            token: finalFeeToken,
+                            amount: feeAmount,
+                            amountUSD: '0', // USD value of fee not directly available
+                            percentage: '0', // Percentage calculation complex
+                            included: false, // Assume fee is paid separately or via tx.value
+                        },
+                    ]
+                    : [],
+                // Include potential operating expense as another fee?
+                // const operatingExpense = estimation?.srcChainTokenIn?.approximateOperatingExpense;
+                // if (feeToken && operatingExpense && operatingExpense !== '0') {
+                //    feeCosts.push({ ... })
+                // }
+                estimatedGas: feeAmount, // Using Debridge fixFee as a placeholder for estimated gas display
+                // Other potential fields needed by useRoutes that might be missing:
+                // gasPrice: tx.gasPrice, // Not directly available in Debridge response
+                // dexId: // Not applicable for Debridge
+            };
+        }
+        catch (error) {
+            console.error('Error getting Debridge quote:', error.response?.data || error.message);
+            return null;
+        }
+    }
+    /**
+     * Build Debridge EVM cross-chain transaction data (Completed in swapUThenCross)
+     * @param params Contains account, route, receiver, etc.
+     * @returns Returns transactionRequest data from swapUThenCross
+     */
+    static async buildBridgeData(params) {
+        // Return type needs more specific definition
+        const { route, account, receiver } = params; // toMiddlewareRoute, swapResult in Debridge dLN mode seems not needed
+        console.log('Debridge buildBridgeData called with:', params);
+        // Debridge dLN transaction data in swapUThenCross already obtained via /dln/order/create-tx
+        if (route && route.bridgeRoute && route.bridgeRoute.transactionRequest) {
+            const { transactionRequest, bridgeId, fees } = route.bridgeRoute;
+            const { fixFee } = fees?.middlewareFee || {}; // Get previous calculated fee
+            const bridgeRouteFromAddress = DebridgeService.getDebridgeTokenAddress(route.bridgeRoute.fromAsset);
+            // Debridge dLN tx object returned by `create-tx` contains `to`, `data`, `value`
+            // We need to encode it for passing to OpenOcean aggregation contract (if applicable)
+            // Format: [bridgeId, feeAmount, bridgeTokenAddress, encodedBridgeData]
+            // encodedBridgeData: abi.encode(['address', 'bytes'], [tx.to, tx.data])
+            // Check if transactionRequest is valid
+            if (!transactionRequest ||
+                !transactionRequest.to ||
+                !transactionRequest.data) {
+                console.error('Invalid transactionRequest in route for buildBridgeData');
+                return null;
+            }
+            try {
+                // Use viem to encode Debridge target address and data ABI
+                const abiParams = parseAbiParameters('address to, bytes data');
+                const sendData = encodeAbiParameters(abiParams, [
+                    transactionRequest.to,
+                    transactionRequest.data,
+                ]);
+                // Return array format expected by aggregation contract
+                // Note: Here feeAmount should be Debridge fee (fixFee), need to pay with native token
+                // If input token is native token, this fee will be included in msg.value;
+                // If input token is ERC20, this fee needs additional handling (possibly needs aggregation contract support?)
+                // OpenOcean aggregation contract might need explicit fee parameter. Here assuming fixFee.
+                const feeAmount = fixFee || '0'; // Use fee from quote
+                console.log('Encoded sendData for Debridge:', sendData);
+                console.log('Params for Aggregator:', [
+                    bridgeId,
+                    feeAmount,
+                    bridgeRouteFromAddress,
+                    sendData,
+                ]);
+                // Return final built data, this data will be sent to OpenOcean aggregator contract
+                return [bridgeId, feeAmount, bridgeRouteFromAddress, sendData];
+            }
+            catch (encodeError) {
+                console.error('Error encoding Debridge transaction data:', encodeError);
+                return null;
+            }
+        }
+        else {
+            console.error('Missing route or transactionRequest in buildBridgeData for Debridge');
+            // If no transactionRequest, try to refetch create-tx API to get
+            // This needs to extract necessary information from route
+            if (route?.bridgeRoute) {
+                const { fromAsset, toAsset, inputAmount } = route.bridgeRoute;
+                if (fromAsset && toAsset && inputAmount && account && receiver) {
+                    console.log('Attempting to refetch Debridge transaction data...');
+                    const quoteResult = await DebridgeService.swapUThenCross({
+                        fromMsg: fromAsset,
+                        toMsg: toAsset,
+                        inAmount: inputAmount,
+                        slippage_tolerance: '1', // Default slippage or get from route?
+                        account: account,
+                        receiver: receiver,
+                    });
+                    if (quoteResult?.bridgeRoute?.transactionRequest) {
+                        const { transactionRequest, bridgeId } = quoteResult.bridgeRoute;
+                        const fixFee = quoteResult.fees?.middlewareFee?.amount || '0';
+                        const bridgeRouteFromAddress = DebridgeService.getDebridgeTokenAddress(fromAsset);
+                        try {
+                            const abiParams = parseAbiParameters('address to, bytes data');
+                            const sendData = encodeAbiParameters(abiParams, [
+                                transactionRequest.to,
+                                transactionRequest.data,
+                            ]);
+                            console.log('Re-encoded sendData for Debridge:', sendData);
+                            console.log('Params for Aggregator (refetched):', [
+                                bridgeId,
+                                fixFee,
+                                bridgeRouteFromAddress,
+                                sendData,
+                            ]);
+                            return [bridgeId, fixFee, bridgeRouteFromAddress, sendData];
+                        }
+                        catch (encodeError) {
+                            console.error('Error encoding refetched Debridge transaction data:', encodeError);
+                            return null;
+                        }
+                    }
+                    else {
+                        console.error('Failed to refetch Debridge transaction data.');
+                        return null;
+                    }
+                }
+            }
+            return null; // Return null indicating build failure
+        }
+    }
+    /**
+     * Build Debridge transaction data from Solana to EVM
+     * @param params Contains account, route, receiver
+     * @returns Solana transaction object { code, data: { from, to, data, value } } or null
+     */
+    static async buildSolanaBridgeData(params) {
+        const { account, route, receiver } = params;
+        const { bridgeRoute } = route || {};
+        const { fromAsset, toAsset, inputAmount, toChainId } = bridgeRoute || {};
+        if (!fromAsset ||
+            !toAsset ||
+            !inputAmount ||
+            !toChainId ||
+            fromAsset.chainId !== 7565164) {
+            console.error('Invalid params for buildSolanaBridgeData', params);
+            return null;
+        }
+        const debridgeSrcChainId = DebridgeService.getDebridgeChainId(fromAsset.chainId); // Should be '7565164'
+        const debridgeDstChainId = DebridgeService.getDebridgeChainId(toChainId);
+        const debridgeSrcToken = DebridgeService.getDebridgeTokenAddress(fromAsset); // Handles native SOL mapping
+        const debridgeDstToken = DebridgeService.getDebridgeTokenAddress(toAsset); // Handles native EVM mapping
+        const queryParams = {
+            srcChainId: debridgeSrcChainId,
+            srcChainTokenIn: debridgeSrcToken,
+            srcChainTokenInAmount: inputAmount,
+            dstChainId: debridgeDstChainId,
+            dstChainTokenOut: debridgeDstToken,
+            senderAddress: account,
+            srcChainOrderAuthorityAddress: account,
+            dstChainTokenOutRecipient: receiver,
+            srcChainRefundAddress: account,
+            dstChainOrderAuthorityAddress: receiver,
+            referralCode: DebridgeService.REFERRAL_CODE.toString(), // Ensure referralCode is string
+        };
+        const url = new URL(`${DebridgeService.DEBRIDGE_QUOTE_URL}/dln/order/create-tx`);
+        Object.entries(queryParams).forEach(([key, value]) => {
+            if (value !== undefined && value !== null) {
+                url.searchParams.append(key, value.toString());
+            }
+        });
+        try {
+            console.log('Calling Debridge create-tx for Solana with url:', url.toString());
+            const response = await fetch(url.toString());
+            const data = await response.json();
+            console.log('Debridge create-tx (Solana) response:', data);
+            if (!response.ok) {
+                const error = new Error(`HTTP error! status: ${response.status}`);
+                error.response = { status: response.status, data: data };
+                throw error;
+            }
+            if (!data?.tx) {
+                console.error('Invalid response from Debridge create-tx API for Solana', data);
+                return null;
+            }
+            const { tx, fixFee } = data;
+            let valueToSend = tx.value || '0';
+            if (DebridgeService.isNativeToken(fromAsset.address) &&
+                (!tx.value || tx.value === '0') &&
+                fixFee) {
+                try {
+                    // Use BigInt for large number addition
+                    const totalValue = (BigInt(inputAmount) + BigInt(fixFee)).toString();
+                    valueToSend = totalValue;
+                    console.warn(`tx.value was missing for native SOL, calculating value as inputAmount + fixFee: ${inputAmount} + ${fixFee} = ${valueToSend}`);
+                }
+                catch (mathError) {
+                    console.error('Error calculating total value for Solana native send:', mathError);
+                    valueToSend = tx.value || '0';
+                }
+            }
+            else if (!DebridgeService.isNativeToken(fromAsset.address) &&
+                fixFee &&
+                fixFee !== '0') {
+                console.warn(`Sending SPL token but fixFee (${fixFee}) exists. This fee might need separate handling in SOL.`);
+            }
+            return {
+                code: 200, // response.status should be 200 here
+                data: {
+                    from: account,
+                    to: tx.to,
+                    data: tx.data,
+                    value: valueToSend,
+                },
+            };
+        }
+        catch (error) {
+            console.error('Error fetching Debridge Solana transaction:', error.response?.data || error.message);
+            return null;
+        }
+    }
+}
+DebridgeService.DEBRIDGE_API_URL = 'https://api.debridge.finance'; // Correct API URL
+DebridgeService.DEBRIDGE_QUOTE_URL = 'https://deswap.debridge.finance/v1.0';
+DebridgeService.REFERRAL_CODE = 31824;
+// Map STATUS to internal unified status code
+DebridgeService.STATUS_MAP = {
+    10: '5', // success (Debridge internal)
+    14: '2', // failure (Debridge internal)
+    8: '3', // comfir (Debridge internal)
+    DELIVERED: '5',
+    FAILED: '2',
+    INFLIGHT: '3', // Pending/In progress
+    EXECUTED: '5', // Likely success
+    CANCELLED: '2', // Failure
+    PENDING: '3', // Pending
+    ERROR: '2', // Failure
+    // dLN/deswap statuses
+    Created: '3', // Pending
+    Fulfilled: '5', // Success
+    SentUnlock: '3', // In progress
+    ClaimedUnlock: '5', // Success (final step for receiver)
+    // Common statuses from original code (might need adjustments)
+    Success: '5',
+    Pending: '3',
+    Stucked: '3', // Consider mapping to '3' (Pending) or '2' (Failure)
+    Reverted: '2',
+    'Not found': '2',
+    destination_executed: '5',
+    error: '2',
+    source_gateway_called: '3', // In progress
+    2: '5', // ccip success? Needs verification
+    success: '5',
+};
+//# sourceMappingURL=DebridgeService.js.map