genius-intents 0.28.0 → 0.29.1-develop.0

package/dist/protocols/liquid-mesh/liquid-mesh.service.js

@@ -0,0 +1,706 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LiquidMeshService = void 0;
+const axios_1 = __importDefault(require("axios"));
+const bs58_1 = __importDefault(require("bs58"));
+const jose_1 = require("jose");
+const crypto_1 = require("crypto");
+const enums_1 = require("../../types/enums");
+const address_1 = require("../../utils/address");
+const logger_1 = require("../../utils/logger");
+const constants_1 = require("../../utils/constants");
+const is_native_1 = require("../../utils/is-native");
+const throw_error_1 = require("../../utils/throw-error");
+const create_error_message_1 = require("../../utils/create-error-message");
+let logger;
+/**
+ * The `LiquidMeshService` class implements the IIntentProtocol interface for token swaps
+ * using the Liquid Mesh aggregator. It provides functionality for fetching price quotes
+ * and generating transaction data for token swaps on various EVM-compatible blockchains.
+ *
+ * @implements {IIntentProtocol}
+ */
+class LiquidMeshService {
+    constructor(config) {
+        /**
+         * The protocol identifier for Liquid Mesh.
+         */
+        this.protocol = enums_1.ProtocolEnum.LIQUID_MESH;
+        /**
+         * The list of blockchain networks supported by the Liquid Mesh service.
+         */
+        this.chains = [enums_1.ChainIdEnum.BSC, enums_1.ChainIdEnum.BASE, enums_1.ChainIdEnum.SOLANA];
+        this.networkIds = {
+            [enums_1.ChainIdEnum.BSC]: 'bsc',
+            [enums_1.ChainIdEnum.BASE]: 'base',
+            [enums_1.ChainIdEnum.SOLANA]: 'sol',
+        };
+        /**
+         * Indicates that the service operates only on a single blockchain.
+         */
+        this.singleChain = true;
+        /**
+         * Indicates that the service does not support cross-chain operations.
+         */
+        this.multiChain = false;
+        /**
+         * The endpoint for quote requests.
+         */
+        this.quoteEndpoint = '/v1/quote';
+        /**
+         * Cache for approve addresses per network to avoid repeated API calls.
+         */
+        this._approvalContract = '0x8157a9d65807521FBB8db8f37EEEcEfDD247E9B1';
+        if (config?.debug) {
+            logger_1.LoggerFactory.configure(logger_1.LoggerFactory.createConsoleLogger({ level: logger_1.LogLevelEnum.DEBUG }));
+        }
+        // Use custom logger if provided
+        else if (config?.logger) {
+            logger_1.LoggerFactory.configure(config.logger);
+        }
+        logger = logger_1.LoggerFactory.getLogger();
+        // Initialize proxy configuration first (takes precedence over direct API access)
+        if (config?.liquidMeshProxyUrl) {
+            this._proxyUrl = config.liquidMeshProxyUrl;
+            this._proxyApiKey = config.liquidMeshProxyApiKey;
+            logger.debug('Liquid Mesh configured to use proxy', {
+                proxyUrl: this._proxyUrl,
+                hasProxyApiKey: !!this._proxyApiKey,
+            });
+        }
+        else {
+            // Only initialize direct API credentials if not using proxy
+            this._apiKey = config?.liquidMeshApiKey;
+            // Initialize Ed25519 private key if credentials are provided
+            if (config?.liquidMeshPrivateKeyBase64Seed && config?.liquidMeshPublicKeyBase64) {
+                this._privateKeyPromise = this._initializePrivateKey(config.liquidMeshPrivateKeyBase64Seed, config.liquidMeshPublicKeyBase64);
+            }
+        }
+    }
+    /**
+     * Converts a standard Base64 string to Base64URL encoding.
+     * Base64URL replaces '+' with '-', '/' with '_', and removes '=' padding.
+     *
+     * @param base64 - The standard Base64 encoded string.
+     * @returns The Base64URL encoded string.
+     */
+    _toBase64Url(base64) {
+        return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+    }
+    /**
+     * Initializes the Ed25519 private key from base64-encoded seed and public key.
+     * Automatically converts standard Base64 to Base64URL if needed.
+     *
+     * @param privateKeySeed - The Ed25519 private key seed (Base64 or Base64URL).
+     * @param publicKey - The Ed25519 public key (Base64 or Base64URL).
+     */
+    async _initializePrivateKey(privateKeySeed, publicKey) {
+        try {
+            // Convert to Base64URL if standard Base64 is provided
+            const d = this._toBase64Url(privateKeySeed);
+            const x = this._toBase64Url(publicKey);
+            logger.debug('Initializing Ed25519 private key for Liquid Mesh', {
+                dLength: d.length,
+                xLength: x.length,
+            });
+            this._privateKey = await (0, jose_1.importJWK)({
+                kty: 'OKP',
+                crv: 'Ed25519',
+                d,
+                x,
+            }, 'EdDSA');
+            logger.debug('Successfully initialized Ed25519 private key for Liquid Mesh');
+        }
+        catch (error) {
+            logger.error('Failed to initialize Ed25519 private key', error, {
+                errorMessage: error instanceof Error ? error.message : String(error),
+            });
+            throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.INVALID_PARAMS, `Failed to initialize Liquid Mesh authentication credentials: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Generates a signed JWT for Liquid Mesh API authentication.
+     *
+     * @param method - The HTTP method (GET, POST, etc.).
+     * @param path - The canonical request path (e.g., /v1/bsc/quote?amount=100).
+     * @param body - The request body (empty string for GET requests).
+     * @returns A promise that resolves to the signed JWT token.
+     */
+    async _generateAuthToken(method, path, body = '') {
+        if (!this._apiKey || !this._privateKey) {
+            // Wait for private key initialization if in progress
+            if (this._privateKeyPromise) {
+                await this._privateKeyPromise;
+            }
+            if (!this._apiKey || !this._privateKey) {
+                throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.INVALID_PARAMS, 'Liquid Mesh API credentials not configured. Please provide liquidMeshApiKey, liquidMeshPrivateKeyBase64Seed, and liquidMeshPublicKeyBase64 in config.');
+            }
+        }
+        const timestamp = Date.now();
+        const preimage = `${timestamp}${method.toUpperCase()}${path}${body}`;
+        const message = (0, crypto_1.createHash)('sha256').update(preimage).digest('hex');
+        logger.debug('Generating Liquid Mesh auth token', {
+            method: method.toUpperCase(),
+            path,
+            timestamp,
+        });
+        const token = await new jose_1.SignJWT({
+            tim: timestamp,
+            message,
+            iss: this._apiKey,
+        })
+            .setProtectedHeader({ typ: 'JWT', alg: 'EdDSA' })
+            .setIssuedAt()
+            .setExpirationTime('2s')
+            .sign(this._privateKey);
+        return token;
+    }
+    /**
+     * Generates the authentication headers for Liquid Mesh API requests.
+     *
+     * @param method - The HTTP method.
+     * @param path - The canonical request path.
+     * @param body - The request body.
+     * @returns A promise that resolves to the headers object.
+     */
+    async _getAuthHeaders(method, path, body = '') {
+        const token = await this._generateAuthToken(method, path, body);
+        return {
+            /* eslint-disable @typescript-eslint/naming-convention */
+            'LM-API-KEY': this._apiKey,
+            Authorization: `Bearer ${token}`,
+            'Content-Type': 'application/json',
+            /* eslint-enable @typescript-eslint/naming-convention */
+        };
+    }
+    /**
+     * Checks if the service is configured to use a proxy.
+     *
+     * @returns True if using proxy, false for direct API access.
+     */
+    _isUsingProxy() {
+        return !!this._proxyUrl;
+    }
+    /**
+     * Builds the request URL, routing through proxy if configured.
+     * When proxy is enabled, the original target URL is passed as a query parameter.
+     *
+     * @param targetUrl - The original Liquid Mesh API URL.
+     * @returns The URL to use for the request (proxy URL or original URL).
+     */
+    _buildRequestUrl(targetUrl) {
+        if (!this._proxyUrl) {
+            return targetUrl;
+        }
+        const proxyUrl = new URL(this._proxyUrl);
+        proxyUrl.searchParams.set('targetUrl', targetUrl);
+        if (this._proxyApiKey) {
+            proxyUrl.searchParams.set('api_key', this._proxyApiKey);
+        }
+        logger.debug('Routing request through proxy', {
+            proxyUrl: this._proxyUrl,
+            targetUrl,
+        });
+        return proxyUrl.toString();
+    }
+    /**
+     * Gets the appropriate headers for the request.
+     * When using proxy, no auth headers are needed (proxy handles authentication).
+     * For direct API access, generates JWT auth headers.
+     *
+     * @param method - The HTTP method.
+     * @param path - The canonical request path.
+     * @param body - The request body.
+     * @returns A promise that resolves to the headers object.
+     */
+    async _getRequestHeaders(method, path, body = '') {
+        // When using proxy, the proxy handles authentication
+        if (this._isUsingProxy()) {
+            return {
+                /* eslint-disable @typescript-eslint/naming-convention */
+                'Content-Type': 'application/json',
+                /* eslint-enable @typescript-eslint/naming-convention */
+            };
+        }
+        // For direct API access, generate auth headers
+        return this._getAuthHeaders(method, path, body);
+    }
+    /**
+     * Checks if the provided configuration object is valid.
+     *
+     * @typeParam T - The expected shape of the configuration object.
+     * @param config - The configuration object to validate.
+     * @returns `true` if the configuration is valid, otherwise `false`.
+     */
+    isCorrectConfig(config) {
+        // Liquid Mesh doesn't require specific config keys
+        // Accept any config object
+        return config !== null && typeof config === 'object';
+    }
+    /**
+     * Checks if the given network is Solana.
+     *
+     * @param networkId - The chain ID to check.
+     * @returns True if the network is Solana.
+     */
+    _isSolanaNetwork(networkId) {
+        return networkId === enums_1.ChainIdEnum.SOLANA;
+    }
+    /**
+     * Gets the native token address for the given network.
+     *
+     * @param networkId - The chain ID.
+     * @returns The native token address for the network.
+     */
+    _getNativeAddress(networkId) {
+        return this._isSolanaNetwork(networkId) ? constants_1.SOL_NATIVE_ADDRESS : constants_1.NATIVE_ADDRESS;
+    }
+    _wrapSolanaMessageAsTransaction(base64Message) {
+        // Decode base64 to get raw bytes
+        const bytes = Buffer.from(base64Message, 'base64');
+        if (bytes.length === 0) {
+            throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.INVALID_PARAMS, 'Empty message bytes from Liquid Mesh');
+        }
+        // Detect if this is already a complete transaction or just raw message bytes
+        // A complete transaction starts with: [sigCount] [sig1...] [sig2...] [message...]
+        // A raw message starts with either: [0x80 + version] [header...] (versioned) or [numRequiredSigs] [header...] (legacy)
+        const firstByte = bytes[0];
+        // Check if this looks like a complete transaction by seeing if we can find
+        // a valid message at the expected offset
+        const potentialSigCount = firstByte;
+        const potentialMessageStart = 1 + potentialSigCount * 64;
+        // If potentialMessageStart is within bounds, check if there's a valid message there
+        if (potentialSigCount <= 10 && potentialMessageStart < bytes.length) {
+            const potentialMessageFirstByte = bytes[potentialMessageStart];
+            // Check if byte at message start looks like a valid message header
+            const isVersionedAtOffset = (potentialMessageFirstByte & 0x80) !== 0;
+            const isLegacyAtOffset = potentialMessageFirstByte > 0 && potentialMessageFirstByte <= 127;
+            if (isVersionedAtOffset || isLegacyAtOffset) {
+                // This appears to be a complete transaction already
+                // Verify by checking if the message parses correctly
+                const messageBytes = bytes.slice(potentialMessageStart);
+                let messageHeaderOffset = 0;
+                if (isVersionedAtOffset) {
+                    messageHeaderOffset = 1; // Skip version prefix
+                }
+                const numRequiredSigsResponse = messageBytes[messageHeaderOffset];
+                const numRequiredSigs = numRequiredSigsResponse ?? 0;
+                // Final sanity check: signature count should match or be >= required sigs
+                if (potentialSigCount >= numRequiredSigs || potentialSigCount === 0) {
+                    logger.debug('Data appears to be a complete transaction, encoding as-is', {
+                        signatureCount: potentialSigCount,
+                        messageStart: potentialMessageStart,
+                        firstMessageByte: `0x${potentialMessageFirstByte.toString(16)}`,
+                        numRequiredSignatures: numRequiredSigs,
+                        totalLength: bytes.length,
+                    });
+                    // If sigCount is 0 but signatures are required, we need to add empty slots
+                    if (potentialSigCount === 0 && numRequiredSigs > 0) {
+                        // Extract the message and wrap it properly
+                        return this._wrapRawMessage(messageBytes, numRequiredSigs);
+                    }
+                    // Already a complete transaction with proper signature slots
+                    return bs58_1.default.encode(bytes);
+                }
+            }
+        }
+        // If we get here, treat the bytes as raw message bytes that need wrapping
+        return this._wrapRawMessage(bytes);
+    }
+    _wrapRawMessage(messageBytes, numRequiredSignaturesOverride) {
+        // Parse the message to get the number of required signatures
+        let numRequiredSignatures;
+        let messageHeaderOffset = 0;
+        const firstByte = messageBytes[0];
+        // Check if this is a versioned message (high bit set means version prefix)
+        if ((firstByte & 0x80) !== 0) {
+            // Versioned message - first byte is version prefix, header starts at byte 1
+            messageHeaderOffset = 1;
+            numRequiredSignatures = messageBytes[messageHeaderOffset] ?? 0;
+        }
+        else {
+            // Legacy message - first byte is numRequiredSignatures (part of header)
+            numRequiredSignatures = firstByte;
+        }
+        // Allow override (used when we detected a complete txn with 0 sig slots)
+        if (numRequiredSignaturesOverride !== undefined) {
+            numRequiredSignatures = numRequiredSignaturesOverride;
+        }
+        logger.debug('Wrapping raw Solana message as transaction', {
+            messageLength: messageBytes.length,
+            firstByte: `0x${firstByte.toString(16)}`,
+            isVersioned: (firstByte & 0x80) !== 0,
+            numRequiredSignatures,
+        });
+        // Create the full transaction buffer:
+        // 1 byte for signature count + (numRequiredSignatures * 64 bytes for empty signatures) + message
+        const signatureSlotSize = 64;
+        const fullTransactionLength = 1 + numRequiredSignatures * signatureSlotSize + messageBytes.length;
+        const fullTransaction = Buffer.alloc(fullTransactionLength);
+        // Write signature count
+        fullTransaction[0] = numRequiredSignatures;
+        // Signature slots are already zeroed by Buffer.alloc
+        // Write message bytes after the signature slots
+        const messageOffset = 1 + numRequiredSignatures * signatureSlotSize;
+        messageBytes.copy(fullTransaction, messageOffset);
+        return bs58_1.default.encode(fullTransaction);
+    }
+    /**
+     * Fetches a price quote for a token swap from the Liquid Mesh API.
+     *
+     * @param {IntentPriceParams} params - The parameters required for the price quote.
+     *
+     * @returns {Promise<Omit<PriceResponse, 'protocolResponse'> & { protocolResponse: LiquidMeshPriceResponse }>}
+     * A promise that resolves to a `PriceResponse` object containing:
+     * - The amount of output tokens expected from the swap.
+     * - Gas estimation for the transaction.
+     * - The raw response from the Liquid Mesh API.
+     *
+     * @throws {SdkError} If the parameters are invalid or unsupported.
+     * @throws {SdkError} If the API returns an invalid response.
+     * @throws {SdkError} If there's an error fetching the price.
+     */
+    async fetchPrice(params) {
+        this.validatePriceParams(params);
+        const requestParams = this.priceParamsToRequestParams(params);
+        logger.debug('Generated Liquid Mesh price request params', requestParams);
+        try {
+            const networkId = this.networkIds[params.networkIn];
+            if (!networkId) {
+                logger.error(`Unsupported network ID for Liquid Mesh: ${params.networkIn}`);
+                throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.INVALID_PARAMS, `Unsupported network ID for Liquid Mesh: ${params.networkIn}`);
+            }
+            const baseUrl = `https://api.liquidmesh.io/v1/${networkId}/quote`;
+            const url = new URL(baseUrl);
+            // Add query parameters
+            Object.entries(requestParams).forEach(([key, value]) => {
+                if (value !== undefined && value !== null) {
+                    url.searchParams.append(key, value.toString());
+                }
+            });
+            // Build the canonical path with query string for JWT signing (used for direct API access)
+            const canonicalPath = `/v1/${params.networkIn}/quote?${url.searchParams.toString()}`;
+            const headers = await this._getRequestHeaders('GET', canonicalPath, '');
+            const requestUrl = this._buildRequestUrl(url.toString());
+            logger.debug(`Making request to Liquid Mesh API: ${requestUrl}`);
+            const response = await axios_1.default.get(requestUrl, { headers });
+            const liquidMeshResponse = response.data;
+            if (!liquidMeshResponse || liquidMeshResponse.code !== 0 || !liquidMeshResponse.data) {
+                logger.error('Invalid response received from Liquid Mesh API', undefined, {
+                    liquidMeshResponse,
+                });
+                throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.PRICE_NOT_FOUND, liquidMeshResponse?.msg || 'Invalid response received from Liquid Mesh API');
+            }
+            const quoteData = liquidMeshResponse.data;
+            logger.debug('Successfully received price info from Liquid Mesh', {
+                amountOut: quoteData.outputAmount,
+                gasEstimate: quoteData.estimatedGas,
+            });
+            const amountOut = quoteData.outputAmount;
+            if (!amountOut) {
+                logger.error('No output amount received from Liquid Mesh', undefined, {
+                    liquidMeshResponse,
+                });
+                throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.PRICE_NOT_FOUND, 'No output amount received from Liquid Mesh');
+            }
+            return {
+                protocol: this.protocol,
+                networkIn: params.networkIn,
+                networkOut: params.networkOut,
+                tokenIn: params.tokenIn,
+                tokenOut: params.tokenOut,
+                amountIn: params.amountIn,
+                amountOut,
+                estimatedGas: quoteData.estimatedGas?.toString(),
+                protocolResponse: {
+                    quoteData,
+                },
+                slippage: params.slippage,
+            };
+        }
+        catch (error) {
+            const formattedError = (0, create_error_message_1.createErrorMessage)(error, this.protocol);
+            throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.PRICE_NOT_FOUND, formattedError);
+        }
+    }
+    /**
+     * Fetches a swap quote from the Liquid Mesh API and builds the transaction data
+     * needed to execute the swap.
+     *
+     * Note: Liquid Mesh uses a single endpoint for both price and quote. The quote
+     * endpoint returns route information that can be used to construct the swap transaction.
+     *
+     * @param {IntentQuoteParams} params - The parameters required for the swap quote.
+     *
+     * @returns {Promise<QuoteResponse & { protocolResponse: LiquidMeshPriceResponse }>}
+     * A promise that resolves to a `QuoteResponse` object containing:
+     * - The expected amount of output tokens.
+     * - The transaction data needed to execute the swap.
+     * - Gas estimates for the transaction.
+     *
+     * @throws {SdkError} If the parameters are invalid or unsupported.
+     * @throws {SdkError} If the API returns an invalid response.
+     * @throws {SdkError} If there's an error fetching the quote.
+     */
+    async fetchQuote(params) {
+        logger.info(`Fetching swap quote for address: ${params.from}`);
+        const nativeAddress = this._getNativeAddress(params.networkIn);
+        params.tokenIn = (0, is_native_1.isNative)(params.tokenIn) ? nativeAddress : params.tokenIn;
+        params.tokenOut = (0, is_native_1.isNative)(params.tokenOut) ? nativeAddress : params.tokenOut;
+        this.validatePriceParams(params);
+        const { networkIn } = params;
+        let { priceResponse } = params;
+        if (!priceResponse || !this.isLiquidMeshPriceResponse(priceResponse.protocolResponse)) {
+            logger.info('No price response received, fetching price...');
+            priceResponse = await this.fetchPrice(params);
+        }
+        if (!this.isLiquidMeshPriceResponse(priceResponse.protocolResponse)) {
+            logger.error('Invalid price response received', undefined, {
+                priceResponse,
+            });
+            throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.PRICE_NOT_FOUND, 'Invalid price response received');
+        }
+        const quoteData = priceResponse.protocolResponse.quoteData;
+        console.log(`QUOTE_DATA`, quoteData);
+        // Route to appropriate handler based on network type
+        if (this._isSolanaNetwork(networkIn)) {
+            return this._fetchSolanaQuote(params, quoteData, priceResponse);
+        }
+        return this._fetchEvmQuote(params, quoteData, priceResponse);
+    }
+    /**
+     * Fetches a swap quote for EVM chains and builds the transaction data.
+     *
+     * @private
+     */
+    async _fetchEvmQuote(params, quoteData, priceResponse) {
+        const { from, receiver, tokenIn, amountIn, networkIn, networkOut } = params;
+        try {
+            logger.debug('Processing Liquid Mesh EVM quote response');
+            if (!quoteData || !quoteData.outputAmount) {
+                logger.error('No output amount received from Liquid Mesh', undefined, {
+                    quoteData,
+                });
+                throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.QUOTE_NOT_FOUND, 'No output amount received from Liquid Mesh');
+            }
+            // Call the swap endpoint to get transaction calldata
+            // Convert slippage from percentage to basis points (1% = 100 bps)
+            const slippageBps = Math.round(params.slippage * 100);
+            const swapRequestBody = {
+                userAddress: (0, address_1.formatAddress)(from),
+                slippageBps,
+                swapInfo: quoteData,
+                disableSimulate: true,
+            };
+            const networkId = this.networkIds[networkIn];
+            if (!networkId) {
+                logger.error(`Unsupported network ID for Liquid Mesh: ${networkIn}`);
+                throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.INVALID_PARAMS, `Unsupported network ID for Liquid Mesh: ${networkIn}`);
+            }
+            const swapUrl = `https://api.liquidmesh.io/v1/${networkId}/swap`;
+            const swapPath = `/v1/${networkId}/swap`;
+            const swapBodyString = JSON.stringify(swapRequestBody);
+            const swapHeaders = await this._getRequestHeaders('POST', swapPath, swapBodyString);
+            const swapRequestUrl = this._buildRequestUrl(swapUrl);
+            logger.debug(`Making request to Liquid Mesh swap API: ${swapRequestUrl}`, swapRequestBody);
+            const swapResponse = await axios_1.default.post(swapRequestUrl, swapRequestBody, {
+                headers: swapHeaders,
+            });
+            if (!swapResponse.data || swapResponse.data.code !== 0 || !swapResponse.data.data) {
+                logger.error('Invalid response received from Liquid Mesh swap API', undefined, {
+                    swapResponse: swapResponse.data,
+                });
+                throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.QUOTE_NOT_FOUND, swapResponse.data?.msg || 'Invalid response received from Liquid Mesh swap API');
+            }
+            const swapData = swapResponse.data.data;
+            const callMsg = swapData.callMsg;
+            const gasEstimate = swapData.estimatedGas?.toString() || quoteData.estimatedGas?.toString() || '0';
+            const gasLimit = Math.floor(Number(gasEstimate) * 1.1).toString(); // 10% buffer
+            const evmExecutionPayload = {
+                transactionData: {
+                    data: callMsg.data,
+                    to: callMsg.to,
+                    value: callMsg.value || ((0, is_native_1.isNative)(tokenIn) ? amountIn : '0'),
+                    gasEstimate,
+                    gasLimit,
+                },
+                approval: {
+                    token: tokenIn,
+                    amount: amountIn,
+                    spender: this._approvalContract,
+                },
+            };
+            const quote = {
+                protocol: this.protocol,
+                tokenIn: tokenIn,
+                tokenOut: quoteData.outputToken,
+                amountIn: amountIn,
+                amountOut: quoteData.outputAmount,
+                from,
+                receiver: receiver || from,
+                evmExecutionPayload,
+                slippage: priceResponse.slippage,
+                networkIn,
+                networkOut,
+                protocolResponse: {
+                    quoteData,
+                    swapData,
+                },
+            };
+            return quote;
+        }
+        catch (error) {
+            const formattedError = (0, create_error_message_1.createErrorMessage)(error, this.protocol);
+            throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.QUOTE_NOT_FOUND, formattedError);
+        }
+    }
+    /**
+     * Fetches a swap quote for Solana and builds the transaction data.
+     *
+     * @private
+     */
+    async _fetchSolanaQuote(params, quoteData, priceResponse) {
+        const { from, receiver, tokenIn, amountIn, networkIn, networkOut } = params;
+        try {
+            logger.debug('Processing Liquid Mesh Solana quote response');
+            if (!quoteData || !quoteData.outputAmount) {
+                logger.error('No output amount received from Liquid Mesh', undefined, {
+                    quoteData,
+                });
+                throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.QUOTE_NOT_FOUND, 'No output amount received from Liquid Mesh');
+            }
+            const overrideParams = params?.overrideParamsLiquidMesh;
+            const computeUnitLimit = overrideParams?.liquidMeshComputeUnitLimit;
+            const prioritizationFeeLamports = overrideParams?.liquidMeshPrioritizationFeeLamports;
+            const jitoAccount = overrideParams?.liquidMeshJitoAccount;
+            const jitoTips = overrideParams?.liquidMeshJitoTips;
+            // Call the swap endpoint to get serialized transaction
+            // Convert slippage from percentage to basis points (1% = 100 bps)
+            const slippageBps = Math.round(params.slippage * 100);
+            const swapRequestBody = {
+                userAddress: from, // Solana address in base58
+                slippageBps,
+                swapInfo: quoteData,
+                disableSimulate: true,
+                ...(computeUnitLimit && { computeUnitLimit }),
+                ...(prioritizationFeeLamports && { prioritizationFeeLamports }),
+                ...(jitoAccount && { jitoAccount }),
+                ...(jitoTips && { jitoTips }),
+            };
+            const networkId = this.networkIds[networkIn];
+            if (!networkId) {
+                logger.error(`Unsupported network ID for Liquid Mesh: ${networkIn}`);
+                throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.INVALID_PARAMS, `Unsupported network ID for Liquid Mesh: ${networkIn}`);
+            }
+            const swapUrl = `https://api.liquidmesh.io/v1/${networkId}/swap`;
+            const swapPath = `/v1/${networkId}/swap`;
+            const swapBodyString = JSON.stringify(swapRequestBody);
+            const swapHeaders = await this._getRequestHeaders('POST', swapPath, swapBodyString);
+            const swapRequestUrl = this._buildRequestUrl(swapUrl);
+            logger.debug(`Making request to Liquid Mesh Solana swap API: ${swapRequestUrl}`, swapRequestBody);
+            const swapResponse = await axios_1.default.post(swapRequestUrl, swapRequestBody, {
+                headers: swapHeaders,
+            });
+            if (!swapResponse.data || swapResponse.data.code !== 0 || !swapResponse.data.data) {
+                logger.error('Invalid response received from Liquid Mesh Solana swap API', undefined, {
+                    swapResponse: swapResponse.data,
+                });
+                throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.QUOTE_NOT_FOUND, swapResponse.data?.msg || 'Invalid response received from Liquid Mesh Solana swap API');
+            }
+            const swapData = swapResponse.data.data;
+            // Liquid Mesh returns a base64-encoded raw message (not a full serialized transaction)
+            // We need to wrap it with the proper signature structure before converting to base58
+            const base58Transaction = this._wrapSolanaMessageAsTransaction(swapData.swapTransaction);
+            const svmExecutionPayload = [base58Transaction];
+            const quote = {
+                protocol: this.protocol,
+                tokenIn: tokenIn,
+                tokenOut: quoteData.outputToken,
+                amountIn: amountIn,
+                amountOut: quoteData.outputAmount,
+                from,
+                receiver: receiver || from,
+                svmExecutionPayload,
+                slippage: priceResponse.slippage,
+                networkIn,
+                networkOut,
+                protocolResponse: {
+                    quoteData,
+                    swapData,
+                },
+            };
+            return quote;
+        }
+        catch (error) {
+            const formattedError = (0, create_error_message_1.createErrorMessage)(error, this.protocol);
+            throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.QUOTE_NOT_FOUND, formattedError);
+        }
+    }
+    /**
+     * Transforms the price parameters to the format expected by the Liquid Mesh API.
+     *
+     * @param {IntentPriceParams} params - The original price parameters.
+     *
+     * @returns {LiquidMeshPriceRequestParams} The transformed parameters ready for the Liquid Mesh API.
+     */
+    priceParamsToRequestParams(params) {
+        const { tokenIn, tokenOut, amountIn, networkIn, from } = params;
+        logger.debug('Converting price params to Liquid Mesh request params', {
+            params,
+        });
+        const nativeAddress = this._getNativeAddress(networkIn);
+        const isSolana = this._isSolanaNetwork(networkIn);
+        const requestParams = {
+            chainId: networkIn.toString(),
+            inputToken: (0, is_native_1.isNative)(tokenIn) ? nativeAddress : tokenIn,
+            outputToken: (0, is_native_1.isNative)(tokenOut) ? nativeAddress : tokenOut,
+            amount: amountIn,
+            // For Solana, don't use formatAddress as it expects EVM checksummed addresses
+            userAddress: isSolana ? from : (0, address_1.formatAddress)(from),
+        };
+        logger.debug('Generated Liquid Mesh request params', requestParams);
+        return requestParams;
+    }
+    /**
+     * Validates the parameters for a price quote request.
+     *
+     * @param {IntentPriceParams} params - The parameters to validate.
+     *
+     * @throws {SdkError} If any of the parameters are invalid or unsupported.
+     */
+    validatePriceParams(params) {
+        const { networkIn, networkOut } = params;
+        logger.debug('Validating price params');
+        if (!this.multiChain && networkIn !== networkOut) {
+            logger.error('Multi-chain swaps not supported');
+            throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.INVALID_PARAMS, 'Multi-chain swaps not supported');
+        }
+        if (!this.singleChain && networkIn === networkOut) {
+            logger.error('Single-chain swaps not supported');
+            throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.INVALID_PARAMS, 'Single-chain swaps not supported');
+        }
+        if (!this.chains.includes(networkIn)) {
+            logger.error(`Network ${networkIn} not supported`);
+            throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.INVALID_PARAMS, `Network ${networkIn} not supported`);
+        }
+        if (!this.chains.includes(networkOut)) {
+            logger.error(`Network ${networkOut} not supported`);
+            throw (0, throw_error_1.sdkError)(enums_1.SdkErrorEnum.INVALID_PARAMS, `Network ${networkOut} not supported`);
+        }
+    }
+    /**
+     * Type guard to check if a response is a valid Liquid Mesh price response.
+     *
+     * @param {RawProtocolPriceResponse} response - The response to check.
+     *
+     * @returns {boolean} True if the response is a valid Liquid Mesh price response.
+     */
+    isLiquidMeshPriceResponse(response) {
+        return 'quoteData' in response;
+    }
+}
+exports.LiquidMeshService = LiquidMeshService;
+//# sourceMappingURL=liquid-mesh.service.js.map