@recoillink/cli 0.0.0-stage → 45.0.1

package/bundle/230.index.js

@@ -0,0 +1,569 @@
+export const id = 230;
+export const ids = [230];
+export const modules = {
+
+/***/ 65230:
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   LiFiBridge: () => (/* binding */ LiFiBridge)
+/* harmony export */ });
+/* harmony import */ var _lifi_sdk__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(38972);
+/* harmony import */ var _lifi_sdk__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(88943);
+/* harmony import */ var _lifi_sdk__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(91170);
+/* harmony import */ var _lifi_sdk__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(16950);
+/* harmony import */ var _lifi_sdk__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(89302);
+/* harmony import */ var _lifi_sdk__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(68648);
+/* harmony import */ var _lifi_sdk__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(83793);
+/* harmony import */ var _lifi_sdk__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(38706);
+/* harmony import */ var bs58__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(64537);
+/* harmony import */ var _recoillink_utils__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(16639);
+/* harmony import */ var _recoillink_utils__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(93142);
+/* harmony import */ var _recoillink_utils__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(21387);
+/* harmony import */ var viem__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(27503);
+/* harmony import */ var viem__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(20458);
+/* harmony import */ var viem_accounts__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(67227);
+/* harmony import */ var viem_chains__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(55516);
+/* harmony import */ var viem_chains__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(86296);
+/* harmony import */ var viem_chains__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(70763);
+/* harmony import */ var viem_chains__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(35540);
+/* harmony import */ var _utils_solanaKeyParser_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(97781);
+
+
+
+
+
+
+
+/**
+ * LiFi API base URL for REST endpoints.
+ * The SDK doesn't support toAmount quotes, so we use REST API directly.
+ */
+const LIFI_API_BASE = 'https://li.quest/v1';
+/**
+ * Known chains for viem - add more as needed.
+ * TODO: can we think of a cleaner way to do this?
+ */
+const VIEM_CHAINS = {
+    [viem_chains__WEBPACK_IMPORTED_MODULE_2__/* .mainnet */ .r.id]: viem_chains__WEBPACK_IMPORTED_MODULE_2__/* .mainnet */ .r,
+    [viem_chains__WEBPACK_IMPORTED_MODULE_3__/* .arbitrum */ .D.id]: viem_chains__WEBPACK_IMPORTED_MODULE_3__/* .arbitrum */ .D,
+    [viem_chains__WEBPACK_IMPORTED_MODULE_4__/* .base */ .E.id]: viem_chains__WEBPACK_IMPORTED_MODULE_4__/* .base */ .E,
+    [viem_chains__WEBPACK_IMPORTED_MODULE_5__/* .optimism */ .R.id]: viem_chains__WEBPACK_IMPORTED_MODULE_5__/* .optimism */ .R,
+};
+/**
+ * Mapping from Hyperlane domain IDs to LiFi chain IDs for non-EVM chains.
+ * EVM chains use their native chain ID which is the same in both systems.
+ * Non-EVM chains (e.g., Solana) have different identifiers in each system.
+ *
+ * @see https://docs.li.fi/introduction/lifi-architecture/solana-overview
+ */
+const HYPERLANE_TO_LIFI_CHAIN_IDS = {
+    1399811149: 1151111081099710, // Solana: Hyperlane domain → LiFi chain ID
+};
+/**
+ * Get viem chain config by chain ID.
+ * Falls back to a minimal chain config if not found.
+ */
+function getViemChain(chainId, rpcUrl) {
+    const chain = VIEM_CHAINS[chainId];
+    if (chain) {
+        if (rpcUrl) {
+            return { ...chain, rpcUrls: { default: { http: [rpcUrl] } } };
+        }
+        return chain;
+    }
+    // Fallback for chains not in our registry
+    return {
+        id: chainId,
+        name: `Chain ${chainId}`,
+        nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+        rpcUrls: {
+            default: { http: rpcUrl ? [rpcUrl] : [] },
+        },
+    };
+}
+function toBase58SolanaKey(rawKey) {
+    const trimmedKey = rawKey.trim();
+    if (!trimmedKey.startsWith('[') && !trimmedKey.includes(',')) {
+        try {
+            const decoded = bs58__WEBPACK_IMPORTED_MODULE_0__["default"].decode(trimmedKey);
+            if (decoded.length === 64) {
+                return trimmedKey;
+            }
+        }
+        catch {
+            // Not valid base58, continue to parse as byte array
+        }
+    }
+    const bytes = (0,_utils_solanaKeyParser_js__WEBPACK_IMPORTED_MODULE_1__/* .parseSolanaPrivateKey */ .E)(trimmedKey);
+    return bs58__WEBPACK_IMPORTED_MODULE_0__["default"].encode(bytes);
+}
+/**
+ * LiFi implementation of IExternalBridge using the official @lifi/sdk.
+ *
+ * The SDK provides:
+ * - Automatic token approvals via executeRoute()
+ * - Multi-step route handling (swap → bridge → swap)
+ * - Built-in status tracking via getStatus()
+ * - Native support for EVM, Solana, and other chains
+ *
+ * @see https://docs.li.fi/integrate-li.fi-sdk
+ */
+class LiFiBridge {
+    static NATIVE_TOKEN_ADDRESS = '0x0000000000000000000000000000000000000000';
+    externalBridgeId = 'lifi';
+    /**
+     * Convert a Hyperlane domain ID to a LiFi-compatible chain ID.
+     * For EVM chains, these are identical (e.g., Arbitrum = 42161 in both).
+     * For non-EVM chains like Solana, LiFi uses different chain identifiers.
+     */
+    static toLiFiChainId(chainId) {
+        return HYPERLANE_TO_LIFI_CHAIN_IDS[chainId] ?? chainId;
+    }
+    logger;
+    initialized = false;
+    _executeLock = Promise.resolve();
+    config;
+    chainMetadataByChainId;
+    constructor(config, logger) {
+        this.config = config;
+        this.logger = logger;
+        // Build LiFi chainId -> metadata map for O(1) lookups.
+        // Numeric chainIds are only unique for EVM chains; non-EVM chains can
+        // legitimately collide (e.g. radix and ethereum both use 1), so index
+        // non-EVM chains only through explicit Hyperlane-domain -> LiFi mappings.
+        this.chainMetadataByChainId = new Map();
+        if (config.chainMetadata) {
+            const metadataByDomainId = new Map();
+            for (const metadata of Object.values(config.chainMetadata)) {
+                metadataByDomainId.set(metadata.domainId, metadata);
+                if (metadata.chainId !== undefined && (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_6__/* .isEVMLike */ .Us)(metadata.protocol)) {
+                    this.chainMetadataByChainId.set(Number(metadata.chainId), metadata);
+                }
+            }
+            // Also key by LiFi chain IDs so both Hyperlane domains and LiFi IDs
+            // resolve to the same metadata for non-EVM chains like Solana.
+            for (const [hyperlaneDomainId, lifiChainId] of Object.entries(HYPERLANE_TO_LIFI_CHAIN_IDS)) {
+                const metadata = metadataByDomainId.get(Number(hyperlaneDomainId));
+                if (metadata !== undefined) {
+                    this.chainMetadataByChainId.set(Number(lifiChainId), metadata);
+                }
+            }
+        }
+    }
+    getNativeTokenAddress() {
+        return LiFiBridge.NATIVE_TOKEN_ADDRESS;
+    }
+    initialize() {
+        if (this.initialized)
+            return;
+        (0,_lifi_sdk__WEBPACK_IMPORTED_MODULE_7__/* .createConfig */ .Z)({
+            integrator: this.config.integrator,
+            apiKey: this.config.apiKey,
+        });
+        this.initialized = true;
+        this.logger.info({ integrator: this.config.integrator }, 'LiFi SDK initialized');
+    }
+    /**
+     * Resolve RPC URL for a given EVM chainId from chain metadata.
+     * Iterates metadata to find matching chainId and returns first HTTP RPC URL.
+     */
+    getRpcUrlForChainId(chainId) {
+        return this.getMetadataForChainId(chainId)?.rpcUrls?.[0]?.http;
+    }
+    getProtocolTypeForChainId(chainId) {
+        return this.getMetadataForChainId(chainId)?.protocol;
+    }
+    getMetadataForChainId(chainId) {
+        const directMetadata = this.chainMetadataByChainId.get(chainId);
+        if (directMetadata) {
+            return directMetadata;
+        }
+        const matches = Object.values(this.config.chainMetadata ?? {}).filter((metadata) => metadata.chainId !== undefined && Number(metadata.chainId) === chainId);
+        return matches.length === 1 ? matches[0] : undefined;
+    }
+    addressesEqual(a, b, chainId) {
+        const protocol = this.getProtocolTypeForChainId(chainId);
+        // Sealevel uses base58 addresses where case is significant.
+        if (protocol === _recoillink_utils__WEBPACK_IMPORTED_MODULE_6__/* .ProtocolType */ .Hb.Sealevel) {
+            return a === b;
+        }
+        return a.toLowerCase() === b.toLowerCase();
+    }
+    /**
+     * Configure the LiFi SDK provider for the route source protocol.
+     */
+    configureLiFiProvider(protocol, key, fromChain, fromRpcUrl) {
+        const providers = [];
+        switch (protocol) {
+            case _recoillink_utils__WEBPACK_IMPORTED_MODULE_6__/* .ProtocolType */ .Hb.Ethereum: {
+                const account = (0,viem_accounts__WEBPACK_IMPORTED_MODULE_8__/* .privateKeyToAccount */ .R)((0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_9__/* .ensure0x */ .Ho)(key));
+                const chain = getViemChain(fromChain, fromRpcUrl);
+                const walletClient = (0,viem__WEBPACK_IMPORTED_MODULE_10__/* .createWalletClient */ .F)({
+                    account,
+                    chain,
+                    transport: (0,viem__WEBPACK_IMPORTED_MODULE_11__/* .http */ .L)(fromRpcUrl),
+                });
+                providers.push((0,_lifi_sdk__WEBPACK_IMPORTED_MODULE_12__/* .EVM */ .Z)({
+                    getWalletClient: async () => walletClient,
+                    switchChain: async (requiredChainId) => {
+                        const switchRpcUrl = this.getRpcUrlForChainId(requiredChainId);
+                        const requiredChain = getViemChain(requiredChainId, switchRpcUrl);
+                        return (0,viem__WEBPACK_IMPORTED_MODULE_10__/* .createWalletClient */ .F)({
+                            account,
+                            chain: requiredChain,
+                            transport: (0,viem__WEBPACK_IMPORTED_MODULE_11__/* .http */ .L)(switchRpcUrl),
+                        });
+                    },
+                }));
+                break;
+            }
+            case _recoillink_utils__WEBPACK_IMPORTED_MODULE_6__/* .ProtocolType */ .Hb.Sealevel: {
+                const base58Key = toBase58SolanaKey(key);
+                providers.push((0,_lifi_sdk__WEBPACK_IMPORTED_MODULE_13__/* .Solana */ .j)({
+                    getWalletAdapter: async () => new _lifi_sdk__WEBPACK_IMPORTED_MODULE_14__/* .KeypairWalletAdapter */ .E(base58Key),
+                }));
+                break;
+            }
+            default:
+                throw new Error(`Unsupported protocol type '${protocol}' for LiFi provider`);
+        }
+        _lifi_sdk__WEBPACK_IMPORTED_MODULE_15__/* .config */ .$.setProviders(providers);
+        this.logger.debug({
+            fromChain,
+            protocol,
+        }, 'Configured LiFi provider for route execution');
+    }
+    /**
+     * Get a quote for bridging tokens.
+     * Supports two modes:
+     * - fromAmount: "I'm sending X, what do I get?" (uses SDK)
+     * - toAmount: "I want X, how much do I send?" (uses REST API)
+     *
+     * Returns route data ready for execution.
+     */
+    async quote(params) {
+        this.initialize();
+        // Validate that exactly one of fromAmount or toAmount is provided
+        if (params.fromAmount !== undefined && params.toAmount !== undefined) {
+            throw new Error('Cannot specify both fromAmount and toAmount - provide exactly one');
+        }
+        if (params.fromAmount === undefined && params.toAmount === undefined) {
+            throw new Error('Must specify either fromAmount or toAmount');
+        }
+        (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_16__/* .assert */ .v)(params.fromAmount === undefined || params.fromAmount > 0n, 'fromAmount must be positive');
+        (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_16__/* .assert */ .v)(params.toAmount === undefined || params.toAmount > 0n, 'toAmount must be positive');
+        // Dispatch to appropriate quote method
+        if (params.toAmount !== undefined) {
+            return this.quoteByReceivingAmount(params);
+        }
+        else {
+            return this.quoteBySpendingAmount(params);
+        }
+    }
+    /**
+     * Get a quote by specifying the amount to send (standard quote).
+     * Uses the LiFi SDK.
+     */
+    async quoteBySpendingAmount(params) {
+        this.logger.debug({ params }, 'Requesting LiFi quote by spending amount');
+        const lifiFromChain = LiFiBridge.toLiFiChainId(params.fromChain);
+        const lifiToChain = LiFiBridge.toLiFiChainId(params.toChain);
+        const quote = await (0,_lifi_sdk__WEBPACK_IMPORTED_MODULE_17__/* .getQuote */ .fn)({
+            fromChain: lifiFromChain,
+            toChain: lifiToChain,
+            fromToken: params.fromToken,
+            toToken: params.toToken,
+            fromAmount: params.fromAmount.toString(),
+            fromAddress: params.fromAddress,
+            toAddress: params.toAddress ?? params.fromAddress,
+            slippage: params.slippage ?? this.config.defaultSlippage ?? 0.005,
+            // Prefer faster routes for rebalancing
+            order: 'RECOMMENDED',
+        });
+        const { gasCosts, feeCosts } = this.extractCosts(quote);
+        this.logger.info({
+            quoteId: quote.id,
+            tool: quote.tool,
+            fromAmount: quote.action.fromAmount,
+            toAmount: quote.estimate.toAmount,
+            toAmountMin: quote.estimate.toAmountMin,
+            executionDuration: quote.estimate.executionDuration,
+            gasCosts: gasCosts.toString(),
+            feeCosts: feeCosts.toString(),
+        }, 'LiFi quote received (fromAmount)');
+        return {
+            id: quote.id,
+            tool: quote.tool,
+            fromAmount: BigInt(quote.action.fromAmount),
+            toAmount: BigInt(quote.estimate.toAmount),
+            toAmountMin: BigInt(quote.estimate.toAmountMin),
+            executionDuration: quote.estimate.executionDuration,
+            gasCosts,
+            feeCosts,
+            route: quote, // Store full quote for conversion to route
+            requestParams: {
+                ...params,
+                fromChain: lifiFromChain,
+                toChain: lifiToChain,
+            },
+        };
+    }
+    /**
+     * Get a quote by specifying the amount to receive (reverse quote).
+     * Uses the LiFi REST API directly since the SDK doesn't support toAmount.
+     */
+    async quoteByReceivingAmount(params) {
+        this.logger.debug({ params }, 'Requesting LiFi quote by receiving amount');
+        const lifiFromChain = LiFiBridge.toLiFiChainId(params.fromChain);
+        const lifiToChain = LiFiBridge.toLiFiChainId(params.toChain);
+        const queryParams = new URLSearchParams({
+            fromChain: lifiFromChain.toString(),
+            toChain: lifiToChain.toString(),
+            fromToken: params.fromToken,
+            toToken: params.toToken,
+            toAmount: params.toAmount.toString(),
+            fromAddress: params.fromAddress,
+            toAddress: params.toAddress ?? params.fromAddress,
+            slippage: (params.slippage ?? this.config.defaultSlippage ?? 0.005)
+                .toFixed(4)
+                .replace(/\.?0+$/, ''),
+            order: 'RECOMMENDED',
+            integrator: this.config.integrator,
+        });
+        if (this.config.apiKey) {
+            queryParams.set('apiKey', this.config.apiKey);
+        }
+        const url = `${LIFI_API_BASE}/quote/toAmount?${queryParams.toString()}`;
+        this.logger.debug({ url: url.replace(/apiKey=[^&]+/, 'apiKey=***') }, 'Fetching LiFi toAmount quote');
+        const response = await fetch(url);
+        if (!response.ok) {
+            const errorBody = await response.text();
+            throw new Error(`LiFi toAmount quote failed: ${response.status} ${response.statusText} - ${errorBody}`);
+        }
+        const quote = await response.json();
+        const { gasCosts, feeCosts } = this.extractCosts(quote);
+        this.logger.info({
+            quoteId: quote.id,
+            tool: quote.tool,
+            fromAmount: quote.action.fromAmount,
+            toAmount: quote.estimate.toAmount,
+            toAmountMin: quote.estimate.toAmountMin,
+            executionDuration: quote.estimate.executionDuration,
+            gasCosts: gasCosts.toString(),
+            feeCosts: feeCosts.toString(),
+        }, 'LiFi quote received (toAmount)');
+        return {
+            id: quote.id,
+            tool: quote.tool,
+            fromAmount: BigInt(quote.action.fromAmount),
+            toAmount: BigInt(quote.estimate.toAmount),
+            toAmountMin: BigInt(quote.estimate.toAmountMin),
+            executionDuration: quote.estimate.executionDuration,
+            gasCosts,
+            feeCosts,
+            route: quote, // Store full quote for conversion to route
+            requestParams: {
+                ...params,
+                fromChain: lifiFromChain,
+                toChain: lifiToChain,
+            },
+        };
+    }
+    /**
+     * Extract gas and fee costs from a LiFi quote response.
+     * - gasCosts: Sum of all gas costs (transaction fees)
+     * - feeCosts: Sum of non-included fee costs (protocol fees not deducted from amount)
+     */
+    extractCosts(quote) {
+        let gasCosts = 0n;
+        let feeCosts = 0n;
+        // Sum up gas costs
+        if (quote.estimate.gasCosts) {
+            for (const cost of quote.estimate.gasCosts) {
+                gasCosts += BigInt(cost.amount);
+            }
+        }
+        // Sum up non-included fee costs
+        // (included fees are already deducted from toAmount, so we only count non-included)
+        if (quote.estimate.feeCosts) {
+            for (const cost of quote.estimate.feeCosts) {
+                if (!cost.included) {
+                    feeCosts += BigInt(cost.amount);
+                }
+            }
+        }
+        return { gasCosts, feeCosts };
+    }
+    /**
+     * Execute a bridge transfer using the SDK.
+     * Handles approvals, transaction signing, and execution automatically.
+     *
+     * @param quote - Quote obtained from quote()
+     * @param privateKeys - Private keys keyed by protocol type for signing transactions
+     */
+    async execute(quote, privateKeys) {
+        this.initialize();
+        // Convert quote to route for execution
+        const route = (0,_lifi_sdk__WEBPACK_IMPORTED_MODULE_18__/* .convertQuoteToRoute */ ._)(quote.route);
+        this.validateRouteAgainstRequest(route, quote.requestParams);
+        const fromChain = route.fromChainId;
+        const toChain = route.toChainId;
+        const fromProtocol = this.getProtocolTypeForChainId(fromChain);
+        const sourceProtocol = fromProtocol ?? _recoillink_utils__WEBPACK_IMPORTED_MODULE_6__/* .ProtocolType */ .Hb.Ethereum;
+        (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_16__/* .assert */ .v)(privateKeys[sourceProtocol], `Missing private key for source chain protocol ${sourceProtocol}`);
+        this.logger.info({
+            quoteId: quote.id,
+            tool: quote.tool,
+            fromChain,
+            toChain,
+            fromAmount: quote.fromAmount.toString(),
+        }, 'Executing LiFi bridge transfer');
+        const fromRpcUrl = this.getRpcUrlForChainId(fromChain);
+        let release;
+        const acquired = new Promise((resolve) => {
+            release = resolve;
+        });
+        const prev = this._executeLock;
+        this._executeLock = acquired;
+        await prev;
+        let txHash;
+        let executedRoute;
+        try {
+            this.configureLiFiProvider(sourceProtocol, privateKeys[sourceProtocol], fromChain, fromRpcUrl);
+            // Execute route with update callbacks
+            executedRoute = await (0,_lifi_sdk__WEBPACK_IMPORTED_MODULE_19__/* .executeRoute */ .Zk)(route, {
+                // Update callback for route progress
+                updateRouteHook: (updatedRoute) => {
+                    this.logger.debug({ step: updatedRoute.steps[0]?.id }, 'Route step updated');
+                    // Extract txHash from execution if available (RouteExtended has LiFiStepExtended with execution)
+                    const execution = updatedRoute.steps[0]?.execution;
+                    if (execution?.process) {
+                        for (const process of execution.process) {
+                            if (process.txHash) {
+                                txHash = process.txHash;
+                            }
+                        }
+                    }
+                },
+                // Auto-accept rate updates for rebalancing
+                acceptExchangeRateUpdateHook: async () => true,
+            });
+        }
+        finally {
+            release();
+        }
+        // Extract txHash from executed route if not captured in callbacks
+        if (!txHash) {
+            const execution = executedRoute.steps[0]?.execution;
+            if (execution?.process) {
+                for (const process of execution.process) {
+                    if (process.txHash) {
+                        txHash = process.txHash;
+                        break;
+                    }
+                }
+            }
+        }
+        if (!txHash) {
+            throw new Error('No transaction hash found in executed route');
+        }
+        this.logger.info({ txHash, quoteId: quote.id }, 'LiFi bridge transaction executed');
+        // Extract transfer ID if available (some bridges provide this)
+        let transferId;
+        const processes = executedRoute.steps[0]?.execution?.process;
+        const txInfo = processes?.find((p) => p.txHash === txHash);
+        if (txInfo && 'lifiExplorerLink' in txInfo) {
+            // Extract transfer ID from explorer link if available
+            const link = txInfo.lifiExplorerLink;
+            const match = link?.match(/\/tx\/([^/]+)/);
+            if (match) {
+                transferId = match[1];
+            }
+        }
+        return {
+            txHash,
+            fromChain,
+            toChain,
+            transferId,
+        };
+    }
+    /**
+     * Validate that the route returned by LiFi matches the original request parameters.
+     * Prevents execution against wrong chains, tokens, or recipients if the bridge API
+     * returns a route that diverges from what was originally requested.
+     *
+     * TODO: Layer 2 validation — validate transaction calldata in route.steps[].transactionRequest
+     * and route.steps[0].estimate.approvalAddress against a known whitelist.
+     */
+    validateRouteAgainstRequest(route, requestParams) {
+        (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_16__/* .assert */ .v)(route.fromChainId === requestParams.fromChain, `Route fromChainId ${route.fromChainId} does not match requested ${requestParams.fromChain}`);
+        (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_16__/* .assert */ .v)(route.toChainId === requestParams.toChain, `Route toChainId ${route.toChainId} does not match requested ${requestParams.toChain}`);
+        (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_16__/* .assert */ .v)(this.addressesEqual(route.fromToken.address, requestParams.fromToken, route.fromChainId), `Route fromToken ${route.fromToken.address} does not match requested ${requestParams.fromToken}`);
+        (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_16__/* .assert */ .v)(this.addressesEqual(route.toToken.address, requestParams.toToken, route.toChainId), `Route toToken ${route.toToken.address} does not match requested ${requestParams.toToken}`);
+        const expectedToAddress = requestParams.toAddress ?? requestParams.fromAddress;
+        (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_16__/* .assert */ .v)(this.addressesEqual(route.toAddress ?? '', expectedToAddress, route.toChainId), `Route toAddress ${route.toAddress} does not match requested ${expectedToAddress}`);
+        (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_16__/* .assert */ .v)(this.addressesEqual(route.fromAddress ?? '', requestParams.fromAddress, route.fromChainId), `Route fromAddress ${route.fromAddress} does not match requested ${requestParams.fromAddress}`);
+        const routeFromAmount = BigInt(route.fromAmount);
+        if (requestParams.fromAmount !== undefined) {
+            (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_16__/* .assert */ .v)(routeFromAmount === requestParams.fromAmount, `Route fromAmount ${route.fromAmount} does not match requested ${requestParams.fromAmount}`);
+        }
+        if (requestParams.toAmount !== undefined) {
+            const routeToAmount = BigInt(route.toAmount);
+            (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_16__/* .assert */ .v)(routeToAmount >= requestParams.toAmount, `Route toAmount ${route.toAmount} is less than requested ${requestParams.toAmount}`);
+        }
+        (0,_recoillink_utils__WEBPACK_IMPORTED_MODULE_16__/* .assert */ .v)(routeFromAmount > 0n, 'Route fromAmount must be positive');
+    }
+    /**
+     * Get the status of a bridge transfer.
+     * Uses SDK's built-in status tracking.
+     */
+    async getStatus(txHash, fromChain, toChain) {
+        this.initialize();
+        try {
+            const status = await (0,_lifi_sdk__WEBPACK_IMPORTED_MODULE_17__/* .getStatus */ .BS)({
+                txHash,
+                fromChain: LiFiBridge.toLiFiChainId(fromChain),
+                toChain: LiFiBridge.toLiFiChainId(toChain),
+            });
+            switch (status.status) {
+                case 'DONE': {
+                    // receiving can be PendingReceivingInfo (only chainId) or ExtendedTransactionInfo (has txHash, amount)
+                    const receiving = status.receiving;
+                    const receivingTxHash = receiving && 'txHash' in receiving ? (receiving.txHash ?? '') : '';
+                    const receivedAmount = receiving && 'amount' in receiving
+                        ? BigInt(receiving.amount ?? '0')
+                        : BigInt(0);
+                    return {
+                        status: 'complete',
+                        receivingTxHash,
+                        receivedAmount,
+                    };
+                }
+                case 'FAILED':
+                    return {
+                        status: 'failed',
+                        error: status.substatus,
+                    };
+                case 'NOT_FOUND':
+                case 'INVALID':
+                    return { status: 'not_found' };
+                case 'PENDING':
+                default:
+                    return {
+                        status: 'pending',
+                        substatus: status.substatus,
+                    };
+            }
+        }
+        catch (error) {
+            this.logger.warn({ txHash, error }, 'Failed to get LiFi status');
+            return { status: 'not_found' };
+        }
+    }
+}
+//# sourceMappingURL=LiFiBridge.js.map
+
+/***/ })
+
+};